eva4j 1.0.17 → 1.0.18

package/templates/shared/configurations/rabbitmqConfig/RabbitMQConfig.java.ejs

@@ -0,0 +1,100 @@
+package <%= packageName %>.shared.infrastructure.configurations.rabbitmqConfig;
+
+import org.springframework.amqp.core.*;
+import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
+import org.springframework.amqp.rabbit.connection.ConnectionFactory;
+import org.springframework.amqp.rabbit.core.RabbitAdmin;
+import org.springframework.amqp.rabbit.core.RabbitTemplate;
+import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
+import org.springframework.amqp.support.converter.MessageConverter;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.ApplicationRunner;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.amqp.rabbit.annotation.EnableRabbit;
+import org.springframework.retry.backoff.ExponentialBackOffPolicy;
+import org.springframework.retry.policy.SimpleRetryPolicy;
+import org.springframework.retry.support.RetryTemplate;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+@Configuration
+@EnableRabbit
+public class RabbitMQConfig {
+
+  private static final Logger log = LoggerFactory.getLogger(RabbitMQConfig.class);
+
+  @Value("${spring.rabbitmq.listener.simple.retry.max-attempts}")
+  private int maxAttempts;
+
+  @Value("${spring.rabbitmq.listener.simple.retry.initial-interval}")
+  private long initialInterval;
+
+  @Value("${spring.rabbitmq.listener.simple.retry.multiplier:1.0}")
+  private double multiplier;
+
+  @Value("${spring.rabbitmq.listener.simple.retry.max-interval:10000}")
+  private long maxInterval;
+
+  @Bean
+  public MessageConverter jackson2JsonMessageConverter() {
+    return new Jackson2JsonMessageConverter();
+  }
+
+  @Bean
+  public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
+    return new RabbitAdmin(connectionFactory);
+  }
+
+  @Bean
+  public ApplicationRunner rabbitInitializer(RabbitAdmin rabbitAdmin) {
+    return args -> rabbitAdmin.initialize();
+  }
+
+  @Bean
+  public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory,
+                                       MessageConverter jackson2JsonMessageConverter) {
+    RabbitTemplate template = new RabbitTemplate(connectionFactory);
+    template.setMessageConverter(jackson2JsonMessageConverter);
+    template.setMandatory(true);
+    template.setConfirmCallback((correlationData, ack, cause) -> {
+      if (!ack) {
+        log.error("Message not confirmed by broker: {}", cause);
+      }
+    });
+    template.setReturnsCallback(returned -> {
+      log.error("Message returned — unroutable: exchange={}, routingKey={}, replyText={}",
+          returned.getExchange(), returned.getRoutingKey(), returned.getReplyText());
+    });
+    return template;
+  }
+
+  @Bean
+  public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(
+      ConnectionFactory connectionFactory,
+      MessageConverter jackson2JsonMessageConverter) {
+
+    SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
+    factory.setConnectionFactory(connectionFactory);
+    factory.setMessageConverter(jackson2JsonMessageConverter);
+    factory.setAcknowledgeMode(AcknowledgeMode.MANUAL);
+    factory.setDefaultRequeueRejected(false);
+
+    // Retry template with exponential backoff
+    RetryTemplate retryTemplate = new RetryTemplate();
+    SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy();
+    retryPolicy.setMaxAttempts(maxAttempts);
+    retryTemplate.setRetryPolicy(retryPolicy);
+
+    ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
+    backOffPolicy.setInitialInterval(initialInterval);
+    backOffPolicy.setMultiplier(multiplier);
+    backOffPolicy.setMaxInterval(maxInterval);
+    retryTemplate.setBackOffPolicy(backOffPolicy);
+
+    factory.setRetryTemplate(retryTemplate);
+
+    return factory;
+  }
+}

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

