eva4j 1.0.13 → 1.0.14

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<%= aggregateName %>sQuery;
+<% } -%>
+<% 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) { -%>
+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 <%= aggregateName %>s — page={}, size={}, sortBy={}, sortDirection={}",
+                page, size, sortBy, sortDirection);
+        return useCaseMediator.dispatch(new FindAll<%= aggregateName %>sQuery(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 replace Object with the actual return type
+    public Object <%= 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 <%= aggregateName %>s 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 <%= aggregateName %>s 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/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,12 @@
+package <%= packageName %>.<%= moduleName %>.application.queries;
+
+import <%= packageName %>.shared.domain.interfaces.Query;
+
+/**
+ * <%= useCaseName %>Query
+ * TODO: Add the parameters required by this query and replace the return type placeholder.
+ */
+public record <%= useCaseName %>Query(
+        // TODO: Replace with actual query parameters
+        String id
+) implements Query<Object> {}

package/templates/crud/ScaffoldQueryHandler.java.ejs

@@ -0,0 +1,40 @@
+package <%= packageName %>.<%= moduleName %>.application.usecases;
+
+import <%= packageName %>.<%= moduleName %>.application.queries.<%= useCaseName %>Query;
+import <%= packageName %>.<%= moduleName %>.domain.repositories.<%= aggregateName %>Repository;
+import <%= packageName %>.shared.domain.annotations.ApplicationComponent;
+import <%= packageName %>.shared.domain.interfaces.QueryHandler;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * <%= useCaseName %>QueryHandler
+ * TODO: Implement the query logic for "<%= useCaseName %>".
+ *
+ * Suggested steps:
+ *   1. Read parameters from the query record
+ *   2. Retrieve data from the repository
+ *   3. Map the result to a DTO and return it
+ */
+@Slf4j
+@ApplicationComponent
+public class <%= useCaseName %>QueryHandler implements QueryHandler<<%= useCaseName %>Query, Object> {
+
+    private final <%= aggregateName %>Repository repository;
+
+    public <%= useCaseName %>QueryHandler(<%= aggregateName %>Repository repository) {
+        this.repository = repository;
+    }
+
+    @Override
+    public Object handle(<%= useCaseName %>Query query) {
+        log.info("Handling <%= useCaseName %>Query: {}", query);
+
+        // TODO: Implement query logic
+        // Example:
+        // return repository.findById(query.id())
+        //         .map(mapper::toDto)
+        //         .orElseThrow(() -> new EntityNotFoundException("<%= aggregateName %> not found"));
+
+        throw new UnsupportedOperationException("<%= useCaseName %> not yet implemented");
+    }
+}

package/templates/crud/SubEntityAddCommand.java.ejs

@@ -0,0 +1,17 @@
+package <%= packageName %>.<%= moduleName %>.application.commands;
+
+<% (imports || []).forEach(imp => { %>
+<%- imp %>
+<% }); %>
+import <%= packageName %>.shared.domain.interfaces.Command;
+
+/**
+ * <%= useCaseName %>Command
+ * Adds a new <%= entityName %> to the <%= aggregateName %> aggregate.
+ */
+public record <%= useCaseName %>Command(
+        <%- idType %> id<% if (entityFields && entityFields.length > 0) { %>,<% } %>
+<% (entityFields || []).forEach(function(field, idx) { %>
+        <%- field.javaType %> <%= field.name %><% if (idx < entityFields.length - 1) { %>,<% } %>
+<% }); %>
+) implements Command {}

package/templates/crud/SubEntityAddCommandHandler.java.ejs

@@ -0,0 +1,43 @@
+package <%= packageName %>.<%= moduleName %>.application.usecases;
+
+import <%= packageName %>.<%= moduleName %>.application.commands.<%= useCaseName %>Command;
+import <%= packageName %>.<%= moduleName %>.domain.models.entities.<%= aggregateName %>;
+import <%= packageName %>.<%= moduleName %>.domain.models.entities.<%= entityName %>;
+import <%= packageName %>.<%= moduleName %>.domain.repositories.<%= aggregateName %>Repository;
+import <%= packageName %>.shared.domain.annotations.ApplicationComponent;
+import <%= packageName %>.shared.domain.customExceptions.NotFoundException;
+import <%= packageName %>.shared.domain.interfaces.CommandHandler;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * <%= useCaseName %>CommandHandler
+ * Loads the <%= aggregateName %> aggregate and adds a new <%= entityName %> to it.
+ *
+ * The aggregate root must expose: <%= addMethodName %>(<%= entityName %> item)
+ */
+@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 for <%= aggregateName %> id: {}", command.id());
+
+        <%= aggregateName %> entity = repository.findById(command.id())
+                .orElseThrow(() -> new NotFoundException("<%= aggregateName %> not found with id: " + command.id()));
+
+        <%= entityName %> item = new <%= entityName %>(<% (entityFields || []).forEach(function(field, idx) { %>command.<%= field.name %>()<% if (idx < entityFields.length - 1) { %>, <% } %><% }); %>);
+        entity.<%= addMethodName %>(item);
+        repository.save(entity);
+
+        log.info("<%= entityName %> added to <%= aggregateName %> id: {}", command.id());
+    }
+}

