eva4j 1.0.13 → 1.0.15

package/templates/kafka-event/DomainEventHandlerMethod.ejs

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

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

@@ -3,6 +3,12 @@ package <%= packageName %>.<%= moduleName %>.application.events;
 <% const needsLocalDate = eventFields && eventFields.some(f => f.javaType === 'LocalDate' || f.javaType === 'LocalDateTime' || f.javaType === 'LocalTime'); %>
 <% const needsUUID = eventFields && eventFields.some(f => f.javaType === 'UUID'); %>
 <% const needsList = eventFields && eventFields.some(f => f.isCollection); %>
+<%
+  const _STANDARD_TYPES = new Set(['String','Integer','Long','Double','Float','Boolean','BigDecimal','LocalDate','LocalDateTime','LocalTime','Instant','UUID']);
+  const _customElementTypes = eventFields
+    ? [...new Set(eventFields.filter(f => f.isCollection && f.collectionElementType && !_STANDARD_TYPES.has(f.collectionElementType)).map(f => f.collectionElementType))]
+    : [];
+%>
 <% if (needsBigDecimal) { %>
 import java.math.BigDecimal;
 <% } %>
@@ -16,7 +22,17 @@ import java.util.UUID;
 <% if (needsList) { %>
 import java.util.List;
 <% } %>
+<% _customElementTypes.forEach(typeName => { %>
+import <%= packageName %>.<%= moduleName %>.domain.models.events.<%- typeName %>;
+<% }); %>
 
+/**
+ * Integration Event — broker-side projection of the corresponding domain event.
+ * <p>
+ * This record is the data carrier published to the message broker. It is intentionally
+ * decoupled from the domain event so that changes in broker technology or serialization
+ * format never affect the domain model.
+ */
 public record <%= eventClassName %>(
 <% if (eventFields && eventFields.length > 0) { %>
 <% eventFields.forEach((field, idx) => { %>

package/templates/kafka-listener/KafkaController.java.ejs

@@ -23,7 +23,7 @@ public class KafkaController {
         this.useCaseMediator = useCaseMediator;
     }
 
-    @KafkaListener(topics = "<%= topicSpringProperty %>")
+    @KafkaListener(topics = "<%= topicSpringProperty %>", groupId = "${spring.application.name}-<%= moduleName %>-group")
     void <%= methodName %>(EventEnvelope<Map<String, Object>> event, Acknowledgment ack) {
         // TODO: Implement event processing logic
         // Example: useCaseMediator.dispatch(new YourCommand(event.data()));

package/templates/kafka-listener/KafkaListenerClass.java.ejs

@@ -26,7 +26,7 @@ public class <%= listenerClassName %> {
         this.useCaseMediator = useCaseMediator;
     }
 
-    @KafkaListener(topics = "<%= topicSpringProperty %>")
+    @KafkaListener(topics = "<%= topicSpringProperty %>", groupId = "${spring.application.name}-<%= moduleName %>-group")
     public void handle(EventEnvelope<Map<String, Object>> event, Acknowledgment ack) {
         // TODO: Implement event processing logic
         // Example: useCaseMediator.dispatch(new YourCommand(event.data()));

package/templates/kafka-listener/ListenerClass.java.ejs

@@ -0,0 +1,65 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.kafkaListener;
+
+import <%= packageName %>.<%= moduleName %>.application.commands.<%= commandClassName %>;
+import <%= packageName %>.shared.infrastructure.configurations.useCaseConfig.UseCaseMediator;
+import <%= packageName %>.shared.infrastructure.eventEnvelope.EventEnvelope;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.kafka.annotation.KafkaListener;
+import org.springframework.kafka.support.Acknowledgment;
+import org.springframework.stereotype.Component;
+
+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 %>;
+<% }); %>
+/**
+ * Kafka listener for topic <%= topicConstant %>.
+ * Consumes events produced by: <%= producer %>.
+ * Dispatches to use case: <%= useCase %>.
+ */
+@Component("<%= moduleName %>.<%= listenerClassName %>")
+public class <%= listenerClassName %> {
+
+    private final UseCaseMediator useCaseMediator;
+    private final ObjectMapper objectMapper;
+
+    @Value("<%= topicSpringProperty %>")
+    private String <%= topicVariableName %>Topic;
+
+    public <%= listenerClassName %>(UseCaseMediator useCaseMediator, ObjectMapper objectMapper) {
+        this.useCaseMediator = useCaseMediator;
+        this.objectMapper = objectMapper;
+    }
+
+    @KafkaListener(topics = "<%= topicSpringProperty %>", groupId = "${spring.application.name}-<%= moduleName %>-group")
+    public void handle(EventEnvelope<Map<String, Object>> event, Acknowledgment ack) {
+<% (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 ? ',' : '' %>
+<% }); %>
+        ));
+        ack.acknowledge();
+    }
+}

package/templates/kafka-listener/ListenerCommand.java.ejs

@@ -0,0 +1,31 @@
+package <%= packageName %>.<%= moduleName %>.application.commands;
+
+import <%= packageName %>.shared.domain.interfaces.Command;
+<% 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'); %>
+<% const needsList        = fields && fields.some(f => f.javaType && f.javaType.startsWith('List')); %>
+<% 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;
+<% } %><% if (needsList) { %>import java.util.List;
+<% } %><% (nestedTypes || []).forEach(nt => { %>import <%= packageName %>.<%= moduleName %>.application.events.<%= nt.name %>;
+<% }); %>
+/**
+ * Command dispatched when <%= event %> is received from topic <%= topicConstant %>.
+ * Produced by: <%= producer %>.
+ * Handled by use case: <%= useCase %>.
+ */
+public record <%= commandClassName %>(
+<% if (fields && fields.length > 0) { %>
+<% fields.forEach((f, i) => { %>
+    <%- f.javaType %> <%= f.name %><%= i < fields.length - 1 ? ',' : '' %>
+<% }); %>
+<% } else { %>
+    // TODO: Add command fields
+<% } %>
+) implements Command {}

