eva4j 1.0.13 → 1.0.15

package/src/utils/yaml-to-entity.js

@@ -1,7 +1,7 @@
 const yaml = require('js-yaml');
 const fs = require('fs-extra');
 const pluralize = require('pluralize');
-const { toPascalCase, toCamelCase, toSnakeCase } = require('./naming');
+const { toPascalCase, toCamelCase, toSnakeCase, toKebabCase } = require('./naming');
 
 /**
  * Parse domain.yaml and extract aggregates with entities and value objects
@@ -23,10 +23,38 @@ async function parseDomainYaml(yamlPath, packageName = '', moduleName = '') {
     packageName,
     moduleName
   }));
-  
+
+  const endpoints = parseEndpoints(domainData);
+  const listeners = parseListeners(domainData);
+
+  // ── C2-006: useCase name collision between endpoints and listeners ─────────
+  // Both sections generate a "{UseCase}Command.java". The generator processes
+  // listeners first, then endpoints — the endpoint run silently overwrites the
+  // listener command, leaving the KafkaListener dispatching a constructor that
+  // no longer exists → compile error.
+  const endpointUseCases = new Set(
+    endpoints ? endpoints.versions.flatMap(v => v.operations.map(op => op.useCase)) : []
+  );
+  const collisions = listeners
+    .map(l => l.useCase)
+    .filter(uc => endpointUseCases.has(uc));
+  if (collisions.length > 0) {
+    throw new Error(
+      `[C2-006] useCase name collision in domain.yaml:\n` +
+      collisions.map(uc =>
+        `  - "${uc}" appears in both endpoints: (operation) and listeners: (useCase).\n` +
+        `    Both would generate "${uc}Command.java" — the endpoint version overwrites the listener version.\n` +
+        `    Fix: rename the listener useCase, e.g. "${uc.replace(/^Create/, 'Initialize')}".`
+      ).join('\n')
+    );
+  }
+
   return {
     aggregates,
-    allEnums: extractAllEnums(domainData.aggregates)
+    allEnums: extractAllEnums(domainData.aggregates),
+    endpoints,
+    listeners,
+    ports: parsePorts(domainData, moduleName)
   };
 }
 
@@ -79,10 +107,21 @@ function parseAggregate(aggregateData) {
     return {
       name: eventName,
       fieldName: toCamelCase(eventName),
-      fields: eventFields
+      fields: eventFields,
+      triggers: event.triggers || []
     };
   });
 
+  // Build inverse map: { methodName → [event, ...] }
+  // Used by the AggregateRoot template to emit raise() calls inside transition methods.
+  const triggeredEventsMap = {};
+  domainEvents.forEach(event => {
+    (event.triggers || []).forEach(method => {
+      if (!triggeredEventsMap[method]) triggeredEventsMap[method] = [];
+      triggeredEventsMap[method].push(event);
+    });
+  });
+
   return {
     name: toPascalCase(name),
     packageName: aggregateData.package || '',
@@ -91,7 +130,9 @@ function parseAggregate(aggregateData) {
     valueObjects: parsedValueObjects,
     aggregateMethods,
     allEntities: parsedEntities,
-    domainEvents
+    domainEvents,
+    triggeredEventsMap,
+    enums: aggregateEnums
   };
 }
 
@@ -107,8 +148,16 @@ function parseAggregate(aggregateData) {
  * @returns {Object} Parsed entity
  */
 function parseEntity(entityData, aggregateName, packageName = '', moduleName = '', aggregateEnums = [], valueObjectNames = [], inverseRelationships = {}) {
-  const { name, isRoot = false, tableName, properties, fields: fieldsYaml, relationships = [], auditable = false, audit } = entityData;
+  const { name, isRoot = false, tableName, properties, fields: fieldsYaml, relationships = [], auditable = false, audit, hasSoftDelete = false } = entityData;
   
+  // Validate hasSoftDelete
+  if (hasSoftDelete !== undefined && typeof hasSoftDelete !== 'boolean') {
+    throw new Error(`Entity "${name}": hasSoftDelete must be a boolean (true/false)`);
+  }
+  if (hasSoftDelete === true && isRoot === false) {
+    console.warn(`⚠️  Entity "${name}": hasSoftDelete is only supported on the aggregate root (isRoot: true). It will be ignored for secondary entities.`);
+  }
+
   // Accept both 'properties' and 'fields' field names
   let entityFields = properties || fieldsYaml || [];
   
@@ -172,6 +221,15 @@ function parseEntity(entityData, aggregateName, packageName = '', moduleName = '
       ];
     }
   }
