eva4j 1.0.11 → 1.0.13

package/src/commands/generate-temporal-flow.js

@@ -0,0 +1,216 @@
+const inquirer = require('inquirer');
+const ora = require('ora');
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs-extra');
+const ConfigManager = require('../utils/config-manager');
+const { isEva4jProject, moduleExists } = require('../utils/validator');
+const { toPackagePath, toPascalCase } = require('../utils/naming');
+const { renderAndWrite } = require('../utils/template-engine');
+const ChecksumManager = require('../utils/checksum-manager');
+
+async function generateTemporalFlowCommand(moduleName, flowName, options = {}) {
+  const projectDir = process.cwd();
+
+  if (!(await isEva4jProject(projectDir))) {
+    console.error(chalk.red('❌ Not in an eva4j project directory'));
+    console.error(chalk.gray('Run this command inside a project created with eva4j'));
+    process.exit(1);
+  }
+
+  const configManager = new ConfigManager(projectDir);
+
+  if (!(await configManager.featureExists('temporal'))) {
+    console.error(chalk.red('❌ Temporal client is not installed in this project'));
+    console.error(chalk.gray('Install Temporal first using: eva add temporal-client'));
+    process.exit(1);
+  }
+
+  if (!moduleName) {
+    const answer = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'moduleName',
+        message: 'Module name:',
+        validate: (v) => (v.trim() ? true : 'Module name is required'),
+      },
+    ]);
+    moduleName = answer.moduleName.trim();
+  }
+
+  const projectConfig = await configManager.loadProjectConfig();
+  if (!projectConfig) {
+    console.error(chalk.red('❌ Could not load project configuration'));
+    console.error(chalk.gray('Make sure .eva4j.json exists in the project root'));
+    process.exit(1);
+  }
+
+  const { packageName } = projectConfig;
+  const packagePath = toPackagePath(packageName);
+
+  if (!(await configManager.moduleExists(moduleName))) {
+    console.error(chalk.red(`❌ Module '${moduleName}' does not exist`));
+    console.error(chalk.gray(`Create it first using: eva add module ${moduleName}`));
+    process.exit(1);
+  }
+
+  if (!(await moduleExists(projectDir, packagePath, moduleName))) {
+    console.error(chalk.red(`❌ Module directory for '${moduleName}' not found`));
+    process.exit(1);
+  }
+
+  if (!flowName) {
+    const answer = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'flowName',
+        message: 'Workflow name (e.g. process-order, Payment):',
+        validate: (v) => (v.trim() ? true : 'Workflow name is required'),
+      },
+    ]);
+    flowName = answer.flowName.trim();
+  }
+
+  const flowPascalCase = toPascalCase(flowName);
+
+  const moduleBasePath = path.join(
+    projectDir,
+    'src',
+    'main',
+    'java',
+    packagePath,
+    moduleName
+  );
+
+  const checksumManager = new ChecksumManager(moduleBasePath);
+  await checksumManager.load();
+
+  const spinner = ora(`Generating ${flowPascalCase}WorkFlow...`).start();
+
+  try {
+    const context = {
+      packageName,
+      moduleName,
+      flowPascalCase,
+    };
+
+    const templatesDir = path.join(__dirname, '..', '..', 'templates', 'temporal-flow');
+    const usecasesDir = path.join(moduleBasePath, 'application', 'usecases');
+    const writeOptions = { force: options.force, checksumManager };
+
+    // 1. Generate WorkFlow interface
+    spinner.text = `Generating ${flowPascalCase}WorkFlow interface...`;
+    await renderAndWrite(
+      path.join(templatesDir, 'WorkFlowInterface.java.ejs'),
+      path.join(usecasesDir, `${flowPascalCase}WorkFlow.java`),
+      context,
+      writeOptions
+    );
+
+    // 2. Generate WorkFlow implementation
+    spinner.text = `Generating ${flowPascalCase}WorkFlowImpl...`;
+    await renderAndWrite(
+      path.join(templatesDir, 'WorkFlowImpl.java.ejs'),
+      path.join(usecasesDir, `${flowPascalCase}WorkFlowImpl.java`),
+      context,
+      writeOptions
+    );
+
+    // 3. Generate WorkFlow service facade
+    spinner.text = `Generating ${flowPascalCase}WorkFlowService...`;
+    await renderAndWrite(
+      path.join(templatesDir, 'WorkFlowService.java.ejs'),
+      path.join(usecasesDir, `${flowPascalCase}WorkFlowService.java`),
+      context,
+      writeOptions
+    );
+
+    // 4. Register workflow implementation in TemporalConfig.java
+    spinner.text = 'Registering workflow in TemporalConfig...';
+    await registerWorkflowInTemporalConfig(projectDir, packagePath, packageName, moduleName, flowPascalCase);
+
+    spinner.succeed(chalk.green(`✅ ${flowPascalCase}WorkFlow generated successfully`));
+
+    console.log(chalk.blue('\n📁 Generated files:'));
+    console.log(chalk.gray(`  ${moduleName}/application/usecases/${flowPascalCase}WorkFlow.java`));
+    console.log(chalk.gray(`  ${moduleName}/application/usecases/${flowPascalCase}WorkFlowImpl.java`));
+    console.log(chalk.gray(`  ${moduleName}/application/usecases/${flowPascalCase}WorkFlowService.java`));
+    console.log(chalk.blue('\n📝 Updated files:'));
+    console.log(chalk.gray('  shared/infrastructure/configurations/temporalConfig/TemporalConfig.java'));
+
+    await checksumManager.save();
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to generate temporal flow'));
+    console.error(chalk.red(error.message));
+    process.exit(1);
+  }
+}
+
+async function registerWorkflowInTemporalConfig(projectDir, packagePath, packageName, moduleName, flowPascalCase) {
+  const configPath = path.join(
+    projectDir,
+    'src',
+    'main',
+    'java',
+    packagePath,
+    'shared',
+    'infrastructure',
+    'configurations',
+    'temporalConfig',
+    'TemporalConfig.java'
+  );
+
+  if (!(await fs.pathExists(configPath))) {
+    console.warn(chalk.yellow('\n⚠️  TemporalConfig.java not found — skipping auto-registration'));
+    return;
+  }
+
+  let content = await fs.readFile(configPath, 'utf-8');
+
+  const implClass = `${flowPascalCase}WorkFlowImpl`;
+  const importLine = `import ${packageName}.${moduleName}.application.usecases.${implClass};`;
+
+  // Add import if not already present
+  if (!content.includes(importLine)) {
+    const importBlockMatch = content.match(/^import .+;(\r?\n)/m);
+    if (importBlockMatch) {
+      // Find position after last import line
+      const allImports = [...content.matchAll(/^import .+;/gm)];
+      if (allImports.length > 0) {
+        const lastImport = allImports[allImports.length - 1];
+        const insertPos = lastImport.index + lastImport[0].length;
+        content = content.slice(0, insertPos) + '\n' + importLine + content.slice(insertPos);
+      }
+    }
+  }
+
+  // Remove TODO comment and commented-out example placeholder
+  content = content.replace(/[ \t]*\/\/ TODO: register your workflow implementation types here\r?\n/g, '');
+  content = content.replace(/[ \t]*\/\/ workflowWorker\.registerWorkflowImplementationTypes\(MyWorkflowImpl\.class\);\r?\n?/g, '');
+
+  // Check if there is already an active registerWorkflowImplementationTypes call
+  const activeRegisterRegex = /workflowWorker\.registerWorkflowImplementationTypes\(([^)]+)\);/;
+  if (activeRegisterRegex.test(content)) {
+    // Add the new class, filtering out the stale MyWorkflowImpl example if still present
+    content = content.replace(activeRegisterRegex, (match, classes) => {
+      const classList = classes
+        .split(',')
+        .map((c) => c.trim())
+        .filter((c) => c !== 'MyWorkflowImpl.class');
+      if (!classList.includes(`${implClass}.class`)) {
+        classList.push(`${implClass}.class`);
+      }
+      return `workflowWorker.registerWorkflowImplementationTypes(${classList.join(', ')});`;
+    });
+  } else {
+    // Insert active registration after the workflowWorker declaration line
+    content = content.replace(
+      /(Worker workflowWorker = workerFactory\.newWorker\([^;]+;\r?\n)/,
+      `$1        workflowWorker.registerWorkflowImplementationTypes(${implClass}.class);\n`
+    );
+  }
+
+  await fs.writeFile(configPath, content, 'utf-8');
+}
+
+module.exports = generateTemporalFlowCommand;

