eva4j 1.0.16 → 1.0.18

package/src/commands/generate-entities.js

@@ -5,15 +5,19 @@ const fs = require('fs-extra');
 const inquirer = require('inquirer');
 const ConfigManager = require('../utils/config-manager');
 const { isEva4jProject } = require('../utils/validator');
-const { toPackagePath, toCamelCase, toKebabCase, toPascalCase, getApplicationClassName, pluralizeWord } = require('../utils/naming');
+const { toPackagePath, toCamelCase, toKebabCase, toPascalCase, getApplicationClassName, pluralizeWord, singularizeWord } = require('../utils/naming');
 const { renderAndWrite, renderTemplate } = require('../utils/template-engine');
-const { parseDomainYaml, generateEntityImports, generateValidationImports } = require('../utils/yaml-to-entity');
+const { parseDomainYaml, generateEntityImports, generateValidationImports, resolveLifecycleEventArgs, resolveEventArgs } = require('../utils/yaml-to-entity');
 const { createOrUpdateUrlsConfig, ensureUrlsImport } = require('./generate-http-exchange');
 const SharedGenerator = require('../generators/shared-generator');
 const ChecksumManager = require('../utils/checksum-manager');
 const { generateFakeValue, initSeed } = require('../utils/fake-data');
 const { getInstalledBroker, generateSingleKafkaEvent, buildKafkaEventContext, updateKafkaYml,
         generateEventRecord, createOrUpdateMessageBroker, updateDomainEventHandler } = require('./generate-kafka-event');
+const { generateSingleRabbitEvent, buildRabbitEventContext, updateRabbitMQYml, updateRabbitMQYmlQueue,
+        createOrUpdateRabbitMessageBroker, updateRabbitMQConfigForConsumer, updateRabbitMQYmlForConsumer } = require('./generate-rabbitmq-event');
+const { parseSystemYaml } = require('../utils/system-yaml-parser');
+const { computeWorkflowInputFields } = require('./generate-temporal-system');
 
 // Maximum depth for recursive relationship traversal
 const MAX_DEPTH = 5;