+
+  // Inject deletedAt field for soft-delete root entities
+  const effectiveSoftDelete = hasSoftDelete === true && isRoot === true;
+  if (effectiveSoftDelete) {
+    entityFields = [
+      ...entityFields,
+      { name: 'deletedAt', type: 'LocalDateTime' }
+    ];
+  }
   
   const className = toPascalCase(name);
   const fieldName = toCamelCase(name);
@@ -204,6 +262,7 @@ function parseEntity(entityData, aggregateName, packageName = '', moduleName = '
     fieldName,
     tableName: table,
     isRoot,
+    hasSoftDelete: effectiveSoftDelete,
     auditable: auditable === true, // Legacy support
     audit: auditConfig, // New audit configuration
     fields,
@@ -233,7 +292,7 @@ function buildAnnotationString(validation) {
   if (value !== undefined)     params.push(`value = ${value}`);
   if (min !== undefined)       params.push(`min = ${min}`);
   if (max !== undefined)       params.push(`max = ${max}`);
-  if (regexp !== undefined)    params.push(`regexp = "${regexp}"`);
+  if (regexp !== undefined)    params.push(`regexp = "${regexp.replace(/\\/g, '\\\\')}"`);
   if (integer !== undefined)   params.push(`integer = ${integer}`);
   if (fraction !== undefined)  params.push(`fraction = ${fraction}`);
   if (inclusive !== undefined) params.push(`inclusive = ${inclusive}`);
@@ -961,6 +1020,239 @@ function extractAllEnums(aggregates) {
   return Array.from(enumsMap.values());
 }
 
+/**
+ * Parse the optional endpoints section from domain.yaml.
+ * When present, controls which use cases and versioned controllers are generated.
+ * @param {Object} domainData - Raw parsed YAML data
+ * @returns {Object|null} Parsed endpoints structure or null if not declared
+ */
+function parseEndpoints(domainData) {
+  if (!domainData.endpoints) return null;
+  const { basePath = '/', versions = [] } = domainData.endpoints;
+  return {
+    basePath,
+    versions: versions.map(v => ({
+      version: v.version,
+      operations: (v.operations || []).map(op => {
+        const method = (op.method || 'GET').toUpperCase();
+        return {
+          method,
+          path: op.path || '/',
+          description: op.description || '',
+          useCase: toPascalCase(op.useCase),
+          type: method === 'GET' ? 'query' : 'command'
+        };
+      })
+    }))
+  };
+}
+
+/**
+ * Parse the optional listeners section from domain.yaml.
+ * Declares integration events this module CONSUMES from external producers.
+ * @param {Object} domainData - Raw parsed YAML data
+ * @returns {Array} Parsed listeners array (empty if not declared)
+ */
+function parseListeners(domainData) {
+  if (!domainData.listeners || !Array.isArray(domainData.listeners)) return [];
+  return domainData.listeners.map(listener => {
+    const eventName = toPascalCase(listener.event);
+    // Normalise: strip trailing 'Event' suffix for class naming, re-add it consistently
+    const baseName = eventName.endsWith('Event') ? eventName.slice(0, -5) : eventName;
+    const integrationEventClassName = `${baseName}IntegrationEvent`;
+    // e.g. PaymentApprovedKafkaListener
+    const listenerClassName = `${baseName}KafkaListener`;
+    const useCaseName = toPascalCase(listener.useCase);
+    const commandClassName = `${useCaseName}Command`;
+    const topic = listener.topic || null;
+    const fields = (listener.fields || []).map(f => ({
+      name: toCamelCase(f.name),
+      javaType: f.type
+    }));
+    const nestedTypes = (listener.nestedTypes || []).map(nt => ({
+      name: toPascalCase(nt.name),
+      fields: (nt.fields || []).map(f => ({
+        name: toCamelCase(f.name),
+        javaType: f.type
+      }))
+    }));
+    return {
+      event: eventName,
+      baseName,
+      producer: listener.producer || null,
+      topic,
+      useCase: useCaseName,
+      commandClassName,
+      integrationEventClassName,
+      listenerClassName,
+      fields,
+      nestedTypes
+    };
+  });
+}
+
+/**
+ * Derive a domain model type name from a method name.
+ * Strips common verb prefixes and 'ById/ByName/...' suffixes so that
+ * 'findCustomerById' → 'Customer', 'processPayment' → 'Payment'.
+ * @param {string} methodName  camelCase method name
+ * @returns {string} PascalCase domain model name
+ */
+function deriveDomainType(methodName) {
+  let name = toPascalCase(methodName);
+
+  // Strip verb prefix
+  name = name.replace(
+    /^(Find|Get|Fetch|Search|Retrieve|List|Check|Process|Create|Update|Delete|Cancel|Submit|Execute)/,
+    ''
+  );
+
+  // Strip trailing 'By{Something}' (e.g. ById, ByName, ByCode)
+  name = name.replace(/By[A-Z][a-zA-Z0-9]*$/, '');
+
+  // Strip common informational suffixes
+  name = name.replace(/(?:Status|Availability|All)$/, '');
+
+  // Fall back to full PascalCase method name if we stripped everything
+  return name || toPascalCase(methodName);
+}
+
+/**
+ * Parse the optional ports section from domain.yaml.
+ * Declares HTTP services this module CALLS synchronously (Feign clients).
+ * Entries sharing the same service: are grouped into a single FeignClient.
+ * @param {Object} domainData - Raw parsed YAML data
+ * @param {string} moduleName - Module name (used for property key naming)
+ * @returns {Array} Parsed port service groups (empty if not declared)
+ */
+function parsePorts(domainData, moduleName = '') {
+  if (!domainData.ports || !Array.isArray(domainData.ports)) return [];
+
+  const serviceMap = new Map();
+
+  for (const entry of domainData.ports) {
+    if (!entry.service || !entry.name) continue;
+
+    const serviceName = toPascalCase(entry.service);
+    const methodName  = toCamelCase(entry.name);
+    const methodPascal = toPascalCase(entry.name);
+
+    // Parse HTTP verb + path
+    const httpParts = (entry.http || 'GET /').trim().split(/\s+/);
+    const httpVerb  = (httpParts[0] || 'GET').toUpperCase();
+    const httpPath  = httpParts[1] || '/';
+
+    // Extract path variables: /screenings/{id}/seats → ['id']
+    const pathVarMatches = httpPath.match(/\{(\w+)\}/g) || [];
+    const pathVariables  = pathVarMatches.map(pv => pv.slice(1, -1));
+
+    // Response fields
+    const responseFields = (entry.fields || []).map(f => ({
+      name: toCamelCase(f.name),
+      javaType: f.type
+    }));
+
+    // Body fields (POST/PUT/PATCH only)
+    const bodyAllowed = httpVerb !== 'GET' && httpVerb !== 'DELETE';
+    const bodyFields  = bodyAllowed
+      ? (entry.body || []).map(f => ({ name: toCamelCase(f.name), javaType: f.type }))
+      : [];
+
+    // nestedTypes per method
+    const nestedTypes = (entry.nestedTypes || []).map(nt => ({
+      name: toPascalCase(nt.name),
+      fields: (nt.fields || []).map(f => ({
+        name: toCamelCase(f.name),
+        javaType: f.type
+      }))
+    }));
+
+    const returnList      = entry.returnList === true;
+    const hasResponse     = responseFields.length > 0;
+    const hasBody         = bodyFields.length > 0;
+    // ACL: infra DTO name (lives in infrastructure/adapters/{service}/)
+    const infraDtoName    = hasResponse ? `${methodPascal}Dto` : null;
+    // Domain model type (lives in domain/models/)
+    const domainType      = hasResponse
+      ? (entry.domainType ? toPascalCase(entry.domainType) : deriveDomainType(entry.name))
+      : null;
+    // Keep responseDtoName as alias to infraDtoName for backward-compat
+    const responseDtoName = infraDtoName;
+    const requestDtoName  = hasBody ? `${methodPascal}RequestDto` : null;
+
+    const method = {
+      name: methodName,
+      namePascal: methodPascal,
+      httpVerb,
+      httpPath,
+      pathVariables,
+      fields: responseFields,
+      bodyFields,
+      nestedTypes,
+      returnList,
+      hasResponse,
+      hasBody,
+      infraDtoName,
+      domainType,
+      responseDtoName,
+      requestDtoName
+    };
+
+    if (!serviceMap.has(serviceName)) {
+      serviceMap.set(serviceName, {
+        serviceName,
+        serviceNameCamelCase: toCamelCase(serviceName),
+        target: entry.target || null,
+        baseUrl: entry.baseUrl || null,
+        methods: [],
+        nestedTypes: [],
+        domainModels: []  // ACL: unique domain models per service group
+      });
+    }
+
+    const group = serviceMap.get(serviceName);
+    group.methods.push(method);
+
+    // Keep baseUrl from the first entry that declares it
+    if (entry.baseUrl && !group.baseUrl) {
+      group.baseUrl = entry.baseUrl;
+    }
+
+    // Deduplicate nestedTypes within the service group
+    for (const nt of nestedTypes) {
+      if (!group.nestedTypes.some(existing => existing.name === nt.name)) {
+        group.nestedTypes.push(nt);
+      }
+    }
+
+    // ACL: collect unique domain models (by name) across all methods in this service
+    if (method.domainType && method.hasResponse) {
+      if (!group.domainModels.some(dm => dm.name === method.domainType)) {
+        group.domainModels.push({
+          name: method.domainType,
+          fields: method.fields
+        });
+      }
+    }
+  }
+
+  const moduleKebab = toKebabCase(moduleName);
+
+  return Array.from(serviceMap.values()).map(group => {
+    const serviceKebab = toKebabCase(group.serviceName);
+    return {
+      ...group,
+      baseUrl: group.baseUrl || 'http://localhost:8080',
+      baseUrlProperty: `${moduleKebab}.${serviceKebab}.base-url`,
+      feignClientName: `${moduleKebab}-${serviceKebab}`,
+      feignClientClassName:  `${group.serviceName}FeignClient`,
+      feignAdapterClassName: `${group.serviceName}FeignAdapter`,
+      feignConfigClassName:  `${group.serviceName}FeignConfig`,
+      adapterPackage: group.serviceNameCamelCase
+    };
+  });
+}
+
 module.exports = {
   parseDomainYaml,
   parseAggregate,
@@ -969,5 +1261,7 @@ module.exports = {
   generateAggregateMethods,
   generateEntityImports,
   generateValidationImports,
-  generateAggregateMethodImports
+  generateAggregateMethodImports,
+  parseListeners,
+  parsePorts
 };

package/templates/aggregate/AggregateMapper.java.ejs

@@ -82,8 +82,9 @@ public class <%= aggregateName %>Mapper {
   <% } else if (!rel.isCollection && rel.type === 'OneToOne') { %>
         // Map OneToOne relationship <%= rel.fieldName %>
         if (domain.get<%= rel.fieldName.charAt(0).toUpperCase() + rel.fieldName.slice(1) %>() != null) {
-            <%= rel.target %>Jpa <%= rel.fieldName %>Jpa = toJpa<%= rel.target %>(domain.get<%= rel.fieldName.charAt(0).toUpperCase() + rel.fieldName.slice(1) %>(), jpa);
-            jpa.set<%= rel.fieldName.charAt(0).toUpperCase() + rel.fieldName.slice(1) %>(<%= rel.fieldName %>Jpa);
+            <%= rel.target %>Jpa <%= rel.fieldName %>Jpa = toJpa<%= rel.target %>(domain.get<%= rel.fieldName.charAt(0).toUpperCase() + rel.fieldName.slice(1) %>());
+<% if (rel.mappedBy) { %>            <%= rel.fieldName %>Jpa.set<%= rel.mappedBy.charAt(0).toUpperCase() + rel.mappedBy.slice(1) %>(jpa);
+<% } %>            jpa.set<%= rel.fieldName.charAt(0).toUpperCase() + rel.fieldName.slice(1) %>(<%= rel.fieldName %>Jpa);
         }
   <% } else if (!rel.isCollection) { %>
         jpa.set<%= rel.fieldName.charAt(0).toUpperCase() + rel.fieldName.slice(1) %>(toJpa<%= rel.target %>(domain.get<%= rel.fieldName.charAt(0).toUpperCase() + rel.fieldName.slice(1) %>()));

package/templates/aggregate/AggregateRepository.java.ejs

@@ -17,7 +17,13 @@ public interface <%= rootEntity.name %>Repository {
     
     Page<<%= rootEntity.name %>> findAll(Pageable pageable);
     
-    void deleteById(<%= rootEntity.fields[0].javaType %> id);
-    
     boolean existsById(<%= rootEntity.fields[0].javaType %> id);
+<% if (!hasSoftDelete) { %>
+    void deleteById(<%= rootEntity.fields[0].javaType %> id);
+<% } %>
+<% if (findByOps && findByOps.length > 0) { %>
+<% findByOps.forEach(function(op) { %>
+    Page<<%= rootEntity.name %>> <%= op.jpaMethodName %>(<%= op.fieldJavaType %> <%= op.fieldName %>, Pageable pageable);
+<% }); %>
+<% } %>
 }

package/templates/aggregate/AggregateRepositoryImpl.java.ejs

@@ -49,13 +49,23 @@ public class <%= rootEntity.name %>RepositoryImpl implements <%= rootEntity.name
                 .map(mapper::toDomain);
     }
     
+    @Override
+    public boolean existsById(<%= rootEntity.fields[0].javaType %> id) {
+        return jpaRepository.existsById(id);
+    }
+<% if (!hasSoftDelete) { %>
     @Override
     public void deleteById(<%= rootEntity.fields[0].javaType %> id) {
         jpaRepository.deleteById(id);
     }
-    
+<% } %>
+<% if (findByOps && findByOps.length > 0) { %>
+<% findByOps.forEach(function(op) { %>
     @Override
-    public boolean existsById(<%= rootEntity.fields[0].javaType %> id) {
-        return jpaRepository.existsById(id);
+    public Page<<%= rootEntity.name %>> <%= op.jpaMethodName %>(<%= op.fieldJavaType %> <%= op.fieldName %>, Pageable pageable) {
+        return jpaRepository.<%= op.jpaMethodName %>(<%= op.fieldName %>, pageable)
+                .map(mapper::toDomain);
     }
+<% }); %>
+<% } %>
 }

package/templates/aggregate/AggregateRoot.java.ejs

@@ -18,6 +18,14 @@ import <%= packageName %>.shared.domain.DomainEvent;
 import <%= packageName %>.<%= moduleName %>.domain.models.events.<%= event.name %>;
 <% }); %>
 <% } %>
