eva4j 1.0.17 → 1.0.18

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

@@ -3,5 +3,5 @@
 
   @Bean
   public NewTopic <%= beanMethodName %>() {
-    return new NewTopic(<%= valueFieldName %>, <%= partitions %>, (short) <%= replicas %>);
+    return new NewTopic(<%= valueFieldName %>, defaultPartitions, defaultReplicas);
   }

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

@@ -12,7 +12,7 @@ import org.slf4j.MDC;
 public class <%= modulePascalCase %>KafkaMessageBroker implements MessageBroker {
 
   @Value("<%= topicSpringProperty %>")
-  private String <%= topicNameKebab.replace(/-/g, '') %>Topic;
+  private String <%= topicNameCamel %>Topic;
 
   private final KafkaTemplate<String, Object> kafkaTemplate;
 
@@ -23,10 +23,10 @@ public class <%= modulePascalCase %>KafkaMessageBroker implements MessageBroker
   @Override
   public void publish<%= eventClassName %>(<%= eventClassName %> event) {
     EventEnvelope<<%= eventClassName %>> envelope = EventEnvelope.of(
-      <%= topicNameKebab.replace(/-/g, '') %>Topic,
+      <%= topicNameCamel %>Topic,
       event,
       MDC.get("correlationId")
     );
-    kafkaTemplate.send(<%= topicNameKebab.replace(/-/g, '') %>Topic, envelope);
+    kafkaTemplate.send(<%= topicNameCamel %>Topic, envelope);
   }
 }

package/templates/ports/PortAclMapper.java.ejs

@@ -0,0 +1,35 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.adapters.<%= adapterPackage %>;
+
+import org.springframework.stereotype.Component;
+<% const allMethods = methods || []; %>
+<% const responseMethods = allMethods.filter(m => m.hasResponse); %>
+<% /* ACL: import domain models */ %>
+<% const uniqueDomainTypes = [...new Set(responseMethods.map(m => m.domainType))]; %>
+<% uniqueDomainTypes.forEach(dt => { %>import <%= packageName %>.<%= moduleName %>.domain.models.<%= adapterPackage %>.<%= dt %>;
+<% }); %>
+<% /* Import infra DTOs from dtos sub-package */ %>
+<% const uniqueInfraDtos = [...new Set(responseMethods.map(m => m.infraDtoName))]; %>
+<% uniqueInfraDtos.forEach(dto => { %>import <%= packageName %>.<%= moduleName %>.infrastructure.adapters.<%= adapterPackage %>.dtos.<%= dto %>;
+<% }); %>
+
+/**
+ * ACL (Anti-Corruption Layer) mapper for {@link <%= serviceName %>}.
+ *
+ * <p>Maps infrastructure DTOs (shaped by the external service) to domain models.
+ * If the external API changes, only these methods need to be updated;
+ * domain logic using the domain models remains untouched.
+ */
+@Component("<%= moduleName %>.<%= aclMapperClassName %>")
+public class <%= aclMapperClassName %> {
+<% responseMethods.forEach(m => { %>
+
+    public <%- m.domainType %> to<%= m.domainType %>(<%= m.infraDtoName %> dto) {
+        if (dto == null) return null;
+        return new <%= m.domainType %>(
+<%     m.fields.forEach((f, i) => { %>
+            dto.<%= f.name %>()<%= i < m.fields.length - 1 ? ',' : '' %>
+<%     }); %>
+        );
+    }
+<% }); %>
+}

package/templates/ports/PortFeignAdapter.java.ejs

