eva4j 1.0.11 → 1.0.13

package/templates/crud/Controller.java.ejs

@@ -2,9 +2,11 @@ package <%= packageName %>.<%= moduleName %>.infrastructure.rest.controllers.<%=
 
 import <%= packageName %>.<%= moduleName %>.application.commands.Create<%= aggregateName %>Command;
 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.dtos.<%= aggregateName %>ResponseDto;
+import <%= packageName %>.shared.application.dtos.PagedResponse;
 import <%= packageName %>.shared.infrastructure.configurations.useCaseConfig.UseCaseMediator;
 
 import io.swagger.v3.oas.annotations.Operation;
@@ -14,8 +16,6 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.HttpStatus;
 import org.springframework.web.bind.annotation.*;
 
-import java.util.List;
-
 @RestController
 @RequestMapping("/api/<%= apiVersion %>/<%= resourceNameKebab %>")
 @Slf4j
@@ -49,10 +49,15 @@ public class <%= aggregateName %>Controller {
 
     @GetMapping
     @ResponseStatus(HttpStatus.OK)
-    @Operation(summary = "Get all <%= aggregateName %>s")
-    public List<<%= aggregateName %>ResponseDto> findAll() {
-        log.info("Finding all <%= aggregateName %>s");
-        return useCaseMediator.dispatch(new FindAll<%= aggregateName %>sQuery());
+    @Operation(summary = "Get all <%= aggregateName %>s (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={}",
+                page, size, sortBy, sortDirection);
+        return useCaseMediator.dispatch(new FindAll<%= aggregateName %>sQuery(page, size, sortBy, sortDirection));
     }
 
     @DeleteMapping("/{id}")
@@ -62,4 +67,29 @@ public class <%= aggregateName %>Controller {
         log.info("Deleting <%= aggregateName %>: {}", id);
         useCaseMediator.dispatch(new Delete<%= aggregateName %>Command(id));
     }
+
+    @PatchMapping("/{id}")
+    @ResponseStatus(HttpStatus.NO_CONTENT)
+    @Operation(summary = "Update <%= aggregateName %>")
+    public void update(
+            @PathVariable <%- idType %> id,
+            @RequestBody Update<%= aggregateName %>Command command) {
+        log.info("Updating <%= aggregateName %>: {}", id);
+        useCaseMediator.dispatch(new Update<%= aggregateName %>Command(
+                id<% if (commandFields && commandFields.length > 0) { %>,<% } %>
+<% commandFields.forEach((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((rel, idx) => { %>
+                command.<%= rel.fieldName %>()<% if (idx < oneToManyRelationships.length - 1 || (oneToOneRelationships && oneToOneRelationships.length > 0)) { %>,<% } %>
+<% }); %>
+<% } %>
+<% if (oneToOneRelationships && oneToOneRelationships.length > 0) { %>
+<% oneToOneRelationships.forEach((rel, idx) => { %>
+                command.<%= rel.fieldName %>()<% if (idx < oneToOneRelationships.length - 1) { %>,<% } %>
+<% }); %>
+<% } %>
+        ));
+    }
 }

package/templates/crud/ListQuery.java.ejs

@@ -1,9 +1,13 @@
 package <%= packageName %>.<%= moduleName %>.application.queries;
 
-import java.util.List;
 import <%= packageName %>.<%= moduleName %>.application.dtos.<%= aggregateName %>ResponseDto;
+import <%= packageName %>.shared.application.dtos.PagedResponse;
 import <%= packageName %>.shared.domain.interfaces.Query;
 
 public record FindAll<%= aggregateName %>sQuery(
-) implements Query<List<<%= aggregateName %>ResponseDto>> {
+    int page,
+    int size,
+    String sortBy,
+    String sortDirection
+) implements Query<PagedResponse<<%= aggregateName %>ResponseDto>> {
 }

package/templates/crud/ListQueryHandler.java.ejs

@@ -5,25 +5,30 @@ import <%= packageName %>.<%= moduleName %>.application.dtos.<%= aggregateName %
 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;
 
 /**
  * FindAll<%= aggregateName %>sQueryHandler
- * Handles retrieval of all <%= aggregateName %>s
+ * Handles retrieval of all <%= aggregateName %>s (paginated)
  */
 @Slf4j
 @ApplicationComponent
-public class FindAll<%= aggregateName %>sQueryHandler implements QueryHandler<FindAll<%= aggregateName %>sQuery, List<<%= aggregateName %>ResponseDto>> {
+public class FindAll<%= aggregateName %>sQueryHandler implements QueryHandler<FindAll<%= aggregateName %>sQuery, PagedResponse<<%= aggregateName %>ResponseDto>> {
 
     private final <%= aggregateName %>Repository repository;
     private final <%= aggregateName %>ApplicationMapper mapper;
 
-    public FindAll<%= aggregateName %>sQueryHandler(<%= aggregateName %>Repository repository, 
+    public FindAll<%= aggregateName %>sQueryHandler(<%= aggregateName %>Repository repository,
                                                      <%= aggregateName %>ApplicationMapper mapper) {
         this.repository = repository;
         this.mapper = mapper;
@@ -31,12 +36,21 @@ public class FindAll<%= aggregateName %>sQueryHandler implements QueryHandler<Fi
 
     @Override
     @Transactional(readOnly = true)
-    public List<<%= aggregateName %>ResponseDto> handle(FindAll<%= aggregateName %>sQuery query) {
-        log.info("Handling FindAll<%= aggregateName %>sQuery");
-        
-        List<<%= aggregateName %>> entities = repository.findAll();
-        
-        log.info("FindAll<%= aggregateName %>s retrieved - total elements: {}", entities.size());
-        return mapper.toDto(entities);
+    public PagedResponse<<%= aggregateName %>ResponseDto> handle(FindAll<%= aggregateName %>sQuery query) {
+        log.info("Handling FindAll<%= aggregateName %>sQuery — page={}, size={}, sortBy={}, sortDirection={}",
+                query.page(), query.size(), query.sortBy(), query.sortDirection());
+
+        Sort sort = Sort.by(Sort.Direction.fromString(query.sortDirection()), query.sortBy());
+        Pageable pageable = PageRequest.of(query.page(), query.size(), sort);
+
+        Page<<%= aggregateName %>> page = repository.findAll(pageable);
+        List<<%= aggregateName %>ResponseDto> content = page.getContent().stream()
+                .map(mapper::toDto)
+                .toList();
+
+        log.info("FindAll<%= aggregateName %>s retrieved — page={}/{}, totalElements={}",
+                page.getNumber() + 1, page.getTotalPages(), page.getTotalElements());
+
+        return PagedResponse.of(content, page.getNumber(), page.getSize(), page.getTotalElements());
     }
 }

package/templates/crud/UpdateCommand.java.ejs

@@ -0,0 +1,52 @@
+package <%= packageName %>.<%= moduleName %>.application.commands;
+
+import <%= packageName %>.shared.domain.interfaces.Command;
+<% if (hasValueObjects) { %>
+import <%= packageName %>.<%= moduleName %>.domain.models.valueObjects.*;
+<% } %>
+<% if (hasEnums) { %>
+import <%= packageName %>.<%= moduleName %>.domain.models.enums.*;
+<% } %>
+<% if (oneToManyRelationships && oneToManyRelationships.length > 0) { %>
+import java.util.List;
+import jakarta.validation.Valid;
+<% oneToManyRelationships.forEach(rel => { %>
+import <%= packageName %>.<%= moduleName %>.application.dtos.Create<%= rel.targetEntityName %>Dto;
+<% }); %>
+<% } %>
+<% if (oneToOneRelationships && oneToOneRelationships.length > 0) { %>
+import jakarta.validation.Valid;
+<% oneToOneRelationships.forEach(rel => { %>
+import <%= packageName %>.<%= moduleName %>.application.dtos.Create<%= rel.targetEntityName %>Dto;
+<% }); %>
+<% } %>
+<% imports.forEach(imp => { %>
+<%- imp %>
+<% }); %>
+
+/**
+ * Update<%= aggregateName %>Command — PATCH
+ *
+ * All fields except {@code id} are nullable.
+ * The handler only applies fields that are non-null,
+ * following the partial-update (PATCH) semantics.
+ */
+public record Update<%= aggregateName %>Command(
+    <%- idType %> id<% if (commandFields && commandFields.length > 0) { %>,<% } %>
+<% commandFields.forEach((field, idx) => { %>
+    <%- field.javaType %> <%= field.name %><% if (idx < commandFields.length - 1 || (oneToManyRelationships && oneToManyRelationships.length > 0) || (oneToOneRelationships && oneToOneRelationships.length > 0)) { %>,<% } %>
+<% }); %>
+<% if (oneToManyRelationships && oneToManyRelationships.length > 0) { %>
+<% oneToManyRelationships.forEach((rel, idx) => { %>
+    @Valid
+    List<Create<%= rel.targetEntityName %>Dto> <%= rel.fieldName %><% if (idx < oneToManyRelationships.length - 1 || (oneToOneRelationships && oneToOneRelationships.length > 0)) { %>,<% } %>
+<% }); %>
+<% } %>
+<% if (oneToOneRelationships && oneToOneRelationships.length > 0) { %>
+<% oneToOneRelationships.forEach((rel, idx) => { %>
+    @Valid
+    Create<%= rel.targetEntityName %>Dto <%= rel.fieldName %><% if (idx < oneToOneRelationships.length - 1) { %>,<% } %>
+<% }); %>
+<% } %>
+) implements Command {
+}

package/templates/crud/UpdateCommandHandler.java.ejs

@@ -0,0 +1,105 @@
+package <%= packageName %>.<%= moduleName %>.application.usecases;
+
+import <%= packageName %>.<%= moduleName %>.application.commands.Update<%= aggregateName %>Command;
+import <%= packageName %>.<%= moduleName %>.domain.models.entities.<%= aggregateName %>;
+import <%= packageName %>.<%= moduleName %>.domain.repositories.<%= aggregateName %>Repository;
+<% if ((commandFields || []).some(f => f.originalVoType)) { %>
+import <%= packageName %>.<%= moduleName %>.application.mappers.<%= aggregateName %>ApplicationMapper;
+<% } %>
+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;
+
+/**
+ * Update<%= aggregateName %>CommandHandler — PATCH
+ *
+ * Reconstructs the <%= aggregateName %> aggregate using the full constructor,
+ * merging each command field with the existing entity value.
+ * Non-null command fields override the current value; null fields are preserved
+ * from the loaded entity. No setters are required on the domain entity.
+ */
+@Slf4j
+@ApplicationComponent
+public class Update<%= aggregateName %>CommandHandler implements CommandHandler<Update<%= aggregateName %>Command> {
+
+    private final <%= aggregateName %>Repository repository;
+<% if ((commandFields || []).some(f => f.originalVoType)) { %>
+    private final <%= aggregateName %>ApplicationMapper mapper;
+
+    public Update<%= aggregateName %>CommandHandler(
+            <%= aggregateName %>Repository repository,
+            <%= aggregateName %>ApplicationMapper mapper) {
+        this.repository = repository;
+        this.mapper = mapper;
+    }
+<% } else { %>
+    public Update<%= aggregateName %>CommandHandler(<%= aggregateName %>Repository repository) {
+        this.repository = repository;
+    }
+<% } %>
+
+    @Override
+    @Transactional
+    public void handle(Update<%= aggregateName %>Command command) {
+        log.info("Handling Update<%= aggregateName %>Command for id: {}", command.id());
+
+        <%= aggregateName %> existing = repository
+                .findById(command.id())
+                .orElseThrow(() -> new NotFoundException("<%= aggregateName %> not found with id: " + command.id()));
+
+<%
+    // Build a lookup map: field name → commandField (with originalVoType info)
+    const cmdFieldMap = {};
+    (commandFields || []).forEach(f => { cmdFieldMap[f.name] = f; });
+
+    // oneToOneRelationships are non-collection non-inverse rels → appear in the full constructor
+    const ctorRels = oneToOneRelationships || [];
+    const totalArgs = (rootEntity.fields || []).length + ctorRels.length;
+    let argIdx = 0;
+
+    function capitalize(s) { return s.charAt(0).toUpperCase() + s.slice(1); }
+%>
+        // Merge: use command value when non-null, otherwise preserve existing value.
+        // The full constructor is called so no setters are needed on the domain entity.
+        <%= aggregateName %> updated = new <%= aggregateName %>(
+<% (rootEntity.fields || []).forEach(field => { argIdx++; %>
+<%   const cmdField = cmdFieldMap[field.name]; %>
+<%   const getter = `existing.get${capitalize(field.name)}()`; %>
+<%   const comma = argIdx < totalArgs ? ',' : ''; %>
+<%   if (cmdField && cmdField.originalVoType) { %>
+                command.<%= field.name %>() != null
+                        ? mapper.to<%= cmdField.originalVoType %>(command.<%= field.name %>())
+                        : <%= getter %><%= comma %>
+<%   } else if (cmdField) { %>
+                command.<%= field.name %>() != null ? command.<%= field.name %>() : <%= getter %><%= comma %>
+<%   } else { %>
+                <%= getter %><%= comma %> // preserved: <%= field.name %>
+<%   } %>
+<% }); %>
+<% ctorRels.forEach(rel => { argIdx++; %>
+<%   const comma = argIdx < totalArgs ? ',' : ''; %>
+                existing.get<%= capitalize(rel.fieldName) %>()<%= comma %> // preserved: <%= rel.fieldName %>
+<% }); %>
+        );
+<% if ((oneToManyRelationships || []).length > 0) { %>
+
+        // TODO: Collection relationships require an explicit replacement strategy.
+        //       Choose the right approach for your domain and uncomment:
+        //
+        //  Option A — Clear-and-replace (simple, loses existing entity ids):
+        //    existing.get<collection>().clear();
+        //    command.<collection>().forEach(dto -> entity.add<Item>(...));
+        //
+        //  Option B — Merge by id (preserves audit trail, more complex):
+        //    reconcile existing items against command items by id
+<% (oneToManyRelationships || []).forEach(rel => { %>
+        // if (command.<%= rel.fieldName %>() != null) { /* replace <%= rel.fieldName %> */ }
+<% }); %>
+<% } %>
+
+        repository.save(updated);
+        log.info("<%= aggregateName %> updated successfully with id: {}", command.id());
+    }
+}

package/templates/kafka-event/DomainEventHandlerMethod.ejs

@@ -0,0 +1 @@
+messageBroker.publish<%= eventClassName %>(new <%= eventClassName %>(<% if (domainEventFields && domainEventFields.length > 0) { domainEventFields.forEach(function(field, idx) { %>event.get<%= field.name.charAt(0).toUpperCase() + field.name.slice(1) %>()<%= idx < domainEventFields.length - 1 ? ', ' : '' %><% }); } %>));

package/templates/kafka-event/Event.java.ejs

@@ -1,10 +1,33 @@
 package <%= packageName %>.<%= moduleName %>.application.events;
+<% const needsBigDecimal = eventFields && eventFields.some(f => f.javaType === 'BigDecimal'); %>
+<% const needsLocalDate = eventFields && eventFields.some(f => f.javaType === 'LocalDate' || f.javaType === 'LocalDateTime' || f.javaType === 'LocalTime'); %>
+<% const needsUUID = eventFields && eventFields.some(f => f.javaType === 'UUID'); %>
+<% const needsList = eventFields && eventFields.some(f => f.isCollection); %>
+<% if (needsBigDecimal) { %>
+import java.math.BigDecimal;
+<% } %>
+<% if (needsLocalDate) { %>
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+<% } %>
+<% if (needsUUID) { %>
+import java.util.UUID;
+<% } %>
+<% if (needsList) { %>
+import java.util.List;
+<% } %>
 
 public record <%= eventClassName %>(
+<% if (eventFields && eventFields.length > 0) { %>
+<% eventFields.forEach((field, idx) => { %>
+  <%- field.javaType %> <%= field.name %><%= idx < eventFields.length - 1 ? ',' : '' %>
+<% }); %>
+<% } else { %>
   // TODO: Add your event fields here
   // Example:
   // Long id,
   // String name,
   // LocalDateTime createdAt
+<% } %>
 ) {
 }

package/templates/shared/application/dtos/PagedResponse.java.ejs

@@ -0,0 +1,30 @@
+package <%= packageName %>.shared.application.dtos;
+
+import java.util.List;
+
+/**
+ * Generic paginated response wrapper.
+ * Decouples API responses from Spring Data's Page internals.
+ *
+ * @param <T> the type of content elements
+ */
+public record PagedResponse<T>(
+    List<T> content,
+    int page,
+    int size,
+    long totalElements,
+    int totalPages
+) {
+
+    /**
+     * Creates a PagedResponse from Spring Data's Page object via explicit parameters.
+     */
+    public static <T> PagedResponse<T> of(
+            List<T> content,
+            int page,
+            int size,
+            long totalElements) {
+        int totalPages = size == 0 ? 1 : (int) Math.ceil((double) totalElements / size);
+        return new PagedResponse<>(content, page, size, totalElements, totalPages);
+    }
+}

package/templates/shared/configurations/temporalConfig/TemporalConfig.java.ejs

@@ -0,0 +1,104 @@
+package <%= packageName %>.shared.infrastructure.configurations.temporalConfig;
+
+import <%= packageName %>.shared.domain.interfaces.HeavyActivity;
+import <%= packageName %>.shared.domain.interfaces.LightActivity;
+import io.temporal.client.WorkflowClient;
+import io.temporal.serviceclient.WorkflowServiceStubs;
+import io.temporal.worker.Worker;
+import io.temporal.worker.WorkerFactory;
+import io.temporal.worker.WorkerOptions;
+import jakarta.annotation.PreDestroy;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import java.util.List;
+
+@Configuration
+public class TemporalConfig {
+
+    @Value("${temporal.service-url}")
+    private String temporalServiceUrl;
+
+    @Value("${temporal.namespace}")
+    private String namespace;
+
+    @Value("${temporal.flow-queue}")
+    private String flowQueue;
+
+    @Value("${temporal.number-flow-worker}")
+    private Integer numberFlowWorker;
+
+    @Value("${temporal.heavy-queue}")
+    private String heavyQueue;
+
+    @Value("${temporal.number-heavy-worker}")
+    private Integer numberHeavyWorker;
+
+    @Value("${temporal.light-queue}")
+    private String lightQueue;
+
+    @Value("${temporal.number-light-worker}")
+    private Integer numberLightWorker;
+
+    private WorkerFactory workerFactory;
+
+    @Bean
+    public WorkflowServiceStubs workflowServiceStubs() {
+        return WorkflowServiceStubs.newServiceStubs(
+            io.temporal.serviceclient.WorkflowServiceStubsOptions.newBuilder()
+                .setTarget(temporalServiceUrl)
+                .build()
+        );
+    }
+
+    @Bean
+    public WorkflowClient workflowClient(WorkflowServiceStubs serviceStubs) {
+        return WorkflowClient.newInstance(
+            serviceStubs,
+            io.temporal.client.WorkflowClientOptions.newBuilder()
+                .setNamespace(namespace)
+                .build()
+        );
+    }
+
+    @Bean
+    public WorkerFactory workerFactory(WorkflowClient client,
+                                       List<HeavyActivity> heavyActivities,
+                                       List<LightActivity> lightActivities) {
+
+        workerFactory = WorkerFactory.newInstance(client);
+
+        // 1. WORKER DE FLUJO (Orquestador)
+        WorkerOptions workflowOptions = WorkerOptions.newBuilder()
+            .setMaxConcurrentWorkflowTaskExecutionSize(numberFlowWorker)
+            .build();
+        Worker workflowWorker = workerFactory.newWorker(flowQueue, workflowOptions);
+        // TODO: register your workflow implementation types here
+        // workflowWorker.registerWorkflowImplementationTypes(MyWorkflowImpl.class);
+
+        // 2. WORKER PESADO (tareas complejas)
+        WorkerOptions heavyOptions = WorkerOptions.newBuilder()
+            .setMaxConcurrentActivityExecutionSize(numberHeavyWorker)
+            .build();
+        Worker heavyWorker = workerFactory.newWorker(heavyQueue, heavyOptions);
+        heavyWorker.registerActivitiesImplementations(heavyActivities.toArray());
+
+        // 3. WORKER LIGERO (tareas rápidas)
+        WorkerOptions lightOptions = WorkerOptions.newBuilder()
+            .setMaxConcurrentActivityExecutionSize(numberLightWorker)
+            .build();
+        Worker lightWorker = workerFactory.newWorker(lightQueue, lightOptions);
+        lightWorker.registerActivitiesImplementations(lightActivities.toArray());
+
+        workerFactory.start();
+        return workerFactory;
+    }
+
+    @PreDestroy
+    public void destroy() {
+        if (workerFactory != null) {
+            workerFactory.shutdown();
+        }
+    }
+}

package/templates/shared/domain/DomainEvent.java.ejs

@@ -0,0 +1,40 @@
+package <%= packageName %>.shared.domain;
+
+import java.time.LocalDateTime;
+import java.util.UUID;
+
+/**
+ * DomainEvent - Base class for all domain events
+ *
+ * Domain events represent facts that occurred in the business domain.
+ * They are immutable, pure Java (no Spring or infrastructure dependencies).
+ *
+ * Usage: extend this class in your domain/models/events/ classes.
+ *
+ * NOTE: For guaranteed delivery (at-least-once semantics), consider implementing
+ * the Transactional Outbox Pattern on top of this mechanism.
+ */
+public abstract class DomainEvent {
+
+    private final String eventId;
+    private final LocalDateTime occurredOn;
+    private final String aggregateId;
+
+    protected DomainEvent(String aggregateId) {
+        this.eventId = UUID.randomUUID().toString();
+        this.occurredOn = LocalDateTime.now();
+        this.aggregateId = aggregateId;
+    }
+
+    public String getEventId() {
+        return eventId;
+    }
+
+    public LocalDateTime getOccurredOn() {
+        return occurredOn;
+    }
+
+    public String getAggregateId() {
+        return aggregateId;
+    }
+}

package/templates/shared/interfaces/HeavyActivity.java.ejs

@@ -0,0 +1,4 @@
+package <%= packageName %>.shared.domain.interfaces;
+
+public interface HeavyActivity {
+}

package/templates/shared/interfaces/LightActivity.java.ejs

@@ -0,0 +1,4 @@
+package <%= packageName %>.shared.domain.interfaces;
+
+public interface LightActivity {
+}

package/templates/temporal-activity/ActivityImpl.java.ejs

@@ -0,0 +1,14 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.adapters.activities;
+
+import <%= packageName %>.<%= moduleName %>.application.ports.<%= activityPascalCase %>Activity;
+import <%= packageName %>.shared.domain.interfaces.<%= activityCategory %>;
+import org.springframework.stereotype.Component;
+
+@Component
+public class <%= activityPascalCase %>ActivityImpl implements <%= activityPascalCase %>Activity, <%= activityCategory %> {
+
+    @Override
+    public void execute(String flowId) {
+        //todo: implement the logic
+    }
+}

package/templates/temporal-activity/ActivityInterface.java.ejs

@@ -0,0 +1,11 @@
+package <%= packageName %>.<%= moduleName %>.application.ports;
+
+import io.temporal.activity.ActivityInterface;
+import io.temporal.activity.ActivityMethod;
+
+@ActivityInterface
+public interface <%= activityPascalCase %>Activity {
+
+    @ActivityMethod(name = "<%= activityPascalCase %>")
+    void execute(String flowId);
+}

package/templates/temporal-flow/WorkFlowImpl.java.ejs

@@ -0,0 +1,64 @@
+package <%= packageName %>.<%= moduleName %>.application.usecases;
+
+import io.temporal.activity.ActivityOptions;
+import io.temporal.common.RetryOptions;
+import io.temporal.workflow.Saga;
+import io.temporal.workflow.SignalMethod;
+import io.temporal.workflow.QueryMethod;
+import io.temporal.workflow.Workflow;
+
+import java.time.Duration;
+
+public class <%= flowPascalCase %>WorkFlowImpl implements <%= flowPascalCase %>WorkFlow {
+
+    private Saga.Options sagaOptions = new Saga.Options.Builder()
+        .setParallelCompensation(false)
+        .build();
+
+    private Saga saga = new Saga(sagaOptions);
+
+    private final ActivityOptions lightActivityOptions = ActivityOptions.newBuilder()
+        .setStartToCloseTimeout(Duration.ofSeconds(30))
+        .setTaskQueue("LIGHT_TASK_QUEUE")
+        .setRetryOptions(
+            RetryOptions.newBuilder()
+                .setMaximumAttempts(2)
+                .setInitialInterval(Duration.ofSeconds(1))
+                .setMaximumInterval(Duration.ofSeconds(10))
+                .setBackoffCoefficient(2.0)
+                .build()
+        ).build();
+
+    private final ActivityOptions heavyActivityOptions = ActivityOptions.newBuilder()
+        .setStartToCloseTimeout(Duration.ofSeconds(120))
+        .setTaskQueue("HEAVY_TASK_QUEUE")
+        .setRetryOptions(
+            RetryOptions.newBuilder()
+                .setMaximumAttempts(2)
+                .setInitialInterval(Duration.ofSeconds(1))
+                .setMaximumInterval(Duration.ofSeconds(10))
+                .setBackoffCoefficient(2.0)
+                .build()
+        ).build();
+
+    @Override
+    public void start(String workFlowId) {
+        try {
+            //todo: workflow logic
+        } catch (Exception e) {
+            saga.compensate();
+        }
+    }
+
+    @SignalMethod
+    @Override
+    public void confirm() {
+
+    }
+
+    @QueryMethod
+    @Override
+    public String getStatus() {
+        return "";
+    }
+}

package/templates/temporal-flow/WorkFlowInterface.java.ejs

@@ -0,0 +1,19 @@
+package <%= packageName %>.<%= moduleName %>.application.usecases;
+
+import io.temporal.workflow.QueryMethod;
+import io.temporal.workflow.SignalMethod;
+import io.temporal.workflow.WorkflowInterface;
+import io.temporal.workflow.WorkflowMethod;
+
+@WorkflowInterface
+public interface <%= flowPascalCase %>WorkFlow {
+
+    @WorkflowMethod
+    void start(String flowId);
+
+    @SignalMethod
+    void confirm();
+
+    @QueryMethod
+    String getStatus();
+}