+<%
+const _needsLocalDateTimeImport = Object.values(triggeredEventsMap || {}).flat().some(function(ev) {
+  return (ev.fields || []).some(function(ef) { return ef.name.endsWith('At') && ef.javaType === 'LocalDateTime'; });
+}) && !imports.some(function(imp) { return imp.includes('LocalDateTime'); });
+%>
+<% if (_needsLocalDateTimeImport) { %>
+import java.time.LocalDateTime;
+<% } %>
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -82,7 +90,7 @@ public class <%= name %> {
 <% }); %>
     }
 
-<% const creationFields = fields.filter(f => f.name !== 'id' && f.name !== 'createdAt' && f.name !== 'updatedAt' && f.name !== 'createdBy' && f.name !== 'updatedBy' && !f.readOnly && !f.autoInit); %>
+<% const creationFields = fields.filter(f => f.name !== 'id' && f.name !== 'createdAt' && f.name !== 'updatedAt' && f.name !== 'createdBy' && f.name !== 'updatedBy' && f.name !== 'deletedAt' && !f.readOnly && !f.autoInit); %>
 <% const autoInitFields = fields.filter(f => f.autoInit); %>
 <% const defaultValueFields = fields.filter(f => f.readOnly && !f.autoInit && f.javaDefaultValue); %>
 <% if (creationFields.length > 0 || autoInitFields.length > 0 || defaultValueFields.length > 0) { %>
@@ -184,8 +192,40 @@ public class <%= name %> {
         }
 <% } %>
         this.<%= field.name %> = this.<%= field.name %>.transitionTo(<%- field.javaType %>.<%= transition.to %>);
