eva4j 1.0.16 → 1.0.18

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

@@ -49,12 +49,16 @@ async function parseDomainYaml(yamlPath, packageName = '', moduleName = '') {
     );
   }
 
+  const ports = parsePorts(domainData, moduleName);
+  const readModels = parseReadModels(domainData, moduleName, ports);
+
   return {
     aggregates,
     allEnums: extractAllEnums(domainData.aggregates),
     endpoints,
     listeners,
-    ports: parsePorts(domainData, moduleName)
+    ports,
+    readModels
   };
 }
 
@@ -108,7 +112,9 @@ function parseAggregate(aggregateData) {
       name: eventName,
       fieldName: toCamelCase(eventName),
       fields: eventFields,
-      triggers: event.triggers || []
+      triggers: event.triggers || [],
+      lifecycle: event.lifecycle || null,
+      notifies: event.notifies || []
     };
   });
 
@@ -122,6 +128,17 @@ function parseAggregate(aggregateData) {
     });
   });
 
+  // Build lifecycle map: { create → [event, ...], update → [...], delete → [...], softDelete → [...] }
+  // Used by templates to emit raise() calls at CRUD lifecycle points.
+  const VALID_LIFECYCLE_VALUES = ['create', 'update', 'delete', 'softDelete'];
+  const lifecycleEventsMap = {};
+  domainEvents.forEach(event => {
+    if (event.lifecycle && VALID_LIFECYCLE_VALUES.includes(event.lifecycle)) {
+      if (!lifecycleEventsMap[event.lifecycle]) lifecycleEventsMap[event.lifecycle] = [];
+      lifecycleEventsMap[event.lifecycle].push(event);
+    }
+  });
+
   return {
     name: toPascalCase(name),
     packageName: aggregateData.package || '',
@@ -132,6 +149,7 @@ function parseAggregate(aggregateData) {
     allEntities: parsedEntities,
     domainEvents,
     triggeredEventsMap,
+    lifecycleEventsMap,
     enums: aggregateEnums
   };
 }
@@ -675,14 +693,16 @@ function generateAggregateMethods(root, secondaryEntities) {
       }
       
       // remove method
+      const secondaryIdField = secondaryEntity ? secondaryEntity.fields.find(f => f.name === 'id') : null;
+      const secondaryIdType = secondaryIdField ? secondaryIdField.javaType : 'String';
       methods.push({
-        name: `remove${toPascalCase(singularName)}`,
+        name: `remove${toPascalCase(singularName)}ById`,
         returnType: 'void',
         parameters: [{
-          name: 'id',
-          type: 'Long'
+          name: 'itemId',
+          type: secondaryIdType
         }],
-        body: `this.${rel.fieldName}.removeIf(item -> item.getId().equals(id));`
+        body: `this.${rel.fieldName}.removeIf(item -> item.getId().equals(itemId));`
       });
       
       // get unmodifiable collection
@@ -1060,8 +1080,8 @@ function parseListeners(domainData) {
     // 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`;
+    // Generic suffix — broker-specific suffix applied in generate-entities.js
+    const listenerClassName = `${baseName}Listener`;
     const useCaseName = toPascalCase(listener.useCase);
     const commandClassName = `${useCaseName}Command`;
     const topic = listener.topic || null;
@@ -1253,6 +1273,255 @@ function parsePorts(domainData, moduleName = '') {
   });
 }
 