@@ -20,9 +20,11 @@ import java.util.stream.Collectors;
 public class <%= feignAdapterClassName %> implements <%= serviceName %> {
 
     private final <%= feignClientClassName %> feignClient;
+    private final <%= aclMapperClassName %> aclMapper;
 
-    public <%= feignAdapterClassName %>(<%= feignClientClassName %> feignClient) {
+    public <%= feignAdapterClassName %>(<%= feignClientClassName %> feignClient, <%= aclMapperClassName %> aclMapper) {
         this.feignClient = feignClient;
+        this.aclMapper = aclMapper;
     }
 <% allMethods.forEach(m => { %>
 <%   /* Public override returns domain model; FeignClient returns infra DTO */ %>
@@ -39,29 +41,12 @@ public class <%= feignAdapterClassName %> implements <%= serviceName %> {
 <%   if (!m.hasResponse) { %>
         feignClient.<%= m.name %>(<%= args.join(', ') %>);
 <%   } else if (m.returnList) { %>
-        List<<%= m.infraDtoName %>> dtos = feignClient.<%= m.name %>(<%= args.join(', ') %>);
-        return dtos.stream().map(dto -> to<%= m.domainType %>(dto)).collect(Collectors.toList());
+        return feignClient.<%= m.name %>(<%= args.join(', ') %>).stream()
+            .map(aclMapper::to<%= m.domainType %>)
+            .collect(Collectors.toList());
 <%   } else { %>
-        return to<%= m.domainType %>(feignClient.<%= m.name %>(<%= args.join(', ') %>));
+        return aclMapper.to<%= m.domainType %>(feignClient.<%= m.name %>(<%= args.join(', ') %>));
 <%   } %>
     }
 <% }); %>
-
-    // ── ACL Mappers ─────────────────────────────────────────────────────────
-    // Maps infra DTOs (shaped by the external service) to domain models.
-    // If the external API changes, only these methods need to be updated.
-<%
-  // Build one mapper per method that has a response
-  const responseMethods = allMethods.filter(m => m.hasResponse);
-%>
-<% responseMethods.forEach(m => { %>
-    private <%- m.domainType %> to<%= m.domainType %>(<%= m.infraDtoName %> dto) {
-        if (dto == null) return null;
-        return new <%= m.domainType %>(
-<%     m.fields.forEach((f, i) => { %>
-            dto.<%= f.name %>()<%= i < m.fields.length - 1 ? ',' : '' %>
-<%     }); %>
-        );
-    }
-<% }); %>
 }

package/templates/ports/PortFeignClient.java.ejs

@@ -23,6 +23,10 @@ import java.time.LocalTime;
 <% }); %>
 <% (nestedTypes || []).forEach(nt => { %>import <%= packageName %>.<%= moduleName %>.application.dtos.<%= nt.name %>;
 <% }); %>
