eva4j 1.0.16 → 1.0.18

package/templates/read-model/ReadModelRabbitListener.java.ejs

@@ -0,0 +1,71 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.rabbitListener;
+<% const isUpsert = action === 'UPSERT'; %>
+<% if (isUpsert) { %>
+
+import <%= packageName %>.<%= moduleName %>.application.events.<%= integrationEventClassName %>;
+<% } %>
+import <%= packageName %>.<%= moduleName %>.application.usecases.<%= syncHandlerName %>;
+import <%= packageName %>.shared.infrastructure.eventEnvelope.EventEnvelope;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.rabbitmq.client.Channel;
+import org.springframework.amqp.core.Message;
+import org.springframework.amqp.rabbit.annotation.RabbitListener;
+import org.springframework.stereotype.Component;
+
+import java.io.IOException;
+import java.util.Map;
+<% if (isUpsert) { %>
+<% const needsBigDecimal = fields && fields.some(f => f.javaType === 'BigDecimal'); %>
+<% const needsLocalDate  = fields && fields.some(f => ['LocalDate','LocalDateTime','LocalTime'].includes(f.javaType)); %>
+<% const needsInstant    = fields && fields.some(f => f.javaType === 'Instant'); %>
+<% const needsUUID       = fields && fields.some(f => f.javaType === 'UUID'); %>
+<% if (needsBigDecimal) { %>import java.math.BigDecimal;
+<% } %><% if (needsLocalDate) { %>import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+<% } %><% if (needsInstant) { %>import java.time.Instant;
+<% } %><% if (needsUUID) { %>import java.util.UUID;
+<% } %>
+<% } %>
+
+/**
+ * RabbitMQ listener for read model sync — queue: <%= topicConstant %>.
+ * Delegates to <%= syncHandlerName %>.on<%= eventBaseName %>().
+ */
+@Component("<%= moduleName %>.<%= listenerClassName %>")
+public class <%= listenerClassName %> {
+
+    private final <%= syncHandlerName %> syncHandler;
+    private final ObjectMapper objectMapper;
+
+    public <%= listenerClassName %>(<%= syncHandlerName %> syncHandler, ObjectMapper objectMapper) {
+        this.syncHandler = syncHandler;
+        this.objectMapper = objectMapper;
+    }
+
+    @RabbitListener(queues = "<%= topicSpringProperty %>")
+    public void handle(Message message, Channel channel) throws IOException {
+        EventEnvelope<Map<String, Object>> event = objectMapper.readValue(
+                message.getBody(),
+                new TypeReference<EventEnvelope<Map<String, Object>>>() {});
+
+<% if (isUpsert) { %>
+<% (fields || []).forEach(f => { %>
+        <%- f.javaType %> <%= f.name %> = objectMapper.convertValue(event.data().get("<%= f.payloadKey || f.name %>"), <%- f.javaType %>.class);
+<% }); %>
+
+        syncHandler.on<%= eventBaseName %>(new <%= integrationEventClassName %>(
+<% (fields || []).forEach((f, i) => { %>
+                <%= f.name %><%= i < fields.length - 1 ? ',' : '' %>
+<% }); %>
+        ));
+<% } else { %>
+        String id = objectMapper.convertValue(event.data().get("<%= (fields[0] && fields[0].payloadKey) || 'id' %>"), String.class);
+        syncHandler.on<%= eventBaseName %>(id);
+<% } %>
+
+        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
+    }
+}

package/templates/read-model/ReadModelRepository.java.ejs

@@ -0,0 +1,42 @@
+package <%= packageName %>.<%= moduleName %>.domain.repositories;
+<% const needsBigDecimal = fields && fields.some(f => f.javaType === 'BigDecimal'); %>
+<% const needsLocalDate  = fields && fields.some(f => ['LocalDate','LocalDateTime','LocalTime'].includes(f.javaType)); %>
+<% const needsInstant    = fields && fields.some(f => f.javaType === 'Instant'); %>
+<% const needsUUID       = fields && fields.some(f => f.javaType === 'UUID'); %>
+<% if (needsBigDecimal) { %>
+import java.math.BigDecimal;
+<% } %>
+<% if (needsLocalDate) { %>
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+<% } %>
+<% if (needsInstant) { %>
+import java.time.Instant;
+<% } %>
+<% if (needsUUID) { %>
+import java.util.UUID;
+<% } %>
+
+import <%= packageName %>.<%= moduleName %>.domain.models.readmodels.<%= domainClassName %>;
+
+import java.util.Optional;
+
+/**
+ * Repository interface for the <%= domainClassName %> read model.
+ * Provides read-only access and upsert/delete for event-driven sync.
+ */
+public interface <%= repositoryName %> {
+
+    void upsert(<%= domainClassName %> readModel);
+
+    void deleteById(String id);
+<% if (hasSoftDelete) { %>
+
+    void softDeleteById(String id);
+<% } %>
+
+    Optional<<%= domainClassName %>> findById(String id);
+
+    boolean existsById(String id);
+}

