eva4j 1.0.17 → 1.0.18

package/src/commands/generate-entities.js

@@ -14,6 +14,10 @@ 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;
@@ -284,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) {
       
@@ -604,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'),
@@ -699,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`
+          });
         }
       }
     }
@@ -720,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())
@@ -769,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)) {
@@ -786,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)
@@ -844,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())
@@ -876,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
 
@@ -908,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.`));
       }
     }
 
@@ -936,6 +1165,8 @@ async function generateEntitiesCommand(moduleName, options = {}) {
 
         const adapterDir = path.join(moduleBasePath, 'infrastructure', 'adapters', adapterPackage);
 
+        const aclMapperClassName = `${serviceName}AclMapper`;
+
         const portContext = {
           packageName,
           moduleName,
@@ -948,6 +1179,7 @@ async function generateEntitiesCommand(moduleName, options = {}) {
           feignClientClassName,
           feignAdapterClassName,
           feignConfigClassName,
+          aclMapperClassName,
           adapterPackage,
           methods,
           nestedTypes,
@@ -988,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,
@@ -1000,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`
           });
         }
 
@@ -1061,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'),
@@ -1086,7 +1331,7 @@ async function generateEntitiesCommand(moduleName, options = {}) {
 
     // ── Generate Read Models (local projections of external data) ────────────
     if (readModels && readModels.length > 0) {
-      if (broker === 'kafka' || broker === 'mock') {
+      if (broker === 'kafka' || broker === 'rabbitmq' || broker === 'mock') {
         spinner.start(`Generating ${readModels.length} read model(s)...`);
 
         const readModelTemplatesDir = path.join(__dirname, '..', '..', 'templates', 'read-model');
@@ -1258,13 +1503,53 @@ async function generateEntitiesCommand(moduleName, options = {}) {
 
               // 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' to generate listener classes.`));
+        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.`));
       }
     }
 
@@ -1616,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'
       };
     }
   }
@@ -2058,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'),
@@ -2102,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(