+<% /* Infra response DTOs live in infrastructure.adapters.{service}.dtos */ %>
+<% const uniqueInfraDtos = [...new Set(allMethods.filter(m => m.hasResponse).map(m => m.infraDtoName))]; %>
+<% uniqueInfraDtos.forEach(dto => { %>import <%= packageName %>.<%= moduleName %>.infrastructure.adapters.<%= adapterPackage %>.dtos.<%= dto %>;
+<% }); %>
 @FeignClient(
     name = "<%= feignClientName %>",
     url = "${<%= baseUrlProperty %>}",

package/templates/ports/PortResponseDto.java.ejs

@@ -1,4 +1,4 @@
-package <%= packageName %>.<%= moduleName %>.infrastructure.adapters.<%= adapterPackage %>;
+package <%= packageName %>.<%= moduleName %>.infrastructure.adapters.<%= adapterPackage %>.dtos;
 <% 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'); %>

package/templates/rabbitmq-event/RabbitConfigBean.java.ejs

@@ -0,0 +1,33 @@
+  @Value("${queues.<%= topicNameKebab %>}")
+  private String <%= valueFieldName %>QueueName;
+
+  @Value("${routing-keys.<%= topicNameKebab %>}")
+  private String <%= valueFieldName %>RoutingKeyValue;
+
+  @Bean
+  public Queue <%= beanMethodName %>Queue() {
+    return QueueBuilder.durable(<%= valueFieldName %>QueueName)
+        .withArgument("x-dead-letter-exchange", <%= moduleName %>ExchangeName + ".dlx")
+        .build();
+  }
+
+  @Bean
+  public Binding <%= beanMethodName %>Binding() {
+    return BindingBuilder
+        .bind(<%= beanMethodName %>Queue())
+        .to(<%= moduleName %>Exchange())
+        .with(<%= valueFieldName %>RoutingKeyValue);
+  }
+
+  @Bean
+  public Queue <%= beanMethodName %>Dlq() {
+    return QueueBuilder.durable(<%= valueFieldName %>QueueName + ".dlq").build();
+  }
+
+  @Bean
+  public Binding <%= beanMethodName %>DlqBinding() {
+    return BindingBuilder
+        .bind(<%= beanMethodName %>Dlq())
+        .to(<%= moduleName %>DlxExchange())
+        .with(<%= valueFieldName %>RoutingKeyValue);
+  }

package/templates/rabbitmq-event/RabbitConfigExchange.java.ejs

@@ -0,0 +1,12 @@
+  @Value("${exchanges.<%= moduleName %>}")
+  private String <%= moduleName %>ExchangeName;
+
+  @Bean
+  public TopicExchange <%= moduleName %>Exchange() {
+    return new TopicExchange(<%= moduleName %>ExchangeName, true, false);
+  }
+
+  @Bean
+  public TopicExchange <%= moduleName %>DlxExchange() {
+    return new TopicExchange(<%= moduleName %>ExchangeName + ".dlx", true, false);
+  }

package/templates/rabbitmq-event/RabbitMessageBroker.java.ejs

@@ -0,0 +1,35 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.adapters.rabbitmqMessageBroker;
+
+import <%= packageName %>.<%= moduleName %>.application.events.<%= eventClassName %>;
+import <%= packageName %>.<%= moduleName %>.application.ports.MessageBroker;
+import <%= packageName %>.shared.infrastructure.eventEnvelope.EventEnvelope;
+import org.springframework.amqp.rabbit.core.RabbitTemplate;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+import org.slf4j.MDC;
+
+@Component("<%= moduleCamelCase %>RabbitMessageBroker")
+public class <%= modulePascalCase %>RabbitMessageBroker implements MessageBroker {
+
+  @Value("${exchanges.<%= moduleName %>}")
+  private String exchange;
+
+  @Value("${routing-keys.<%= topicNameKebab %>}")
+  private String <%= topicNameCamel %>RoutingKey;
+
+  private final RabbitTemplate rabbitTemplate;
+
+  public <%= modulePascalCase %>RabbitMessageBroker(RabbitTemplate rabbitTemplate) {
+    this.rabbitTemplate = rabbitTemplate;
+  }
+
+  @Override
+  public void publish<%= eventClassName %>(<%= eventClassName %> event) {
+    EventEnvelope<<%= eventClassName %>> envelope = EventEnvelope.of(
+      <%= topicNameCamel %>RoutingKey,
+      event,
+      MDC.get("correlationId")
+    );
+    rabbitTemplate.convertAndSend(exchange, <%= topicNameCamel %>RoutingKey, envelope);
+  }
+}

package/templates/rabbitmq-event/RabbitMessageBrokerMethod.java.ejs

@@ -0,0 +1,9 @@
+  @Override
+  public void publish<%= eventClassName %>(<%= eventClassName %> event) {
+    EventEnvelope<<%= eventClassName %>> envelope = EventEnvelope.of(
+      <%= valueFieldName %>,
+      event,
+      MDC.get("correlationId")
+    );
+    rabbitTemplate.convertAndSend(exchange, <%= valueFieldName %>, envelope);
+  }

package/templates/rabbitmq-listener/RabbitConfigConsumerBean.java.ejs

@@ -0,0 +1,33 @@
+  @Value("${queues.<%= topicKey %>}")
+  private String <%= valueFieldName %>QueueName;
+
+  @Value("${routing-keys.<%= topicKey %>}")
+  private String <%= valueFieldName %>RoutingKeyValue;
+
+  @Bean
+  public Queue <%= beanMethodName %>Queue() {
+    return QueueBuilder.durable(<%= valueFieldName %>QueueName)
+        .withArgument("x-dead-letter-exchange", <%= producerModule %>ExchangeName + ".dlx")
+        .build();
+  }
+
+  @Bean
+  public Binding <%= beanMethodName %>Binding() {
+    return BindingBuilder
+        .bind(<%= beanMethodName %>Queue())
+        .to(<%= producerModule %>Exchange())
+        .with(<%= valueFieldName %>RoutingKeyValue);
+  }
+
+  @Bean
+  public Queue <%= beanMethodName %>Dlq() {
+    return QueueBuilder.durable(<%= valueFieldName %>QueueName + ".dlq").build();
+  }
+
+  @Bean
+  public Binding <%= beanMethodName %>DlqBinding() {
+    return BindingBuilder
+        .bind(<%= beanMethodName %>Dlq())
+        .to(<%= producerModule %>DlxExchange())
+        .with(<%= valueFieldName %>RoutingKeyValue);
+  }

package/templates/rabbitmq-listener/RabbitConfigConsumerExchange.java.ejs

@@ -0,0 +1,12 @@
+  @Value("${exchanges.<%= producerModule %>}")
+  private String <%= producerModule %>ExchangeName;
+
+  @Bean
+  public TopicExchange <%= producerModule %>Exchange() {
+    return new TopicExchange(<%= producerModule %>ExchangeName, true, false);
+  }
+
+  @Bean
+  public TopicExchange <%= producerModule %>DlxExchange() {
+    return new TopicExchange(<%= producerModule %>ExchangeName + ".dlx", true, false);
+  }

package/templates/rabbitmq-listener/RabbitListenerClass.java.ejs

@@ -0,0 +1,82 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.rabbitListener;
+
+import <%= packageName %>.<%= moduleName %>.application.commands.<%= commandClassName %>;
+import <%= packageName %>.shared.infrastructure.configurations.useCaseConfig.UseCaseMediator;
+import <%= packageName %>.shared.infrastructure.eventEnvelope.EventEnvelope;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.rabbitmq.client.Channel;
+import org.springframework.amqp.core.Message;
+import org.springframework.amqp.rabbit.annotation.RabbitListener;
+import org.springframework.stereotype.Component;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.Map;
+<% const hasLists = fields && fields.some(f => f.javaType && f.javaType.startsWith('List')); %>
+<% if (hasLists) { %>import java.util.List;
+<% } %><% 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;
+<% } %><% (nestedTypes || []).forEach(nt => { %>import <%= packageName %>.<%= moduleName %>.application.events.<%= nt.name %>;
+<% }); %>
+/**
+ * RabbitMQ listener for queue <%= topicConstant %>.
+ * Consumes events produced by: <%= producer %>.
+ * Dispatches to use case: <%= useCase %>.
+ */
+@Component("<%= moduleName %>.<%= listenerClassName %>")
+public class <%= listenerClassName %> {
+
+    private static final Logger log = LoggerFactory.getLogger(<%= listenerClassName %>.class);
+
+    private final UseCaseMediator useCaseMediator;
+    private final ObjectMapper objectMapper;
+
+    public <%= listenerClassName %>(UseCaseMediator useCaseMediator, ObjectMapper objectMapper) {
+        this.useCaseMediator = useCaseMediator;
+        this.objectMapper = objectMapper;
+    }
+
+    @RabbitListener(queues = "<%= topicSpringProperty %>")
+    public void handle(Message message, Channel channel) throws IOException {
+        long deliveryTag = message.getMessageProperties().getDeliveryTag();
+
+        EventEnvelope<Map<String, Object>> event;
+        try {
+            event = objectMapper.readValue(
+                    message.getBody(),
+                    new TypeReference<EventEnvelope<Map<String, Object>>>() {});
+        } catch (JsonProcessingException e) {
+            log.error("Fatal deserialization error — sending to DLQ: {}", e.getMessage());
+            channel.basicNack(deliveryTag, false, false);
+            return;
+        }
+
+<% (fields || []).forEach(f => { %><%
+  const listMatch = f.javaType.match(/^List<(.+)>$/);
+  if (listMatch) { %>
+        <%- f.javaType %> <%= f.name %> = objectMapper.convertValue(
+                event.data().get("<%= f.name %>"),
+                objectMapper.getTypeFactory().constructCollectionType(List.class, <%= listMatch[1] %>.class));
+<%  } else { %>
+        <%- f.javaType %> <%= f.name %> = objectMapper.convertValue(event.data().get("<%= f.name %>"), <%- f.javaType %>.class);
+<%  } %><% }); %>
+        useCaseMediator.dispatch(new <%= commandClassName %>(
+<% (fields || []).forEach((f, i) => { %>
+                <%= f.name %><%= i < fields.length - 1 ? ',' : '' %>
+<% }); %>
+        ));
+        channel.basicAck(deliveryTag, false);
+    }
+}