package/templates/read-model/ReadModelRepositoryImpl.java.ejs

@@ -0,0 +1,85 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.database.repositories;
+<% const needsBigDecimal = fields && fields.some(f => f.javaType === 'BigDecimal'); %>
+<% const needsLocalDate  = fields && fields.some(f => ['LocalDate','LocalDateTime','LocalTime'].includes(f.javaType)); %>
+<% const needsInstant    = fields && fields.some(f => f.javaType === 'Instant'); %>
+<% const needsUUID       = fields && fields.some(f => f.javaType === 'UUID'); %>
+<% if (needsBigDecimal) { %>
+import java.math.BigDecimal;
+<% } %>
+<% if (needsLocalDate || hasSoftDelete) { %>
+import java.time.LocalDateTime;
+<% } %>
+<% if (needsInstant) { %>
+import java.time.Instant;
+<% } %>
+<% if (needsUUID) { %>
+import java.util.UUID;
+<% } %>
+
+import <%= packageName %>.<%= moduleName %>.domain.models.readmodels.<%= domainClassName %>;
+import <%= packageName %>.<%= moduleName %>.domain.repositories.<%= repositoryName %>;
+import <%= packageName %>.<%= moduleName %>.infrastructure.database.entities.<%= jpaEntityName %>;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+/**
+ * Repository implementation for the <%= domainClassName %> read model.
+ * Maps between domain read model and JPA entity.
+ */
+@Repository("<%= moduleName %>.<%= repositoryImplName %>")
+public class <%= repositoryImplName %> implements <%= repositoryName %> {
+
+    private final <%= jpaRepositoryName %> jpaRepository;
+
+    public <%= repositoryImplName %>(<%= jpaRepositoryName %> jpaRepository) {
+        this.jpaRepository = jpaRepository;
+    }
+
+    @Override
+    public void upsert(<%= domainClassName %> readModel) {
+        <%= jpaEntityName %> entity = jpaRepository.findById(readModel.getId())
+                .orElseGet(() -> {
+                    <%= jpaEntityName %> newEntity = new <%= jpaEntityName %>();
+                    newEntity.setId(readModel.getId());
+                    return newEntity;
+                });
+<% fields.filter(f => f.name !== 'id').forEach(field => { %>
+        entity.set<%= field.name.charAt(0).toUpperCase() + field.name.slice(1) %>(readModel.get<%= field.name.charAt(0).toUpperCase() + field.name.slice(1) %>());
+<% }); %>
+        jpaRepository.save(entity);
+    }
+
+    @Override
+    public void deleteById(String id) {
+        jpaRepository.deleteById(id);
+    }
+
+    @Override
+    public Optional<<%= domainClassName %>> findById(String id) {
+        return jpaRepository.findById(id).map(this::toDomain);
+    }
+
+    @Override
+    public boolean existsById(String id) {
+        return jpaRepository.existsById(id);
+    }
+<% if (hasSoftDelete) { %>
+
+    @Override
+    public void softDeleteById(String id) {
+        jpaRepository.findById(id).ifPresent(entity -> {
+            entity.setDeletedAt(LocalDateTime.now());
+            jpaRepository.save(entity);
+        });
+    }
+<% } %>
+
+    private <%= domainClassName %> toDomain(<%= jpaEntityName %> entity) {
+        return new <%= domainClassName %>(
+<% fields.forEach((field, idx) => { %>
+                entity.get<%= field.name.charAt(0).toUpperCase() + field.name.slice(1) %>()<%= idx < fields.length - 1 ? ',' : '' %>
+<% }); %>
+        );
+    }
+}

package/templates/read-model/ReadModelSyncHandler.java.ejs

