eva4j 1.0.16 → 1.0.18

package/src/commands/add-temporal-client.js

@@ -80,6 +80,10 @@ async function addTemporalClientCommand() {
     spinner.text = 'Generating TemporalConfig class...';
     await generateTemporalConfigClass(projectDir, context);
 
+    // 5b. Generate TemporalWorkerFactoryLifecycle.java
+    spinner.text = 'Generating TemporalWorkerFactoryLifecycle class...';
+    await generateTemporalLifecycleClass(projectDir, context);
+
     // 6. Update docker-compose.yaml if it exists
     spinner.text = 'Updating docker-compose.yaml...';
     await updateDockerCompose(projectDir, context);
@@ -99,13 +103,14 @@ async function addTemporalClientCommand() {
     console.log(chalk.gray('  │   └── production/temporal.yaml'));
     console.log(chalk.gray('  ├── shared/domain/interfaces/HeavyActivity.java'));
     console.log(chalk.gray('  ├── shared/domain/interfaces/LightActivity.java'));
-    console.log(chalk.gray('  └── shared/infrastructure/configurations/temporalConfig/TemporalConfig.java'));
+    console.log(chalk.gray('  ├── shared/infrastructure/configurations/temporalConfig/TemporalConfig.java'));
+    console.log(chalk.gray('  └── shared/infrastructure/configurations/temporalConfig/TemporalWorkerFactoryLifecycle.java'));
 
     console.log(chalk.blue('\n✅ Temporal client configured successfully!'));
     console.log(chalk.white('\n   Service URL:  localhost:7233'));
     console.log(chalk.white('   Namespace:    default'));
     console.log(chalk.white('   Temporal UI:  http://localhost:8088'));
-    console.log(chalk.yellow('\n   ⚠️  Register your workflow implementation types in TemporalConfig.java'));
+    console.log(chalk.yellow('\n   ⚠️  Run "eva g temporal-flow <module>" to create workflows with module-scoped queues'));
     console.log(chalk.gray('   Run "docker-compose up -d" to start the Temporal cluster'));
     console.log(chalk.gray('   Update temporal.yaml files to customize service URLs per environment'));
     console.log();
@@ -235,6 +240,21 @@ async function generateTemporalConfigClass(projectDir, context) {
   await renderAndWrite(templatePath, outputPath, context);
 }
 
+/**
+ * Generate TemporalWorkerFactoryLifecycle.java class
+ */
+async function generateTemporalLifecycleClass(projectDir, context) {
+  const templatePath = path.join(
+    __dirname, '..', '..', 'templates', 'shared', 'configurations', 'temporalConfig', 'TemporalWorkerFactoryLifecycle.java.ejs'
+  );
+  const outputPath = path.join(
+    projectDir, 'src', 'main', 'java', context.packagePath,
+    'shared', 'infrastructure', 'configurations', 'temporalConfig', 'TemporalWorkerFactoryLifecycle.java'
+  );
+
+  await renderAndWrite(templatePath, outputPath, context);
+}
+
 /**
  * Update docker-compose.yaml to add Temporal services
  */

package/src/commands/build.js

@@ -7,13 +7,18 @@ const yaml = require('js-yaml');
 
 const ConfigManager = require('../utils/config-manager');
 const { isEva4jProject } = require('../utils/validator');
-const { toCamelCase, toPackagePath } = require('../utils/naming');
+const { toCamelCase, toPascalCase, toScreamingSnakeCase, toPackagePath } = require('../utils/naming');
 const SharedGenerator = require('../generators/shared-generator');
 const { renderAndWrite } = require('../utils/template-engine');
 const addModuleCommand = require('./add-module');
 const addKafkaClientCommand = require('./add-kafka-client');
+const addRabbitMQClientCommand = require('./add-rabbitmq-client');
+const addTemporalClientCommand = require('./add-temporal-client');
 const generateEntitiesCommand = require('./generate-entities');
+const generateTemporalSystemCommand = require('./generate-temporal-system');
+const generateTemporalActivityCommand = require('./generate-temporal-activity');
 const { generateUnifiedPostmanCollection } = require('../generators/postman-generator');
+const ChecksumManager = require('../utils/checksum-manager');
 
 // ── H2 mock config ─────────────────────────────────────────────────────────────
 const H2_DB_YAML = (packageName) => `spring:
@@ -244,7 +249,16 @@ async function swapToH2(projectDir, packageName, configManager) {
   if (await fs.pathExists(kafkaConfigPath)) {
     backups.kafkaConfig = { path: kafkaConfigPath, content: await fs.readFile(kafkaConfigPath, 'utf-8') };
   }
-  // When Kafka is not installed, omit the key entirely — restoreFromH2() iterates
+
+  // ── RabbitMQConfig.java — backup so it can be restored later ──────────────
+  const rabbitConfigPath = path.join(
+    projectDir, 'src', 'main', 'java', packagePath,
+    'shared', 'infrastructure', 'configurations', 'rabbitmqConfig', 'RabbitMQConfig.java'
+  );
+  if (await fs.pathExists(rabbitConfigPath)) {
+    backups.rabbitConfig = { path: rabbitConfigPath, content: await fs.readFile(rabbitConfigPath, 'utf-8') };
+  }
+  // When broker is not installed, omit the key entirely — restoreFromH2() iterates
   // Object.values(backups) and would crash trying to destructure a null entry.
 
   // Persist backups BEFORE writing any file so a crash mid-swap is recoverable
@@ -267,6 +281,11 @@ async function swapToH2(projectDir, packageName, configManager) {
       /\n?[ \t]*\/\/ Kafka\n[ \t]*implementation 'org\.springframework\.kafka:spring-kafka'\n[ \t]*testImplementation 'org\.springframework\.kafka:spring-kafka-test'\n\n?[ \t]*/,
       '\n\t'
     );
+    // Remove spring-amqp dependencies block when RabbitMQ is installed
+    swapped = swapped.replace(
+      /\n?[ \t]*\/\/ RabbitMQ\n[ \t]*implementation 'org\.springframework\.boot:spring-boot-starter-amqp'\n[ \t]*testImplementation 'org\.springframework\.amqp:spring-rabbit-test'\n\n?[ \t]*/,
+      '\n\t'
+    );
     await fs.writeFile(buildGradlePath, swapped, 'utf-8');
   }
 
@@ -278,11 +297,16 @@ async function swapToH2(projectDir, packageName, configManager) {
     await fs.remove(kafkaConfigPath);
   }
 
+  // ── Remove RabbitMQConfig.java (restored from backup on eva build) ────────
+  if (backups.rabbitConfig) {
+    await fs.remove(rabbitConfigPath);
+  }
+
   return backups;
 }
 
 /**
- * Backup and swap ONLY the broker layer (Kafka → Spring Event bus).
+ * Backup and swap ONLY the broker layer (Kafka/RabbitMQ → Spring Event bus).
  * Database config (db.yaml) and SecurityConfig.java are left untouched.
  * Persists backups to .eva4j.json with _mockOnlyBroker = true.
  */
@@ -305,15 +329,29 @@ async function swapBrokerOnly(projectDir, packageName, configManager) {
     backups.kafkaConfig = { path: kafkaConfigPath, content: await fs.readFile(kafkaConfigPath, 'utf-8') };
   }
 
+  // ── RabbitMQConfig.java ───────────────────────────────────────────────────
+  const rabbitConfigPath = path.join(
+    projectDir, 'src', 'main', 'java', packagePath,
+    'shared', 'infrastructure', 'configurations', 'rabbitmqConfig', 'RabbitMQConfig.java'
+  );
+  if (await fs.pathExists(rabbitConfigPath)) {
+    backups.rabbitConfig = { path: rabbitConfigPath, content: await fs.readFile(rabbitConfigPath, 'utf-8') };
+  }
+
   // Persist backups BEFORE writing any file so a crash mid-swap is recoverable
   await configManager.saveMockBackup(backups, { onlyBroker: true });
 
   // ── Remove spring-kafka from build.gradle (keep existing DB driver line) ──
   if (backups.buildGradle) {
-    const swapped = backups.buildGradle.content.replace(
+    let swapped = backups.buildGradle.content.replace(
       /\n?[ \t]*\/\/ Kafka\n[ \t]*implementation 'org\.springframework\.kafka:spring-kafka'\n[ \t]*testImplementation 'org\.springframework\.kafka:spring-kafka-test'\n\n?[ \t]*/,
       '\n\t'
     );
+    // Remove spring-amqp dependencies block when RabbitMQ is installed
+    swapped = swapped.replace(
+      /\n?[ \t]*\/\/ RabbitMQ\n[ \t]*implementation 'org\.springframework\.boot:spring-boot-starter-amqp'\n[ \t]*testImplementation 'org\.springframework\.amqp:spring-rabbit-test'\n\n?[ \t]*/,
+      '\n\t'
+    );
     await fs.writeFile(buildGradlePath, swapped, 'utf-8');
   }
 
@@ -322,6 +360,11 @@ async function swapBrokerOnly(projectDir, packageName, configManager) {
     await fs.remove(kafkaConfigPath);
   }
 
+  // ── Remove RabbitMQConfig.java (restored from backup on eva build) ────────
+  if (backups.rabbitConfig) {
+    await fs.remove(rabbitConfigPath);
+  }
+
   return backups;
 }
 
@@ -343,6 +386,38 @@ async function restoreFromH2(configManager) {
   return Object.keys(backups).length;
 }
 
+// ── Temporal module queue helper ─────────────────────────────────────────────
+/**
+ * Append module-specific queue configuration to temporal.yaml files (idempotent).
+ * Same logic as generate-temporal-flow.js appendModuleQueues().
+ */
+async function appendTemporalModuleQueues(projectDir, moduleName, moduleScreamingSnake) {
+  const resourcesDir = path.join(projectDir, 'src', 'main', 'resources', 'parameters');
+
+  const moduleSection = [
+    `    ${moduleName}:`,
+    `      flow-queue: ${moduleScreamingSnake}_WORKFLOW_QUEUE`,
+    `      heavy-queue: ${moduleScreamingSnake}_HEAVY_TASK_QUEUE`,
+    `      light-queue: ${moduleScreamingSnake}_LIGHT_TASK_QUEUE`,
+  ].join('\n');
+
+  for (const env of ENVS) {
+    const yamlPath = path.join(resourcesDir, env, 'temporal.yaml');
+    if (!(await fs.pathExists(yamlPath))) continue;
+
+    let content = await fs.readFile(yamlPath, 'utf-8');
+    if (content.includes(`${moduleName}:`)) continue;
+
+    if (!content.includes('modules:')) {
+      content = content.trimEnd() + '\n  modules:\n' + moduleSection + '\n';
+    } else {
+      content = content.trimEnd() + '\n' + moduleSection + '\n';
+    }
+
+    await fs.writeFile(yamlPath, content, 'utf-8');
+  }
+}
+
 // ── Main build command ──────────────────────────────────────────────────────────
 async function buildCommand(options = {}) {
   const projectDir = process.cwd();
@@ -400,6 +475,39 @@ async function buildCommand(options = {}) {
       }
     }
 
+    // ── Clean up stale mock adapter files ──────────────────────────────────────
+    // Mock mode always generates adapters under kafkaMessageBroker/ regardless of
+    // the installed broker. When the real broker is RabbitMQ, those files would
+    // coexist with the real rabbitmqMessageBroker/ adapters after restore,
+    // causing a ConflictingBeanDefinitionException. Remove them proactively.
+    if (await configManager.featureExists('rabbitmq')) {
+      const { packageName: pkgCleanup } = projectConfig;
+      const pkgPathCleanup = toPackagePath(pkgCleanup);
+      const modules = projectConfig.modules || [];
+      for (const mod of modules) {
+        const mockAdapterDir = path.join(
+          projectDir, 'src', 'main', 'java', pkgPathCleanup,
+          mod, 'infrastructure', 'adapters', 'kafkaMessageBroker'
+        );
+        if (await fs.pathExists(mockAdapterDir)) {
+          // Safety check: only remove if the files are mock implementations
+          const files = await fs.readdir(mockAdapterDir);
+          const isMockDir = files.length > 0 && await (async () => {
+            for (const f of files) {
+              const content = await fs.readFile(path.join(mockAdapterDir, f), 'utf-8');
+              if (content.includes('ApplicationEventPublisher') && !content.includes('KafkaTemplate')) {
+                return true;
+              }
+            }
+            return false;
+          })();
+          if (isMockDir) {
+            await fs.remove(mockAdapterDir);
+          }
+        }
+      }
+    }
+
     console.log(chalk.green('   ✅ Configuration restored to original.\n'));
   }
 
@@ -423,18 +531,24 @@ async function buildCommand(options = {}) {
 
       const backups = await swapBrokerOnly(projectDir, pkgName, configManager);
       const hasKafkaBackup = !!backups.kafkaConfig;
+      const hasRabbitBackup = !!backups.rabbitConfig;
+      const hasBrokerBackup = hasKafkaBackup || hasRabbitBackup;
       console.log(chalk.green(`  ✅ ${Object.keys(backups).length} file(s) backed up and replaced`));
       if (hasKafkaBackup) {
         console.log(chalk.green('  ✅ KafkaConfig.java removed (Spring Events will be used instead)'));
         console.log(chalk.green('  ✅ spring-kafka dependencies removed from build.gradle'));
       }
+      if (hasRabbitBackup) {
+        console.log(chalk.green('  ✅ RabbitMQConfig.java removed (Spring Events will be used instead)'));
+        console.log(chalk.green('  ✅ spring-amqp dependencies removed from build.gradle'));
+      }
       console.log(chalk.gray('     Backup saved to .eva4j.json — will be restored on next eva build\n'));
 
-      // ── Regenerate broker layer if system.yaml exists and Kafka was installed
+      // ── Regenerate broker layer if system.yaml exists and broker was installed
       const systemDirBo = path.join(projectDir, 'system');
       const systemYamlPathBo = path.join(systemDirBo, 'system.yaml');
 
-      if (hasKafkaBackup && (await fs.pathExists(systemYamlPathBo))) {
+      if (hasBrokerBackup && (await fs.pathExists(systemYamlPathBo))) {
         let systemConfigBo;
         try {
           const content = await fs.readFile(systemYamlPathBo, 'utf-8');
@@ -475,7 +589,7 @@ async function buildCommand(options = {}) {
             await generateEntitiesCommand(mod.name, { force: false, brokerMode: 'mock' });
           }
         }
-      } else if (hasKafkaBackup) {
+      } else if (hasBrokerBackup) {
         console.log(chalk.yellow('  ℹ️  No system/system.yaml found — broker files must be regenerated manually.'));
         console.log(chalk.yellow('     Run: eva g entities <module> (with --force if needed)'));
       }
@@ -495,18 +609,24 @@ async function buildCommand(options = {}) {
 
     const backups = await swapToH2(projectDir, pkgName, configManager);
     const hasKafkaBackup = !!backups.kafkaConfig;
+    const hasRabbitBackup = !!backups.rabbitConfig;
+    const hasBrokerBackup = hasKafkaBackup || hasRabbitBackup;
     console.log(chalk.green(`  ✅ ${Object.keys(backups).length} file(s) backed up and replaced`));
     if (hasKafkaBackup) {
       console.log(chalk.green('  ✅ KafkaConfig.java removed (Spring Events will be used instead)'));
       console.log(chalk.green('  ✅ spring-kafka dependencies removed from build.gradle'));
     }
+    if (hasRabbitBackup) {
+      console.log(chalk.green('  ✅ RabbitMQConfig.java removed (Spring Events will be used instead)'));
+      console.log(chalk.green('  ✅ spring-amqp dependencies removed from build.gradle'));
+    }
     console.log(chalk.gray('     Backup saved to .eva4j.json — will be restored on next eva build\n'));
 
-    // ── Regenerate broker layer if system.yaml exists and Kafka was installed ──
+    // ── Regenerate broker layer if system.yaml exists and broker was installed ──
     const systemDir = path.join(projectDir, 'system');
     const systemYamlPath = path.join(systemDir, 'system.yaml');
 
-    if (hasKafkaBackup && (await fs.pathExists(systemYamlPath))) {
+    if (hasBrokerBackup && (await fs.pathExists(systemYamlPath))) {
       let systemConfig;
       try {
         const content = await fs.readFile(systemYamlPath, 'utf-8');
@@ -549,7 +669,7 @@ async function buildCommand(options = {}) {
           await generateEntitiesCommand(mod.name, { force: false, brokerMode: 'mock' });
         }
       }
-    } else if (hasKafkaBackup) {
+    } else if (hasBrokerBackup) {
       console.log(chalk.yellow('  ℹ️  No system/system.yaml found — broker files must be regenerated manually.'));
       console.log(chalk.yellow('     Run: eva g entities <module> (with --force if needed)'));
     }
@@ -583,6 +703,8 @@ async function buildCommand(options = {}) {
   }
 
   const { modules = [], messaging } = systemConfig;
+  const orchestration = systemConfig.orchestration;
+  const temporalEnabled = orchestration && orchestration.enabled === true && orchestration.engine === 'temporal';
 
   if (!modules.length) {
     console.log(chalk.yellow('⚠️  No modules defined in system/system.yaml'));
@@ -592,6 +714,9 @@ async function buildCommand(options = {}) {
   console.log(chalk.blue('\n🏗️  eva build\n'));
   console.log(chalk.gray(`  Project : ${projectConfig.projectName || projectConfig.artifactId}`));
   console.log(chalk.gray(`  Modules : ${modules.map(m => m.name).join(', ')}`));
+  if (temporalEnabled) {
+    console.log(chalk.gray(`  Orchestr: Temporal (${orchestration.temporal && orchestration.temporal.namespace || 'default'})`));
+  }
   console.log();
 
   // ── STEP 1: Create modules ───────────────────────────────────────────────
@@ -633,12 +758,34 @@ async function buildCommand(options = {}) {
         console.log(chalk.cyan('  ➕ Installing kafka-client'));
         await addKafkaClientCommand();
       }
+    } else if (broker === 'rabbitmq') {
+      if (await configManager.featureExists('rabbitmq')) {
+        console.log(chalk.gray('  ⏭  rabbitmq-client — already installed, skipping'));
+      } else {
+        console.log(chalk.cyan('  ➕ Installing rabbitmq-client'));
+        await addRabbitMQClientCommand();
+      }
     } else {
-      console.log(chalk.yellow(`  ⚠️  Broker '${broker}' is not supported by eva build (only kafka is supported)`));
+      console.log(chalk.yellow(`  ⚠️  Broker '${broker}' is not supported by eva build (only kafka and rabbitmq are supported)`));
     }
 
     console.log();
 
+    // ── STEP 2b: Install Temporal client (if orchestration configured) ──────
+    if (temporalEnabled) {
+      console.log(chalk.blue('━━━ Step 2b: Installing Temporal client ━━━━━━━━━━━━━━━━━━━━━━'));
+
+      if (await configManager.featureExists('temporal')) {
+        console.log(chalk.gray('  ⏭  temporal-client — already installed, skipping'));
+      } else {
+        console.log(chalk.cyan('  ➕ Installing temporal-client'));
+        await addTemporalClientCommand();
+        await configManager.loadProjectConfig();
+      }
+
+      console.log();
+    }
+
     // ── STEP 3: Copy domain.yaml files ──────────────────────────────────────
     console.log(chalk.blue('━━━ Step 3: Copying domain.yaml files ━━━━━━━━━━━━━━━━━━━━━━━'));
 
@@ -684,6 +831,115 @@ async function buildCommand(options = {}) {
 
     console.log();
 
+    // ── STEP 4b+4c: Generate Temporal infrastructure & workflows ─────────────
+    if (temporalEnabled && (await configManager.featureExists('temporal'))) {
+      const rawWorkflows = Array.isArray(systemConfig.workflows) ? systemConfig.workflows : [];
+
+      // Collect all modules that participate in Temporal (trigger or target)
+      const temporalModulesSet = new Set();
+      for (const wf of rawWorkflows) {
+        if (wf.trigger && wf.trigger.module) temporalModulesSet.add(toCamelCase(wf.trigger.module));
+        for (const step of wf.steps || []) {
+          if (step.target) temporalModulesSet.add(toCamelCase(step.target));
+        }
+      }
+      // Also include modules with activities: in domain.yaml
+      for (const mod of modules) {
+        const modCamel = toCamelCase(mod.name);
+        const domYaml = path.join(projectDir, 'src', 'main', 'java', packagePath, modCamel, 'domain.yaml');
+        if (await fs.pathExists(domYaml)) {
+          const data = yaml.load(await fs.readFile(domYaml, 'utf-8'));
+          if (data && Array.isArray(data.activities) && data.activities.length > 0) {
+            temporalModulesSet.add(modCamel);
+          }
+        }
+      }
+
+      if (temporalModulesSet.size > 0) {
+        // ── Step 4b: Module-level Temporal infrastructure ────────────────────
+        console.log(chalk.blue('━━━ Step 4b: Generating Temporal module infrastructure ━━━━━━━'));
+
+        const temporalFlowTemplates = path.join(__dirname, '..', '..', 'templates', 'temporal-flow');
+
+        for (const modCamel of temporalModulesSet) {
+          const modPascal = toPascalCase(modCamel);
+          const modScreamingSnake = toScreamingSnakeCase(modCamel);
+          const moduleBasePath = path.join(projectDir, 'src', 'main', 'java', packagePath, modCamel);
+          if (!(await fs.pathExists(moduleBasePath))) continue;
+
+          const checksumMgr = new ChecksumManager(moduleBasePath);
+          await checksumMgr.load();
+          const wOpts = { force: generateOptions.force, checksumManager: checksumMgr };
+
+          const ctx = {
+            packageName,
+            moduleName: modCamel,
+            modulePascalCase: modPascal,
+            moduleCamelCase: modCamel,
+            moduleScreamingSnake: modScreamingSnake,
+          };
+
+          // Marker interfaces (idempotent)
+          const interfacesDir = path.join(moduleBasePath, 'domain', 'interfaces');
+          await renderAndWrite(
+            path.join(temporalFlowTemplates, 'ModuleHeavyActivity.java.ejs'),
+            path.join(interfacesDir, `${modPascal}HeavyActivity.java`),
+            ctx, wOpts
+          );
+          await renderAndWrite(
+            path.join(temporalFlowTemplates, 'ModuleLightActivity.java.ejs'),
+            path.join(interfacesDir, `${modPascal}LightActivity.java`),
+            ctx, wOpts
+          );
+
+          // Worker config (idempotent)
+          const configDir = path.join(moduleBasePath, 'infrastructure', 'configurations');
+          await renderAndWrite(
+            path.join(temporalFlowTemplates, 'ModuleTemporalWorkerConfig.java.ejs'),
+            path.join(configDir, `${modPascal}TemporalWorkerConfig.java`),
+            ctx, wOpts
+          );
+
+          // temporal.yaml queues
+          await appendTemporalModuleQueues(projectDir, modCamel, modScreamingSnake);
+
+          await checksumMgr.save();
+          console.log(chalk.green(`  ✅ ${modCamel} — Temporal worker infrastructure`));
+        }
+
+        // Generate activities per module (YAML-driven, non-interactive)
+        for (const mod of modules) {
+          const modCamel = toCamelCase(mod.name);
+          if (!temporalModulesSet.has(modCamel)) continue;
+
+          const domYaml = path.join(projectDir, 'src', 'main', 'java', packagePath, modCamel, 'domain.yaml');
+          if (!(await fs.pathExists(domYaml))) continue;
+          const data = yaml.load(await fs.readFile(domYaml, 'utf-8'));
+          if (!data || !Array.isArray(data.activities) || data.activities.length === 0) continue;
+
+          console.log(chalk.cyan(`  ⚙️  Generating activities for: ${mod.name}`));
+          try {
+            await generateTemporalActivityCommand(modCamel, null, { force: generateOptions.force, generateAll: true });
+          } catch (err) {
+            console.log(chalk.yellow(`  ⚠️  Activity generation failed for ${mod.name}: ${err.message}`));
+          }
+        }
+
+        console.log();
+      }
+
+      // ── Step 4c: Cross-module workflows from system.yaml ──────────────────
+      if (rawWorkflows.length > 0) {
+        console.log(chalk.blue('━━━ Step 4c: Generating Temporal workflows ━━━━━━━━━━━━━━━━━━'));
+        try {
+          await generateTemporalSystemCommand({ force: generateOptions.force });
+        } catch (err) {
+          console.log(chalk.yellow(`  ⚠️  Temporal workflow generation failed: ${err.message}`));
+        }
+        console.log();
+      }
+    }
+
     // ── STEP 5: Generate unified Postman collection ─────────────────────────
     console.log(chalk.blue('━━━ Step 5: Generating unified Postman collection ━━━━━━━━━━━━'));