package/templates/rabbitmq-listener/RabbitListenerSimple.java.ejs

@@ -0,0 +1,56 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.rabbitListener;
+
+import <%= packageName %>.shared.infrastructure.configurations.useCaseConfig.UseCaseMediator;
+import <%= packageName %>.shared.infrastructure.eventEnvelope.EventEnvelope;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.rabbitmq.client.Channel;
+import org.springframework.amqp.core.Message;
+import org.springframework.amqp.rabbit.annotation.RabbitListener;
+import org.springframework.stereotype.Component;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * RabbitMQ listener for queue <%= topicValue %>
+ */
+@Component("<%= listenerBeanName %>")
+public class <%= listenerClassName %> {
+
+    private static final Logger log = LoggerFactory.getLogger(<%= listenerClassName %>.class);
+
+    private final UseCaseMediator useCaseMediator;
+    private final ObjectMapper objectMapper;
+
+    public <%= listenerClassName %>(UseCaseMediator useCaseMediator, ObjectMapper objectMapper) {
+        this.useCaseMediator = useCaseMediator;
+        this.objectMapper = objectMapper;
+    }
+
+    @RabbitListener(queues = "<%= topicSpringProperty %>")
+    public void handle(Message message, Channel channel) throws IOException {
+        long deliveryTag = message.getMessageProperties().getDeliveryTag();
+
+        EventEnvelope<Map<String, Object>> event;
+        try {
+            event = objectMapper.readValue(
+                    message.getBody(),
+                    new TypeReference<EventEnvelope<Map<String, Object>>>() {});
+        } catch (JsonProcessingException e) {
+            log.error("Fatal deserialization error — sending to DLQ: {}", e.getMessage());
+            channel.basicNack(deliveryTag, false, false);
+            return;
+        }
+
+        // TODO: Implement event processing logic
+        // Example: useCaseMediator.dispatch(new YourCommand(event.data()));
+
+        channel.basicAck(deliveryTag, false);
+    }
+
+}

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