package/templates/kafka-listener/ListenerCommandHandler.java.ejs

@@ -0,0 +1,23 @@
+package <%= packageName %>.<%= moduleName %>.application.usecases;
+
+import <%= packageName %>.<%= moduleName %>.application.commands.<%= commandClassName %>;
+import <%= packageName %>.shared.domain.annotations.ApplicationComponent;
+import <%= packageName %>.shared.domain.interfaces.CommandHandler;
+
+/**
+ * Handles <%= commandClassName %> dispatched when <%= event %> is received.
+ * Produced by: <%= producer %>.
+ */
+@ApplicationComponent
+public class <%= useCase %>CommandHandler implements CommandHandler<<%= commandClassName %>> {
+
+  public <%= useCase %>CommandHandler() {
+
+  }
+
+  @Override
+  public void handle(<%= commandClassName %> command) {
+    // TODO: implement <%= useCase %> logic
+  }
+
+}

package/templates/kafka-listener/ListenerIntegrationEvent.java.ejs

@@ -0,0 +1,37 @@
+package <%= packageName %>.<%= moduleName %>.application.events;
+<% const needsBigDecimal = fields && fields.some(f => f.javaType === 'BigDecimal'); %>
+<% const needsLocalDate  = fields && fields.some(f => f.javaType === 'LocalDate' || f.javaType === 'LocalDateTime' || f.javaType === 'LocalTime'); %>
+<% const needsUUID       = fields && fields.some(f => f.javaType === 'UUID'); %>
+<% const needsList       = fields && fields.some(f => f.javaType && f.javaType.startsWith('List')); %>
+<% if (needsBigDecimal) { %>
+import java.math.BigDecimal;
+<% } %>
+<% if (needsLocalDate) { %>
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+<% } %>
+<% if (needsUUID) { %>
+import java.util.UUID;
+<% } %>
+<% if (needsList) { %>
+import java.util.List;
+<% } %>
+
+/**
+ * Integration Event consumed from topic <%= topicConstant %>.
+ * Produced by: <%= producer %>.
+ * <p>
+ * This record is the typed payload received from the message broker.
+ * It is intentionally decoupled from the producer's domain model so that
+ * changes in the producer never force changes here beyond the agreed contract.
+ */
+public record <%= integrationEventClassName %>(
+<% if (fields && fields.length > 0) { %>
+<% fields.forEach((field, idx) => { %>
+    <%- field.javaType %> <%= field.name %><%= idx < fields.length - 1 ? ',' : '' %>
+<% }); %>
+<% } else { %>
+    // TODO: Add payload fields matching the producer's Integration Event
+<% } %>
+) {}