package/src/generators/module-generator.js

@@ -25,6 +25,7 @@ class ModuleGenerator {
     // Create domain subdirectories
     await fs.ensureDir(path.join(moduleBasePath, 'domain', 'models', 'entities'));
     await fs.ensureDir(path.join(moduleBasePath, 'domain', 'models', 'valueObjects'));
+    await fs.ensureDir(path.join(moduleBasePath, 'domain', 'models', 'events'));
     await fs.ensureDir(path.join(moduleBasePath, 'domain', 'repositories'));
     await fs.ensureDir(path.join(moduleBasePath, 'domain', 'services'));
     

package/src/generators/shared-generator.js

@@ -67,6 +67,32 @@ class SharedGenerator {
     await fs.ensureDir(eventsPath);
   }
 
+  async generatePagedResponse(basePath) {
+    const dtosPath = path.join(basePath, 'application', 'dtos');
+    const destPath = path.join(dtosPath, 'PagedResponse.java');
+
+    // Only generate if it doesn't exist yet
+    if (await fs.pathExists(destPath)) {
+      return;
+    }
+
+    await fs.ensureDir(dtosPath);
+    await this.generateFile('application/dtos/PagedResponse.java.ejs', destPath);
+  }
+
+  async generateDomainEvent(basePath) {
+    const domainPath = path.join(basePath, 'domain');
+    const destPath = path.join(domainPath, 'DomainEvent.java');
+
+    // Only generate if it doesn't exist yet
+    if (await fs.pathExists(destPath)) {
+      return;
+    }
+
+    await fs.ensureDir(domainPath);
+    await this.generateFile('domain/DomainEvent.java.ejs', destPath);
+  }
+
   async generatePackageInfo(basePath) {
     await this.generateFile('package-info.java.ejs', 
       path.join(basePath, 'package-info.java'));

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

@@ -36,7 +36,7 @@ async function parseDomainYaml(yamlPath, packageName = '', moduleName = '') {
  * @returns {Object} Parsed aggregate with entities and value objects
  */
 function parseAggregate(aggregateData) {
-  const { name, entities = [], valueObjects = [], enums = [], packageName = '', moduleName = '' } = aggregateData;
+  const { name, entities = [], valueObjects = [], enums = [], events = [], packageName = '', moduleName = '' } = aggregateData;
   
   // Find the aggregate root
   const rootEntity = entities.find(e => e.isRoot === true);
@@ -72,6 +72,17 @@ function parseAggregate(aggregateData) {
   const allRootImports = new Set([...parsedRoot.imports, ...methodImports]);
   parsedRoot.imports = Array.from(allRootImports).sort();
   
+  // Parse domain events declared at aggregate level
+  const domainEvents = events.map(event => {
+    const eventName = toPascalCase(event.name);
+    const eventFields = (event.fields || []).map(f => parseProperty(f, aggregateEnums, valueObjectNames));
+    return {
+      name: eventName,
+      fieldName: toCamelCase(eventName),
+      fields: eventFields
+    };
+  });
+
   return {
     name: toPascalCase(name),
     packageName: aggregateData.package || '',
@@ -79,7 +90,8 @@ function parseAggregate(aggregateData) {
     secondaryEntities,
     valueObjects: parsedValueObjects,
     aggregateMethods,
-    allEntities: parsedEntities
+    allEntities: parsedEntities,
+    domainEvents
   };
 }
 
@@ -230,8 +242,80 @@ function buildAnnotationString(validation) {
   return params.length === 0 ? `@${type}` : `@${type}(${params.join(', ')})`;
 }
 
+/**
+ * Compute the Java literal for a defaultValue declared in domain.yaml.
+ * Returns a string ready to be emitted in a template (e.g. `0`, `"foo"`, `Status.ACTIVE`).
+ * Returns null for unsupported combinations — callers should guard before emitting.
+ *
+ * @param {*}       rawValue  - The raw value from YAML (string, number, boolean)
+ * @param {string}  javaType  - The resolved Java type (e.g. "String", "BigDecimal")
+ * @param {boolean} isEnum    - Whether the field type is an enum
+ * @returns {string|null}
+ */
+function computeJavaDefaultValue(rawValue, javaType, isEnum) {
+  if (rawValue === null || rawValue === undefined) return null;
+
+  const strValue = String(rawValue);
+
+  // Enum type: emit EnumType.VALUE
+  if (isEnum) {
+    return `${javaType}.${strValue}`;
+  }
+
+  switch (javaType) {
+    case 'String':
+      return `"${strValue}"`;
+    case 'Boolean':
+      return strValue.toLowerCase() === 'true' ? 'true' : 'false';
+    case 'Integer':
+    case 'int':
+      return strValue;
+    case 'Long':
+    case 'long':
+      return `${strValue}L`;
+    case 'Double':
+    case 'double':
+    case 'Float':
+    case 'float':
+      return strValue;
+    case 'BigDecimal':
+      return `new BigDecimal("${strValue}")`;
+    case 'LocalDateTime':
+      if (strValue === 'now') return 'LocalDateTime.now()';
+      return null; // arbitrary datetime strings not supported
+    case 'LocalDate':
+      if (strValue === 'now') return 'LocalDate.now()';
+      return null;
+    case 'LocalTime':
+      if (strValue === 'now') return 'LocalTime.now()';
+      return null;
+    case 'Instant':
+      if (strValue === 'now') return 'Instant.now()';
+      return null;
+    case 'UUID':
+      if (strValue === 'random') return 'UUID.randomUUID()';
+      return null;
+    default:
+      // Unknown type — cannot safely emit a literal
+      return null;
+  }
+}
+
 function parseProperty(propData, valueObjectNames = [], aggregateEnums = []) {
-  const { name, type, annotations = [], isValueObject = false, isEmbedded = false, enumValues, readOnly = false, hidden = false, validations = [] } = propData;
+  const { name, type, annotations = [], isValueObject = false, isEmbedded = false, enumValues, readOnly = false, hidden = false, validations = [], reference = null, defaultValue = null } = propData;
+
+  if (defaultValue !== null && !readOnly) {
+    console.warn(`⚠️  Field "${name}": "defaultValue" is only meaningful for readOnly fields. It will be ignored since readOnly is not set.`);
+  }
+
+  if (reference !== null) {
+    if (typeof reference !== 'object' || !reference.aggregate || typeof reference.aggregate !== 'string') {
+      throw new Error(`Field "${name}": "reference" must be an object with at least "aggregate" (string). Example:\n  reference:\n    aggregate: Customer\n    module: customers`);
+    }
+    if (reference.module !== undefined && typeof reference.module !== 'string') {
+      throw new Error(`Field "${name}": "reference.module" must be a string.`);
+    }
+  }
   
   const javaType = mapYamlTypeToJava(type, enumValues);
   const fieldName = toCamelCase(name);
@@ -286,7 +370,12 @@ function parseProperty(propData, valueObjectNames = [], aggregateEnums = []) {
     validationAnnotations: validations.map(v => buildAnnotationString(v)),
     transitionMeta,
     autoInit,
-    autoInitValue
+    autoInitValue,
+    reference,
+    defaultValue,
+    javaDefaultValue: (readOnly && !autoInit && defaultValue !== null)
+      ? computeJavaDefaultValue(defaultValue, javaType, !!enumValues || isEnumType)
+      : null
   };
 }
 

package/templates/aggregate/AggregateRepository.java.ejs

@@ -1,7 +1,8 @@
 package <%= packageName %>.<%= moduleName %>.domain.repositories;
 
 import <%= packageName %>.<%= moduleName %>.domain.models.entities.<%= rootEntity.name %>;
-import java.util.List;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
 import java.util.Optional;
 
 /**
@@ -14,7 +15,7 @@ public interface <%= rootEntity.name %>Repository {
     
     Optional<<%= rootEntity.name %>> findById(<%= rootEntity.fields[0].javaType %> id);
     
-    List<<%= rootEntity.name %>> findAll();
+    Page<<%= rootEntity.name %>> findAll(Pageable pageable);
     
     void deleteById(<%= rootEntity.fields[0].javaType %> id);
     

package/templates/aggregate/AggregateRepositoryImpl.java.ejs

@@ -1,14 +1,17 @@
 package <%= packageName %>.<%= moduleName %>.infrastructure.database.repositories;
 
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Repository;
+<% if (hasDomainEvents) { %>
+import org.springframework.context.ApplicationEventPublisher;
+<% } %>
 import lombok.RequiredArgsConstructor;
 import <%= packageName %>.<%= moduleName %>.domain.models.entities.<%= rootEntity.name %>;
 import <%= packageName %>.<%= moduleName %>.domain.repositories.<%= rootEntity.name %>Repository;
 import <%= packageName %>.<%= moduleName %>.infrastructure.database.entities.<%= rootEntity.name %>Jpa;
 import <%= packageName %>.<%= moduleName %>.infrastructure.database.mappers.<%= aggregateName %>Mapper;
-import java.util.List;
 import java.util.Optional;
-import java.util.stream.Collectors;
 
 /**
  * <%= rootEntity.name %>RepositoryImpl
@@ -20,11 +23,17 @@ public class <%= rootEntity.name %>RepositoryImpl implements <%= rootEntity.name
     
     private final <%= rootEntity.name %>JpaRepository jpaRepository;
     private final <%= aggregateName %>Mapper mapper;
+<% if (hasDomainEvents) { %>
+    private final ApplicationEventPublisher eventPublisher;
+<% } %>
     
     @Override
     public <%= rootEntity.name %> save(<%= rootEntity.name %> <%= rootEntity.fieldName %>) {
         <%= rootEntity.name %>Jpa jpa = mapper.toJpa(<%= rootEntity.fieldName %>);
         <%= rootEntity.name %>Jpa saved = jpaRepository.save(jpa);
+<% if (hasDomainEvents) { %>
+        <%= rootEntity.fieldName %>.pullDomainEvents().forEach(eventPublisher::publishEvent);
+<% } %>
         return mapper.toDomain(saved);
     }
     
@@ -33,12 +42,11 @@ public class <%= rootEntity.name %>RepositoryImpl implements <%= rootEntity.name
         return jpaRepository.findById(id)
                 .map(mapper::toDomain);
     }
-    
+
     @Override
-    public List<<%= rootEntity.name %>> findAll() {
-        return jpaRepository.findAll().stream()
-                .map(mapper::toDomain)
-                .collect(Collectors.toList());
+    public Page<<%= rootEntity.name %>> findAll(Pageable pageable) {
+        return jpaRepository.findAll(pageable)
+                .map(mapper::toDomain);
     }
     
     @Override

package/templates/aggregate/AggregateRoot.java.ejs

@@ -12,6 +12,12 @@ import <%= packageName %>.<%= moduleName %>.domain.models.enums.*;
 <% if (fields.some(f => f.transitionMeta && f.transitionMeta.transitions.some(t => t.guard))) { %>
 import <%= packageName %>.shared.domain.customExceptions.BusinessException;
 <% } %>
+<% if (domainEvents && domainEvents.length > 0) { %>
+import <%= packageName %>.shared.domain.DomainEvent;
+<% domainEvents.forEach(event => { %>
+import <%= packageName %>.<%= moduleName %>.domain.models.events.<%= event.name %>;
+<% }); %>
+<% } %>
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -21,11 +27,37 @@ import java.util.List;
  * Domain entity (pure Java class without Lombok)
  */
 public class <%= name %> {
+<% if (domainEvents && domainEvents.length > 0) { %>
+
+    // ─── Domain Events ──────────────────────────────────────────────────────────
+    private final List<DomainEvent> _domainEvents = new ArrayList<>();
+
+    /**
+     * Registers a domain event to be published after successful persistence.
+     * Call this inside business methods when something significant happens.
+     */
+    protected void raise(DomainEvent event) {
+        _domainEvents.add(event);
+    }
+
+    /**
+     * Returns all pending domain events and clears the internal list (atomic).
+     * Called by the repository implementation after jpaRepository.save().
+     */
+    public List<DomainEvent> pullDomainEvents() {
+        List<DomainEvent> events = Collections.unmodifiableList(new ArrayList<>(_domainEvents));
+        _domainEvents.clear();
+        return events;
+    }
+<% } %>
     
 <% fields.forEach(field => { %>
   <% if (field.isCollection) { %>
     private <%- field.javaType %> <%= field.name %> = new ArrayList<>();
   <% } else { %>
+  <% if (field.reference) { %>
+    /** Cross-aggregate reference → <%= field.reference.aggregate %><% if (field.reference.module) { %> (module: <%= field.reference.module %>)<% } %> */
+  <% } %>
     private <%- field.javaType %> <%= field.name %>;
   <% } %>
 <% }); %>
@@ -52,7 +84,8 @@ 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 autoInitFields = fields.filter(f => f.autoInit); %>
-<% if (creationFields.length > 0 || autoInitFields.length > 0) { %>
+<% const defaultValueFields = fields.filter(f => f.readOnly && !f.autoInit && f.javaDefaultValue); %>
+<% 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++; %><% }); %>) {
 <% creationFields.forEach(field => { %>
@@ -60,6 +93,9 @@ public class <%= name %> {
 <% }); %>
 <% autoInitFields.forEach(field => { %>
         this.<%= field.name %> = <%- field.javaType %>.<%= field.autoInitValue %>;
+<% }); %>
+<% defaultValueFields.forEach(field => { %>
+        this.<%= field.name %> = <%- field.javaDefaultValue %>;
 <% }); %>
     }
 <% } %>
@@ -134,7 +170,7 @@ public class <%= name %> {
 <% transitionFields.forEach(field => { %>
 <%     const meta = field.transitionMeta; %>
 <%     const methodMap = new Map(); %>
-<%     meta.transitions.forEach(t => { if (!methodMap.has(t.method)) methodMap.set(t.method, t); }); %>
+<%     meta.transitions.forEach(t => { if (t.method && !methodMap.has(t.method)) methodMap.set(t.method, t); }); %>
 <%     methodMap.forEach((transition, methodName) => { %>
 <%         const froms = Array.isArray(transition.from) ? transition.from : [transition.from]; %>
 

package/templates/aggregate/DomainEntity.java.ejs

@@ -51,7 +51,8 @@ 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 autoInitFields = fields.filter(f => f.autoInit); %>
-<% if (creationFields.length > 0 || autoInitFields.length > 0) { %>
+<% const defaultValueFields = fields.filter(f => f.readOnly && !f.autoInit && f.javaDefaultValue); %>
+<% 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++; %><% }); %>) {
 <% creationFields.forEach(field => { %>
@@ -59,6 +60,9 @@ public class <%= name %> {
 <% }); %>
 <% autoInitFields.forEach(field => { %>
         this.<%= field.name %> = <%- field.javaType %>.<%= field.autoInitValue %>;
+<% }); %>
+<% defaultValueFields.forEach(field => { %>
+        this.<%= field.name %> = <%- field.javaDefaultValue %>;
 <% }); %>
     }
 <% } %>
@@ -136,7 +140,7 @@ public class <%= name %> {
 <% transitionFields.forEach(field => { %>
 <%     const meta = field.transitionMeta; %>
 <%     const methodMap = new Map(); %>
-<%     meta.transitions.forEach(t => { if (!methodMap.has(t.method)) methodMap.set(t.method, t); }); %>
+<%     meta.transitions.forEach(t => { if (t.method && !methodMap.has(t.method)) methodMap.set(t.method, t); }); %>
 <%     methodMap.forEach((transition, methodName) => { %>
 <%         const froms = Array.isArray(transition.from) ? transition.from : [transition.from]; %>
 

package/templates/aggregate/DomainEventHandler.java.ejs

@@ -0,0 +1,62 @@
+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 => { %>
+import <%= packageName %>.<%= moduleName %>.domain.models.events.<%= event.name %>;
+<% }); %>
+<% if (hasKafkaEvents) { %>
+import <%= packageName %>.<%= moduleName %>.domain.repositories.MessageBroker;
+<% } %>
+
+/**
+ * <%= aggregateName %>DomainEventHandler — Domain Event Bridge
+ *
+ * This handler 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]
+ *
+ * AFTER_COMMIT ensures the external event is only published if 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.
+ */
+@ApplicationComponent
+public class <%= aggregateName %>DomainEventHandler {
+<% if (hasKafkaEvents) { %>
+
+    private final MessageBroker messageBroker;
+
+    public <%= aggregateName %>DomainEventHandler(MessageBroker messageBroker) {
+        this.messageBroker = messageBroker;
+    }
+<% } %>
+<% domainEvents.forEach(event => { %>
+
+    /**
+     * Handles {@link <%= event.name %>} after the wrapping transaction commits.
+     * <% if (!event.kafka) { %>
+     * 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 (event.kafka) { %>
+        messageBroker.send<%= event.name %>(event);
+    <% } else { %>
+        // TODO: handle <%= event.name %> — add your side-effect logic here
+        //   e.g.:  notificationService.notify(event);
+        //          readModelUpdater.on(event);
+    <% } %>
+    }
+<% }); %>
+}