@@ -216,6 +220,9 @@ async function generateEntitiesCommand(moduleName, options = {}) {
   const { packageName, artifactId } = projectConfig;
   const packagePath = toPackagePath(packageName);
 
+  // Normalise module name to camelCase (system.yaml uses kebab-case, .eva4j.json stores camelCase)
+  moduleName = toCamelCase(moduleName);
+
   // Validate module exists
   if (!(await configManager.moduleExists(moduleName))) {
     console.error(chalk.red(`❌ Module '${moduleName}' not found`));
@@ -244,7 +251,7 @@ async function generateEntitiesCommand(moduleName, options = {}) {
 
   try {
     // Parse domain.yaml
-    const { aggregates, allEnums, endpoints, listeners, ports } = await parseDomainYaml(domainYamlPath, packageName, moduleName);
+    const { aggregates, allEnums, endpoints, listeners, ports, readModels } = await parseDomainYaml(domainYamlPath, packageName, moduleName);
     
     spinner.succeed(chalk.green(`Found ${aggregates.length} aggregate(s) and ${allEnums.length} enum(s)`));
     
@@ -273,7 +280,7 @@ async function generateEntitiesCommand(moduleName, options = {}) {
     }
 
     // Detect installed message broker for auto-wiring integration events
-    const installedBroker = (hasDomainEventsInModule || (listeners && listeners.length > 0))
+    const installedBroker = (hasDomainEventsInModule || (listeners && listeners.length > 0) || (readModels && readModels.length > 0))
       ? await getInstalledBroker(configManager)
       : null;
     // When brokerMode:'mock' is requested AND a broker is installed, use mock Spring-Events adapter
@@ -281,6 +288,33 @@ async function generateEntitiesCommand(moduleName, options = {}) {
       ? 'mock'
       : installedBroker;
 
+    // Detect Temporal for auto-wiring DomainEvent → Workflow bridge
+    const hasNotifiesInModule = aggregates.some(agg =>
+      (agg.domainEvents || []).some(e => (e.notifies || []).length > 0)
+    );
+    const temporalInstalled = hasNotifiesInModule
+      ? await configManager.featureExists('temporal')
+      : false;
+
+    // Build workflow → inputFields map for typed DomainEvent → Workflow bridge
+    const workflowInputMap = new Map();
+    if (temporalInstalled) {
+      try {
+        const systemDir = path.join(projectDir, 'system');
+        if (await fs.pathExists(path.join(systemDir, 'system.yaml'))) {
+          const { workflows } = await parseSystemYaml(systemDir);
+          for (const wf of workflows) {
+            const inputFields = computeWorkflowInputFields(wf.steps);
+            const flowPascal = wf.namePascal.replace(/Workflow$/, '');
+            workflowInputMap.set(wf.namePascal, { inputFields, flowPascal });
+            workflowInputMap.set(wf.name, { inputFields, flowPascal });
+          }
+        }
+      } catch (_) {
+        // system.yaml not required — standalone modules work without it
+      }
+    }
+
     // Generate audit-related shared components if needed
     if (hasAuditableEntities || hasTrackUserEntities) {
       
@@ -369,6 +403,9 @@ async function generateEntitiesCommand(moduleName, options = {}) {
       const { name: aggregateName, rootEntity, secondaryEntities, valueObjects } = aggregate;
 
       // 1. Generate Domain Aggregate Root
+      const resolvedLifecycle = resolveLifecycleEventArgs(
+        aggregate.lifecycleEventsMap || {}, rootEntity.name, rootEntity.fields, valueObjects
+      );
       const rootDomainContext = {
         packageName,
         moduleName,
@@ -381,7 +418,8 @@ async function generateEntitiesCommand(moduleName, options = {}) {
         auditable: rootEntity.auditable,
         hasSoftDelete: rootEntity.hasSoftDelete || false,
         domainEvents: aggregate.domainEvents || [],
-        triggeredEventsMap: aggregate.triggeredEventsMap || {}
+        triggeredEventsMap: aggregate.triggeredEventsMap || {},
+        lifecycleEventsMap: resolvedLifecycle
       };
 
       await renderAndWrite(
@@ -393,6 +431,7 @@ async function generateEntitiesCommand(moduleName, options = {}) {
       generatedFiles.push({ type: 'Domain Entity', name: rootEntity.name, path: `${moduleName}/domain/models/entities/${rootEntity.name}.java` });
 
       // 2. Generate JPA Aggregate Root
+      const hasCreateLifecycle = !!(aggregate.lifecycleEventsMap && aggregate.lifecycleEventsMap.create && aggregate.lifecycleEventsMap.create.length > 0);
       const rootJpaContext = {
         packageName,
         moduleName,
@@ -405,7 +444,8 @@ async function generateEntitiesCommand(moduleName, options = {}) {
         enums: allEnums,
         auditable: rootEntity.auditable,
         audit: rootEntity.audit,
-        hasSoftDelete: rootEntity.hasSoftDelete || false
+        hasSoftDelete: rootEntity.hasSoftDelete || false,
+        hasCreateLifecycle
       };
 
       await renderAndWrite(
@@ -524,6 +564,8 @@ async function generateEntitiesCommand(moduleName, options = {}) {
         moduleName,
         rootEntity,
         hasSoftDelete: rootEntity.hasSoftDelete || false,
+        hasDomainEvents: (aggregate.domainEvents || []).length > 0,
+        hasDeleteLifecycle: !!(aggregate.lifecycleEventsMap || {}).delete,
         findByOps: []
       };
 
@@ -551,6 +593,7 @@ async function generateEntitiesCommand(moduleName, options = {}) {
         aggregateName,
         rootEntity,
         hasDomainEvents: (aggregate.domainEvents || []).length > 0,
+        hasDeleteLifecycle: !!(aggregate.lifecycleEventsMap || {}).delete,
         hasSoftDelete: rootEntity.hasSoftDelete || false,
         findByOps: []
       };
@@ -592,9 +635,19 @@ async function generateEntitiesCommand(moduleName, options = {}) {
           aggregateName,
           domainEvents: aggregateDomainEvents.map(e => ({
             ...e,
-            integrationEventClassName: `${e.name}IntegrationEvent`
+            integrationEventClassName: `${e.name}IntegrationEvent`,
+            notifies: (e.notifies || []).map(n => {
+              const wfKey = toPascalCase(n.workflow || '');
+              const meta = workflowInputMap.get(wfKey);
+              return {
+                ...n,
+                inputFields: meta ? meta.inputFields : [],
+                flowPascal: meta ? meta.flowPascal : wfKey.replace(/Workflow$/, ''),
+              };
+            }),
           })),
-          broker
+          broker,
+          temporal: temporalInstalled
         };
         await renderAndWrite(
           path.join(__dirname, '..', '..', 'templates', 'aggregate', 'DomainEventHandler.java.ejs'),
@@ -687,6 +740,52 @@ async function generateEntitiesCommand(moduleName, options = {}) {
             name: 'MessageBroker (updated)',
             path: `${moduleName}/application/ports/MessageBroker.java`
           });
+        } else if (broker === 'rabbitmq') {
+          // ── RabbitMQ broker: RabbitTemplate adapter ──────────────────────────
+          const STANDARD_EVENT_TYPES = new Set([
+            'String','Integer','Long','Double','Float','Boolean',
+            'BigDecimal','LocalDate','LocalDateTime','LocalTime','Instant','UUID'
+          ]);
+          for (const event of aggregateDomainEvents) {
+            const rabbitCtx = buildRabbitEventContext(packageName, moduleName, event);
+            await generateSingleRabbitEvent(projectDir, packagePath, rabbitCtx);
+            generatedFiles.push({
+              type: 'Integration Event',
+              name: rabbitCtx.eventClassName,
+              path: `${moduleName}/application/events/${rabbitCtx.eventClassName}.java`
+            });
+
+            // Generate stub records for custom collection element types
+            const customElementTypes = [...new Set(
+              (event.fields || [])
+                .filter(f => f.isCollection && f.collectionElementType && !STANDARD_EVENT_TYPES.has(f.collectionElementType))
+                .map(f => f.collectionElementType)
+            )];
+            for (const typeName of customElementTypes) {
+              const stubPath = path.join(moduleBasePath, 'domain', 'models', 'events', `${typeName}.java`);
+              await renderAndWrite(
+                path.join(__dirname, '..', '..', 'templates', 'aggregate', 'DomainEventSnapshot.java.ejs'),
+                stubPath,
+                { packageName, moduleName, name: typeName, fields: [] },
+                { ...writeOptions, overwrite: false }
+              );
+              generatedFiles.push({
+                type: 'Event Snapshot Type',
+                name: typeName,
+                path: `${moduleName}/domain/models/events/${typeName}.java`
+              });
+            }
+          }
+          generatedFiles.push({
+            type: 'Integration Event',
+            name: `${toPascalCase(moduleName)}RabbitMessageBroker (updated)`,
+            path: `${moduleName}/infrastructure/adapters/rabbitmqMessageBroker/${toPascalCase(moduleName)}RabbitMessageBroker.java`
+          });
+          generatedFiles.push({
+            type: 'Integration Event',
+            name: 'MessageBroker (updated)',
+            path: `${moduleName}/application/ports/MessageBroker.java`
+          });
         }
       }
     }
@@ -708,10 +807,12 @@ async function generateEntitiesCommand(moduleName, options = {}) {
           const topicRaw = listener.topic;
           const topicSuffix = topicRaw.includes('.') ? topicRaw.slice(topicRaw.lastIndexOf('.') + 1) : topicRaw;
           const topicKey = topicSuffix.toLowerCase().replace(/_/g, '-');
+          const kafkaListenerClassName = `${listener.baseName}KafkaListener`;
           const listenerContext = {
             packageName,
             moduleName,
             ...listener,
+            listenerClassName: kafkaListenerClassName,
             topicConstant: topicRaw,
             topicSpringProperty: `\${topics.${topicKey}}`,
             topicVariableName: toCamelCase(topicSuffix.toLowerCase())
@@ -757,7 +858,7 @@ async function generateEntitiesCommand(moduleName, options = {}) {
           // If the file is currently a mock Spring listener, force overwrite with the real Kafka impl
           const kafkaListenerPath = path.join(
             moduleBasePath, 'infrastructure', 'kafkaListener',
-            `${listener.listenerClassName}.java`
+            `${kafkaListenerClassName}.java`
           );
           let kafkaListenerWriteOpts = writeOptions;
           if (await fs.pathExists(kafkaListenerPath)) {
@@ -774,8 +875,8 @@ async function generateEntitiesCommand(moduleName, options = {}) {
           );
           generatedFiles.push({
             type: 'Kafka Listener',
-            name: listener.listenerClassName,
-            path: `${moduleName}/infrastructure/kafkaListener/${listener.listenerClassName}.java`
+            name: kafkaListenerClassName,
+            path: `${moduleName}/infrastructure/kafkaListener/${kafkaListenerClassName}.java`
           });
 
           // 3. Register topic in kafka.yaml (all environments)
@@ -832,10 +933,12 @@ async function generateEntitiesCommand(moduleName, options = {}) {
           const topicRaw = listener.topic;
           const topicSuffix = topicRaw.includes('.') ? topicRaw.slice(topicRaw.lastIndexOf('.') + 1) : topicRaw;
           const topicKey = topicSuffix.toLowerCase().replace(/_/g, '-');
+          const mockListenerClassName = `${listener.baseName}KafkaListener`;
           const listenerContext = {
             packageName,
             moduleName,
             ...listener,
+            listenerClassName: mockListenerClassName,
             topicConstant: topicRaw,
             topicSpringProperty: `\${topics.${topicKey}}`,
             topicVariableName: toCamelCase(topicSuffix.toLowerCase())
@@ -864,14 +967,14 @@ async function generateEntitiesCommand(moduleName, options = {}) {
           generatedFiles.push({ type: 'Listener Integration Event', name: listener.integrationEventClassName, path: `${moduleName}/application/events/${listener.integrationEventClassName}.java` });
 
           // 2. Spring @EventListener class (mock — same file path as Kafka listener)
-          const listenerPath = path.join(moduleBasePath, 'infrastructure', 'kafkaListener', `${listener.listenerClassName}.java`);
+          const listenerPath = path.join(moduleBasePath, 'infrastructure', 'kafkaListener', `${mockListenerClassName}.java`);
           await renderAndWrite(
             path.join(__dirname, '..', '..', 'templates', 'mock', 'SpringEventListener.java.ejs'),
             listenerPath,
             listenerContext,
             { ...writeOptions, force: true }
           );
-          generatedFiles.push({ type: 'Spring Listener (mock)', name: listener.listenerClassName, path: `${moduleName}/infrastructure/kafkaListener/${listener.listenerClassName}.java` });
+          generatedFiles.push({ type: 'Spring Listener (mock)', name: mockListenerClassName, path: `${moduleName}/infrastructure/kafkaListener/${mockListenerClassName}.java` });
 
           // 3. NO kafka.yaml update in mock mode
 
@@ -896,8 +999,146 @@ async function generateEntitiesCommand(moduleName, options = {}) {
           generatedFiles.push({ type: 'Handler', name: `${listener.useCase}CommandHandler`, path: `${moduleName}/application/usecases/${listener.useCase}CommandHandler.java` });
         }
         spinner.succeed(chalk.green(`Spring Event listeners generated (mock mode)! ✨`));
+      } else if (broker === 'rabbitmq') {
+        // ── RabbitMQ listeners: @RabbitListener ─────────────────────────────
+        spinner.start(`Generating ${listeners.length} RabbitMQ listener(s)...`);
+        for (const listener of listeners) {
+          if (!listener.topic) {
+            spinner.warn(chalk.yellow(`⚠ listener '${listener.event}': topic is required when there is no system.yaml. Skipping.`));
+            continue;
+          }
+
+          const topicRaw = listener.topic;
+          const topicSuffix = topicRaw.includes('.') ? topicRaw.slice(topicRaw.lastIndexOf('.') + 1) : topicRaw;
+          const topicKey = topicSuffix.toLowerCase().replace(/_/g, '-');
+          const rabbitListenerClassName = `${listener.baseName}RabbitListener`;
+          const consumerTopicKey = `${moduleName}-${topicKey}`;
+          const listenerContext = {
+            packageName,
+            moduleName,
+            ...listener,
+            listenerClassName: rabbitListenerClassName,
+            topicConstant: topicRaw,
+            topicSpringProperty: `\${queues.${consumerTopicKey}}`,
+            topicVariableName: toCamelCase(topicSuffix.toLowerCase())
+          };
+
+          // 0. Nested type records (auxiliary value objects for object-typed fields)
+          for (const nt of (listener.nestedTypes || [])) {
+            const ntPath = path.join(
+              moduleBasePath, 'application', 'events',
+              `${nt.name}.java`
+            );
+            await renderAndWrite(
+              path.join(__dirname, '..', '..', 'templates', 'kafka-listener', 'ListenerNestedType.java.ejs'),
+              ntPath,
+              { packageName, moduleName, name: nt.name, fields: nt.fields },
+              writeOptions
+            );
+            generatedFiles.push({
+              type: 'Listener Nested Type',
+              name: nt.name,
+              path: `${moduleName}/application/events/${nt.name}.java`
+            });
+          }
+
+          // 1. Integration Event record (same template — broker-agnostic)
+          const integrationEventPath = path.join(
+            moduleBasePath, 'application', 'events',
+            `${listener.integrationEventClassName}.java`
+          );
+          await renderAndWrite(
+            path.join(__dirname, '..', '..', 'templates', 'kafka-listener', 'ListenerIntegrationEvent.java.ejs'),
+            integrationEventPath,
+            listenerContext,
+            writeOptions
+          );
+          generatedFiles.push({
+            type: 'Listener Integration Event',
+            name: listener.integrationEventClassName,
+            path: `${moduleName}/application/events/${listener.integrationEventClassName}.java`
+          });
+
+          // 2. RabbitMQ listener class
+          const rabbitListenerPath = path.join(
+            moduleBasePath, 'infrastructure', 'rabbitListener',
+            `${rabbitListenerClassName}.java`
+          );
+          let rabbitListenerWriteOpts = writeOptions;
+          if (await fs.pathExists(rabbitListenerPath)) {
+            const existing = await fs.readFile(rabbitListenerPath, 'utf-8');
+            if (existing.includes('@EventListener') && !existing.includes('@RabbitListener')) {
+              rabbitListenerWriteOpts = { ...writeOptions, force: true };
+            }
+          }
+          await renderAndWrite(
+            path.join(__dirname, '..', '..', 'templates', 'rabbitmq-listener', 'RabbitListenerClass.java.ejs'),
+            rabbitListenerPath,
+            listenerContext,
+            rabbitListenerWriteOpts
+          );
+          generatedFiles.push({
+            type: 'RabbitMQ Listener',
+            name: rabbitListenerClassName,
+            path: `${moduleName}/infrastructure/rabbitListener/${rabbitListenerClassName}.java`
+          });
+
+          // 3. Register consumer infrastructure in rabbitmq.yaml + RabbitMQConfig.java
+          // Use module-prefixed keys to avoid collision with producer-side in monolith mode
+          const producerModule = toCamelCase(listener.producer || moduleName);
+          const consumerExchangeName = `${producerModule}.events`;
+          const consumerRoutingKey = topicKey.replace(/-/g, '.');
+          const consumerQueueName = `${moduleName}.${topicKey}`;
+          const consumerBeanMethodName = `${toCamelCase(consumerTopicKey)}Topic`;
+
+          await updateRabbitMQYmlForConsumer(
+            projectDir, consumerTopicKey, consumerQueueName,
+            producerModule, consumerExchangeName, consumerRoutingKey
+          );
+          await updateRabbitMQConfigForConsumer(projectDir, packagePath, {
+            producerModule,
+            topicKey: consumerTopicKey,
+            beanMethodName: consumerBeanMethodName,
+            valueFieldName: consumerBeanMethodName
+          });
+
+          // 4. Typed Command dispatched from the listener
+          const commandPath = path.join(
+            moduleBasePath, 'application', 'commands',
+            `${listener.commandClassName}.java`
+          );
+          await renderAndWrite(
+            path.join(__dirname, '..', '..', 'templates', 'kafka-listener', 'ListenerCommand.java.ejs'),
+            commandPath,
+            listenerContext,
+            writeOptions
+          );
+          generatedFiles.push({
+            type: 'Listener Command',
+            name: listener.commandClassName,
+            path: `${moduleName}/application/commands/${listener.commandClassName}.java`
+          });
+
+          // 5. Use case handler that processes the command
+          const handlerPath = path.join(
+            moduleBasePath, 'application', 'usecases',
+            `${listener.useCase}CommandHandler.java`
+          );
+          await renderAndWrite(
+            path.join(__dirname, '..', '..', 'templates', 'kafka-listener', 'ListenerCommandHandler.java.ejs'),
+            handlerPath,
+            listenerContext,
+            writeOptions
+          );
+          generatedFiles.push({
+            type: 'Handler',
+            name: `${listener.useCase}CommandHandler`,
+            path: `${moduleName}/application/usecases/${listener.useCase}CommandHandler.java`
+          });
+        }
+        spinner.succeed(chalk.green(`RabbitMQ listeners generated! ✨`));
       } else if (listeners.length > 0) {
-        console.log(chalk.yellow(`⚠ listeners: section found but no broker is installed. Run 'eva add kafka-client' to generate listener classes.`));
+        console.log(chalk.yellow(`⚠ listeners: section found but no broker is installed. Run 'eva add kafka-client' or 'eva add rabbitmq-client' to generate listener classes.`));
       }
     }
 
@@ -924,6 +1165,8 @@ async function generateEntitiesCommand(moduleName, options = {}) {
 
         const adapterDir = path.join(moduleBasePath, 'infrastructure', 'adapters', adapterPackage);
 
+        const aclMapperClassName = `${serviceName}AclMapper`;
+
         const portContext = {
           packageName,
           moduleName,
@@ -936,6 +1179,7 @@ async function generateEntitiesCommand(moduleName, options = {}) {
           feignClientClassName,
           feignAdapterClassName,
           feignConfigClassName,
+          aclMapperClassName,
           adapterPackage,
           methods,
           nestedTypes,
@@ -976,9 +1220,9 @@ async function generateEntitiesCommand(moduleName, options = {}) {
           });
         }
 
-        // 1b. Infra DTOs (one per method that has fields:) — live in infrastructure/adapters/{service}/
+        // 1b. Infra DTOs (one per method that has fields:) — live in infrastructure/adapters/{service}/dtos/
         for (const method of methods.filter(m => m.hasResponse)) {
-          const infraDtoPath = path.join(adapterDir, `${method.infraDtoName}.java`);
+          const infraDtoPath = path.join(adapterDir, 'dtos', `${method.infraDtoName}.java`);
           await renderAndWrite(
             path.join(__dirname, '..', '..', 'templates', 'ports', 'PortResponseDto.java.ejs'),
             infraDtoPath,
@@ -988,7 +1232,7 @@ async function generateEntitiesCommand(moduleName, options = {}) {
           generatedFiles.push({
             type: 'Port Infra DTO',
             name: method.infraDtoName,
-            path: `${moduleName}/infrastructure/adapters/${adapterPackage}/${method.infraDtoName}.java`
+            path: `${moduleName}/infrastructure/adapters/${adapterPackage}/dtos/${method.infraDtoName}.java`
           });
         }
 
@@ -1049,6 +1293,19 @@ async function generateEntitiesCommand(moduleName, options = {}) {
           path: `${moduleName}/infrastructure/adapters/${adapterPackage}/${feignAdapterClassName}.java`
         });
 
+        // 5b. ACL Mapper (maps infra DTOs → domain models)
+        await renderAndWrite(
+          path.join(__dirname, '..', '..', 'templates', 'ports', 'PortAclMapper.java.ejs'),
+          path.join(adapterDir, `${aclMapperClassName}.java`),
+          portContext,
+          writeOptions
+        );
+        generatedFiles.push({
+          type: 'HTTP Port',
+          name: aclMapperClassName,
+          path: `${moduleName}/infrastructure/adapters/${adapterPackage}/${aclMapperClassName}.java`
+        });
+
         // 6. Feign Config
         await renderAndWrite(
           path.join(__dirname, '..', '..', 'templates', 'ports', 'PortFeignConfig.java.ejs'),
@@ -1072,6 +1329,230 @@ async function generateEntitiesCommand(moduleName, options = {}) {
       spinner.succeed(chalk.green(`HTTP ports generated! ✨`));
     }
 
+    // ── Generate Read Models (local projections of external data) ────────────
+    if (readModels && readModels.length > 0) {
+      if (broker === 'kafka' || broker === 'rabbitmq' || broker === 'mock') {
+        spinner.start(`Generating ${readModels.length} read model(s)...`);
+
+        const readModelTemplatesDir = path.join(__dirname, '..', '..', 'templates', 'read-model');
+
+        for (const rm of readModels) {
+          const rmContext = {
+            packageName,
+            moduleName,
+            ...rm
+          };
+
+          // 1. Domain read model class
+          const domainPath = path.join(
+            moduleBasePath, 'domain', 'models', 'readmodels',
+            `${rm.domainClassName}.java`
+          );
+          await renderAndWrite(
+            path.join(readModelTemplatesDir, 'ReadModelDomain.java.ejs'),
+            domainPath,
+            rmContext,
+            writeOptions
+          );
+          generatedFiles.push({
+            type: 'Read Model',
+            name: rm.domainClassName,
+            path: `${moduleName}/domain/models/readmodels/${rm.domainClassName}.java`
+          });
+
+          // 2. JPA entity
+          const jpaPath = path.join(
+            moduleBasePath, 'infrastructure', 'database', 'entities',
+            `${rm.jpaEntityName}.java`
+          );
+          await renderAndWrite(
+            path.join(readModelTemplatesDir, 'ReadModelJpa.java.ejs'),
+            jpaPath,
+            rmContext,
+            writeOptions
+          );
+          generatedFiles.push({
+            type: 'Read Model',
+            name: rm.jpaEntityName,
+            path: `${moduleName}/infrastructure/database/entities/${rm.jpaEntityName}.java`
+          });
+
+          // 3. JPA repository
+          const jpaRepoPath = path.join(
+            moduleBasePath, 'infrastructure', 'database', 'repositories',
+            `${rm.jpaRepositoryName}.java`
+          );
+          await renderAndWrite(
+            path.join(readModelTemplatesDir, 'ReadModelJpaRepository.java.ejs'),
+            jpaRepoPath,
+            rmContext,
+            writeOptions
+          );
+          generatedFiles.push({
+            type: 'Read Model',
+            name: rm.jpaRepositoryName,
+            path: `${moduleName}/infrastructure/database/repositories/${rm.jpaRepositoryName}.java`
+          });
+
+          // 4. Domain repository interface
+          const repoPath = path.join(
+            moduleBasePath, 'domain', 'repositories',
+            `${rm.repositoryName}.java`
+          );
+          await renderAndWrite(
+            path.join(readModelTemplatesDir, 'ReadModelRepository.java.ejs'),
+            repoPath,
+            rmContext,
+            writeOptions
+          );
+          generatedFiles.push({
+            type: 'Read Model',
+            name: rm.repositoryName,
+            path: `${moduleName}/domain/repositories/${rm.repositoryName}.java`
+          });
+
+          // 5. Repository implementation
+          const repoImplPath = path.join(
+            moduleBasePath, 'infrastructure', 'database', 'repositories',
+            `${rm.repositoryImplName}.java`
+          );
+          await renderAndWrite(
+            path.join(readModelTemplatesDir, 'ReadModelRepositoryImpl.java.ejs'),
+            repoImplPath,
+            rmContext,
+            writeOptions
+          );
+          generatedFiles.push({
+            type: 'Read Model',
+            name: rm.repositoryImplName,
+            path: `${moduleName}/infrastructure/database/repositories/${rm.repositoryImplName}.java`
+          });
+
+          // 6. Sync handler
+          const handlerPath = path.join(
+            moduleBasePath, 'application', 'usecases',
+            `${rm.syncHandlerName}.java`
+          );
+          await renderAndWrite(
+            path.join(readModelTemplatesDir, 'ReadModelSyncHandler.java.ejs'),
+            handlerPath,
+            rmContext,
+            writeOptions
+          );
+          generatedFiles.push({
+            type: 'Read Model',
+            name: rm.syncHandlerName,
+            path: `${moduleName}/application/usecases/${rm.syncHandlerName}.java`
+          });
+
+          // 7. Per syncedBy event: integration event + Kafka listener + topic registration
+          for (const sync of rm.syncedBy) {
+            const listenerContext = {
+              packageName,
+              moduleName,
+              ...sync,
+              syncHandlerName: rm.syncHandlerName,
+              domainClassName: rm.domainClassName,
+              repositoryName: rm.repositoryName
+            };
+
+            // Integration event (reuse if already exists from listeners: section)
+            // Only generate for UPSERT — DELETE/SOFT_DELETE bypass IntegrationEvent entirely
+            const integrationEventPath = path.join(
+              moduleBasePath, 'application', 'events',
+              `${sync.integrationEventClassName}.java`
+            );
+            if (sync.action === 'UPSERT' && !(await fs.pathExists(integrationEventPath))) {
+              await renderAndWrite(
+                path.join(__dirname, '..', '..', 'templates', 'kafka-listener', 'ListenerIntegrationEvent.java.ejs'),
+                integrationEventPath,
+                {
+                  packageName,
+                  moduleName,
+                  integrationEventClassName: sync.integrationEventClassName,
+                  topicConstant: sync.topicConstant,
+                  producer: rm.sourceModule,
+                  fields: sync.fields
+                },
+                writeOptions
+              );
+              generatedFiles.push({
+                type: 'Read Model Integration Event',
+                name: sync.integrationEventClassName,
+                path: `${moduleName}/application/events/${sync.integrationEventClassName}.java`
+              });
+            }
+
+            // Kafka listener
+            if (broker === 'kafka') {
+              const kafkaListenerPath = path.join(
+                moduleBasePath, 'infrastructure', 'kafkaListener',
+                `${sync.listenerClassName}.java`
+              );
+              await renderAndWrite(
+                path.join(readModelTemplatesDir, 'ReadModelKafkaListener.java.ejs'),
+                kafkaListenerPath,
+                listenerContext,
+                writeOptions
+              );
+              generatedFiles.push({
+                type: 'Read Model Kafka Listener',
+                name: sync.listenerClassName,
+                path: `${moduleName}/infrastructure/kafkaListener/${sync.listenerClassName}.java`
+              });
+
+              // Register topic in kafka.yaml
+              await updateKafkaYml(projectDir, sync.topicKey, sync.topicConstant);
+            } else if (broker === 'rabbitmq') {
+              const rabbitListenerPath = path.join(
+                moduleBasePath, 'infrastructure', 'rabbitListener',
+                `${sync.listenerClassName}.java`
+              );
+              const rmConsumerTopicKey = `${moduleName}-${sync.topicKey}`;
+              const rabbitListenerContext = {
+                ...listenerContext,
+                topicSpringProperty: `\${queues.${rmConsumerTopicKey}}`
+              };
+              await renderAndWrite(
+                path.join(readModelTemplatesDir, 'ReadModelRabbitListener.java.ejs'),
+                rabbitListenerPath,
+                rabbitListenerContext,
+                writeOptions
+              );
+              generatedFiles.push({
+                type: 'Read Model RabbitMQ Listener',
+                name: sync.listenerClassName,
+                path: `${moduleName}/infrastructure/rabbitListener/${sync.listenerClassName}.java`
+              });
+
+              // Register consumer infrastructure in rabbitmq.yaml + RabbitMQConfig.java
+              // Use module-prefixed keys to avoid collision with producer-side in monolith mode
+              const rmProducerModule = toCamelCase(rm.sourceModule || moduleName);
+              const rmExchangeName = `${rmProducerModule}.events`;
+              const rmRoutingKey = sync.topicKey.replace(/-/g, '.');
+              const rmQueueName = `${moduleName}.${sync.topicKey}`;
+              const rmBeanMethodName = `${toCamelCase(rmConsumerTopicKey)}Topic`;
+
+              await updateRabbitMQYmlForConsumer(
+                projectDir, rmConsumerTopicKey, rmQueueName,
+                rmProducerModule, rmExchangeName, rmRoutingKey
+              );
+              await updateRabbitMQConfigForConsumer(projectDir, packagePath, {
+                producerModule: rmProducerModule,
+                topicKey: rmConsumerTopicKey,
+                beanMethodName: rmBeanMethodName,
+                valueFieldName: rmBeanMethodName
+              });
+            }
+          }
+        }
+
+        spinner.succeed(chalk.green(`Read models generated! ✨`));
+      } else if (readModels.length > 0) {
+        console.log(chalk.yellow(`⚠ readModels: section found but no broker is installed. Run 'eva add kafka-client' or 'eva add rabbitmq-client' to generate listener classes.`));
+      }
+    }
+
     console.log(chalk.blue('\n📦 Generated files:'));
     const groupedFiles = generatedFiles.reduce((acc, file) => {
       if (!acc[file.type]) acc[file.type] = [];
@@ -1113,8 +1594,18 @@ async function generateEntitiesCommand(moduleName, options = {}) {
             }
           }
           if (!op._ownerAggregate) {
-            // True scaffold: heuristic — find aggregate whose name appears inside the use case name
-            const matched = aggregates.find(agg =>
+            // True scaffold: heuristic — strip CRUD verb prefix and singularize to find
+            // the best aggregate match via prefix comparison.
+            // e.g. "FindAllGuarantees" → suffix "Guarantees" → singular "Guarantee"
+            //      → "GuaranteeCatalog".startsWith("guarantee") ✓
+            const ucSuffix = op.useCase.replace(/^(FindAll|GetAll|Get|Create|Update|Delete|Add|Remove)/, '');
+            const singularSuffix = ucSuffix ? singularizeWord(ucSuffix).toLowerCase() : '';
+            const matched = (singularSuffix &&
+              aggregates.find(agg => {
+                const aggLower = agg.name.toLowerCase();
+                return aggLower.startsWith(singularSuffix) || singularSuffix.startsWith(aggLower);
+              })
+            ) || aggregates.find(agg =>
               op.useCase.toLowerCase().includes(agg.name.toLowerCase())
             );
             const owner = matched || aggregates[0];
@@ -1410,11 +1901,14 @@ function classifyUseCase(op, aggregateName, aggregate) {
       };
     }
     if (op.useCase === `Remove${rel.target}`) {
+      const removeTargetEntity = (aggregate.secondaryEntities || []).find(e => e.name === rel.target);
+      const removeIdField = removeTargetEntity ? removeTargetEntity.fields.find(f => f.name === 'id') : null;
       return {
         category: 'subEntityRemove',
         entityName: rel.target,
         fieldName: rel.fieldName,
-        removeMethodName: `remove${rel.target}ById`
+        removeMethodName: `remove${rel.target}ById`,
+        itemIdType: removeIdField ? removeIdField.javaType : 'String'
       };
     }
   }
@@ -1434,6 +1928,34 @@ function classifyUseCase(op, aggregateName, aggregate) {
     }
   }
 
+  // 5. Fuzzy FindAll — useCase starts with "FindAll" and the singular of the
+  //    suffix is a prefix of the aggregate name (or vice-versa).
+  //    e.g. FindAllGuarantees → singular "Guarantee" → "GuaranteeCatalog" starts with it ✓
+  if (op.useCase.startsWith('FindAll')) {
+    const suffix = op.useCase.slice(7);
+    if (suffix) {
+      const singularSuffix = singularizeWord(suffix).toLowerCase();
+      const aggLower = aggregateName.toLowerCase();
+      if (aggLower.startsWith(singularSuffix) || singularSuffix.startsWith(aggLower)) {
+        return { category: 'standard', variant: 'findAll' };
+      }
+    }
+  }
+
+  // 6. Fuzzy Get — useCase starts with "Get" and the suffix matches the
+  //    aggregate name as a prefix (or vice-versa).
+  //    e.g. GetCatTariff → "CatTariff" matches aggregate "CatTariff" ✓
+  if (op.useCase.startsWith('Get') && !op.useCase.startsWith('GetAll')) {
+    const suffix = op.useCase.slice(3);
+    if (suffix) {
+      const suffixLower = suffix.toLowerCase();
+      const aggLower = aggregateName.toLowerCase();
+      if (aggLower.startsWith(suffixLower) || suffixLower.startsWith(aggLower)) {
+        return { category: 'standard', variant: 'getById' };
+      }
+    }
+  }
+
   return { category: 'scaffold' };
 }
 
@@ -1552,13 +2074,18 @@ async function generateEndpointsResources(aggregate, endpoints, moduleName, modu
   const oneToManyRelationshipsApp = enrichRelsWithSchemaExamples(
     transformRelsForApp(oneToManyRelationships, validatedVoNames), localAllEnums, valueObjects);
 
+  const resolvedLifecycleEndpoints = resolveLifecycleEventArgs(
+    aggregate.lifecycleEventsMap || {}, aggregateName, rootEntity.fields, valueObjects
+  );
   const baseContext = {
     packageName, moduleName, aggregateName, aggregateNamePlural, rootEntity, secondaryEntities,
     responseFields, responseSecondaryEntities, idType,
     commandFields: commandFieldsApp, oneToManyRelationships, oneToOneRelationships,
     hasValueObjects, hasEnums, imports: rootEntity.imports,
     resourceNameCamel, resourceNameKebab,
-    hasSoftDelete: rootEntity.hasSoftDelete || false
+    hasSoftDelete: rootEntity.hasSoftDelete || false,
+    domainEvents: aggregate.domainEvents || [],
+    lifecycleEventsMap: resolvedLifecycleEndpoints
   };
 
   // ── Step 1: Validated VO Dtos ────────────────────────────────────────
@@ -1819,7 +2346,8 @@ async function generateEndpointsResources(aggregate, endpoints, moduleName, modu
           useCaseName: op.useCase,
           idType,
           entityName: cl.entityName,
-          removeMethodName: cl.removeMethodName
+          removeMethodName: cl.removeMethodName,
+          itemIdType: cl.itemIdType || 'String'
         };
         await renderAndWrite(
           path.join(templatesDir, 'SubEntityRemoveCommand.java.ejs'),
@@ -1863,7 +2391,10 @@ async function generateEndpointsResources(aggregate, endpoints, moduleName, modu
 
       } else {
         // Scaffold: no semantic pattern matched → generate stub with TODO
-        const scaffoldContext = { packageName, moduleName, aggregateName, useCaseName: op.useCase };
+        const hasPathVar = Boolean(op.path && op.path.includes('{'));
+        const pathVarMatch = hasPathVar ? op.path.match(/\{([^}]+)\}/) : null;
+        const pathVarName = pathVarMatch ? pathVarMatch[1] : 'id';
+        const scaffoldContext = { packageName, moduleName, aggregateName, useCaseName: op.useCase, hasPathVar, pathVarName, idType };
         const scaffoldType = op.type || (op.method === 'GET' ? 'query' : 'command');
         if (scaffoldType === 'command') {
           await renderAndWrite(
@@ -2065,6 +2596,9 @@ async function generateCrudResources(aggregate, moduleName, moduleBasePath, pack
     transformRelsForApp(oneToManyRelationships, validatedVoNames), localAllEnums, valueObjects);
 
   // Base context for all templates
+  const resolvedLifecycleCrud = resolveLifecycleEventArgs(
+    aggregate.lifecycleEventsMap || {}, aggregateName, rootEntity.fields, valueObjects
+  );
   const baseContext = {
     packageName,
     moduleName,
@@ -2085,7 +2619,9 @@ async function generateCrudResources(aggregate, moduleName, moduleBasePath, pack
     resourceNameCamel,
     resourceNameKebab,
     hasSoftDelete: rootEntity.hasSoftDelete || false,
-    hasCreateOperation: true  // In interactive CRUD flow, Create is always generated
+    hasCreateOperation: true,  // In interactive CRUD flow, Create is always generated
+    domainEvents: aggregate.domainEvents || [],
+    lifecycleEventsMap: resolvedLifecycleCrud
   };
 
   // 0. Generate Create<VoName>Dto for validated Value Objects