package/templates/kafka-listener/ListenerMethod.java.ejs

@@ -1,6 +1,6 @@
 
    
-    @KafkaListener(topics = "<%= topicSpringProperty %>")
+    @KafkaListener(topics = "<%= topicSpringProperty %>", groupId = "${spring.application.name}-<%= moduleName %>-group")
     void <%= methodName %>(EventEnvelope<Map<String, Object>> event, Acknowledgment ack) {
         // TODO: Implement event processing logic
         // Example: useCaseMediator.dispatch(new YourCommand(event.data()));

package/templates/kafka-listener/ListenerNestedType.java.ejs

@@ -0,0 +1,28 @@
+package <%= packageName %>.<%= moduleName %>.application.events;
+<% 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'); %>
+<% const needsList       = fields && fields.some(f => f.javaType && f.javaType.startsWith('List')); %>
+<% 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;
+<% } %><% if (needsList) { %>
+import java.util.List;
+<% } %>
+public record <%= name %>(
+<% if (fields && fields.length > 0) { %>
+<% fields.forEach((field, idx) => { %>
+    <%- field.javaType %> <%= field.name %><%= idx < fields.length - 1 ? ',' : '' %>
+<% }); %>
+<% } else { %>
+    // TODO: Add payload fields
+<% } %>
+) {}

package/templates/mock/MockEvent.java.ejs

@@ -0,0 +1,10 @@
+package <%= packageName %>.shared.infrastructure.mockEvent;
+
+import java.util.Map;
+
+/**
+ * In-memory event envelope for mock mode.
+ * Routes events between modules via Spring's ApplicationEventPublisher
+ * instead of Kafka. Generated by eva build --mock.
+ */
+public record MockEvent(String topic, Map<String, Object> data) {}

package/templates/mock/MockMessageBrokerImpl.java.ejs

@@ -0,0 +1,35 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.adapters.kafkaMessageBroker;
+
+import <%= packageName %>.<%= moduleName %>.application.events.<%= eventClassName %>;
+import <%= packageName %>.<%= moduleName %>.application.ports.MessageBroker;
+import <%= packageName %>.shared.infrastructure.mockEvent.MockEvent;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.stereotype.Component;
+
+import java.util.Map;
+
+/**
+ * Mock MessageBroker implementation — routes events via Spring's
+ * ApplicationEventPublisher instead of Kafka.
+ * Generated by eva build --mock. Restored automatically on eva build.
+ */
+@Component("<%= moduleCamelCase %>KafkaMessageBroker")
+public class <%= modulePascalCase %>KafkaMessageBroker implements MessageBroker {
+
+  private final ApplicationEventPublisher eventPublisher;
+  private final ObjectMapper objectMapper;
+
+  public <%= modulePascalCase %>KafkaMessageBroker(ApplicationEventPublisher eventPublisher,
+                                                   ObjectMapper objectMapper) {
+    this.eventPublisher = eventPublisher;
+    this.objectMapper = objectMapper;
+  }
+
+  @Override
+  public void publish<%= eventClassName %>(<%= eventClassName %> event) {
+    @SuppressWarnings("unchecked")
+    Map<String, Object> payload = objectMapper.convertValue(event, Map.class);
+    eventPublisher.publishEvent(new MockEvent("<%= topicName %>", payload));
+  }
+}

package/templates/mock/MockMessageBrokerImplMethod.java.ejs

@@ -0,0 +1,6 @@
+  @Override
+  public void publish<%= eventClassName %>(<%= eventClassName %> event) {
+    @SuppressWarnings("unchecked")
+    Map<String, Object> payload = objectMapper.convertValue(event, Map.class);
+    eventPublisher.publishEvent(new MockEvent("<%= topicName %>", payload));
+  }

package/templates/mock/SpringEventListener.java.ejs