@@ -34,7 +34,7 @@ import lombok.Setter;
  * <p>
  * No audit fields. The @Id mirrors the source entity's ID (not auto-generated).
  */
-@Entity
+@Entity(name = "<%= moduleName %>_<%= jpaEntityName %>")
 @Table(name = "<%= tableName %>")
 @Getter
 @Setter

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

@@ -2,10 +2,12 @@ package <%= packageName %>.<%= moduleName %>.infrastructure.database.repositorie
 
 import <%= packageName %>.<%= moduleName %>.infrastructure.database.entities.<%= jpaEntityName %>;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
 
 /**
  * Spring Data JPA repository for the <%= domainClassName %> read model.
  * Table: <%= tableName %>.
  */
+@Repository("<%= moduleName %>.<%= jpaRepositoryName %>")
 public interface <%= jpaRepositoryName %> extends JpaRepository<<%= jpaEntityName %>, String> {
 }

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/ReadModelRepositoryImpl.java.ejs

@@ -27,7 +27,7 @@ import java.util.Optional;
  * Repository implementation for the <%= domainClassName %> read model.
  * Maps between domain read model and JPA entity.
  */
-@Repository
+@Repository("<%= moduleName %>.<%= repositoryImplName %>")
 public class <%= repositoryImplName %> implements <%= repositoryName %> {
 
     private final <%= jpaRepositoryName %> jpaRepository;
@@ -38,11 +38,15 @@ public class <%= repositoryImplName %> implements <%= repositoryName %> {
 
     @Override
     public void upsert(<%= domainClassName %> readModel) {
-        <%= jpaEntityName %> entity = <%= jpaEntityName %>.builder()
-<% fields.forEach(field => { %>
-                .<%= field.name %>(readModel.get<%= field.name.charAt(0).toUpperCase() + field.name.slice(1) %>())
+        <%= 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) %>());
 <% }); %>
-                .build();
         jpaRepository.save(entity);
     }
 

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

@@ -8,6 +8,7 @@ import <%= packageName %>.<%= moduleName %>.domain.models.readmodels.<%= domainC
 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.
@@ -16,6 +17,7 @@ import <%= packageName %>.shared.domain.annotations.LogExceptions;
  * One method per syncedBy event — Kafka listeners delegate directly to these methods.
  */
 @ApplicationComponent
+@Component("<%= moduleName %>.<%= syncHandlerName %>")
 public class <%= syncHandlerName %> {
 
     private final <%= repositoryName %> repository;

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);