+<%
+    const _triggeredEvents = (triggeredEventsMap || {})[methodName] || [];
+    _triggeredEvents.forEach(function(evt) {
+      const _entityBase = name.charAt(0).toLowerCase() + name.slice(1);
+      const _args = ['this.getId()'];
+      (evt.fields || []).forEach(function(ef) {
+        // Skip {entityName}Id — already provided as aggregateId in the DomainEvent constructor
+        if (ef.name === _entityBase + 'Id') { return; }
+        const _matched = fields.find(function(f) { return f.name === ef.name; });
+        if (_matched) {
+          if (_matched.javaType === ef.javaType) {
+            _args.push('this.get' + ef.name.charAt(0).toUpperCase() + ef.name.slice(1) + '()'); return;
+          }
+          // Type mismatch: entity field may be a VO wrapping the expected primitive/type
+          var _vo = (valueObjects || []).find(function(vo) { return vo.name === _matched.javaType; });
+          if (_vo) {
+            var _voSub = _vo.fields.find(function(voF) { return voF.name === ef.name && voF.javaType === ef.javaType; });
+            if (!_voSub) { _voSub = _vo.fields.find(function(voF) { return voF.javaType === ef.javaType; }); }
+            if (_voSub) {
+              var _oCap = ef.name.charAt(0).toUpperCase() + ef.name.slice(1);
+              var _sCap = _voSub.name.charAt(0).toUpperCase() + _voSub.name.slice(1);
+              _args.push('this.get' + _oCap + '().get' + _sCap + '()'); return;
+            }
+          }
+          _args.push('null /* TODO: provide ' + ef.name + ' (entity returns ' + _matched.javaType + ', expected ' + ef.javaType + ') */'); return;
+        }
+        if (ef.name.endsWith('At') && ef.javaType === 'LocalDateTime') { _args.push('LocalDateTime.now()'); return; }
+        _args.push('null /* TODO: provide ' + ef.name + ' */');
+      });
+%>
+        raise(new <%= evt.name %>(<%= _args.join(', ') %>));
+<%  }); %>
     }
