// LEARNINGCOLLECTIONAPI — NEURAL KNOWLEDGE REPOSITORY

Quickstart

MySQL on localhost:3306 with a schema named root must be live; the JDK 17 toolchain and Kotlin / Gradle versions are managed by the wrapper:

# clone + boot (Spring Boot default port 8080)
git clone https://github.com/MenkeTechnologies/LearningCollectionAPI
cd LearningCollectionAPI
./gradlew bootRun

# build + run diagnostics, then package
./gradlew build
./gradlew bootJar
java -jar build/libs/learningcollection-0.0.1-SNAPSHOT.jar

# forge an OCI container image
./gradlew bootBuildImage

Datasource config lives in src/main/resources/application.properties: jdbc:mysql://localhost:3306/root, user root, empty password, UTC server timezone. Once up, save and query from the shell:

# save a learning (category defaults to "programming")
curl 'http://localhost:8080/add?learning=zsh+globbing+qualifiers'

# search by substring (case-sensitive LIKE %text%)
curl 'http://localhost:8080/filter?learning=zsh'

# quiz: one random learning, full record
curl http://localhost:8080/random

# last 5 learnings, text only
curl http://localhost:8080/recents/5

Full reference: README on GitHub. OpenAPI / Swagger UI is wired via SpringDoc (springdoc-openapi-ui + springdoc-openapi-data-rest).

The domain — one entity, one table

The entire data model is a single JPA entity, LearningCollection (@Table(name = "LearningCollection")), with four columns. There is no second table, no join, no embedded type.

The entity implements Serializable (serialVersionUID = 1L) and has both a four-arg constructor (used by /add) and a no-arg constructor (used by JPA / deserialization).

Two interfaces — convenience GETs vs auto CRUD

REST surface — LearningController endpoints

Ten convenience endpoints, all GET. “Compressed” below means the response is just the learning text strings; “full” means complete LearningCollection records (id / learning / category / dateAdded). Recency is computed as findAll().reversed() (newest-inserted first), randomness as findAll().shuffled().

Auto-generated CRUD — /learning

Because LCRepo is annotated @RepositoryRestResource(collectionResourceRel = "learning", path = "learning") and extends CrudRepository, Spring Data REST exposes a standard hypermedia CRUD surface under /learning with zero controller code. findAllByLearningContaining and findAllByCategoryContaining are surfaced as search resources.

# Spring Data REST CRUD (auto-generated from LCRepo)
GET    /learning              # paged collection (HAL)
GET    /learning/{id}         # one resource
POST   /learning              # create (JSON body)
PUT    /learning/{id}         # replace
PATCH  /learning/{id}         # partial update
DELETE /learning/{id}         # remove
GET    /learning/search       # exported derived queries
       # findAllByLearningContaining, findAllByCategoryContaining

Note that findAllByCategoryContaining exists on the repository and is exposed under the Spring Data REST search resource, but is not wired into any LearningController endpoint — only findAllByLearningContaining is used by the hand-written /filter route.

CORS & configuration

WebConfig implements both WebMvcConfigurer and RepositoryRestConfigurer and opens CORS for all origins on every path (addMapping("/**")) — once for MVC controllers, once for the Spring Data REST layer. This lets the zsh-learn plugin (and any browser client) call the API cross-origin.

Source layout

src/main/kotlin/com/menketechnologies/learningcollection/
├── LearningCollectionApplication.kt   # @SpringBootApplication bootloader
├── LearningController.kt               # @RestController — 10 GET endpoints
├── LearningCollection.kt               # @Entity — id | learning | category | dateAdded
├── LCRepo.kt                           # CrudRepository + @RepositoryRestResource
├── Consts.kt                           # SHORT_CNT, DB_NAME, DEFAULT_CAT, DUMP
└── WebConfig.kt                        # CORS for MVC + Spring Data REST
src/main/resources/
└── application.properties              # MySQL datasource + JPA config
src/test/kotlin/com/menketechnologies/learningcollection/
└── 23 test files                       # controller / entity / repo / config coverage

6 main Kotlin files (147 LOC) plus 23 test files (6,155 LOC). The engineering report (report.html) breaks down the test suite, the dialect of each endpoint, and the full dependency manifest.

License & usage

Authored by MenkeTechnologies. Built with Kotlin on the JVM. The persisted data is yours — a plain MySQL table you can /dump at any time. Part of the MenkeTechnologiesMeta umbrella.