@@ -0,0 +1,54 @@
+package <%= packageName %>.<%= moduleName %>.application.usecases;
+<% const upsertEntries = syncedBy.filter(s => s.action === 'UPSERT'); %>
+<% const upsertImports = [...new Set(upsertEntries.map(s => s.integrationEventClassName))]; %>
+<% upsertImports.forEach(cls => { %>
+import <%= packageName %>.<%= moduleName %>.application.events.<%= cls %>;
+<% }); %>
+import <%= packageName %>.<%= moduleName %>.domain.models.readmodels.<%= domainClassName %>;
+import <%= packageName %>.<%= moduleName %>.domain.repositories.<%= repositoryName %>;
+import <%= packageName %>.shared.domain.annotations.ApplicationComponent;
+import <%= packageName %>.shared.domain.annotations.LogExceptions;
+import org.springframework.stereotype.Component;
+
+/**
+ * Sync handler for the <%= domainClassName %> read model.
+ * Maintains the local projection by processing events from <%= sourceModule %>/<%= sourceName %>.
+ * <p>
+ * One method per syncedBy event — Kafka listeners delegate directly to these methods.
+ */
+@ApplicationComponent
+@Component("<%= moduleName %>.<%= syncHandlerName %>")
+public class <%= syncHandlerName %> {
+
+    private final <%= repositoryName %> repository;
+
+    public <%= syncHandlerName %>(<%= repositoryName %> repository) {
+        this.repository = repository;
+    }
+<% syncedBy.forEach(sync => { %>
+<% if (sync.action === 'UPSERT') { %>
+
+    @LogExceptions
+    public void on<%= sync.eventBaseName %>(<%= sync.integrationEventClassName %> event) {
+        <%= domainClassName %> model = new <%= domainClassName %>(
+<% fields.forEach((field, idx) => { %>
+                event.<%= field.name %>()<%= idx < fields.length - 1 ? ',' : '' %>
+<% }); %>
+        );
+        repository.upsert(model);
+    }
+<% } else if (sync.action === 'DELETE') { %>
+
+    @LogExceptions
+    public void on<%= sync.eventBaseName %>(String id) {
+        repository.deleteById(id);
+    }
+<% } else if (sync.action === 'SOFT_DELETE') { %>
+
+    @LogExceptions
+    public void on<%= sync.eventBaseName %>(String id) {
+        repository.softDeleteById(id);
+    }
+<% } %>
+<% }); %>
+}

package/templates/shared/configurations/kafkaConfig/KafkaConfig.java.ejs

@@ -12,7 +12,7 @@ import org.springframework.kafka.core.KafkaTemplate;
 import org.springframework.kafka.listener.ContainerProperties;
 import org.springframework.kafka.listener.DeadLetterPublishingRecoverer;
 import org.springframework.kafka.listener.DefaultErrorHandler;
-import org.springframework.util.backoff.FixedBackOff;
+import org.springframework.util.backoff.ExponentialBackOff;
 
 
 @Configuration
@@ -20,11 +20,23 @@ import org.springframework.util.backoff.FixedBackOff;
 public class KafkaConfig {
 
   @Value("${spring.kafka.listener.retry.max-attempts}")
-  private long maxAttempts;
+  private int maxAttempts;
 
   @Value("${spring.kafka.listener.retry.backoff-delay}")
   private long backoffDelay;
 
+  @Value("${spring.kafka.listener.retry.backoff-multiplier:1.0}")
+  private double backoffMultiplier;
+
+  @Value("${spring.kafka.listener.retry.backoff-max-delay:30000}")
+  private long backoffMaxDelay;
+
+  @Value("${kafka.topic-defaults.partitions:3}")
+  private int defaultPartitions;
+
+  @Value("${kafka.topic-defaults.replicas:1}")
+  private short defaultReplicas;
+
   @Bean
   public ConcurrentKafkaListenerContainerFactory<String, String> kafkaListenerContainerFactory(
       ConsumerFactory<String, String> consumerFactory,
@@ -39,8 +51,10 @@ public class KafkaConfig {
         // Redirige al topic original + ".DLT"
         (record, ex) -> new TopicPartition(record.topic() + ".DLT", record.partition())
     );
-    // Configura reintentos:
-    FixedBackOff backOff = new FixedBackOff(backoffDelay, maxAttempts);
+    // Configura reintentos con backoff exponencial
+    ExponentialBackOff backOff = new ExponentialBackOff(backoffDelay, backoffMultiplier);
+    backOff.setMaxInterval(backoffMaxDelay);
+    backOff.setMaxAttempts(maxAttempts);
     // Manejador de errores
     DefaultErrorHandler errorHandler = new DefaultErrorHandler(recoverer, backOff);
     factory.setCommonErrorHandler(errorHandler);

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 ? ',' : '' %>
+<% }); %>
+) {
+}