+/**
+ * Derive a Kafka topic name from an event class name.
+ * Strips trailing 'Event' suffix, then converts to SCREAMING_SNAKE_CASE.
+ * e.g. 'ProductCreatedEvent' → 'PRODUCT_CREATED'
+ *      'OrderCancelled'      → 'ORDER_CANCELLED'
+ * @param {string} eventName - PascalCase event name
+ * @returns {string} SCREAMING_SNAKE_CASE topic name
+ */
+function deriveTopicFromEventName(eventName) {
+  const base = eventName.endsWith('Event') ? eventName.slice(0, -5) : eventName;
+  // PascalCase → SCREAMING_SNAKE_CASE
+  return base
+    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+    .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2')
+    .toUpperCase();
+}
+
+/**
+ * Parse the optional readModels section from domain.yaml.
+ * Declares local read model projections maintained via domain events
+ * from external bounded contexts.
+ * @param {Object} domainData - Raw parsed YAML data
+ * @param {string} moduleName - Current module name
+ * @param {Array} ports - Parsed ports (for RM-009 warning)
+ * @returns {Array} Parsed read models array (empty if not declared)
+ */
+function parseReadModels(domainData, moduleName = '', ports = []) {
+  if (!domainData.readModels || !Array.isArray(domainData.readModels)) return [];
+
+  const validActions = ['UPSERT', 'DELETE', 'SOFT_DELETE'];
+
+  return domainData.readModels.map(rm => {
+    const name = toPascalCase(rm.name);
+
+    // RM-001: name must end with 'ReadModel'
+    if (!name.endsWith('ReadModel')) {
+      throw new Error(
+        `[RM-001] Read model "${name}": name must end with "ReadModel" suffix. ` +
+        `Rename to "${name}ReadModel".`
+      );
+    }
+
+    // RM-002: tableName must start with 'rm_'
+    if (!rm.tableName || !rm.tableName.startsWith('rm_')) {
+      throw new Error(
+        `[RM-002] Read model "${name}": tableName must start with "rm_" prefix. ` +
+        `Got: "${rm.tableName || '(empty)'}".`
+      );
+    }
+
+    // Source is required
+    if (!rm.source || !rm.source.module || !rm.source.aggregate) {
+      throw new Error(
+        `[RM-010] Read model "${name}": source.module and source.aggregate are required.`
+      );
+    }
+
+    // RM-010: source.module must differ from current module
+    if (rm.source.module === moduleName || toKebabCase(rm.source.module) === toKebabCase(moduleName)) {
+      throw new Error(
+        `[RM-010] Read model "${name}": source.module ("${rm.source.module}") is the same as the current module. ` +
+        `Read models are for cross-module projections only.`
+      );
+    }
+
+    // Parse fields
+    const fields = (rm.fields || []).map(f => ({
+      name: toCamelCase(f.name),
+      javaType: f.type
+    }));
+
+    // RM-004: fields must include an 'id' field
+    if (!fields.some(f => f.name === 'id')) {
+      throw new Error(
+        `[RM-004] Read model "${name}": fields must include an "id" field.`
+      );
+    }
+
+    // Parse syncedBy
+    const syncedBy = rm.syncedBy || [];
+
+    // RM-005: syncedBy must have at least one entry
+    if (syncedBy.length === 0) {
+      throw new Error(
+        `[RM-005] Read model "${name}": syncedBy must have at least one entry.`
+      );
+    }
+
+    // Derive the source aggregate's id key for payload extraction
+    // e.g., source.aggregate = 'Product' → sourceIdKey = 'productId'
+    const sourceBase = rm.source.aggregate.charAt(0).toLowerCase() + rm.source.aggregate.slice(1);
+    const sourceIdKey = sourceBase + 'Id';
+
+    const parsedSyncedBy = syncedBy.map(sync => {
+      const eventName = toPascalCase(sync.event);
+      const action = (sync.action || '').toUpperCase();
+
+      // RM-006: action must be valid
+      if (!validActions.includes(action)) {
+        throw new Error(
+          `[RM-006] Read model "${name}", event "${eventName}": ` +
+          `syncedBy action must be one of ${validActions.join(', ')}. Got: "${action}".`
+        );
+      }
+
+      const baseName = eventName.endsWith('Event') ? eventName.slice(0, -5) : eventName;
+      const topic = sync.topic || deriveTopicFromEventName(eventName);
+      const topicKey = topic.toLowerCase().replace(/_/g, '-');
+
+      return {
+        event: eventName,
+        eventBaseName: baseName,
+        action,
+        integrationEventClassName: `${baseName}IntegrationEvent`,
+        listenerClassName: `${baseName}ReadModelListener`,
+        topicConstant: topic,
+        topicKey,
+        topicSpringProperty: `\${topics.${topicKey}}`,
+        topicVariableName: toCamelCase(topicKey.replace(/-/g, '_')),
+        // UPSERT needs all readModel fields; DELETE/SOFT_DELETE only need the id
+        // payloadKey maps readModel field names to producer payload keys
+        // e.g., readModel 'id' → payload 'productId' (convention {entityName}Id)
+        fields: action === 'UPSERT'
+          ? fields.map(f => ({ ...f, payloadKey: f.name === 'id' ? sourceIdKey : f.name }))
+          : [{ name: 'id', javaType: 'String', payloadKey: sourceIdKey }]
+      };
+    });
+
+    const hasSoftDelete = parsedSyncedBy.some(s => s.action === 'SOFT_DELETE');
+    const sourceName = toPascalCase(rm.source.aggregate);
+    const sourceModule = rm.source.module;
+
+    // RM-009: warn if ports still has sync calls to the same source module
+    const conflictingPorts = ports.filter(p =>
+      p.target && (p.target === sourceModule || toKebabCase(p.target) === toKebabCase(sourceModule))
+    );
+    if (conflictingPorts.length > 0) {
+      const serviceNames = conflictingPorts.map(p => p.serviceName).join(', ');
+      console.warn(
+        `⚠️  [RM-009] Read model "${name}": ports: section still contains sync calls ` +
+        `to module "${sourceModule}" (services: ${serviceNames}). Consider removing them ` +
+        `since the read model provides local access to that data.`
+      );
+    }
+
+    return {
+      name,
+      sourceName,
+      sourceModule,
+      tableName: rm.tableName,
+      fields,
+      syncedBy: parsedSyncedBy,
+      hasSoftDelete,
+      // Derived class names
+      domainClassName: name,
+      jpaEntityName: `${name}Jpa`,
+      jpaRepositoryName: `${name}JpaRepository`,
+      repositoryName: `${name}Repository`,
+      repositoryImplName: `${name}RepositoryImpl`,
+      syncHandlerName: `Sync${sourceName}ReadModelHandler`
+    };
+  });
+}
+
+/**
+ * Resolve event constructor arguments for a domain event given entity context.
+ * Replicates the same resolution logic used in AggregateRoot.java.ejs for transitions.
+ *
+ * @param {Object} event - Parsed domain event { name, fields }
+ * @param {string} entityName - PascalCase aggregate root name (e.g. 'Product')
+ * @param {Array}  entityFields - Parsed fields of the root entity
+ * @param {Array}  valueObjects - Parsed value objects of the aggregate
+ * @param {string} prefix - Expression prefix for getters (e.g. 'this' or 'updated' or 'entity')
+ * @returns {Object} { args: string[], needsLocalDateTime: boolean, needsUUID: boolean }
+ */
+function resolveEventArgs(event, entityName, entityFields, valueObjects = [], prefix = 'this') {
+  const entityBase = entityName.charAt(0).toLowerCase() + entityName.slice(1);
+  const args = [`${prefix}.getId()`];
+  let needsLocalDateTime = false;
+  let needsUUID = false;
+
+  (event.fields || []).forEach(ef => {
+    // Skip {entityName}Id — already provided as aggregateId in the DomainEvent constructor
+    if (ef.name === entityBase + 'Id') return;
+
+    const matched = entityFields.find(f => f.name === ef.name);
+    if (matched) {
+      if (matched.javaType === ef.javaType) {
+        const cap = ef.name.charAt(0).toUpperCase() + ef.name.slice(1);
+        args.push(`${prefix}.get${cap}()`);
+        return;
+      }
+      // Type mismatch: entity field may be a VO wrapping the expected primitive/type
+      const vo = (valueObjects || []).find(v => v.name === matched.javaType);
+      if (vo) {
+        const voSub = vo.fields.find(voF => voF.name === ef.name && voF.javaType === ef.javaType)
+                    || vo.fields.find(voF => voF.javaType === ef.javaType);
+        if (voSub) {
+          const oCap = ef.name.charAt(0).toUpperCase() + ef.name.slice(1);
+          const sCap = voSub.name.charAt(0).toUpperCase() + voSub.name.slice(1);
+          args.push(`${prefix}.get${oCap}().get${sCap}()`);
+          return;
+        }
+      }
+      // Enum → String: convert via .name()
+      if (matched.isEnum && ef.javaType === 'String') {
+        const cap = ef.name.charAt(0).toUpperCase() + ef.name.slice(1);
+        args.push(`${prefix}.get${cap}().name()`);
+        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()');
+      needsLocalDateTime = true;
+      return;
+    }
+    args.push(`null /* TODO: provide ${ef.name} */`);
+  });
+
+  return { args, needsLocalDateTime, needsUUID };
+}
+
+/**
+ * Pre-compute resolved arguments for all lifecycle events.
+ * Returns an enriched lifecycleEventsMap where each event has a `resolvedArgs` array.
+ *
+ * @param {Object} lifecycleEventsMap - { create: [event, ...], update: [...], ... }
+ * @param {string} entityName - PascalCase aggregate root name
+ * @param {Array}  entityFields - Parsed fields of the root entity
+ * @param {Array}  valueObjects - Parsed value objects of the aggregate
+ * @returns {Object} enriched map: { create: [{ ...event, resolvedArgs, needsLocalDateTime }], ... }
+ */
+function resolveLifecycleEventArgs(lifecycleEventsMap, entityName, entityFields, valueObjects = []) {
+  const resolved = {};
+  // Each lifecycle type uses a different variable name in the generated code
+  // update uses 'this' because raise() is now inside the entity's update() method
+  const prefixMap = { create: 'this', update: 'this', delete: 'entity', softDelete: 'this' };
+  for (const [lifecycle, events] of Object.entries(lifecycleEventsMap)) {
+    const prefix = prefixMap[lifecycle] || 'this';
+    resolved[lifecycle] = events.map(event => {
+      const { args, needsLocalDateTime } = resolveEventArgs(event, entityName, entityFields, valueObjects, prefix);
+      return { ...event, resolvedArgs: args, needsLocalDateTime };
+    });
+  }
+  return resolved;
+}
+
 module.exports = {
   parseDomainYaml,
   parseAggregate,
@@ -1263,5 +1532,8 @@ module.exports = {
   generateValidationImports,
   generateAggregateMethodImports,
   parseListeners,
-  parsePorts
+  parsePorts,
+  parseReadModels,
+  resolveEventArgs,
+  resolveLifecycleEventArgs
 };

package/templates/aggregate/AggregateRepository.java.ejs

@@ -20,6 +20,10 @@ public interface <%= rootEntity.name %>Repository {
     boolean existsById(<%= rootEntity.fields[0].javaType %> id);
 <% if (!hasSoftDelete) { %>
     void deleteById(<%= rootEntity.fields[0].javaType %> id);
+<% if (hasDeleteLifecycle) { %>
+
+    void delete(<%= rootEntity.name %> <%= rootEntity.fieldName %>);
+<% } %>
 <% } %>
 <% if (findByOps && findByOps.length > 0) { %>
 <% findByOps.forEach(function(op) { %>

package/templates/aggregate/AggregateRepositoryImpl.java.ejs

@@ -58,6 +58,14 @@ public class <%= rootEntity.name %>RepositoryImpl implements <%= rootEntity.name
     public void deleteById(<%= rootEntity.fields[0].javaType %> id) {
         jpaRepository.deleteById(id);
     }
+<% if (hasDeleteLifecycle) { %>
+
+    @Override
+    public void delete(<%= rootEntity.name %> <%= rootEntity.fieldName %>) {
+        <%= rootEntity.fieldName %>.pullDomainEvents().forEach(eventPublisher::publishEvent);
+        jpaRepository.deleteById(<%= rootEntity.fieldName %>.getId());
+    }
+<% } %>
 <% } %>
 <% if (findByOps && findByOps.length > 0) { %>
 <% findByOps.forEach(function(op) { %>

package/templates/aggregate/AggregateRoot.java.ejs

@@ -19,9 +19,14 @@ 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'); });
+const _allLifecycleEvents = Object.values(lifecycleEventsMap || {}).flat();
+const _needsLocalDateTimeImport = (
+  Object.values(triggeredEventsMap || {}).flat().some(function(ev) {
+    return (ev.fields || []).some(function(ef) { return ef.name.endsWith('At') && ef.javaType === 'LocalDateTime'; });
+  }) ||
+  _allLifecycleEvents.some(function(ev) { return ev.needsLocalDateTime; })
+) && !imports.some(function(imp) { return imp.includes('LocalDateTime'); });
+const _hasCreateLifecycle = ((lifecycleEventsMap || {}).create || []).length > 0;
 %>
 <% if (_needsLocalDateTimeImport) { %>
 import java.time.LocalDateTime;
@@ -36,6 +41,7 @@ import java.util.List;
  */
 public class <%= name %> {
 <% if (domainEvents && domainEvents.length > 0) { %>
+<%   const _needsPublicRaise = ((lifecycleEventsMap || {}).delete || []).length > 0; %>
 
     // ─── Domain Events ──────────────────────────────────────────────────────────
     private final List<DomainEvent> _domainEvents = new ArrayList<>();
@@ -44,7 +50,7 @@ public class <%= name %> {
      * Registers a domain event to be published after successful persistence.
      * Call this inside business methods when something significant happens.
      */
-    protected void raise(DomainEvent event) {
+    <%= _needsPublicRaise ? 'public' : 'protected' %> void raise(DomainEvent event) {
         _domainEvents.add(event);
     }
 
@@ -93,9 +99,13 @@ public class <%= name %> {
 <% 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); %>
+<% const _createLifecycleEvents = (lifecycleEventsMap || {}).create || []; %>
 <% if (creationFields.length > 0 || autoInitFields.length > 0 || defaultValueFields.length > 0) { %>
     // Constructor for new entity creation (without id, audit fields, readOnly and auto-initialized fields)
     public <%= name %>(<% let paramIdx = 0; %><% creationFields.forEach((field, idx) => { %><% if (paramIdx > 0) { %>, <% } %><%- field.javaType %> <%= field.name %><% paramIdx++; %><% }); %>) {
+<% if (_createLifecycleEvents.length > 0) { %>
+        this.id = java.util.UUID.randomUUID().toString();
+<% } %>
 <% creationFields.forEach(field => { %>
         this.<%= field.name %> = <%= field.name %>;
 <% }); %>
@@ -104,6 +114,26 @@ public class <%= name %> {
 <% }); %>
 <% defaultValueFields.forEach(field => { %>
         this.<%= field.name %> = <%- field.javaDefaultValue %>;
+<% }); %>
+<% _createLifecycleEvents.forEach(function(evt) { %>
+        raise(new <%= evt.name %>(<%= evt.resolvedArgs.join(', ') %>));
+<% }); %>
+    }
+<% } %>
+<% const _updateLifecycleEvents = (lifecycleEventsMap || {}).update || []; %>
+<% if (_updateLifecycleEvents.length > 0 && creationFields.length > 0) { %>
+
+    // ─── Update Method (lifecycle: update) ───────────────────────────────────
+    /**
+     * Updates the entity fields and raises domain event(s).
+     * Receives final (already-merged) values — PATCH semantics are resolved by the caller.
+     */
+    public void update(<% creationFields.forEach((field, idx) => { %><%- field.javaType %> <%= field.name %><%= idx < creationFields.length - 1 ? ', ' : '' %><% }); %>) {
+<% creationFields.forEach(field => { %>
+        this.<%= field.name %> = <%= field.name %>;
+<% }); %>
+<% _updateLifecycleEvents.forEach(function(evt) { %>
+        raise(new <%= evt.name %>(<%= evt.resolvedArgs.join(', ') %>));
 <% }); %>
     }
 <% } %>
@@ -243,6 +273,7 @@ public class <%= name %> {
 <% }); %>
 <% } %>
 <% if (hasSoftDelete) { %>
+<% const _softDeleteLifecycleEvents = (lifecycleEventsMap || {}).softDelete || []; %>
 
     // ─── Soft Delete ─────────────────────────────────────────────────────────
     /**
@@ -254,6 +285,9 @@ public class <%= name %> {
             throw new IllegalStateException("<%= name %> is already deleted");
         }
         this.deletedAt = java.time.LocalDateTime.now();
+<% _softDeleteLifecycleEvents.forEach(function(evt) { %>
+        raise(new <%= evt.name %>(<%= evt.resolvedArgs.join(', ') %>));
+<% }); %>
     }
 
     public boolean isDeleted() {

package/templates/aggregate/DomainEventHandler.java.ejs

@@ -3,67 +3,161 @@ package <%= packageName %>.<%= moduleName %>.application.usecases;
 import <%= packageName %>.shared.domain.annotations.ApplicationComponent;
 import org.springframework.transaction.event.TransactionPhase;
 import org.springframework.transaction.event.TransactionalEventListener;
-<% domainEvents.forEach(event => { %>
+<% domainEvents.forEach(event => { -%>
 import <%= packageName %>.<%= moduleName %>.domain.models.events.<%= event.name %>;
-<% }); %>
-<% if (broker) { %>
-<% domainEvents.forEach(event => { %>
+<% }); -%>
+<% if (broker) { -%>
+<% domainEvents.forEach(event => { -%>
 import <%= packageName %>.<%= moduleName %>.application.events.<%= event.integrationEventClassName %>;
-<% }); %>
+<% }); -%>
 import <%= packageName %>.<%= moduleName %>.application.ports.MessageBroker;
-<% } %>
+<% } -%>
+<%
+  // Collect unique workflow flowPascal names from events with notifies (Temporal bridge)
+  // flowPascal = workflow name with "Workflow" suffix stripped (e.g. PlaceOrderWorkflow → PlaceOrder)
+  // The generated service class is {flowPascal}WorkFlowService (e.g. PlaceOrderWorkFlowService)
+  const _flowPascalSet = new Set();
+  const _inputClassSet = new Set();
+  let _needsLocalDateTimeImport = false;
+  if (typeof temporal !== 'undefined' && temporal) {
+    domainEvents.forEach(event => {
+      const _evFieldNames = new Set((event.fields || []).map(f => f.name));
+      const _aggrIdWf = aggregateName.charAt(0).toLowerCase() + aggregateName.slice(1) + 'Id';
+      (event.notifies || []).forEach(n => {
+        if (n.workflow && n.flowPascal) _flowPascalSet.add(n.flowPascal);
+        if (n.inputFields && n.inputFields.length > 0 && n.flowPascal) {
+          _inputClassSet.add(n.flowPascal + 'Input');
+          // Check if any unresolvable field uses LocalDateTime.now()
+          n.inputFields.forEach(f => {
+            if (f.name !== _aggrIdWf && !_evFieldNames.has(f.name)
+                && f.name.endsWith('At') && f.javaType === 'LocalDateTime') {
+              _needsLocalDateTimeImport = true;
+            }
+          });
+        }
+      });
+    });
+  }
+  const _flowPascals = Array.from(_flowPascalSet);
+  const _hasTemporalBridge = _flowPascals.length > 0;
+-%>
+<% if (_hasTemporalBridge) { -%>
+<% if (_needsLocalDateTimeImport) { -%>
+import java.time.LocalDateTime;
+<% } -%>
+<% _flowPascals.forEach(fp => { -%>
+import <%= packageName %>.<%= moduleName %>.application.usecases.<%= fp %>WorkFlowService;
+<% }); -%>
+<% _inputClassSet.forEach(cls => { -%>
+import <%= packageName %>.<%= moduleName %>.application.usecases.<%= cls %>;
+<% }); -%>
+<% } -%>
 
 /**
  * <%= aggregateName %>DomainEventHandler — Domain Event Bridge
  *
- * Connects the internal Spring event bus (ApplicationEventPublisher) with the
- * external messaging port (MessageBroker).
+ * Connects the internal Spring event bus (ApplicationEventPublisher) with<% if (broker && _hasTemporalBridge) { %>
+ * the external messaging port (MessageBroker) and Temporal workflow orchestration.<% } else if (broker) { %>
+ * the external messaging port (MessageBroker).<% } else if (_hasTemporalBridge) { %>
+ * the Temporal workflow orchestration layer.<% } else { %>
+ * external side effects.<% } %>
  *
  * Architecture:
  *   AggregateRepositoryImpl.save()
  *     → eventPublisher.publishEvent(domainEvent)        [internal Spring bus]
  *       → @TransactionalEventListener(AFTER_COMMIT)     [this class]
+<% if (broker) { -%>
  *         → messageBroker.publish*(integrationEvent)    [port — broker-agnostic]
+<% } -%>
+<% if (_hasTemporalBridge) { -%>
+ *         → workFlowService.startAsync(workflowId)     [Temporal workflow launch]
+<% } -%>
  *
  * AFTER_COMMIT guarantees that external events are published only when the
  * database transaction committed successfully, preventing ghost events from
  * rolled-back operations.
  *
  * Domain Events  (domain/models/events/)  — internal signals scoped to this bounded context.
+<% if (broker) { -%>
  * 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 (broker) { %>
-
-    private final MessageBroker messageBroker;
-
-    public <%= aggregateName %>DomainEventHandler(MessageBroker messageBroker) {
-        this.messageBroker = messageBroker;
+<%
+  // Determine constructor dependencies
+  const _deps = [];
+  if (broker)              _deps.push({ type: 'MessageBroker', name: 'messageBroker' });
+  _flowPascals.forEach(fp => {
+    const svcType = fp + 'WorkFlowService';
+    const svcName = fp.charAt(0).toLowerCase() + fp.slice(1) + 'WorkFlowService';
+    _deps.push({ type: svcType, name: svcName });
+  });
+-%>
+<% if (_deps.length > 0) { %>
+<% _deps.forEach(dep => { -%>
+    private final <%= dep.type %> <%= dep.name %>;
+<% }); %>
+    public <%= aggregateName %>DomainEventHandler(<%= _deps.map(d => d.type + ' ' + d.name).join(', ') %>) {
+<% _deps.forEach(dep => { -%>
+        this.<%= dep.name %> = <%= dep.name %>;
+<% }); -%>
     }
-<% } %>
-<% domainEvents.forEach(event => { %>
+<% } -%>
+<% domainEvents.forEach(event => {
+    const _eventNotifies = (typeof temporal !== 'undefined' && temporal)
+      ? (event.notifies || []).filter(n => n.workflow)
+      : [];
+    const _hasBrokerAction = !!broker;
+    const _hasWorkflowAction = _eventNotifies.length > 0;
+-%>
 
     /**
-     * Handles {@link <%= event.name %>} after the wrapping transaction commits.<% if (!broker) { %>
+     * Handles {@link <%= event.name %>} after the wrapping transaction commits.<% if (!_hasBrokerAction && !_hasWorkflowAction) { %>
      * <p>
      * TODO: Implement the side effect for this event (e.g., send notification,
      *       update a read model, trigger a saga step, etc.).<% } %>
      */
     @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
     public void on<%= event.name %>(<%= event.name %> event) {
-    <% if (broker) { %>
-        <%
+<% if (_hasBrokerAction) {
           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 { %>
+<% } -%>
+<% if (_hasWorkflowAction) { _eventNotifies.forEach(n => {
+          const _svcName = n.flowPascal.charAt(0).toLowerCase() + n.flowPascal.slice(1) + 'WorkFlowService';
+          const _aggrIdFieldWf = aggregateName.charAt(0).toLowerCase() + aggregateName.slice(1) + 'Id';
+          const _eventFieldNames = new Set((event.fields || []).map(f => f.name));
+          const _hasTypedInput = n.inputFields && n.inputFields.length > 0;
+-%>
+<% if (_hasTypedInput) { -%>
+        <%= _svcName %>.startAsync(
+            event.getAggregateId(),
+            new <%= n.flowPascal %>Input(<% n.inputFields.forEach(function(inputF, idx) {
+              let _arg;
+              if (inputF.name === _aggrIdFieldWf) {
+                _arg = 'event.getAggregateId()';
+              } else if (_eventFieldNames.has(inputF.name)) {
+                _arg = 'event.get' + inputF.name.charAt(0).toUpperCase() + inputF.name.slice(1) + '()';
+              } else if (inputF.name.endsWith('At') && inputF.javaType === 'LocalDateTime') {
+                _arg = 'LocalDateTime.now()';
+              } else {
+                _arg = 'null /* TODO: provide ' + inputF.name + ' */';
+              }
+%><%= idx > 0 ? ', ' : '' %><%= _arg %><% }); %>)
+        );
+<% } else { -%>
+        <%= _svcName %>.startAsync(event.getAggregateId());
+<% } -%>
+<% }); } -%>
+<% if (!_hasBrokerAction && !_hasWorkflowAction) { -%>
         // TODO: handle <%= event.name %> — add your side-effect logic here
         //   e.g.:  notificationService.notify(event);
         //          readModelUpdater.on(event);
-    <% } %>
+<% } -%>
     }
 <% }); %>
 }