eva4j 1.0.14 → 1.0.16

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,11 +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),
-    endpoints: parseEndpoints(domainData)
+    endpoints,
+    listeners,
+    ports: parsePorts(domainData, moduleName)
   };
 }
 
@@ -80,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 || '',
@@ -93,6 +131,7 @@ function parseAggregate(aggregateData) {
     aggregateMethods,
     allEntities: parsedEntities,
     domainEvents,
+    triggeredEventsMap,
     enums: aggregateEnums
   };
 }
@@ -109,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 || [];
   
@@ -174,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);
@@ -206,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,
@@ -235,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}`);
@@ -990,6 +1047,212 @@ function parseEndpoints(domainData) {
   };
 }
 
+/**
+ * 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,
@@ -998,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,9 +17,10 @@ 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,15 +49,16 @@ public class <%= rootEntity.name %>RepositoryImpl implements <%= rootEntity.name
                 .map(mapper::toDomain);
     }
     
-    @Override
-    public void deleteById(<%= rootEntity.fields[0].javaType %> id) {
-        jpaRepository.deleteById(id);
-    }
-    
     @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

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

@@ -55,7 +55,10 @@ public class <%= aggregateName %>DomainEventHandler {
     @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
     public void on<%= event.name %>(<%= event.name %> event) {
     <% if (broker) { %>
-        messageBroker.publish<%= event.integrationEventClassName %>(new <%= event.integrationEventClassName %>(<% if (event.fields && event.fields.length > 0) { event.fields.forEach(function(field, idx) { %>event.get<%= field.name.charAt(0).toUpperCase() + field.name.slice(1) %>()<%= idx < event.fields.length - 1 ? ', ' : '' %><% }); } %>));
+        <%
+          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 %>;
     }

package/templates/aggregate/DomainEventSnapshot.java.ejs

@@ -0,0 +1,46 @@
+package <%= packageName %>.<%= moduleName %>.domain.models.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;
+<% } %>
+<% if (needsInstant) { %>
+import java.time.Instant;
+<% } %>
+<% if (needsUUID) { %>
+import java.util.UUID;
+<% } %>
+<% if (needsList) { %>
+import java.util.List;
+<% } %>
+
+/**
+ * <%= name %> — snapshot value type carried in domain events.
+ *
+ * This is a pure domain record with no infrastructure dependencies.
+ * TODO: Define the fields this snapshot should carry.
+ * Example for an order item:
+ *   String productId,
+ *   String productName,
+ *   Integer quantity,
+ *   BigDecimal unitPrice
+ */
+public record <%= name %>(
+<% if (fields && fields.length > 0) { %>
+<% fields.forEach((field, idx) => { %>
+    <%- field.javaType %> <%= field.name %><%= idx < fields.length - 1 ? ',' : '' %>
+<% }); %>
+<% } else { %>
+    // TODO: Add the fields this snapshot should carry
+<% } %>
+) {
+}

package/templates/aggregate/JpaAggregateRoot.java.ejs

@@ -22,11 +22,17 @@ import <%= packageName %>.shared.domain.AuditableEntity;
 <% } else if (auditable) { %>
 import <%= packageName %>.shared.domain.AuditableEntity;
 <% } %>
+<% if (hasSoftDelete) { %>
+import org.hibernate.annotations.SQLRestriction;
+<% } %>
 
 /**
  * <%= name %>Jpa - JPA Entity
  * Persistence entity with JPA annotations
  */
+<% if (hasSoftDelete) { %>
+@SQLRestriction("deleted_at IS NULL")
+<% } %>
 @Entity
 @Table(name = "<%= tableName %>")
 @Getter

package/templates/base/docker/Dockerfile.ejs

@@ -0,0 +1,21 @@
+FROM eclipse-temurin:<%= javaVersion %>-jdk-alpine AS builder
+
+WORKDIR /app
+
+COPY build.gradle settings.gradle ./
+COPY gradle ./gradle
+COPY gradlew ./
+RUN chmod +x gradlew && ./gradlew dependencies --no-daemon || true
+
+COPY src ./src
+RUN ./gradlew bootJar --no-daemon -x test
+
+FROM eclipse-temurin:<%= javaVersion %>-jre-alpine
+
+WORKDIR /app
+
+COPY --from=builder /app/build/libs/*.jar app.jar
+
+EXPOSE <%= serverPort %>
+
+ENTRYPOINT ["java", "-jar", "app.jar"]