package/templates/crud/SubEntityRemoveCommand.java.ejs

@@ -0,0 +1,9 @@
+package <%= packageName %>.<%= moduleName %>.application.commands;
+
+import <%= packageName %>.shared.domain.interfaces.Command;
+
+/**
+ * <%= useCaseName %>Command
+ * Removes the <%= entityName %> identified by itemId from the <%= aggregateName %> aggregate.
+ */
+public record <%= useCaseName %>Command(<%- idType %> id, String itemId) implements Command {}

package/templates/crud/SubEntityRemoveCommandHandler.java.ejs

@@ -0,0 +1,42 @@
+package <%= packageName %>.<%= moduleName %>.application.usecases;
+
+import <%= packageName %>.<%= moduleName %>.application.commands.<%= useCaseName %>Command;
+import <%= packageName %>.<%= moduleName %>.domain.models.entities.<%= aggregateName %>;
+import <%= packageName %>.<%= moduleName %>.domain.repositories.<%= aggregateName %>Repository;
+import <%= packageName %>.shared.domain.annotations.ApplicationComponent;
+import <%= packageName %>.shared.domain.customExceptions.NotFoundException;
+import <%= packageName %>.shared.domain.interfaces.CommandHandler;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * <%= useCaseName %>CommandHandler
+ * Loads the <%= aggregateName %> aggregate and removes the <%= entityName %> by itemId.
+ *
+ * The aggregate root must expose: <%= removeMethodName %>(String itemId)
+ */
+@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 for <%= aggregateName %> id: {}, itemId: {}",
+                command.id(), command.itemId());
+
+        <%= aggregateName %> entity = repository.findById(command.id())
+                .orElseThrow(() -> new NotFoundException("<%= aggregateName %> not found with id: " + command.id()));
+
+        entity.<%= removeMethodName %>(command.itemId());
+        repository.save(entity);
+
+        log.info("<%= entityName %> id: {} removed from <%= aggregateName %> id: {}", command.itemId(), command.id());
+    }
+}

package/templates/crud/TransitionCommand.java.ejs

@@ -0,0 +1,9 @@
+package <%= packageName %>.<%= moduleName %>.application.commands;
+
+import <%= packageName %>.shared.domain.interfaces.Command;
+
+/**
+ * <%= useCaseName %>Command
+ * Triggers the '<%= domainMethod %>' state transition on the <%= aggregateName %> aggregate.
+ */
+public record <%= useCaseName %>Command(<%- idType %> id) implements Command {}

package/templates/crud/TransitionCommandHandler.java.ejs

@@ -0,0 +1,39 @@
+package <%= packageName %>.<%= moduleName %>.application.usecases;
+
+import <%= packageName %>.<%= moduleName %>.application.commands.<%= useCaseName %>Command;
+import <%= packageName %>.<%= moduleName %>.domain.models.entities.<%= aggregateName %>;
+import <%= packageName %>.<%= moduleName %>.domain.repositories.<%= aggregateName %>Repository;
+import <%= packageName %>.shared.domain.annotations.ApplicationComponent;
+import <%= packageName %>.shared.domain.customExceptions.NotFoundException;
+import <%= packageName %>.shared.domain.interfaces.CommandHandler;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * <%= useCaseName %>CommandHandler
+ * Loads the <%= aggregateName %> aggregate and calls entity.<%= domainMethod %>() to execute the transition.
+ */
+@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 for id: {}", command.id());
+
+        <%= aggregateName %> entity = repository.findById(command.id())
+                .orElseThrow(() -> new NotFoundException("<%= aggregateName %> not found with id: " + command.id()));
+
+        entity.<%= domainMethod %>();
+        repository.save(entity);
+
+        log.info("<%= aggregateName %> id: {} transitioned via <%= domainMethod %>()", command.id());
+    }
+}