-<%     }); %>
+<%     });%>
 
     // ─── State Query Helpers ─────────────────────────────────────────────────
 <%     meta.enumValues.forEach(value => { %>
@@ -202,4 +242,22 @@ public class <%= name %> {
 <%     }); %>
 <% }); %>
 <% } %>
+<% if (hasSoftDelete) { %>
+
+    // ─── Soft Delete ─────────────────────────────────────────────────────────
+    /**
+     * Marks this entity as deleted by setting deletedAt timestamp.
+     * Use this instead of physical deletion to preserve records.
+     */
+    public void softDelete() {
+        if (this.deletedAt != null) {
+            throw new IllegalStateException("<%= name %> is already deleted");
+        }
+        this.deletedAt = java.time.LocalDateTime.now();
+    }
+
+    public boolean isDeleted() {
+        return this.deletedAt != null;
+    }
+<% } %>
 }

package/templates/aggregate/DomainEventHandler.java.ejs

@@ -6,32 +6,37 @@ import org.springframework.transaction.event.TransactionalEventListener;
 <% domainEvents.forEach(event => { %>
 import <%= packageName %>.<%= moduleName %>.domain.models.events.<%= event.name %>;
 <% }); %>
-<% if (hasKafkaEvents) { %>
-import <%= packageName %>.<%= moduleName %>.domain.repositories.MessageBroker;
+<% if (broker) { %>
+<% domainEvents.forEach(event => { %>
+import <%= packageName %>.<%= moduleName %>.application.events.<%= event.integrationEventClassName %>;
+<% }); %>
+import <%= packageName %>.<%= moduleName %>.application.ports.MessageBroker;
 <% } %>
 
 /**
  * <%= aggregateName %>DomainEventHandler — Domain Event Bridge
  *
- * This handler connects the internal Spring event bus (ApplicationEventPublisher)
- * with the external messaging port (MessageBroker).
+ * Connects the internal Spring event bus (ApplicationEventPublisher) with the
+ * external messaging port (MessageBroker).
  *
  * Architecture:
  *   AggregateRepositoryImpl.save()
- *     → eventPublisher.publishEvent(domainEvent)   [internal Spring bus]
- *       → @TransactionalEventListener(AFTER_COMMIT) [this class]
- *         → messageBroker.send*(event)             [port — broker-agnostic]
+ *     → eventPublisher.publishEvent(domainEvent)        [internal Spring bus]
+ *       → @TransactionalEventListener(AFTER_COMMIT)     [this class]
+ *         → messageBroker.publish*(integrationEvent)    [port — broker-agnostic]
  *
- * AFTER_COMMIT ensures the external event is only published if the
- * database transaction committed successfully, preventing ghost events
- * from rolled-back operations.
+ * AFTER_COMMIT guarantees that external events are published only when the
+ * database transaction committed successfully, preventing ghost events from
+ * rolled-back operations.
  *
- * To switch brokers (Kafka → RabbitMQ → SNS): change only the MessageBroker
- * adapter in infrastructure/. This class never needs modification.
+ * Domain Events  (domain/models/events/)  — internal signals scoped to this bounded context.
+ * Integration Events (application/events/) — broker-facing projections; changing broker
+ *   technology (Kafka → RabbitMQ → SNS) only requires changing the MessageBroker adapter.
+ *   Domain Events — and therefore this class — never need modification.
  */
 @ApplicationComponent
 public class <%= aggregateName %>DomainEventHandler {
-<% if (hasKafkaEvents) { %>
+<% if (broker) { %>
 
     private final MessageBroker messageBroker;
 
@@ -42,16 +47,18 @@ public class <%= aggregateName %>DomainEventHandler {
 <% domainEvents.forEach(event => { %>
 
     /**
-     * Handles {@link <%= event.name %>} after the wrapping transaction commits.
-     * <% if (!event.kafka) { %>
+     * Handles {@link <%= event.name %>} after the wrapping transaction commits.<% if (!broker) { %>
+     * <p>
      * TODO: Implement the side effect for this event (e.g., send notification,
-     *       update a read model, trigger a saga step, etc.).
-     * <% } %>
+     *       update a read model, trigger a saga step, etc.).<% } %>
      */
     @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
-    public void on<%= event.name %>(<%=  event.name %> event) {
-    <% if (event.kafka) { %>
-        messageBroker.send<%= event.name %>(event);
+    public void on<%= event.name %>(<%= event.name %> event) {
+    <% if (broker) { %>
+        <%
+          const _aggrIdField = aggregateName.charAt(0).toLowerCase() + aggregateName.slice(1) + 'Id';
+        %>
+        messageBroker.publish<%= event.integrationEventClassName %>(new <%= event.integrationEventClassName %>(<% if (event.fields && event.fields.length > 0) { event.fields.forEach(function(field, idx) { %><%= field.name === _aggrIdField ? 'event.getAggregateId()' : 'event.get' + field.name.charAt(0).toUpperCase() + field.name.slice(1) + '()' %><%= idx < event.fields.length - 1 ? ', ' : '' %><% }); } %>));
     <% } else { %>
         // TODO: handle <%= event.name %> — add your side-effect logic here
         //   e.g.:  notificationService.notify(event);

package/templates/aggregate/DomainEventRecord.java.ejs

@@ -1,10 +1,16 @@
 package <%= packageName %>.<%= moduleName %>.domain.models.events;
 
 import <%= packageName %>.shared.domain.DomainEvent;
-<% const needsBigDecimal = fields.some(f => f.javaType === 'BigDecimal'); %>
-<% const needsLocalDate = fields.some(f => f.javaType === 'LocalDate' || f.javaType === 'LocalDateTime' || f.javaType === 'LocalTime'); %>
-<% const needsUUID = fields.some(f => f.javaType === 'UUID'); %>
-<% const needsList = fields.some(f => f.isCollection); %>
+<%
+  // Fields named {aggregateName}Id are excluded — the aggregate id is already
+  // available via getAggregateId() inherited from DomainEvent.
+  const _aggregateBase = aggregateName.charAt(0).toLowerCase() + aggregateName.slice(1);
+  const _ownFields = fields.filter(f => f.name !== _aggregateBase + 'Id');
+%>
+<% const needsBigDecimal = _ownFields.some(f => f.javaType === 'BigDecimal'); %>
+<% const needsLocalDate = _ownFields.some(f => f.javaType === 'LocalDate' || f.javaType === 'LocalDateTime' || f.javaType === 'LocalTime'); %>
+<% const needsUUID = _ownFields.some(f => f.javaType === 'UUID'); %>
+<% const needsList = _ownFields.some(f => f.isCollection); %>
 <% if (needsBigDecimal) { %>
 import java.math.BigDecimal;
 <% } %>
@@ -18,6 +24,15 @@ import java.util.UUID;
 <% if (needsList) { %>
 import java.util.List;
 <% } %>
+<%
+  const _STANDARD_DOMAIN_TYPES = new Set(['String','Integer','Long','Double','Float','Boolean','BigDecimal','LocalDate','LocalDateTime','LocalTime','Instant','UUID']);
+  const _customDomainElementTypes = _ownFields
+    ? [...new Set(_ownFields.filter(f => f.isCollection && f.collectionElementType && !_STANDARD_DOMAIN_TYPES.has(f.collectionElementType)).map(f => f.collectionElementType))]
+    : [];
+%>
+<% _customDomainElementTypes.forEach(typeName => { %>
+import <%= packageName %>.<%= moduleName %>.domain.models.events.<%- typeName %>;
+<% }); %>
 
 /**
  * <%= name %> - Domain Event
@@ -25,23 +40,24 @@ import java.util.List;
  * Raised when: TODO — describe the business fact this event represents.
  * Aggregate:   <%= aggregateName %>
  *
+ * The aggregate id is available via {@link #getAggregateId()} (inherited from DomainEvent).
  * This is a pure domain class. It carries no Spring or infrastructure dependencies.
  * Publish it externally via <%= aggregateName %>DomainEventHandler (application layer).
  */
 public final class <%= name %> extends DomainEvent {
 
-<% fields.forEach(field => { %>
+<% _ownFields.forEach(field => { %>
     private final <%- field.javaType %> <%= field.name %>;
 <% }); %>
 
-    public <%= name %>(String aggregateId<% fields.forEach(field => { %>, <%- field.javaType %> <%= field.name %><% }); %>) {
+    public <%= name %>(String aggregateId<% _ownFields.forEach(field => { %>, <%- field.javaType %> <%= field.name %><% }); %>) {
         super(aggregateId);
-<% fields.forEach(field => { %>
+<% _ownFields.forEach(field => { %>
         this.<%= field.name %> = <%= field.name %>;
 <% }); %>
     }
 
-<% fields.forEach(field => { %>
+<% _ownFields.forEach(field => { %>
     public <%- field.javaType %> get<%= field.name.charAt(0).toUpperCase() + field.name.slice(1) %>() {
         return <%= field.name %>;
     }