eva4j 1.0.16 → 1.0.17

package/src/commands/generate-entities.js

@@ -5,9 +5,9 @@ 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');
@@ -216,6 +216,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 +247,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 +276,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
@@ -369,6 +372,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 +387,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 +400,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 +413,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 +533,8 @@ async function generateEntitiesCommand(moduleName, options = {}) {
         moduleName,
         rootEntity,
         hasSoftDelete: rootEntity.hasSoftDelete || false,
+        hasDomainEvents: (aggregate.domainEvents || []).length > 0,
+        hasDeleteLifecycle: !!(aggregate.lifecycleEventsMap || {}).delete,
         findByOps: []
       };
 
@@ -551,6 +562,7 @@ async function generateEntitiesCommand(moduleName, options = {}) {
         aggregateName,
         rootEntity,
         hasDomainEvents: (aggregate.domainEvents || []).length > 0,
+        hasDeleteLifecycle: !!(aggregate.lifecycleEventsMap || {}).delete,
         hasSoftDelete: rootEntity.hasSoftDelete || false,
         findByOps: []
       };
@@ -1072,6 +1084,190 @@ 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 === '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);
+            }
+          }
+        }
+
+        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.blue('\n📦 Generated files:'));
     const groupedFiles = generatedFiles.reduce((acc, file) => {
       if (!acc[file.type]) acc[file.type] = [];
@@ -1113,8 +1309,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];
@@ -1434,6 +1640,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 +1786,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 ────────────────────────────────────────
@@ -2065,6 +2304,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 +2327,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

package/src/commands/generate-http-exchange.js

@@ -32,6 +32,9 @@ async function generateHttpExchangeCommand(moduleName, portName) {
   const { packageName } = 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 in project configuration`));

package/src/commands/generate-kafka-event.js

@@ -40,6 +40,9 @@ async function generateKafkaEventCommand(moduleName, eventName) {
   const { packageName } = 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 in project configuration`));

package/src/commands/generate-kafka-listener.js

@@ -36,6 +36,9 @@ async function generateKafkaListenerCommand(moduleName) {
   const { packageName, projectName } = 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 in project`));

package/src/commands/generate-record.js

@@ -6,7 +6,7 @@ const inquirer = require('inquirer');
 const clipboardy = require('clipboardy');
 const ConfigManager = require('../utils/config-manager');
 const { isEva4jProject } = require('../utils/validator');
-const { toPackagePath, toPascalCase } = require('../utils/naming');
+const { toPackagePath, toPascalCase, toCamelCase } = require('../utils/naming');
 const { renderAndWrite } = require('../utils/template-engine');
 const { parseJsonToRecords } = require('../utils/json-to-java');
 
@@ -107,7 +107,7 @@ async function generateRecordCommand(options = {}) {
     const { recordName, moduleName, targetFolder } = answers;
 
     // Validate module exists in filesystem
-    const modulePath = path.join(projectDir, 'src', 'main', 'java', packagePath, moduleName);
+    const modulePath = path.join(projectDir, 'src', 'main', 'java', packagePath, toCamelCase(moduleName));
     if (!(await fs.pathExists(modulePath))) {
       console.error(chalk.red(`❌ Module '${moduleName}' not found in filesystem`));
       process.exit(1);

package/src/commands/generate-resource.js

@@ -5,7 +5,7 @@ const path = require('path');
 const fs = require('fs-extra');
 const ConfigManager = require('../utils/config-manager');
 const { isEva4jProject } = require('../utils/validator');
-const { toPackagePath, toPascalCase, pluralizeWord, toKebabCase } = require('../utils/naming');
+const { toPackagePath, toPascalCase, pluralizeWord, toKebabCase, toCamelCase } = require('../utils/naming');
 const { renderAndWrite } = require('../utils/template-engine');
 const ChecksumManager = require('../utils/checksum-manager');
 
@@ -30,6 +30,9 @@ async function generateResourceCommand(moduleName, options = {}) {
   const { packageName } = 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 in project`));

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

@@ -5,7 +5,7 @@ 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 { toPackagePath, toPascalCase, toCamelCase } = require('../utils/naming');
 const { renderAndWrite } = require('../utils/template-engine');
 const ChecksumManager = require('../utils/checksum-manager');
 
@@ -46,6 +46,9 @@ async function generateTemporalActivityCommand(moduleName, activityName, options
   const { packageName } = projectConfig;
   const packagePath = toPackagePath(packageName);
 
+  // Normalise module name to camelCase (system.yaml uses kebab-case, .eva4j.json stores camelCase)
+  moduleName = toCamelCase(moduleName);
+
   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}`));

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

@@ -5,7 +5,7 @@ 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 { toPackagePath, toPascalCase, toCamelCase } = require('../utils/naming');
 const { renderAndWrite } = require('../utils/template-engine');
 const ChecksumManager = require('../utils/checksum-manager');
 
@@ -48,6 +48,9 @@ async function generateTemporalFlowCommand(moduleName, flowName, options = {}) {
   const { packageName } = projectConfig;
   const packagePath = toPackagePath(packageName);
 
+  // Normalise module name to camelCase (system.yaml uses kebab-case, .eva4j.json stores camelCase)
+  moduleName = toCamelCase(moduleName);
+
   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}`));

package/src/commands/generate-usecase.js

@@ -5,7 +5,7 @@ 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 { toPackagePath, toPascalCase, toCamelCase } = require('../utils/naming');
 const { renderAndWrite } = require('../utils/template-engine');
 const ChecksumManager = require('../utils/checksum-manager');
 
@@ -32,6 +32,9 @@ async function generateUsecaseCommand(moduleName, usecaseName, options = {}) {
   const { packageName } = 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 in project configuration`));