eva4j 1.0.16 → 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/ReadModelDomain.java.ejs

@@ -0,0 +1,46 @@
+package <%= packageName %>.<%= moduleName %>.domain.models.readmodels;
+<% 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;
+<% } %>
+
+/**
+ * Local Read Model — projection of data from <%= sourceModule %>/<%= sourceName %>.
+ * <p>
+ * This class is read-only from this module's perspective.
+ * The source module owns mutations; this projection is maintained
+ * via domain events (see syncedBy configuration in domain.yaml).
+ * <p>
+ * No business logic, no setters, no empty constructor.
+ */
+public class <%= domainClassName %> {
+<% fields.forEach(field => { %>
+    private final <%- field.javaType %> <%= field.name %>;
+<% }); %>
+
+    public <%= domainClassName %>(<%= fields.map(f => f.javaType + ' ' + f.name).join(', ') %>) {
+<% fields.forEach(field => { %>
+        this.<%= field.name %> = <%= field.name %>;
+<% }); %>
+    }
+<% fields.forEach(field => { %>
+
+    public <%- field.javaType %> get<%= field.name.charAt(0).toUpperCase() + field.name.slice(1) %>() {
+        return this.<%= field.name %>;
+    }
+<% }); %>
+}

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

@@ -0,0 +1,58 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.database.entities;
+<% 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.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+<% } %>
+<% if (needsInstant) { %>
+import java.time.Instant;
+<% } %>
+<% if (needsUUID) { %>
+import java.util.UUID;
+<% } %>
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+/**
+ * JPA entity for the local read model — table: <%= tableName %>.
+ * Projection of data from <%= sourceModule %>/<%= sourceName %>.
+ * <p>
+ * No audit fields. The @Id mirrors the source entity's ID (not auto-generated).
+ */
+@Entity(name = "<%= moduleName %>_<%= jpaEntityName %>")
+@Table(name = "<%= tableName %>")
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class <%= jpaEntityName %> {
+
+    @Id
+    private String id;
+<% fields.filter(f => f.name !== 'id').forEach(field => { %>
+
+    @Column(name = "<%= field.name.replace(/([A-Z])/g, '_$1').toLowerCase() %>")
+    private <%- field.javaType %> <%= field.name %>;
+<% }); %>
+<% if (hasSoftDelete) { %>
+
+    @Column(name = "deleted_at")
+    private LocalDateTime deletedAt;
+<% } %>
+}

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

@@ -0,0 +1,13 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.database.repositories;
+
+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/ReadModelKafkaListener.java.ejs

@@ -0,0 +1,64 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.kafkaListener;
+<% 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.databind.ObjectMapper;
+import org.springframework.kafka.annotation.KafkaListener;
+import org.springframework.kafka.support.Acknowledgment;
+import org.springframework.stereotype.Component;
+
+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;
+<% } %>
+<% } %>
+
+/**
+ * Kafka listener for read model sync — topic: <%= 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;
+    }
+
+    @KafkaListener(topics = "<%= topicSpringProperty %>", groupId = "${spring.application.name}-<%= moduleName %>-group")
+    public void handle(EventEnvelope<Map<String, Object>> event, Acknowledgment ack) {
+<% 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);
+<% } %>
+
+        ack.acknowledge();
+    }
+}