eva4j 1.0.13 → 1.0.15

package/templates/base/root/system.yaml.ejs

@@ -0,0 +1,97 @@
+# system.yaml
+# ─────────────────────────────────────────────────────────────────────────────
+# Archivo de arquitectura del sistema — System-First Development con eva4j
+#
+# Describe qué módulos existen, qué exponen y cómo se comunican entre sí.
+# Los campos de dominio (aggregates, events, ports) se declaran en domain.yaml.
+#
+# Comandos disponibles:
+#   eva system validate  →  valida coherencia del grafo (referencias, ciclos)
+#   eva generate system  →  genera módulos + domain.yaml con endpoints: pre-generado
+#   eva system diagram   →  genera diagrama Mermaid del sistema
+# ─────────────────────────────────────────────────────────────────────────────
+
+system:
+  name: <%= projectName %>
+  groupId: <%= groupId %>
+  javaVersion: <%= javaVersion %>
+  springBootVersion: <%= springBootVersion %>
+  database: <%= databaseType %>
+
+# messaging:                           # Descomentar si el sistema usa mensajería asíncrona
+#   enabled: true
+#   broker: kafka                      # kafka | rabbitmq | sns-sqs
+#   kafka:
+#     bootstrapServers: localhost:9092
+#     defaultGroupId: <%= projectName %>
+#     topicPrefix: <%= projectName %>  # prefija todos los topics: <%= projectName %>.ORDER_PLACED
+
+modules:
+  # Declara cada módulo del sistema (nombre en plural, kebab-case).
+  # eva generate system genera por cada módulo: carpeta + domain.yaml con endpoints: pre-generado.
+  #
+  # - name: orders
+  #   description: "Gestión del ciclo de vida de pedidos"
+  #   exposes:
+  #     - method: GET
+  #       path: /orders/{id}
+  #       useCase: GetOrder            # PascalCase — alimenta endpoints: en domain.yaml
+  #       description: "Obtener pedido por ID"
+  #     - method: GET
+  #       path: /orders
+  #       useCase: FindAllOrders
+  #       description: "Listar pedidos con filtros y paginación"
+  #     - method: POST
+  #       path: /orders
+  #       useCase: CreateOrder
+  #       description: "Crear nuevo pedido"
+  #     - method: PUT
+  #       path: /orders/{id}/confirm
+  #       useCase: ConfirmOrder
+  #       description: "Confirmar pedido pendiente"
+  #     - method: PUT
+  #       path: /orders/{id}/cancel
+  #       useCase: CancelOrder
+  #       description: "Cancelar pedido (PENDING o CONFIRMED)"
+  #
+  # - name: customers
+  #   description: "Registro y gestión de clientes"
+  #   exposes:
+  #     - method: GET
+  #       path: /customers/{id}
+  #       useCase: GetCustomer
+  #       description: "Obtener cliente por ID"
+  #     - method: POST
+  #       path: /customers
+  #       useCase: CreateCustomer
+  #       description: "Registrar nuevo cliente"
+  #
+  # - name: notifications
+  #   description: "Envío de notificaciones"
+  #   # Sin endpoints REST — solo consume eventos
+
+# integrations:
+#   async:
+#     # Eventos asíncronos entre módulos.
+#     # Los campos del evento se declaran en domain.yaml → events[].fields del productor.
+#     - event: OrderPlacedEvent
+#       producer: orders
+#       topic: ORDER_PLACED
+#       consumers:
+#         - module: payments
+#         - module: notifications
+#
+#     - event: PaymentProcessedEvent
+#       producer: payments
+#       topic: PAYMENT_PROCESSED
+#       consumers:
+#         - module: orders
+#
+#   sync:
+#     # Llamadas HTTP síncronas entre módulos.
+#     # El shape del DTO de respuesta se declara en domain.yaml → ports[] del caller.
+#     - caller: orders
+#       calls: customers
+#       port: CustomerService
+#       using:
+#         - GET /customers/{id}

package/templates/crud/ApplicationMapper.java.ejs

@@ -1,6 +1,8 @@
 package <%= packageName %>.<%= moduleName %>.application.mappers;
 