@@ -1,19 +1,12 @@
 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 {
 
@@ -23,26 +16,6 @@ public class TemporalConfig {
     @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(
@@ -63,42 +36,7 @@ public class TemporalConfig {
     }
 
     @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();
-        }
+    public WorkerFactory workerFactory(WorkflowClient client) {
+        return WorkerFactory.newInstance(client);
     }
 }

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

@@ -0,0 +1,41 @@
+package <%= packageName %>.shared.infrastructure.configurations.temporalConfig;
+
+import io.temporal.worker.WorkerFactory;
+import jakarta.annotation.PreDestroy;
+import org.springframework.context.SmartLifecycle;
+import org.springframework.stereotype.Component;
+
+@Component
+public class TemporalWorkerFactoryLifecycle implements SmartLifecycle {
+
+    private final WorkerFactory workerFactory;
+    private volatile boolean running = false;
+
+    public TemporalWorkerFactoryLifecycle(WorkerFactory workerFactory) {
+        this.workerFactory = workerFactory;
+    }
+
+    @Override
+    public void start() {
+        workerFactory.start();
+        running = true;
+    }
+
+    @Override
+    public void stop() {
+        if (workerFactory != null) {
+            workerFactory.shutdown();
+        }
+        running = false;
+    }
+
+    @Override
+    public boolean isRunning() {
+        return running;
+    }
+
+    @Override
+    public int getPhase() {
+        return Integer.MAX_VALUE;
+    }
+}

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

@@ -1,14 +1,80 @@
 package <%= packageName %>.<%= moduleName %>.infrastructure.adapters.activities;
 
+<% if (shared) { %>
+import <%= packageName %>.shared.domain.contracts.<%= moduleName %>.<%= activityPascalCase %>Activity;
+<% if (hasInput) { %>
+import <%= packageName %>.shared.domain.contracts.<%= moduleName %>.<%= activityPascalCase %>Input;
+<% } %>
+<% if (hasOutput) { %>
+import <%= packageName %>.shared.domain.contracts.<%= moduleName %>.<%= activityPascalCase %>Output;
+<% } %>
+<% } else { %>
 import <%= packageName %>.<%= moduleName %>.application.ports.<%= activityPascalCase %>Activity;
-import <%= packageName %>.shared.domain.interfaces.<%= activityCategory %>;
+<% if (hasInput) { %>
+import <%= packageName %>.<%= moduleName %>.application.dtos.temporal.<%= activityPascalCase %>Input;
+<% } %>
+<% if (hasOutput) { %>
+import <%= packageName %>.<%= moduleName %>.application.dtos.temporal.<%= activityPascalCase %>Output;
+<% } %>
+<% } %>
+import <%= packageName %>.<%= moduleName %>.domain.interfaces.<%= activityCategory %>;
+<% if (isQueryActivity && queryMeta) { %>
+import <%= packageName %>.<%= moduleName %>.domain.models.entities.<%= queryMeta.aggregateName %>;
+import <%= packageName %>.<%= moduleName %>.domain.repositories.<%= queryMeta.aggregateName %>Repository;
+import <%= packageName %>.shared.domain.customExceptions.NotFoundException;
+<% if (queryMeta.voMappingImports && queryMeta.voMappingImports.length > 0) { -%>
+<% queryMeta.voMappingImports.forEach(imp => { -%>
+<%- imp %>
+<% }); -%>
+<% } -%>
+<% } %>
 import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
 
 @Component
 public class <%= activityPascalCase %>ActivityImpl implements <%= activityPascalCase %>Activity, <%= activityCategory %> {
+<% if (isQueryActivity && queryMeta) { %>
+
+    private final <%= queryMeta.aggregateName %>Repository repository;
+
+    public <%= activityPascalCase %>ActivityImpl(<%= queryMeta.aggregateName %>Repository repository) {
+        this.repository = repository;
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public <%= activityPascalCase %>Output execute(<%= activityPascalCase %>Input input) {
+<% const findMethod = (queryMeta.needsEagerLoad && queryMeta.eagerLoadField)
+    ? 'findByIdWith' + queryMeta.eagerLoadField.fieldPascal
+    : 'findById'; -%>
+        <%= queryMeta.aggregateName %> entity = repository.<%= findMethod %>(<%= queryMeta.idFieldAccessor %>)
+            .orElseThrow(() -> new NotFoundException("<%= queryMeta.aggregateName %> not found with id: " + <%= queryMeta.idFieldAccessor %>));
+<% if (queryMeta.outputMappings.some(m => m.preDeclaration)) { -%>
+<% queryMeta.outputMappings.filter(m => m.preDeclaration).forEach(m => { %>
+        <%- m.preDeclaration.varType %> <%- m.preDeclaration.varName %> = <%- m.preDeclaration.getter %> != null
+            ? new <%- m.preDeclaration.varType %>(
+<% m.preDeclaration.ntArgs.forEach((arg, ai) => { -%>
+                <%- arg %><%= ai < m.preDeclaration.ntArgs.length - 1 ? ',' : '' %>
+<% }); -%>
+            )
+            : null;
+<% }); -%>
+<% } -%>
+        return new <%= activityPascalCase %>Output(
+<% queryMeta.outputMappings.forEach((m, i) => { -%>
+            <%- m.accessor %><%= i < queryMeta.outputMappings.length - 1 ? ',' : '' %>
+<% }); -%>
+        );
+    }
+<% } else { %>
 
     @Override
-    public void execute(String flowId) {
+    @Transactional
+    public <%= hasOutput ? activityPascalCase + 'Output' : 'void' %> execute(<%= hasInput ? activityPascalCase + 'Input input' : '' %>) {
         //todo: implement the logic
+<% if (hasOutput) { %>
+        throw new UnsupportedOperationException("Not implemented yet");
+<% } %>
     }
+<% } %>
 }

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

@@ -0,0 +1,14 @@
+package <%= packageName %>.<%= moduleName %>.application.dtos.temporal;
+<%
+const _allImports = [...(imports || []), ...((typeof nestedTypeImportLines !== 'undefined' ? nestedTypeImportLines : []) || [])];
+if (_allImports.length > 0) { %>
+
+<%= _allImports.join('\n') %>
+<% } %>
+
+public record <%= activityPascalCase %>Input(
+<% inputFields.forEach((field, index) => { %>
+    <%- field.javaType %> <%= field.name %><%= index < inputFields.length - 1 ? ',' : '' %>
+<% }); %>
+) {
+}

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

@@ -2,10 +2,16 @@ package <%= packageName %>.<%= moduleName %>.application.ports;
 
 import io.temporal.activity.ActivityInterface;
 import io.temporal.activity.ActivityMethod;
+<% if (hasInput) { %>
+import <%= packageName %>.<%= moduleName %>.application.dtos.temporal.<%= activityPascalCase %>Input;
+<% } %>
+<% if (hasOutput) { %>
+import <%= packageName %>.<%= moduleName %>.application.dtos.temporal.<%= activityPascalCase %>Output;
+<% } %>
 
 @ActivityInterface
 public interface <%= activityPascalCase %>Activity {
 
     @ActivityMethod(name = "<%= activityPascalCase %>")
-    void execute(String flowId);
+    <%= hasOutput ? activityPascalCase + 'Output' : 'void' %> execute(<%= hasInput ? activityPascalCase + 'Input input' : '' %>);
 }

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

@@ -0,0 +1,14 @@
+package <%= packageName %>.<%= moduleName %>.application.dtos.temporal;
+<%
+const _allImports = [...(imports || []), ...((typeof nestedTypeImportLines !== 'undefined' ? nestedTypeImportLines : []) || [])];
+if (_allImports.length > 0) { %>
+
+<%= _allImports.join('\n') %>
+<% } %>
+
+public record <%= activityPascalCase %>Output(
+<% outputFields.forEach((field, index) => { %>
+    <%- field.javaType %> <%= field.name %><%= index < outputFields.length - 1 ? ',' : '' %>
+<% }); %>
+) {
+}

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

@@ -0,0 +1,12 @@
+package <%= packageName %>.<%= moduleName %>.application.dtos.temporal;
+<% if (imports.length > 0) { %>
+
+<%= imports.join('\n') %>
+<% } %>
+
+public record <%= typeName %>(
+<% fields.forEach((field, index) => { %>
+    <%- field.javaType %> <%= field.name %><%= index < fields.length - 1 ? ',' : '' %>
+<% }); %>
+) {
+}

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

@@ -0,0 +1,14 @@
+package <%= packageName %>.shared.domain.contracts.<%= targetModule %>;
+<%
+const _allImports = [...(imports || []), ...((typeof nestedTypeImportLines !== 'undefined' ? nestedTypeImportLines : []) || [])];
+if (_allImports.length > 0) { %>
+
+<%= _allImports.join('\n') %>
+<% } %>
+
+public record <%= activityPascalCase %>Input(
+<% inputFields.forEach((field, index) => { %>
+    <%- field.javaType %> <%= field.name %><%= index < inputFields.length - 1 ? ',' : '' %>
+<% }); %>
+) {
+}

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

@@ -0,0 +1,15 @@
+package <%= packageName %>.shared.domain.contracts.<%= targetModule %>;
+
+import io.temporal.activity.ActivityInterface;
+import io.temporal.activity.ActivityMethod;
+<% if (hasInput) { %>
+<% } %>
+<% if (hasOutput) { %>
+<% } %>
+
+@ActivityInterface
+public interface <%= activityPascalCase %>Activity {
+
+    @ActivityMethod(name = "<%= activityPascalCase %>")
+    <%= hasOutput ? activityPascalCase + 'Output' : 'void' %> execute(<%= hasInput ? activityPascalCase + 'Input input' : '' %>);
+}

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

@@ -0,0 +1,14 @@
+package <%= packageName %>.shared.domain.contracts.<%= targetModule %>;
+<%
+const _allImports = [...(imports || []), ...((typeof nestedTypeImportLines !== 'undefined' ? nestedTypeImportLines : []) || [])];
+if (_allImports.length > 0) { %>
+
+<%= _allImports.join('\n') %>
+<% } %>
+
+public record <%= activityPascalCase %>Output(
+<% outputFields.forEach((field, index) => { %>
+    <%- field.javaType %> <%= field.name %><%= index < outputFields.length - 1 ? ',' : '' %>
+<% }); %>
+) {
+}

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

@@ -0,0 +1,12 @@
+package <%= packageName %>.shared.domain.contracts.<%= targetModule %>;
+<% if (imports.length > 0) { %>
+
+<%= imports.join('\n') %>
+<% } %>
+
+public record <%= typeName %>(
+<% fields.forEach((field, index) => { %>
+    <%- field.javaType %> <%= field.name %><%= index < fields.length - 1 ? ',' : '' %>
+<% }); %>
+) {
+}

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

@@ -0,0 +1,6 @@
+package <%= packageName %>.<%= moduleName %>.domain.interfaces;
+
+import <%= packageName %>.shared.domain.interfaces.HeavyActivity;
+
+public interface <%= modulePascalCase %>HeavyActivity extends HeavyActivity {
+}

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

@@ -0,0 +1,6 @@
+package <%= packageName %>.<%= moduleName %>.domain.interfaces;
+
+import <%= packageName %>.shared.domain.interfaces.LightActivity;
+
+public interface <%= modulePascalCase %>LightActivity extends LightActivity {
+}

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

@@ -0,0 +1,58 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.configurations;
+
+import <%= packageName %>.<%= moduleName %>.domain.interfaces.<%= modulePascalCase %>HeavyActivity;
+import <%= packageName %>.<%= moduleName %>.domain.interfaces.<%= modulePascalCase %>LightActivity;
+import io.temporal.worker.Worker;
+import io.temporal.worker.WorkerFactory;
+import io.temporal.worker.WorkerOptions;
+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 <%= modulePascalCase %>TemporalWorkerConfig {
+
+    @Value("${temporal.number-flow-worker}")
+    private Integer numberFlowWorker;
+
+    @Value("${temporal.number-heavy-worker}")
+    private Integer numberHeavyWorker;
+
+    @Value("${temporal.number-light-worker}")
+    private Integer numberLightWorker;
+
+    public static final String FLOW_QUEUE = "<%= moduleScreamingSnake %>_WORKFLOW_QUEUE";
+    public static final String HEAVY_QUEUE = "<%= moduleScreamingSnake %>_HEAVY_TASK_QUEUE";
+    public static final String LIGHT_QUEUE = "<%= moduleScreamingSnake %>_LIGHT_TASK_QUEUE";
+
+    @Bean
+    public Worker <%= moduleCamelCase %>WorkflowWorker(WorkerFactory workerFactory,
+                                          List<<%= modulePascalCase %>HeavyActivity> heavyActivities,
+                                          List<<%= modulePascalCase %>LightActivity> lightActivities) {
+
+        // 1. WORKER DE FLUJO (Orquestador)
+        WorkerOptions workflowOptions = WorkerOptions.newBuilder()
+            .setMaxConcurrentWorkflowTaskExecutionSize(numberFlowWorker)
+            .build();
+        Worker workflowWorker = workerFactory.newWorker(FLOW_QUEUE, workflowOptions);
+        // registered by eva g temporal-flow
+
+        // 2. WORKER PESADO (tareas complejas)
+        WorkerOptions heavyOptions = WorkerOptions.newBuilder()
+            .setMaxConcurrentActivityExecutionSize(numberHeavyWorker)
+            .build();
+        Worker heavyWorker = workerFactory.newWorker(HEAVY_QUEUE, heavyOptions);
+        heavyWorker.registerActivitiesImplementations(heavyActivities.toArray());
+
+        // 3. WORKER LIGERO (tareas rápidas)
+        WorkerOptions lightOptions = WorkerOptions.newBuilder()
+            .setMaxConcurrentActivityExecutionSize(numberLightWorker)
+            .build();
+        Worker lightWorker = workerFactory.newWorker(LIGHT_QUEUE, lightOptions);
+        lightWorker.registerActivitiesImplementations(lightActivities.toArray());
+
+        return workflowWorker;
+    }
+}