eva4j 1.0.16 → 1.0.18

package/src/utils/naming.js

@@ -47,6 +47,15 @@ function toKebabCase(str) {
     .toLowerCase();
 }
 
+/**
+ * Convert string to SCREAMING_SNAKE_CASE
+ * @param {string} str - Input string
+ * @returns {string} SCREAMING_SNAKE_CASE string
+ */
+function toScreamingSnakeCase(str) {
+  return toSnakeCase(str).toUpperCase();
+}
+
 /**
  * Pluralize a word
  * @param {string} word - Word to pluralize
@@ -56,6 +65,15 @@ function pluralizeWord(word) {
   return pluralize(word);
 }
 
+/**
+ * Singularize a word
+ * @param {string} word - Word to singularize
+ * @returns {string} Singularized word
+ */
+function singularizeWord(word) {
+  return pluralize.singular(word);
+}
+
 /**
  * Convert package name to path
  * @param {string} packageName - Package name (e.g., com.company.project)
@@ -128,7 +146,9 @@ module.exports = {
   toCamelCase,
   toSnakeCase,
   toKebabCase,
+  toScreamingSnakeCase,
   pluralizeWord,
+  singularizeWord,
   toPackagePath,
   getBaseEntity,
   artifactIdToPackageName,

package/src/utils/system-validator.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { toPascalCase, toCamelCase } = require('./naming');
+
 /**
  * Validates a parsed system.yaml object against the S1–S5 static evaluation rules.
  *
@@ -21,6 +23,10 @@ function validateSystem(systemConfig, domainConfigs = {}) {
   const messaging = systemConfig.messaging || {};
   const topicPrefix = (messaging.kafka || {}).topicPrefix || null;
 
+  // Detect Temporal orchestration mode — suppresses Kafka/Feign-specific rules
+  const orchestration = systemConfig.orchestration || {};
+  const isTemporalMode = !!(orchestration.enabled && orchestration.engine === 'temporal');
+
   // Helper: normalize a consumer entry to its module name string
   const consumerModule = (c) => (typeof c === 'string' ? c : c.module);
 
@@ -57,7 +63,17 @@ function validateSystem(systemConfig, domainConfigs = {}) {
     const consumesEvents = asyncEvents.some((e) =>
       (e.consumers || []).some((c) => consumerModule(c) === mod.name)
     );
-    if (!hasExposes && !producesEvents && !consumesEvents) {
+    // In Temporal mode: a module with activities or local workflows is a valid participant
+    const hasTemporalRole = isTemporalMode && (() => {
+      const domCfg = domainConfigs[mod.name] || {};
+      return (Array.isArray(domCfg.activities) && domCfg.activities.length > 0) ||
+             (Array.isArray(domCfg.workflows) && domCfg.workflows.length > 0) ||
+             (systemConfig.workflows || []).some((wf) =>
+               (wf.trigger && toCamelCase(wf.trigger.module) === toCamelCase(mod.name)) ||
+               (wf.steps || []).some((s) => s.target && toCamelCase(s.target) === toCamelCase(mod.name))
+             );
+    })();
+    if (!hasExposes && !producesEvents && !consumesEvents && !hasTemporalRole) {
       errors.push(`[S1-002] Módulo '${mod.name}' no tiene ninguna responsabilidad — no expone endpoints, no produce ni consume eventos`);
       s1_002_found = true;
     }
@@ -346,10 +362,13 @@ function validateSystem(systemConfig, domainConfigs = {}) {
   // ── S5 — Coherencia del sistema global ───────────────────────────────────
 
   // S5-001: messaging.enabled: false with async events declared
-  if (messaging.enabled === false && asyncEvents.length > 0) {
-    warnings.push(`[S5-001] messaging.enabled está en false pero hay ${asyncEvents.length} eventos declarados en integrations.async`);
-  } else if (messaging.enabled !== false && asyncEvents.length > 0) {
-    ok.push('[S5-001] Configuración de messaging es coherente con los eventos declarados ✓');
+  // Not applicable to Temporal-based systems
+  if (!isTemporalMode) {
+    if (messaging.enabled === false && asyncEvents.length > 0) {
+      warnings.push(`[S5-001] messaging.enabled está en false pero hay ${asyncEvents.length} eventos declarados en integrations.async`);
+    } else if (messaging.enabled !== false && asyncEvents.length > 0) {
+      ok.push('[S5-001] Configuración de messaging es coherente con los eventos declarados ✓');
+    }
   }
 
   // S5-002: success event without matching failure event for same subject
@@ -399,12 +418,151 @@ function validateSystem(systemConfig, domainConfigs = {}) {
   }
 
   // S5-004: module with no connection to system graph (info)
-  for (const mod of modules) {
-    const hasAnyConnection =
-      asyncEvents.some((e) => e.producer === mod.name || (e.consumers || []).some((c) => consumerModule(c) === mod.name)) ||
-      syncIntegrations.some((s) => s.caller === mod.name || s.calls === mod.name);
-    if (!hasAnyConnection) {
-      info.push(`[S5-004] Módulo '${mod.name}' no tiene ninguna conexión al grafo del sistema — ni async ni sync`);
+  // Suppressed for Temporal mode — connectivity is via workflows[], not integrations.async[]/sync[]
+  if (!isTemporalMode) {
+    for (const mod of modules) {
+      const hasAnyConnection =
+        asyncEvents.some((e) => e.producer === mod.name || (e.consumers || []).some((c) => consumerModule(c) === mod.name)) ||
+        syncIntegrations.some((s) => s.caller === mod.name || s.calls === mod.name);
+      if (!hasAnyConnection) {
+        info.push(`[S5-004] Módulo '${mod.name}' no tiene ninguna conexión al grafo del sistema — ni async ni sync`);
+      }
+    }
+  }
+
+  // ── T1 — Temporal Workflow Integrity ──────────────────────────────────────
+  // Skipped in Temporal mode — handled exclusively by temporal-validator.js
+  if (!isTemporalMode && orchestration.enabled && Array.isArray(systemConfig.workflows)) {
+    // Build activity registry from domainConfigs: PascalCase name → { module, input[], output[] }
+    const activityMap = new Map();
+    for (const [modName, domainCfg] of Object.entries(domainConfigs)) {
+      if (!domainCfg || !Array.isArray(domainCfg.activities)) continue;
+      const modCamel = toCamelCase(modName);
+      for (const act of domainCfg.activities) {
+        const actPascal = toPascalCase(act.name);
+        const inputNames = Array.isArray(act.input) ? act.input.map((f) => f.name || f) : [];
+        const outputNames = Array.isArray(act.output) ? act.output.map((f) => f.name || f) : [];
+        activityMap.set(`${modCamel}::${actPascal}`, { module: modCamel, inputNames, outputNames });
+      }
+    }
+
+    let t1_001_found = false;
+    let t1_002_found = false;
+    let t1_004_found = false;
+    let t1_006_found = false;
+
+    for (const wf of systemConfig.workflows) {
+      const wfName = wf.name || '(unnamed)';
+      const hostModule = wf.trigger && wf.trigger.module ? toCamelCase(wf.trigger.module) : null;
+      const rawSteps = Array.isArray(wf.steps) ? wf.steps : [];
+
+      // Track available output names from prior steps for T1-002
+      const availableOutputNames = new Set();
+
+      // Compute workflow-level input names: step inputs not satisfied by prior step outputs
+      // (first pass to collect all step outputs)
+      const allStepOutputs = new Map(); // stepIndex → rawOutputNames
+      for (let i = 0; i < rawSteps.length; i++) {
+        const rawOut = Array.isArray(rawSteps[i].output) ? rawSteps[i].output : [];
+        allStepOutputs.set(i, new Set(rawOut));
+      }
+
+      // Compute workflow-level inputs: inputs not provided by any prior step's output
+      const workflowInputNames = new Set();
+      const priorOutputs = new Set();
+      for (let i = 0; i < rawSteps.length; i++) {
+        const stepInputs = Array.isArray(rawSteps[i].input) ? rawSteps[i].input : [];
+        for (const inName of stepInputs) {
+          if (!priorOutputs.has(inName)) {
+            workflowInputNames.add(inName);
+          }
+        }
+        const stepOutputs = allStepOutputs.get(i) || new Set();
+        for (const outName of stepOutputs) {
+          priorOutputs.add(outName);
+        }
+      }
+
+      for (let i = 0; i < rawSteps.length; i++) {
+        const step = rawSteps[i];
+        const actName = step.activity ? toPascalCase(step.activity) : null;
+        if (!actName) continue;
+
+        const targetModule = step.target ? toCamelCase(step.target) : hostModule;
+        const key = `${targetModule}::${actName}`;
+        const registered = activityMap.get(key);
+
+        // T1-004: Activity not found in target module
+        if (!registered) {
+          warnings.push(`[T1-004] Workflow '${wfName}' paso ${i + 1}: actividad '${actName}' no encontrada en activities[] de '${targetModule}'`);
+          t1_004_found = true;
+        }
+
+        // T1-001: Step output name not in activity's formal output fields
+        const rawOutputNames = Array.isArray(step.output) ? step.output : [];
+        if (registered && rawOutputNames.length > 0) {
+          const formalOutputSet = new Set(registered.outputNames);
+          for (const outName of rawOutputNames) {
+            if (!formalOutputSet.has(outName)) {
+              errors.push(`[T1-001] Workflow '${wfName}' paso ${i + 1} (${actName}): output '${outName}' no existe en los campos de salida de la actividad — campos disponibles: [${registered.outputNames.join(', ')}]`);
+              t1_001_found = true;
+            }
+          }
+
+          // T1-003: Step output count exceeds activity formal output count
+          if (rawOutputNames.length > registered.outputNames.length) {
+            warnings.push(`[T1-003] Workflow '${wfName}' paso ${i + 1} (${actName}): declara ${rawOutputNames.length} outputs pero la actividad solo define ${registered.outputNames.length} campos de salida`);
+          }
+        }
+
+        // T1-002: Step input name not resolvable
+        const rawInputNames = Array.isArray(step.input) ? step.input : [];
+        if (rawInputNames.length > 0) {
+          for (const inName of rawInputNames) {
+            if (!availableOutputNames.has(inName)) {
+              // Not from a prior step — must come from workflow input (OK, no error)
+              // But if we detect it's truly orphaned, we'd need full data-flow analysis.
+              // For now, we skip pure workflow-input names (they're always valid).
+            }
+          }
+        }
+
+        // T1-005: Sync step with no output declaration
+        if (step.type !== 'async' && rawOutputNames.length === 0 && registered && registered.outputNames.length > 0) {
+          info.push(`[T1-005] Workflow '${wfName}' paso ${i + 1} (${actName}): paso síncrono sin output: declarado — la actividad define ${registered.outputNames.length} campo(s) de salida que no se propagan`);
+        }
+
+        // Add this step's outputs to available set for subsequent steps
+        for (const outName of rawOutputNames) {
+          availableOutputNames.add(outName);
+        }
+
+        // T1-006: Compensation input field not resolvable
+        if (step.compensation) {
+          const compName = toPascalCase(step.compensation);
+          const compTarget = step.target ? toCamelCase(step.target) : hostModule;
+          const compKey = `${compTarget}::${compName}`;
+          const compRegistered = activityMap.get(compKey);
+          if (compRegistered) {
+            for (const compIn of compRegistered.inputNames) {
+              if (!availableOutputNames.has(compIn) && !workflowInputNames.has(compIn)) {
+                errors.push(`[T1-006] Workflow '${wfName}' paso ${i + 1} (${actName}): compensación '${compName}' requiere input '${compIn}' pero no está disponible en outputs de pasos previos ni en inputs del workflow`);
+                t1_006_found = true;
+              }
+            }
+          }
+        }
+      }
+    }
+
+    if (!t1_001_found) {
+      ok.push('[T1-001] Todos los outputs de pasos de workflow coinciden con campos formales de la actividad ✓');
+    }
+    if (!t1_004_found) {
+      ok.push('[T1-004] Todas las actividades referenciadas en workflows existen en sus módulos target ✓');
+    }
+    if (!t1_006_found) {
+      ok.push('[T1-006] Todos los inputs de compensaciones son resolubles desde outputs de pasos previos o inputs del workflow ✓');
     }
   }
 

package/src/utils/system-yaml-parser.js

@@ -0,0 +1,318 @@
+/**
+ * system-yaml-parser.js
+ *
+ * Parses system.yaml and resolves cross-module workflow definitions by
+ * cross-referencing each workflow step's activity with its target module's
+ * domain.yaml. Produces a rich context tree for template generation.
+ */
+
+const yaml = require('js-yaml');
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const { toPascalCase, toCamelCase, toScreamingSnakeCase } = require('./naming');
+
+// ─── Java type → import mapping (shared with generate-temporal-activity) ────
+const JAVA_TYPE_IMPORTS = {
+  BigDecimal: 'java.math.BigDecimal',
+  LocalDateTime: 'java.time.LocalDateTime',
+  LocalDate: 'java.time.LocalDate',
+  LocalTime: 'java.time.LocalTime',
+  Instant: 'java.time.Instant',
+  UUID: 'java.util.UUID',
+  List: 'java.util.List',
+};
+
+function resolveFieldImports(fields) {
+  const imports = new Set();
+  for (const field of fields) {
+    for (const [type, imp] of Object.entries(JAVA_TYPE_IMPORTS)) {
+      if (field.javaType && field.javaType.includes(type)) {
+        imports.add(`import ${imp};`);
+      }
+    }
+  }
+  return Array.from(imports).sort();
+}
+
+function mapField(field) {
+  let javaType = field.type || 'String';
+  // Default bare collection types to generic <String>
+  if (javaType === 'List' || javaType === 'Set') {
+    javaType = javaType + '<String>';
+  }
+  return { name: field.name, javaType };
+}
+
+/**
+ * Parse a timeout string like "5s", "10m", "2h" into a Duration descriptor.
+ * @param {string|null} timeout
+ * @returns {{ value: number, unit: string }}
+ */
+function parseTimeout(timeout) {
+  if (!timeout) return { value: 30, unit: 'Seconds' };
+  const match = String(timeout).match(/^(\d+)(s|m|h)$/);
+  if (!match) return { value: 30, unit: 'Seconds' };
+  const units = { s: 'Seconds', m: 'Minutes', h: 'Hours' };
+  return { value: parseInt(match[1], 10), unit: units[match[2]] || 'Seconds' };
+}
+
+// ─── Core parser ────────────────────────────────────────────────────────────
+
+/**
+ * Load and parse system.yaml.
+ * @param {string} systemYamlPath - Absolute path to system.yaml
+ * @returns {object} Raw parsed YAML data
+ */
+async function loadSystemYaml(systemYamlPath) {
+  if (!(await fs.pathExists(systemYamlPath))) {
+    throw new Error(`system.yaml not found at ${systemYamlPath}`);
+  }
+  const content = await fs.readFile(systemYamlPath, 'utf-8');
+  return yaml.load(content);
+}
+
+/**
+ * Load the activities section from a module's domain.yaml.
+ * @param {string} domainYamlPath - Absolute path to domain.yaml
+ * @returns {Map<string, object>} Map of PascalCase activity name → raw activity definition
+ */
+async function loadModuleActivities(domainYamlPath) {
+  const activities = new Map();
+  if (!(await fs.pathExists(domainYamlPath))) return activities;
+
+  const content = await fs.readFile(domainYamlPath, 'utf-8');
+  const data = yaml.load(content);
+  if (!data || !Array.isArray(data.activities)) return activities;
+
+  for (const act of data.activities) {
+    activities.set(toPascalCase(act.name), act);
+  }
+  return activities;
+}
+
+/**
+ * Parse system.yaml and resolve all workflow steps against their target module
+ * domain.yaml files.
+ *
+ * @param {string} systemDir - Directory containing system.yaml and domain yamls
+ * @returns {object} Parsed system context:
+ *   {
+ *     system: { name, groupId, javaVersion, springBootVersion, database },
+ *     orchestration: { enabled, engine, temporal: { target, namespace } },
+ *     modules: [{ name, description, exposes }],
+ *     workflows: [ResolvedWorkflow],
+ *     activityRegistry: Map<activityName, { module, definition }>,
+ *     warnings: string[]
+ *   }
+ */
+async function parseSystemYaml(systemDir) {
+  const systemYamlPath = path.join(systemDir, 'system.yaml');
+  const data = await loadSystemYaml(systemYamlPath);
+
+  const warnings = [];
+
+  // ── 1. Basic sections ──────────────────────────────────────────────────
+  const system = data.system || {};
+  const orchestration = data.orchestration || {};
+  const modules = Array.isArray(data.modules) ? data.modules : [];
+  const rawWorkflows = Array.isArray(data.workflows) ? data.workflows : [];
+
+  // ── 2. Load all module activities ──────────────────────────────────────
+  // Map: moduleName (camelCase) → Map<ActivityPascalCase, rawDefinition>
+  const moduleActivitiesMap = new Map();
+
+  for (const mod of modules) {
+    const modCamel = toCamelCase(mod.name);
+    // Domain YAML files can be in the system dir (prototype layout)
+    // or in the project's module directory. Try both.
+    const candidates = [
+      path.join(systemDir, `${mod.name}.yaml`),
+      path.join(systemDir, `${modCamel}.yaml`),
+    ];
+
+    let activities = new Map();
+    for (const candidate of candidates) {
+      activities = await loadModuleActivities(candidate);
+      if (activities.size > 0) break;
+    }
+
+    moduleActivitiesMap.set(modCamel, activities);
+  }
+
+  // ── 3. Build activity registry (flat, for easy lookup) ─────────────────
+  // Map: activityPascalCase → { module (camelCase), definition, inputFields, outputFields }
+  const activityRegistry = new Map();
+
+  for (const [modName, activities] of moduleActivitiesMap) {
+    for (const [actName, actDef] of activities) {
+      activityRegistry.set(actName, {
+        module: modName,
+        definition: actDef,
+        inputFields: Array.isArray(actDef.input) ? actDef.input.map(mapField) : [],
+        outputFields: Array.isArray(actDef.output) ? actDef.output.map(mapField) : [],
+        type: (actDef.type || 'light').toLowerCase(),
+        compensation: actDef.compensation ? toPascalCase(actDef.compensation) : null,
+        timeout: actDef.timeout || null,
+        description: actDef.description || '',
+      });
+    }
+  }
+
+  // ── 4. Resolve workflows ───────────────────────────────────────────────
+  const workflows = rawWorkflows.map((wf) =>
+    resolveWorkflow(wf, activityRegistry, warnings)
+  );
+
+  return {
+    system,
+    orchestration,
+    modules,
+    workflows,
+    activityRegistry,
+    warnings,
+  };
+}
+
+/**
+ * Resolve a single workflow definition: enrich each step with activity
+ * definitions, detect parallel groups, and derive the host module.
+ *
+ * @param {object} wf - Raw workflow from system.yaml
+ * @param {Map} activityRegistry - Global activity lookup
+ * @param {string[]} warnings - Mutable array for warnings
+ * @returns {object} Resolved workflow
+ */
+function resolveWorkflow(wf, activityRegistry, warnings) {
+  const name = wf.name;
+  const namePascal = toPascalCase(name);
+  const trigger = wf.trigger || {};
+  const hostModule = toCamelCase(trigger.module || '');
+  const taskQueue = wf.taskQueue || `${toScreamingSnakeCase(hostModule)}_WORKFLOW_QUEUE`;
+  const isSaga = wf.saga === true;
+
+  const steps = [];
+  const rawSteps = Array.isArray(wf.steps) ? wf.steps : [];
+
+  for (let i = 0; i < rawSteps.length; i++) {
+    const rawStep = rawSteps[i];
+    const activityName = toPascalCase(rawStep.activity);
+    const targetModule = toCamelCase(rawStep.target || hostModule);
+    const isLocal = targetModule === hostModule;
+    const isAsync = rawStep.type === 'async';
+    const isParallel = rawStep.parallel === true;
+    const isOptional = rawStep.optional === true;
+
+    // Resolve from registry
+    const registered = activityRegistry.get(activityName);
+    if (!registered) {
+      warnings.push(
+        `Workflow '${name}' step ${i + 1}: activity '${activityName}' not found in any module's domain.yaml`
+      );
+    }
+
+    const inputFields = registered ? registered.inputFields : (rawStep.input || []).map((n) => ({ name: n, javaType: 'String' }));
+    const outputFields = registered ? registered.outputFields : (rawStep.output || []).map((n) => ({ name: n, javaType: 'String' }));
+    const actType = registered ? registered.type : (rawStep.type === 'async' ? 'light' : 'light');
+    const timeout = rawStep.timeout || (registered ? registered.timeout : null);
+
+    // Resolve compensation
+    let compensation = null;
+    if (rawStep.compensation) {
+      const compName = toPascalCase(rawStep.compensation);
+      const compRegistered = activityRegistry.get(compName);
+      compensation = {
+        name: compName,
+        module: compRegistered ? compRegistered.module : targetModule,
+        inputFields: compRegistered ? compRegistered.inputFields : [],
+      };
+    }
+
+    // Queue for this step's target module
+    const stepQueue = actType === 'heavy'
+      ? `${toScreamingSnakeCase(targetModule)}_HEAVY_TASK_QUEUE`
+      : `${toScreamingSnakeCase(targetModule)}_LIGHT_TASK_QUEUE`;
+
+    // Raw field names from system.yaml (wiring-level names)
+    const rawInputNames = Array.isArray(rawStep.input) ? rawStep.input : [];
+    const rawOutputNames = Array.isArray(rawStep.output) ? rawStep.output : [];
+
+    steps.push({
+      index: i,
+      activityName,
+      activityCamel: activityName.charAt(0).toLowerCase() + activityName.slice(1),
+      targetModule,
+      targetModulePascal: toPascalCase(targetModule),
+      targetModuleScreamingSnake: toScreamingSnakeCase(targetModule),
+      stepQueue,
+      isLocal,
+      isAsync,
+      isParallel,
+      isOptional,
+      actType,
+      timeout,
+      inputFields,
+      outputFields,
+      rawInputNames,
+      rawOutputNames,
+      hasInput: inputFields.length > 0,
+      hasOutput: outputFields.length > 0,
+      compensation,
+      inputImports: resolveFieldImports(inputFields),
+      outputImports: resolveFieldImports(outputFields),
+    });
+  }
+
+  // ── Detect parallel groups ─────────────────────────────────────────────
+  // Consecutive steps with parallel: true form a group
+  const parallelGroups = [];
+  let currentGroup = null;
+  for (const step of steps) {
+    if (step.isParallel) {
+      if (!currentGroup) {
+        currentGroup = { startIndex: step.index, steps: [] };
+      }
+      currentGroup.steps.push(step);
+    } else {
+      if (currentGroup) {
+        parallelGroups.push(currentGroup);
+        currentGroup = null;
+      }
+    }
+  }
+  if (currentGroup) parallelGroups.push(currentGroup);
+
+  // ── Collect unique target modules (for imports) ────────────────────────
+  const targetModules = [...new Set(steps.map((s) => s.targetModule))];
+
+  return {
+    name,
+    namePascal,
+    nameScreamingSnake: toScreamingSnakeCase(name.replace(/Workflow$/, '')),
+    trigger,
+    hostModule,
+    hostModulePascal: toPascalCase(hostModule),
+    hostModuleScreamingSnake: toScreamingSnakeCase(hostModule),
+    taskQueue,
+    isSaga,
+    steps,
+    parallelGroups,
+    targetModules,
+    hasParallelSteps: parallelGroups.length > 0,
+    hasCompensations: steps.some((s) => s.compensation !== null),
+    hasAsyncSteps: steps.some((s) => s.isAsync),
+    hasOptionalSteps: steps.some((s) => s.isOptional),
+  };
+}
+
+// ─── Exports ────────────────────────────────────────────────────────────────
+
+module.exports = {
+  parseSystemYaml,
+  loadSystemYaml,
+  loadModuleActivities,
+  resolveWorkflow,
+  resolveFieldImports,
+  mapField,
+  parseTimeout,
+};