+<% if (hasCreateOperation) { %>
 import <%= packageName %>.<%= moduleName %>.application.commands.Create<%= aggregateName %>Command;
+<% } %>
 import <%= packageName %>.<%= moduleName %>.application.dtos.<%= aggregateName %>ResponseDto;
 <% secondaryEntities.forEach(entity => { %>
 import <%= packageName %>.<%= moduleName %>.application.dtos.Create<%= entity.name %>Dto;
@@ -31,6 +33,7 @@ public class <%= aggregateName %>ApplicationMapper {
 
     // ========== Command to Domain Mapping ==========
     
+<% if (hasCreateOperation) { %>
     /**
      * Convert Create<%= aggregateName %>Command to <%= aggregateName %> domain entity
      */
@@ -98,6 +101,7 @@ public class <%= aggregateName %>ApplicationMapper {
 <% } %>
         return entity;
     }
+<% } %>
 <% if (oneToManyRelationships && oneToManyRelationships.length > 0) { %>
 <% oneToManyRelationships.forEach(rel => { %>
     

package/templates/crud/Controller.java.ejs

@@ -4,7 +4,7 @@ import <%= packageName %>.<%= moduleName %>.application.commands.Create<%= aggre
 import <%= packageName %>.<%= moduleName %>.application.commands.Delete<%= aggregateName %>Command;
 import <%= packageName %>.<%= moduleName %>.application.commands.Update<%= aggregateName %>Command;
 import <%= packageName %>.<%= moduleName %>.application.queries.Get<%= aggregateName %>Query;
-import <%= packageName %>.<%= moduleName %>.application.queries.FindAll<%= aggregateName %>sQuery;
+import <%= packageName %>.<%= moduleName %>.application.queries.FindAll<%= aggregateNamePlural %>Query;
 import <%= packageName %>.<%= moduleName %>.application.dtos.<%= aggregateName %>ResponseDto;
 import <%= packageName %>.shared.application.dtos.PagedResponse;
 import <%= packageName %>.shared.infrastructure.configurations.useCaseConfig.UseCaseMediator;
@@ -49,15 +49,15 @@ public class <%= aggregateName %>Controller {
 
     @GetMapping
     @ResponseStatus(HttpStatus.OK)
-    @Operation(summary = "Get all <%= aggregateName %>s (paginated)")
+    @Operation(summary = "Get all <%= aggregateNamePlural %> (paginated)")
     public PagedResponse<<%= aggregateName %>ResponseDto> findAll(
             @RequestParam(defaultValue = "0") int page,
             @RequestParam(defaultValue = "20") int size,
             @RequestParam(defaultValue = "id") String sortBy,
             @RequestParam(defaultValue = "ASC") String sortDirection) {
-        log.info("Finding all <%= aggregateName %>s — page={}, size={}, sortBy={}, sortDirection={}",
+        log.info("Finding all <%= aggregateNamePlural %> — page={}, size={}, sortBy={}, sortDirection={}",
                 page, size, sortBy, sortDirection);
-        return useCaseMediator.dispatch(new FindAll<%= aggregateName %>sQuery(page, size, sortBy, sortDirection));
+        return useCaseMediator.dispatch(new FindAll<%= aggregateNamePlural %>Query(page, size, sortBy, sortDirection));
     }
 
     @DeleteMapping("/{id}")

package/templates/crud/CreateCommand.java.ejs

@@ -1,6 +1,7 @@
 package <%= packageName %>.<%= moduleName %>.application.commands;
 
 import <%= packageName %>.shared.domain.interfaces.Command;
+import io.swagger.v3.oas.annotations.media.Schema;
 <% if (hasValueObjects) { %>
 import <%= packageName %>.<%= moduleName %>.domain.models.valueObjects.*;
 <% } %>
@@ -29,6 +30,9 @@ public record Create<%= aggregateName %>Command(
 <% (field.validationAnnotations || []).forEach(annotation => { %>
     <%- annotation %>
 <% }); %>
+<% if (field.schemaExample) { %>
+    @Schema(example = "<%= field.schemaExample %>")
+<% } %>
     <%- field.javaType %> <%= field.name %><% if (idx < commandFields.length - 1 || (oneToManyRelationships && oneToManyRelationships.length > 0) || (oneToOneRelationships && oneToOneRelationships.length > 0)) { %>,<% } %>
 <% }); %>
 <% if (oneToManyRelationships && oneToManyRelationships.length > 0) { %>

package/templates/crud/CreateItemDto.java.ejs

@@ -9,6 +9,7 @@ import <%= packageName %>.<%= moduleName %>.domain.models.enums.*;
 <% if (hasNestedRelationships || fields.some(f => f.isCollection)) { %>
 import java.util.List;
 <% } %>
+import io.swagger.v3.oas.annotations.media.Schema;
 <% imports.forEach(imp => { %>
 <%- imp %>
 <% }); %>
@@ -18,6 +19,9 @@ public record Create<%= entityName %>Dto(
 <% (field.validationAnnotations || []).forEach(annotation => { %>
     <%- annotation %>
 <% }); %>
+<% if (field.schemaExample) { %>
+    @Schema(example = "<%= field.schemaExample %>")
+<% } %>
     <%- field.javaType %> <%= field.name %><% if (idx < fields.length - 1 || hasNestedRelationships || (forwardOneToOneRels && forwardOneToOneRels.length > 0)) { %>,<% } %>
 <% }); %>
 <% if (hasNestedRelationships) { %>

package/templates/crud/CreateValueObjectDto.java.ejs

@@ -3,6 +3,7 @@ package <%= packageName %>.<%= moduleName %>.application.dtos;
 <% if (hasEnums) { %>
 import <%= packageName %>.<%= moduleName %>.domain.models.enums.*;
 <% } %>
+import io.swagger.v3.oas.annotations.media.Schema;
 <% imports.forEach(imp => { %>
 <%- imp %>
 <% }); %>
@@ -12,6 +13,9 @@ public record Create<%= voName %>Dto(
 <% (field.validationAnnotations || []).forEach(annotation => { %>
     <%- annotation %>
 <% }); %>
+<% if (field.schemaExample) { %>
+    @Schema(example = "<%= field.schemaExample %>")
+<% } %>
     <%- field.javaType %> <%= field.name %><% if (idx < fields.length - 1) { %>,<% } %>
 <% }); %>
 ) {

package/templates/crud/DeleteCommandHandler.java.ejs

@@ -2,6 +2,9 @@ package <%= packageName %>.<%= moduleName %>.application.usecases;
 
 import <%= packageName %>.<%= moduleName %>.application.commands.Delete<%= aggregateName %>Command;
 import <%= packageName %>.<%= moduleName %>.domain.repositories.<%= aggregateName %>Repository;
+<% if (hasSoftDelete) { %>
+import <%= packageName %>.<%= moduleName %>.domain.models.entities.<%= aggregateName %>;
+<% } %>
 import <%= packageName %>.shared.domain.annotations.ApplicationComponent;
 import <%= packageName %>.shared.domain.customExceptions.NotFoundException;
 import <%= packageName %>.shared.domain.interfaces.CommandHandler;
@@ -26,12 +29,17 @@ public class Delete<%= aggregateName %>CommandHandler implements CommandHandler<
     @Transactional
     public void handle(Delete<%= aggregateName %>Command command) {
         log.info("Handling Delete<%= aggregateName %>Command for id: {}", command.id());
-        
+<% if (hasSoftDelete) { %>
+        <%= aggregateName %> entity = repository.findById(command.id())
+                .orElseThrow(() -> new NotFoundException("<%= aggregateName %> not found with id: " + command.id()));
+        entity.softDelete();
+        repository.save(entity);
+<% } else { %>
         if (!repository.existsById(command.id())) {
             throw new NotFoundException("<%= aggregateName %> not found with id: " + command.id());
         }
-        
         repository.deleteById(command.id());
+<% } %>
         log.info("<%= aggregateName %> deleted successfully with id: {}", command.id());
     }
 }

package/templates/crud/EndpointsController.java.ejs

@@ -0,0 +1,178 @@
+<%
+// ── Classify operations for selective imports ────────────────────────────
+const uniqueOpsMap = new Map();
+operations.forEach(op => { if (!uniqueOpsMap.has(op.useCase)) uniqueOpsMap.set(op.useCase, op); });
+const uniqueOps = Array.from(uniqueOpsMap.values());
+
+const hasCreate      = uniqueOps.some(op => op.isStandard && op.standardType === 'create');
+const hasUpdate      = uniqueOps.some(op => op.isStandard && op.standardType === 'update');
+const hasDelete      = uniqueOps.some(op => op.isStandard && op.standardType === 'delete');
+const hasGetById     = uniqueOps.some(op => op.isStandard && op.standardType === 'getById');
+const hasFindAll     = uniqueOps.some(op => op.isStandard && op.standardType === 'findAll');
+const hasTransition  = uniqueOps.some(op => op.classifiedType === 'transition');
+const hasSubAdd      = uniqueOps.some(op => op.classifiedType === 'subEntityAdd');
+const hasSubRemove   = uniqueOps.some(op => op.classifiedType === 'subEntityRemove');
+const hasFindBy      = uniqueOps.some(op => op.classifiedType === 'findBy');
+
+const transitionOps  = uniqueOps.filter(op => op.classifiedType === 'transition');
+const subAddOps      = uniqueOps.filter(op => op.classifiedType === 'subEntityAdd');
+const subRemoveOps   = uniqueOps.filter(op => op.classifiedType === 'subEntityRemove');
+const findByOps      = uniqueOps.filter(op => op.classifiedType === 'findBy');
+const customCmdUCs   = uniqueOps.filter(op => op.classifiedType === 'scaffold' && op.type !== 'query');
+const customQueryUCs = uniqueOps.filter(op => op.classifiedType === 'scaffold' && op.type === 'query');
+-%>
+package <%= packageName %>.<%= moduleName %>.infrastructure.rest.controllers.<%= resourceNameCamel %>.<%= apiVersion %>;
+
+<% if (hasCreate) { -%>
+import <%= packageName %>.<%= moduleName %>.application.commands.Create<%= aggregateName %>Command;
+<% } -%>
+<% if (hasUpdate) { -%>
+import <%= packageName %>.<%= moduleName %>.application.commands.Update<%= aggregateName %>Command;
+<% } -%>
+<% if (hasDelete) { -%>
+import <%= packageName %>.<%= moduleName %>.application.commands.Delete<%= aggregateName %>Command;
+<% } -%>
+<% if (hasGetById) { -%>
+import <%= packageName %>.<%= moduleName %>.application.queries.Get<%= aggregateName %>Query;
+<% } -%>
+<% if (hasFindAll) { -%>
+import <%= packageName %>.<%= moduleName %>.application.queries.FindAll<%= aggregateNamePlural %>Query;
+<% } -%>
+<% customCmdUCs.forEach(function(op) { -%>
+import <%= packageName %>.<%= moduleName %>.application.commands.<%= op.useCase %>Command;
+<% }); -%>
+<% customQueryUCs.forEach(function(op) { -%>
+import <%= packageName %>.<%= moduleName %>.application.queries.<%= op.useCase %>Query;
+<% }); -%>
+<% transitionOps.forEach(function(op) { -%>
+import <%= packageName %>.<%= moduleName %>.application.commands.<%= op.useCase %>Command;
+<% }); -%>
+<% subAddOps.forEach(function(op) { -%>
+import <%= packageName %>.<%= moduleName %>.application.commands.<%= op.useCase %>Command;
+<% }); -%>
+<% subRemoveOps.forEach(function(op) { -%>
+import <%= packageName %>.<%= moduleName %>.application.commands.<%= op.useCase %>Command;
+<% }); -%>
+<% findByOps.forEach(function(op) { -%>
+import <%= packageName %>.<%= moduleName %>.application.queries.<%= op.useCase %>Query;
+<% }); -%>
+<% if (hasGetById || hasFindAll || hasFindBy || customQueryUCs.length > 0) { -%>
+import <%= packageName %>.<%= moduleName %>.application.dtos.<%= aggregateName %>ResponseDto;
+<% } -%>
+<% if (hasFindAll || hasFindBy) { -%>
+import <%= packageName %>.shared.application.dtos.PagedResponse;
+<% } -%>
+import <%= packageName %>.shared.infrastructure.configurations.useCaseConfig.UseCaseMediator;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/api/<%= apiVersion %><%= basePath %>")
+@Slf4j
+@Tag(name = "<%= aggregateName %>", description = "<%= aggregateName %> Management API")
+public class <%= controllerName %> {
+
+    private final UseCaseMediator useCaseMediator;
+
+    public <%= controllerName %>(UseCaseMediator useCaseMediator) {
+        this.useCaseMediator = useCaseMediator;
+    }
+<% operations.forEach(function(op) { %>
+    /**
+     * <%= op.description || op.useCase %>
+     */
+    @<%- op.httpAnnotation %>(<% if (op.path && op.path !== '/') { %>"<%= op.path %>"<% } %>)
+    @ResponseStatus(<%= op.httpStatus %>)
+    @Operation(summary = "<%= op.description || op.useCase %>")
+<%  if (op.isStandard && op.standardType === 'create') { %>
+    public void <%= op.methodName %>(@Valid @RequestBody Create<%= aggregateName %>Command command) {
+        log.info("Creating <%= aggregateName %>: {}", command);
+        useCaseMediator.dispatch(command);
+    }
+<%  } else if (op.isStandard && op.standardType === 'getById') { %>
+    public <%= aggregateName %>ResponseDto <%= op.methodName %>(@PathVariable <%- idType %> id) {
+        log.info("Finding <%= aggregateName %> by id: {}", id);
+        return useCaseMediator.dispatch(new Get<%= aggregateName %>Query(id));
+    }
+<%  } else if (op.isStandard && op.standardType === 'findAll') { %>
+    public PagedResponse<<%= aggregateName %>ResponseDto> <%= op.methodName %>(
+            @RequestParam(defaultValue = "0") int page,
+            @RequestParam(defaultValue = "20") int size,
+            @RequestParam(defaultValue = "id") String sortBy,
+            @RequestParam(defaultValue = "ASC") String sortDirection) {
+        log.info("Finding all <%= aggregateNamePlural %> — page={}, size={}, sortBy={}, sortDirection={}",
+                page, size, sortBy, sortDirection);
+        return useCaseMediator.dispatch(new FindAll<%= aggregateNamePlural %>Query(page, size, sortBy, sortDirection));
+    }
+<%  } else if (op.isStandard && op.standardType === 'delete') { %>
+    public void <%= op.methodName %>(@PathVariable <%- idType %> id) {
+        log.info("Deleting <%= aggregateName %> id: {}", id);
+        useCaseMediator.dispatch(new Delete<%= aggregateName %>Command(id));
+    }
+<%  } else if (op.isStandard && op.standardType === 'update') { %>
+    public void <%= op.methodName %>(
+            @PathVariable <%- idType %> id,
+            @RequestBody Update<%= aggregateName %>Command command) {
+        log.info("Updating <%= aggregateName %> id: {}", id);
+        useCaseMediator.dispatch(new Update<%= aggregateName %>Command(
+                id<% if (commandFields && commandFields.length > 0) { %>,<% } %>
+<% (commandFields || []).forEach(function(field, idx) { %>
+                command.<%= field.name %>()<% if (idx < commandFields.length - 1 || (oneToManyRelationships && oneToManyRelationships.length > 0) || (oneToOneRelationships && oneToOneRelationships.length > 0)) { %>,<% } %>
+<% }); %>
+<% if (oneToManyRelationships && oneToManyRelationships.length > 0) { %>
+<% oneToManyRelationships.forEach(function(rel, idx) { %>
+                command.<%= rel.fieldName %>()<% if (idx < oneToManyRelationships.length - 1 || (oneToOneRelationships && oneToOneRelationships.length > 0)) { %>,<% } %>
+<% }); %>
+<% } %>
+<% if (oneToOneRelationships && oneToOneRelationships.length > 0) { %>
+<% oneToOneRelationships.forEach(function(rel, idx) { %>
+                command.<%= rel.fieldName %>()<% if (idx < oneToOneRelationships.length - 1) { %>,<% } %>
+<% }); %>
+<% } %>
+        ));
+    }
+<%  } else if (op.classifiedType === 'transition') { %>
+    public void <%= op.methodName %>(@PathVariable <%- op.idType %> id) {
+        log.info("Handling <%= op.useCase %> for <%= aggregateName %> id: {}", id);
+        useCaseMediator.dispatch(new <%= op.useCase %>Command(id));
+    }
+<%  } else if (op.classifiedType === 'subEntityAdd') { %>
+    public void <%= op.methodName %>(@PathVariable <%- op.idType %> id, @Valid @RequestBody <%= op.useCase %>Command command) {
+        log.info("Handling <%= op.useCase %> for <%= aggregateName %> id: {}", id);
+        useCaseMediator.dispatch(new <%= op.useCase %>Command(id<% if (op.classification && op.classification.entityFields && op.classification.entityFields.length > 0) { %>, <% op.classification.entityFields.forEach(function(f, idx) { %>command.<%= f.name %>()<% if (idx < op.classification.entityFields.length - 1) { %>, <% } %><% }); %><% } %>));
+    }
+<%  } else if (op.classifiedType === 'subEntityRemove') { %>
+    public void <%= op.methodName %>(@PathVariable <%- op.idType %> id, @PathVariable String itemId) {
+        log.info("Handling <%= op.useCase %> for <%= aggregateName %> id: {}, itemId: {}", id, itemId);
+        useCaseMediator.dispatch(new <%= op.useCase %>Command(id, itemId));
+    }
+<%  } else if (op.classifiedType === 'findBy') { %>
+    public PagedResponse<<%= aggregateName %>ResponseDto> <%= op.methodName %>(
+            @RequestParam <%- op.classification.fieldJavaType %> <%= op.classification.fieldName %>,
+            @RequestParam(defaultValue = "0") int page,
+            @RequestParam(defaultValue = "20") int size,
+            @RequestParam(defaultValue = "id") String sortBy,
+            @RequestParam(defaultValue = "ASC") String sortDirection) {
+        log.info("Handling <%= op.useCase %> — <%= op.classification.fieldName %>={}, page={}, size={}", <%= op.classification.fieldName %>, page, size);
+        return useCaseMediator.dispatch(new <%= op.useCase %>Query(<%= op.classification.fieldName %>, page, size, sortBy, sortDirection));
+    }
+<%  } else if (op.type === 'command') { %>
+    // TODO: Review the fields declared in <%= op.useCase %>Command and adapt the method signature if needed
+    public void <%= op.methodName %>(<% if (op.hasPathVar) { %>@PathVariable <%- op.idType %> <%= op.pathVarName %>, <% } %>@Valid @RequestBody <%= op.useCase %>Command command) {
+        log.info("Handling <%= op.useCase %>: {}", command);
+        useCaseMediator.dispatch(command);
+    }
+<%  } else { %>
+    // TODO: Review the parameters in <%= op.useCase %>Query and adapt the return type if needed
+    public <%- op.returnType %> <%= op.methodName %>(<% if (op.hasPathVar) { %>@PathVariable <%- op.idType %> <%= op.pathVarName %><% } %>) {
+        log.info("Handling <%= op.useCase %>");
+        return useCaseMediator.dispatch(new <%= op.useCase %>Query(<% if (op.hasPathVar) { %><%= op.pathVarName %><% } %>));
+    }
+<%  } -%>
+<% }); %>
+}

package/templates/crud/FindByQuery.java.ejs

@@ -0,0 +1,17 @@
+package <%= packageName %>.<%= moduleName %>.application.queries;
+
+import <%= packageName %>.shared.domain.interfaces.Query;
+import <%= packageName %>.shared.application.dtos.PagedResponse;
+import <%= packageName %>.<%= moduleName %>.application.dtos.<%= aggregateName %>ResponseDto;
+
+/**
+ * <%= useCaseName %>Query
+ * Returns a paginated list of <%= aggregateNamePlural %> filtered by <%= fieldName %>.
+ */
+public record <%= useCaseName %>Query(
+        <%- fieldJavaType %> <%= fieldName %>,
+        int page,
+        int size,
+        String sortBy,
+        String sortDirection
+) implements Query<PagedResponse<<%= aggregateName %>ResponseDto>> {}

package/templates/crud/FindByQueryHandler.java.ejs

@@ -0,0 +1,57 @@
+package <%= packageName %>.<%= moduleName %>.application.usecases;
+
+import <%= packageName %>.<%= moduleName %>.application.queries.<%= useCaseName %>Query;
+import <%= packageName %>.<%= moduleName %>.application.dtos.<%= aggregateName %>ResponseDto;
+import <%= packageName %>.<%= moduleName %>.application.mappers.<%= aggregateName %>ApplicationMapper;
+import <%= packageName %>.<%= moduleName %>.domain.models.entities.<%= aggregateName %>;
+import <%= packageName %>.<%= moduleName %>.domain.repositories.<%= aggregateName %>Repository;
+import <%= packageName %>.shared.application.dtos.PagedResponse;
+import <%= packageName %>.shared.domain.annotations.ApplicationComponent;
+import <%= packageName %>.shared.domain.interfaces.QueryHandler;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+/**
+ * <%= useCaseName %>QueryHandler
+ * Returns paginated <%= aggregateNamePlural %> filtered by <%= fieldName %>.
+ * Calls repository.<%= jpaMethodName %>(<%= fieldName %>, pageable).
+ */
+@Slf4j
+@ApplicationComponent
+public class <%= useCaseName %>QueryHandler implements QueryHandler<<%= useCaseName %>Query, PagedResponse<<%= aggregateName %>ResponseDto>> {
+
+    private final <%= aggregateName %>Repository repository;
+    private final <%= aggregateName %>ApplicationMapper mapper;
+
+    public <%= useCaseName %>QueryHandler(<%= aggregateName %>Repository repository,
+                                           <%= aggregateName %>ApplicationMapper mapper) {
+        this.repository = repository;
+        this.mapper = mapper;
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public PagedResponse<<%= aggregateName %>ResponseDto> handle(<%= useCaseName %>Query query) {
+        log.info("Handling <%= useCaseName %>Query — <%= fieldName %>={}, page={}, size={}",
+                query.<%= fieldName %>(), query.page(), query.size());
+
+        Sort sort = Sort.by(Sort.Direction.fromString(query.sortDirection()), query.sortBy());
+        Pageable pageable = PageRequest.of(query.page(), query.size(), sort);
+
+        Page<<%= aggregateName %>> page = repository.<%= jpaMethodName %>(query.<%= fieldName %>(), pageable);
+        List<<%= aggregateName %>ResponseDto> content = page.getContent().stream()
+                .map(mapper::toDto)
+                .toList();
+
+        log.info("<%= useCaseName %> retrieved — page={}/{}, totalElements={}",
+                page.getNumber() + 1, page.getTotalPages(), page.getTotalElements());
+
+        return PagedResponse.of(content, page.getNumber(), page.getSize(), page.getTotalElements());
+    }
+}

package/templates/crud/ListQuery.java.ejs

@@ -4,7 +4,7 @@ import <%= packageName %>.<%= moduleName %>.application.dtos.<%= aggregateName %
 import <%= packageName %>.shared.application.dtos.PagedResponse;
 import <%= packageName %>.shared.domain.interfaces.Query;
 
-public record FindAll<%= aggregateName %>sQuery(
+public record FindAll<%= aggregateNamePlural %>Query(
     int page,
     int size,
     String sortBy,

package/templates/crud/ListQueryHandler.java.ejs

@@ -1,6 +1,6 @@
 package <%= packageName %>.<%= moduleName %>.application.usecases;
 
-import <%= packageName %>.<%= moduleName %>.application.queries.FindAll<%= aggregateName %>sQuery;
+import <%= packageName %>.<%= moduleName %>.application.queries.FindAll<%= aggregateNamePlural %>Query;
 import <%= packageName %>.<%= moduleName %>.application.dtos.<%= aggregateName %>ResponseDto;
 import <%= packageName %>.<%= moduleName %>.application.mappers.<%= aggregateName %>ApplicationMapper;
 import <%= packageName %>.<%= moduleName %>.domain.models.entities.<%= aggregateName %>;
@@ -18,17 +18,17 @@ import org.springframework.transaction.annotation.Transactional;
 import java.util.List;
 
 /**
- * FindAll<%= aggregateName %>sQueryHandler
- * Handles retrieval of all <%= aggregateName %>s (paginated)
+ * FindAll<%= aggregateNamePlural %>QueryHandler
+ * Handles retrieval of all <%= aggregateNamePlural %> (paginated)
  */
 @Slf4j
 @ApplicationComponent
-public class FindAll<%= aggregateName %>sQueryHandler implements QueryHandler<FindAll<%= aggregateName %>sQuery, PagedResponse<<%= aggregateName %>ResponseDto>> {
+public class FindAll<%= aggregateNamePlural %>QueryHandler implements QueryHandler<FindAll<%= aggregateNamePlural %>Query, PagedResponse<<%= aggregateName %>ResponseDto>> {
 
     private final <%= aggregateName %>Repository repository;
     private final <%= aggregateName %>ApplicationMapper mapper;
 
-    public FindAll<%= aggregateName %>sQueryHandler(<%= aggregateName %>Repository repository,
+    public FindAll<%= aggregateNamePlural %>QueryHandler(<%= aggregateName %>Repository repository,
                                                      <%= aggregateName %>ApplicationMapper mapper) {
         this.repository = repository;
         this.mapper = mapper;
@@ -36,8 +36,8 @@ public class FindAll<%= aggregateName %>sQueryHandler implements QueryHandler<Fi
 
     @Override
     @Transactional(readOnly = true)
-    public PagedResponse<<%= aggregateName %>ResponseDto> handle(FindAll<%= aggregateName %>sQuery query) {
-        log.info("Handling FindAll<%= aggregateName %>sQuery — page={}, size={}, sortBy={}, sortDirection={}",
+    public PagedResponse<<%= aggregateName %>ResponseDto> handle(FindAll<%= aggregateNamePlural %>Query query) {
+        log.info("Handling FindAll<%= aggregateNamePlural %>Query — page={}, size={}, sortBy={}, sortDirection={}",
                 query.page(), query.size(), query.sortBy(), query.sortDirection());
 
         Sort sort = Sort.by(Sort.Direction.fromString(query.sortDirection()), query.sortBy());
@@ -48,7 +48,7 @@ public class FindAll<%= aggregateName %>sQueryHandler implements QueryHandler<Fi
                 .map(mapper::toDto)
                 .toList();
 
-        log.info("FindAll<%= aggregateName %>s retrieved — page={}/{}, totalElements={}",
+        log.info("FindAll<%= aggregateNamePlural %> retrieved — page={}/{}, totalElements={}",
                 page.getNumber() + 1, page.getTotalPages(), page.getTotalElements());
 
         return PagedResponse.of(content, page.getNumber(), page.getSize(), page.getTotalElements());

package/templates/crud/ScaffoldCommand.java.ejs

@@ -0,0 +1,12 @@
+package <%= packageName %>.<%= moduleName %>.application.commands;
+
+import <%= packageName %>.shared.domain.interfaces.Command;
+
+/**
+ * <%= useCaseName %>Command
+ * TODO: Add the fields required by this use case and remove the placeholder.
+ */
+public record <%= useCaseName %>Command(
+        // TODO: Replace with actual command fields
+        String id
+) implements Command {}

package/templates/crud/ScaffoldCommandHandler.java.ejs

@@ -0,0 +1,43 @@
+package <%= packageName %>.<%= moduleName %>.application.usecases;
+
+import <%= packageName %>.<%= moduleName %>.application.commands.<%= useCaseName %>Command;
+import <%= packageName %>.<%= moduleName %>.domain.repositories.<%= aggregateName %>Repository;
+import <%= packageName %>.shared.domain.annotations.ApplicationComponent;
+import <%= packageName %>.shared.domain.interfaces.CommandHandler;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * <%= useCaseName %>CommandHandler
+ * TODO: Implement the business logic for the use case "<%= useCaseName %>".
+ *
+ * Suggested steps:
+ *   1. Find the aggregate root by ID via repository
+ *   2. Call the appropriate domain method (e.g. entity.someBusinessMethod())
+ *   3. Persist the result via repository.save(entity)
+ */
+@Slf4j
+@ApplicationComponent
+public class <%= useCaseName %>CommandHandler implements CommandHandler<<%= useCaseName %>Command> {
+
+    private final <%= aggregateName %>Repository repository;
+
+    public <%= useCaseName %>CommandHandler(<%= aggregateName %>Repository repository) {
+        this.repository = repository;
+    }
+
+    @Override
+    @Transactional
+    public void handle(<%= useCaseName %>Command command) {
+        log.info("Handling <%= useCaseName %>Command: {}", command);
+
+        // TODO: Implement business logic
+        // Example:
+        // <%= aggregateName %> entity = repository.findById(command.id())
+        //         .orElseThrow(() -> new EntityNotFoundException("<%= aggregateName %> not found"));
+        // entity.someBusinessMethod();
+        // repository.save(entity);
+
+        throw new UnsupportedOperationException("<%= useCaseName %> not yet implemented");
+    }
+}

package/templates/crud/ScaffoldQuery.java.ejs

@@ -0,0 +1,13 @@
+package <%= packageName %>.<%= moduleName %>.application.queries;
+
+import <%= packageName %>.<%= moduleName %>.application.dtos.<%= aggregateName %>ResponseDto;
+import <%= packageName %>.shared.domain.interfaces.Query;
+
+/**
+ * <%= useCaseName %>Query
+ * TODO: Add the parameters required by this query and adapt the return type if needed.
+ */
+public record <%= useCaseName %>Query(
+        // TODO: Replace with actual query parameters
+        String id
+) implements Query<<%= aggregateName %>ResponseDto> {}