Everything you get
CrudCraft turns annotated JPA entities into controllers, services, repositories and DTOs at compile time. You keep full control over security, mapping and endpoints—without carrying a reflection-heavy runtime.
Generator
The annotation processor scans your entities and writes the layers you would otherwise copy-paste (or let AI write): Controller, Service, Repository, RequestDto, ResponseDto (plus a Reference DTO) and a MapStruct Mapper. It fails at build-time so runtime stays predictable.
Generates XRequestDto, XResponseDto and XReferenceDto.
Fields are selected via @Request and @Dto (with simplified flag).
Bean Validation annotations are carried over; enum fields get OpenAPI @Schema(allowableValues).
Generates an interface XMapper with fromRequest, update, patch,
toResponse and toSimplified. MapStruct compiles the implementation—no runtime reflection,
just fast, typed mappers.
Generates JpaRepository + JpaSpecificationExecutor per entity.
QueryDSL support stays opt-in so the default stack remains lean.
Your concrete service extends AbstractCrudService and wires the repository + mapper.
Hook methods like postSave and preDelete let you enforce invariants or fix relationships.
Controllers extend AbstractCrudController and expose GET/POST/PUT/PATCH/DELETE,
search and bulk endpoints based on your template. Security annotations are emitted when enabled.
When editable=true, stubs are copied into your source tree once and never overwritten.
Add business logic freely while the base stays generated.
Queries
Mark fields with @Searchable and CrudCraft generates a typed SearchRequest and JPA Specification.
Clients combine values with explicit operators—simple to read, easy to secure.
EQUALS, NOT_EQUALS, CONTAINS, STARTS_WITH, ENDS_WITH,
IN, NOT_IN, LT, LTE, GT, GTE,
BETWEEN, IS_NULL, IS_NOT_NULL, size operators and more.
We prioritize JPA Specification for broad compatibility and performance. QueryDSL can be added where it shines, but the default path stays predictable and small.
Configure how deep relations are traversed for search with crudcraft.search.depth.
Practical defaults avoid “SELECT * of the world” while keeping queries expressive.
Safety
Add constraints where they belong. Endpoint access lives in policies, row-level access in a handler, and field-level guards on DTOs. The generator emits the right glue so you can reason locally.
Select a template (e.g. FULL, READ_ONLY, NO_DELETE) and/or include/omit methods.
When secure=true, the controller is generated with @PreAuthorize expressions from your policy.
Provide a RowSecurityHandler<T> to scope reads and writes—tenant fences, ownership checks, or custom predicates/specifications that are always applied.
Use @FieldSecurity(readRoles, writeRoles) on DTO fields. Writes get filtered before persistence; reads are
redacted after mapping. The behavior is declarative and obvious in code review.
Engine
The runtime is intentionally small. Abstract base classes implement the common paths while your app stays in charge. Minimal reflection, fail-fast behavior and measured hooks result in predictable throughput.
Implements CRUD, bulk, exists/count and both full and simplified listings. It composes the generated Specification with row-security and delegates mapping to MapStruct.
Spring MVC endpoints with Pageable support and optional export. Generics are there for type safety; behavior stays boring on purpose.
Heavy lifting happens at build time. Runtime reflection is avoided on hot paths; metadata is cached; mapping is compiled. The result: quick startup and stable latency.
Data model
Keep bidirectional associations consistent and map relations to DTOs intentionally. Embedded types and enums are treated with care for accurate JSON and OpenAPI.
Generated helpers ensure child↔parent pointers remain in sync after save and before delete. Call them from service hooks for robust aggregates.
Relation fields are mapped to the appropriate DTO type automatically—full or simplified—so API shapes stay consistent across aggregates.
Embedded types become embedded DTOs and enums expose their values in OpenAPI for great DX in Swagger/clients.
Beyond CRUD
Ship the affordances real apps need: multi-record operations, count/exists probes, streaming exports and light-weight list views.
/batch/create|update|patch|delete|find|exists endpoints are available where useful. Prefer
saveAll semantics and consider per-item error reporting for large flows.
Stream exports with sensible limits to protect your app. Choose allowed formats and row caps in configuration.
Pageable endpoints with “simplified” DTO projections for list pages keep payloads small and UIs snappy.
Quality
Constraints travel with your DTOs and errors are formatted consistently so clients can recover gracefully.
Bean Validation annotations are copied to request/response DTOs, keeping invariants intact at the boundary.
A small exception handler produces consistent JSON for validation failures, not-found errors and more.
DX
The starter provides light auto-configuration and properties for search depth and export limits. Utilities and docs keep your codebase tidy as you scale.
Minimal Spring Boot auto-config (properties + exception handler). No hidden frameworks.
Tweak crudcraft.search.depth, export limits and template defaults at the application level.
A one-time copier preserves your edits; shared codegen utilities centralize naming and file I/O to avoid duplication.