@@ -0,0 +1,61 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.kafkaListener;
+
+import <%= packageName %>.<%= moduleName %>.application.commands.<%= commandClassName %>;
+import <%= packageName %>.shared.infrastructure.configurations.useCaseConfig.UseCaseMediator;
+import <%= packageName %>.shared.infrastructure.mockEvent.MockEvent;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Component;
+
+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 %>;
+<% }); %>
+/**
+ * Spring in-memory listener for topic <%= topicConstant %>.
+ * Consumes MockEvent published by: <%= producer %>.
+ * Dispatches to use case: <%= useCase %>.
+ * Generated by eva build --mock. Restored automatically on eva build.
+ */
+@Component("<%= moduleName %>.<%= listenerClassName %>")
+public class <%= listenerClassName %> {
+
+    private final UseCaseMediator useCaseMediator;
+    private final ObjectMapper objectMapper;
+
+    public <%= listenerClassName %>(UseCaseMediator useCaseMediator, ObjectMapper objectMapper) {
+        this.useCaseMediator = useCaseMediator;
+        this.objectMapper = objectMapper;
+    }
+
+    @EventListener(condition = "#event.topic() == '<%= topicConstant %>'")
+    public void handle(MockEvent event) {
+        Map<String, Object> data = event.data();
+<% (fields || []).forEach(f => { %><%
+  const listMatch = f.javaType.match(/^List<(.+)>$/);
+  if (listMatch) { %>
+        <%- f.javaType %> <%= f.name %> = objectMapper.convertValue(
+                data.get("<%= f.name %>"),
+                objectMapper.getTypeFactory().constructCollectionType(List.class, <%= listMatch[1] %>.class));
+<%  } else { %>
+        <%- f.javaType %> <%= f.name %> = objectMapper.convertValue(data.get("<%= f.name %>"), <%- f.javaType %>.class);
+<%  } %><% }); %>
+        useCaseMediator.dispatch(new <%= commandClassName %>(
+<% (fields || []).forEach((f, i) => { %>
+                <%= f.name %><%= i < fields.length - 1 ? ',' : '' %>
+<% }); %>
+        ));
+    }
+}

package/templates/ports/PortDomainModel.java.ejs

@@ -0,0 +1,35 @@
+package <%= packageName %>.<%= moduleName %>.domain.models.<%= adapterPackage %>;
+<% 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'); %>
+<% const needsList       = fields && fields.some(f => f.javaType && f.javaType.startsWith('List')); %>
+<% 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;
+<% } %><% if (needsList) { %>
+import java.util.List;
+<% } %>
+/**
+ * Domain model for the <%- name %> concept consumed from <%= target || serviceName %>.
+ *
+ * <p>ACL (Anti-Corruption Layer): this record is the domain-side abstraction.
+ * The corresponding infra DTO lives in
+ * {@code infrastructure.adapters.<%= adapterPackage %>} and is mapped
+ * by the Feign adapter — if the external API changes, only the adapter
+ * mapper needs to be updated; domain logic using this type remains untouched.
+ */
+public record <%= name %>(
+<% if (fields && fields.length > 0) { %>
+<% fields.forEach((f, i) => { %>
+    <%- f.javaType %> <%= f.name %><%= i < fields.length - 1 ? ',' : '' %>
+<% }); %>
+<% } %>
+) {}

package/templates/ports/PortFeignAdapter.java.ejs

