Repo: https://github.com/mzivkovicdev/spring-crud-generator

This release focuses on making generated projects feel more “production-ready” out of the box: field-level validation, more reliable Redis caching, and better compatibility with Spring Boot 3 and Spring Boot 4. It also improves behavior when OSIV (Open Session in View) is disabled by generating resources that use EntityGraph where needed, avoiding common lazy-loading pitfalls.

What’s new in v1.1.0

Field-level validation in YAML (fields.validation)

You can now define common validation rules directly in your YAML spec and get generated validation annotations in the right place (DTO/request layer), including regex-based constraints via pattern.

Why this matters:

• validation rules live next to your model definition (single source of truth)

• generated APIs fail fast with clear 400 responses instead of leaking issues deeper into the stack

• less repetitive boilerplate for request validation

Supported examples include required, email, pattern (regex), min, max etc.

Caching fixes (correct @Cacheable(value=...))

Caching was previously easy to misconfigure in generated code due to incorrect @Cacheable(value = ...) values. This version fixes the generated cache names so caching behaves consistently across resources.

Why this matters:

• wrong cache names = cache misses (no benefit) or collisions (hard-to-debug behavior)

• consistent naming makes it easier to monitor and invalidate caches correctly

Redis improvement: safer caching with Hibernate lazy loading

Redis caching is improved by adding HibernateLazyNullModule, which makes serialization safer around Hibernate proxies and lazy-loaded associations.

Why this matters:

• caching entities/DTOs can blow up when lazy fields are involved (serialization issues, unexpected proxy handling, etc.)

• this reduces “works locally, breaks in prod” surprises when Redis is enabled and your domain model has lazily loaded relationships

OSIV config + EntityGraph support (OSIV default: false)

This release introduces:

• additionalProperties.spring.jpa.open-in-view (default: false)

• EntityGraph support in generated resources when OSIV is disabled

Why this matters:

• many teams disable OSIV to avoid hidden DB access during serialization and to keep boundaries clean

• once OSIV is off, naive lazy loading can cause LazyInitializationException

• EntityGraph helps fetch what’s needed explicitly during the service/repository call instead of during JSON serialization

Highlights

• Field validation (fields.validation): configure common validation rules directly in YAML (including regex via pattern).

• Caching fixes: corrected generated @Cacheable(value=...) values.

• Redis improvement: added HibernateLazyNullModule for safer caching with Hibernate lazy loading.

• OSIV config: additionalProperties.spring.jpa.open-in-view (default: false), with EntityGraph support when OSIV is off.

• Stability: docs/tests updated, refactoring, and an NPE fix when min/max are not provided.

Short YAML example

configuration:
  database: postgresql
  javaVersion: 21
  springBootVersion: 4
  cache:
    enabled: true
    type: REDIS
    expiration: 10
  additionalProperties:
    spring.jpa.open-in-view: false
entities:
  - name: UserEntity
    storageName: user_table
    fields:
      - name: id
        type: Long
        id:
          strategy: IDENTITY
      - name: email
        type: String
        validation:
          required: true
          email: true
      - name: password
        type: String
        validation:
          required: true
          pattern: "^(?=.*[A-Za-z])(?=.*\\d)[A-Za-z\\d]{8,}$"

The repository contains an updated full CRUD spec YAML reference example with all supported options.

What this generates (high-level)

• CRUD layers (entities, transfer objects, repositories, services, mappers and controllers)

• validation annotations for request fields (e.g. @NotBlank, @Email, @Pattern)

• Redis caching wired via Spring Cache abstraction, with corrected cache names

• when OSIV is off, generated repository/service methods use EntityGraph patterns to fetch required relations safely

If you try v1.1.0, feedback is welcome. If you find the project useful, I’d really appreciate a star on the repo — it helps a lot:
https://github.com/mzivkovicdev/spring-crud-generator