@@ -0,0 +1,67 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.adapters.<%= adapterPackage %>;
+
+import <%= packageName %>.<%= moduleName %>.domain.repositories.<%= serviceName %>;
+import org.springframework.stereotype.Component;
+<% const allMethods = methods || []; %>
+<% const hasAnyList = allMethods.some(m => m.returnList); %>
+<% if (hasAnyList) { %>import java.util.List;
+import java.util.stream.Collectors;
+<% } %>
+<% /* ACL: import domain models — the types the port interface returns */ %>
+<% const uniqueDomainTypes = [...new Set(allMethods.filter(m => m.domainType).map(m => m.domainType))]; %>
+<% uniqueDomainTypes.forEach(dt => { %>import <%= packageName %>.<%= moduleName %>.domain.models.<%= adapterPackage %>.<%= dt %>;
+<% }); %>
+<% /* Request DTOs and nested types stay in application.dtos */ %>
+<% allMethods.filter(m => m.hasBody).forEach(m => { %>import <%= packageName %>.<%= moduleName %>.application.dtos.<%= m.requestDtoName %>;
+<% }); %>
+<% (nestedTypes || []).forEach(nt => { %>import <%= packageName %>.<%= moduleName %>.application.dtos.<%= nt.name %>;
+<% }); %>
+@Component("<%= moduleName %>.<%= feignAdapterClassName %>")
+public class <%= feignAdapterClassName %> implements <%= serviceName %> {
+
+    private final <%= feignClientClassName %> feignClient;
+
+    public <%= feignAdapterClassName %>(<%= feignClientClassName %> feignClient) {
+        this.feignClient = feignClient;
+    }
+<% allMethods.forEach(m => { %>
+<%   /* Public override returns domain model; FeignClient returns infra DTO */ %>
+<%   const domainReturn = !m.hasResponse ? 'void'
+       : m.returnList ? `List<${m.domainType}>`
+       : m.domainType; %>
+<%   const params = []; %>
+<%   const args  = []; %>
+<%   m.pathVariables.forEach(pv => { params.push(`String ${pv}`); args.push(pv); }); %>
+<%   if (m.hasBody) { params.push(`${m.requestDtoName} body`); args.push('body'); } %>
+
+    @Override
+    public <%- domainReturn %> <%= m.name %>(<%= params.join(', ') %>) {
+<%   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());
+<%   } else { %>
+        return 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

@@ -0,0 +1,45 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.adapters.<%= adapterPackage %>;
+
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.web.bind.annotation.*;
+<% const allMethods = methods || []; %>
+<% const bodyFields = allMethods.flatMap(m => m.bodyFields || []); %>
+<% const hasAnyList = allMethods.some(m => m.returnList); %>
+<% const needsBigDecimal = bodyFields.some(f => f.javaType === 'BigDecimal'); %>
+<% const needsLocalDate  = bodyFields.some(f => ['LocalDate','LocalDateTime','LocalTime'].includes(f.javaType)); %>
+<% const needsInstant    = bodyFields.some(f => f.javaType === 'Instant'); %>
+<% const needsUUID       = bodyFields.some(f => f.javaType === 'UUID'); %>
+<% const needsListField  = bodyFields.some(f => f.javaType && f.javaType.startsWith('List')); %>
+<% if (hasAnyList || needsListField) { %>import java.util.List;
+<% } %><% 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;
+<% } %>
+<% /* Request DTOs and nested types live in application.dtos */ %>
+<% allMethods.filter(m => m.hasBody).forEach(m => { %>import <%= packageName %>.<%= moduleName %>.application.dtos.<%= m.requestDtoName %>;
+<% }); %>
+<% (nestedTypes || []).forEach(nt => { %>import <%= packageName %>.<%= moduleName %>.application.dtos.<%= nt.name %>;
+<% }); %>
+@FeignClient(
+    name = "<%= feignClientName %>",
+    url = "${<%= baseUrlProperty %>}",
+    configuration = <%= feignConfigClassName %>.class
+)
+public interface <%= feignClientClassName %> {
+<% allMethods.forEach(m => { %>
+<%   /* FeignClient returns the infra DTO (or void), not the domain model */ %>
+<%   const returnType = !m.hasResponse ? 'void'
+       : m.returnList ? `List<${m.infraDtoName}>`
+       : m.infraDtoName; %>
+<%   const httpVerbLower = m.httpVerb.charAt(0) + m.httpVerb.slice(1).toLowerCase(); %>
+<%   const mappingAnnotation = `@${httpVerbLower.charAt(0).toUpperCase()}${httpVerbLower.slice(1)}Mapping("${m.httpPath}")`; %>
+<%   const paramList = []; %>
+<%   m.pathVariables.forEach(pv => { paramList.push(`@PathVariable("${pv}") String ${pv}`); }); %>
+<%   if (m.hasBody) { paramList.push(`@RequestBody ${m.requestDtoName} body`); } %>
+    <%- mappingAnnotation %>
+    <%- returnType %> <%= m.name %>(<%- paramList.join(', ') %>);
+<% }); %>
+}

package/templates/ports/PortFeignConfig.java.ejs

@@ -0,0 +1,24 @@
+package <%= packageName %>.<%= moduleName %>.infrastructure.adapters.<%= adapterPackage %>;
+
+import feign.Logger;
+import feign.Request;
+import org.springframework.context.annotation.Bean;
+
+import java.util.concurrent.TimeUnit;
+
+public class <%= feignConfigClassName %> {
+
+    @Bean
+    public Logger.Level feignLoggerLevel() {
+        return Logger.Level.BASIC;
+    }
+
+    @Bean
+    public Request.Options feignOptions() {
+        return new Request.Options(
+            15, TimeUnit.SECONDS,   // connect timeout
+            15, TimeUnit.SECONDS,   // read timeout
+            true
+        );
+    }
+}

package/templates/ports/PortInterface.java.ejs

@@ -0,0 +1,45 @@
+package <%= packageName %>.<%= moduleName %>.domain.repositories;
+<% /* ── Compute all imports needed ── */ %>
+<% const allMethods = methods || []; %>
+<% const hasAnyList = allMethods.some(m => m.returnList); %>
+<% const bodyFields = allMethods.flatMap(m => m.bodyFields || []); %>
+<% const needsBigDecimal = bodyFields.some(f => f.javaType === 'BigDecimal'); %>
+<% const needsLocalDate  = bodyFields.some(f => ['LocalDate','LocalDateTime','LocalTime'].includes(f.javaType)); %>
+<% const needsInstant    = bodyFields.some(f => f.javaType === 'Instant'); %>
+<% const needsUUID       = bodyFields.some(f => f.javaType === 'UUID'); %>
+<% const needsListField  = bodyFields.some(f => f.javaType && f.javaType.startsWith('List')); %>
+<% if (hasAnyList || needsListField) { %>import java.util.List;
+<% } %><% 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;
+<% } %>
+<% /* ACL: port interface returns domain models, not infra DTOs */ %>
+<% const uniqueDomainTypes = [...new Set(allMethods.filter(m => m.domainType).map(m => m.domainType))]; %>
+<% uniqueDomainTypes.forEach(dt => { %>import <%= packageName %>.<%= moduleName %>.domain.models.<%= adapterPackage %>.<%= dt %>;
+<% }); %>
+<% /* Import request DTOs */ %>
+<% allMethods.filter(m => m.hasBody).forEach(m => { %>import <%= packageName %>.<%= moduleName %>.application.dtos.<%= m.requestDtoName %>;
+<% }); %>
+<% /* Import nested types */ %>
+<% (nestedTypes || []).forEach(nt => { %>import <%= packageName %>.<%= moduleName %>.application.dtos.<%= nt.name %>;
+<% }); %>
+/**
+ * Secondary port — HTTP client to <%= target || serviceName %>.
+ * The domain depends on this interface; the infrastructure provides the Feign implementation.
+ * All return types are domain models (ACL pattern).
+ */
+public interface <%= serviceName %> {
+<% allMethods.forEach(m => { %>
+<%   /* Domain models are the return type — void when no response */ %>
+<%   const returnType = !m.hasResponse ? 'void'
+       : m.returnList ? `List<${m.domainType}>`
+       : m.domainType; %>
+<%   const params = []; %>
+<%   m.pathVariables.forEach(pv => { params.push(`String ${pv}`); }); %>
+<%   if (m.hasBody) { params.push(`${m.requestDtoName} body`); } %>
+    <%- returnType %> <%= m.name %>(<%= params.join(', ') %>);
+<% }); %>
+}

package/templates/ports/PortNestedType.java.ejs

@@ -0,0 +1,28 @@
+package <%= packageName %>.<%= moduleName %>.application.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'); %>
+<% const needsUUID       = fields && fields.some(f => f.javaType === 'UUID'); %>
+<% const needsList       = fields && fields.some(f => f.javaType && f.javaType.startsWith('List')); %>
+<% 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;
+<% } %><% if (needsList) { %>
+import java.util.List;
+<% } %>
+public record <%= name %>(
+<% if (fields && fields.length > 0) { %>
+<% fields.forEach((field, idx) => { %>
+    <%- field.javaType %> <%= field.name %><%= idx < fields.length - 1 ? ',' : '' %>
+<% }); %>
+<% } else { %>
+    // TODO: Add fields
+<% } %>
+) {}