eva4j 1.0.17 → 1.0.18

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

@@ -3,12 +3,499 @@ const ora = require('ora');
 const chalk = require('chalk');
 const path = require('path');
 const fs = require('fs-extra');
+const yaml = require('js-yaml');
 const ConfigManager = require('../utils/config-manager');
 const { isEva4jProject, moduleExists } = require('../utils/validator');
-const { toPackagePath, toPascalCase, toCamelCase } = require('../utils/naming');
+const { toPackagePath, toPascalCase, toCamelCase, toScreamingSnakeCase } = require('../utils/naming');
 const { renderAndWrite } = require('../utils/template-engine');
 const ChecksumManager = require('../utils/checksum-manager');
 
+// ─── Java type → import mapping ─────────────────────────────────────────────
+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',
+};
+
+/**
+ * Resolve Java imports for a list of typed fields.
+ * @param {Array<{javaType: string}>} fields
+ * @returns {string[]} sorted import statements
+ */
+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();
+}
+
+/**
+ * Parse the `activities:` section from a module's domain.yaml.
+ * Returns null if the file does not exist or has no activities.
+ * @param {string} domainYamlPath
+ * @returns {Array|null}
+ */
+async function parseActivitiesFromYaml(domainYamlPath) {
+  if (!(await fs.pathExists(domainYamlPath))) return null;
+  const content = await fs.readFile(domainYamlPath, 'utf-8');
+  const data = yaml.load(content);
+  if (!data || !Array.isArray(data.activities) || data.activities.length === 0) return null;
+  return data.activities;
+}
+
+/**
+ * Extract aggregate info (root entity name + fields) from domain.yaml data.
+ * Returns null if no aggregate with a root entity is found.
+ * @param {string} domainYamlPath
+ * @returns {object|null} { aggregateName, rootEntityName, rootFieldNames: Set<string>, idFieldName, idFieldType }
+ */
+async function parseAggregateInfo(domainYamlPath) {
+  if (!(await fs.pathExists(domainYamlPath))) return null;
+  const content = await fs.readFile(domainYamlPath, 'utf-8');
+  const data = yaml.load(content);
+  if (!data || !Array.isArray(data.aggregates) || data.aggregates.length === 0) return null;
+
+  for (const agg of data.aggregates) {
+    const entities = Array.isArray(agg.entities) ? agg.entities : [];
+    const root = entities.find((e) => e.isRoot === true);
+    if (!root || !Array.isArray(root.fields)) continue;
+
+    const aggregateName = toPascalCase(agg.name);
+    const rootEntityName = toPascalCase(root.name);
+    const rootFieldNames = new Set(root.fields.map((f) => f.name));
+    const rootFieldTypes = new Map(root.fields.map((f) => [f.name, f.type || 'String']));
+    const idField = root.fields.find((f) => f.name === 'id');
+
+    // Build voFieldsMap: PascalCase VO name → raw fields array
+    const voFieldsMap = new Map();
+    const voList = Array.isArray(agg.valueObjects) ? agg.valueObjects : [];
+    for (const vo of voList) {
+      voFieldsMap.set(toPascalCase(vo.name), Array.isArray(vo.fields) ? vo.fields : []);
+    }
+
+    // Build lazyRelationshipFields: camelCase field name → { relType, target, jpaFieldName }
+    // OneToMany / ManyToMany are LAZY by JPA default; OneToOne / ManyToOne are EAGER by default.
+    const lazyRelationshipFields = new Map();
+    const relationships = Array.isArray(root.relationships) ? root.relationships : [];
+    for (const rel of relationships) {
+      const relType = (rel.type || '').trim();
+      const fetchType = (rel.fetch || '').toUpperCase();
+      const isToMany = relType === 'OneToMany' || relType === 'ManyToMany';
+      // LAZY when: *ToMany (unless explicitly EAGER) OR any type explicitly marked LAZY
+      const isLazy = isToMany ? fetchType !== 'EAGER' : fetchType === 'LAZY';
+      if (!isLazy) continue;
+      const targetPascal = toPascalCase(rel.target || '');
+      if (!targetPascal) continue;
+      const fieldBase = targetPascal.charAt(0).toLowerCase() + targetPascal.slice(1);
+      const fieldName = isToMany ? fieldBase + 's' : fieldBase; // simple plural for *ToMany
+      lazyRelationshipFields.set(fieldName, { relType, target: targetPascal, jpaFieldName: fieldName });
+    }
+
+    return {
+      aggregateName,
+      rootEntityName,
+      rootFieldNames,
+      rootFieldTypes,
+      voFieldsMap,
+      lazyRelationshipFields,
+      idFieldName: idField ? idField.name : 'id',
+      idFieldType: idField ? (idField.type || 'String') : 'String',
+    };
+  }
+  return null;
+}
+
+/**
+ * Check if a field name represents an entity ID for the given aggregate.
+ * Matches: 'id', '{entityName}Id' (e.g. 'shoppingCartId' for ShoppingCart),
+ * or the abbreviated last-word form: '{lastWord}Id' (e.g. 'cartId' for ShoppingCart).
+ * @param {string} fieldName
+ * @param {object} aggregateInfo
+ * @returns {boolean}
+ */
+function isIdField(fieldName, aggregateInfo) {
+  const entityLower = aggregateInfo.rootEntityName.charAt(0).toLowerCase() + aggregateInfo.rootEntityName.slice(1);
+  // Split camelCase to get the last word: 'shoppingCart' → ['shopping','Cart'] → 'cart'
+  const nameParts = entityLower.split(/(?=[A-Z])/);
+  const lastWord = nameParts[nameParts.length - 1].toLowerCase();
+  return fieldName === 'id'
+    || fieldName === `${entityLower}Id`
+    || (nameParts.length > 1 && fieldName === `${lastWord}Id`);
+}
+
+/**
+ * Map a single YAML field definition {name, type} to {name, javaType}.
+ * @param {{name: string, type: string}} field
+ * @returns {{name: string, javaType: string}}
+ */
+function mapField(field) {
+  return { name: field.name, javaType: field.type || 'String' };
+}
+
+/**
+ * Build the template context for a single activity from its YAML definition.
+ * @param {object} activity  - Raw activity object from domain.yaml
+ * @param {string} packageName
+ * @param {string} moduleName
+ * @param {boolean} shared  - Whether this activity's contracts live in shared/
+ * @param {object|null} aggregateInfo - Aggregate info for query activity detection
+ * @returns {object} context for templates
+ */
+function buildActivityContext(activity, packageName, moduleName, shared = false, aggregateInfo = null, sharedNestedTypes = new Set(), existingSharedTypes = new Map()) {
+  const activityPascalCase = toPascalCase(activity.name);
+  const modulePascalCase = toPascalCase(moduleName);
+  const categoryType = (activity.type || 'light').toLowerCase() === 'heavy' ? 'HeavyActivity' : 'LightActivity';
+  const activityCategory = `${modulePascalCase}${categoryType}`;
+
+  const inputFields = Array.isArray(activity.input) ? activity.input.map(mapField) : [];
+  const outputFields = Array.isArray(activity.output) ? activity.output.map(mapField) : [];
+  const hasInput = inputFields.length > 0;
+  const hasOutput = outputFields.length > 0;
+
+  // ── Query activity detection ──────────────────────────────────────────────
+  // An activity is a "query activity" when:
+  //   1. Name starts with "Get"
+  //   2. Exactly 1 input field that is an entity ID
+  //   3. Has output fields
+  //   4. Module has an aggregate with root entity
+  let isQueryActivity = false;
+  let queryMeta = null;
+
+  if (aggregateInfo
+      && activityPascalCase.startsWith('Get')
+      && inputFields.length === 1
+      && hasOutput
+      && isIdField(inputFields[0].name, aggregateInfo)) {
+    isQueryActivity = true;
+    const idAccessor = `input.${inputFields[0].name}()`;
+    const entityLower = aggregateInfo.rootEntityName.charAt(0).toLowerCase() + aggregateInfo.rootEntityName.slice(1);
+    const entityIdAlias = `${entityLower}Id`; // e.g. 'customerId' for Customer
+    const SIMPLE_TYPES = new Set(['String', 'Integer', 'Long', 'Boolean', 'BigDecimal', 'LocalDate', 'LocalDateTime', 'LocalTime', 'Instant', 'UUID', 'Double', 'Float']);
+    // Build nestedTypesMap: PascalCase name → raw fields array (for VO→nestedType detection)
+    const nestedTypesMap = new Map();
+    if (Array.isArray(activity.nestedTypes)) {
+      for (const nt of activity.nestedTypes) {
+        nestedTypesMap.set(toPascalCase(nt.name), Array.isArray(nt.fields) ? nt.fields : []);
+      }
+    }
+    const outputMappings = outputFields.map((f) => {
+      // Match {entityName}Id → entity.getId()
+      if (f.name === entityIdAlias && aggregateInfo.rootFieldNames.has('id')) {
+        return { fieldName: f.name, accessor: 'entity.getId()' };
+      }
+      if (aggregateInfo.rootFieldNames.has(f.name)) {
+        const getter = 'entity.get' + f.name.charAt(0).toUpperCase() + f.name.slice(1) + '()';
+        const entityFieldType = aggregateInfo.rootFieldTypes ? aggregateInfo.rootFieldTypes.get(f.name) : null;
+        // Enum/VO → String: append .name() when output expects String but entity field is not a simple type
+        if (f.javaType === 'String' && entityFieldType && !SIMPLE_TYPES.has(entityFieldType)) {
+          return { fieldName: f.name, accessor: getter + '.name()' };
+        }
+        // VO → nestedType: when entity field is a VO and output expects a declared nestedType
+        const voFields = entityFieldType && aggregateInfo.voFieldsMap ? aggregateInfo.voFieldsMap.get(entityFieldType) : null;
+        const ntFields = nestedTypesMap.get(f.javaType);
+        if (voFields && ntFields) {
+          const ntArgs = ntFields.map((ntField) => {
+            const voField = voFields.find((vf) => vf.name === ntField.name);
+            return voField
+              ? `${getter}.get${ntField.name.charAt(0).toUpperCase() + ntField.name.slice(1)}()`
+              : `null /* TODO: derive ${ntField.name} */`;
+          });
+          return {
+            fieldName: f.name,
+            accessor: f.name,
+            preDeclaration: { varType: f.javaType, varName: f.name, getter, ntArgs },
+          };
+        }
+        return { fieldName: f.name, accessor: getter };
+      }
+      return { fieldName: f.name, accessor: `null /* TODO: derive ${f.name} from entity */` };
+    });
+    const voMappingImports = outputMappings
+      .filter((m) => m.preDeclaration)
+      .map((m) => (shared
+        ? `import ${packageName}.shared.domain.contracts.${moduleName}.${m.preDeclaration.varType};`
+        : `import ${packageName}.${moduleName}.application.dtos.temporal.${m.preDeclaration.varType};`));
+
+    // ── Eager load detection ──────────────────────────────────────────────
+    // If any output field is a List<...> whose name matches a LAZY relationship,
+    // we must use findByIdWith{Field} (JOIN FETCH) instead of findById.
+    let needsEagerLoad = false;
+    let eagerLoadField = null;
+    const lazyMap = aggregateInfo.lazyRelationshipFields;
+    if (lazyMap && lazyMap.size > 0) {
+      for (const f of outputFields) {
+        if (!f.javaType.startsWith('List<')) continue;
+        for (const [lazyFieldName, lazyInfo] of lazyMap.entries()) {
+          const lazyFieldPascal = lazyFieldName.charAt(0).toUpperCase() + lazyFieldName.slice(1);
+          const outputFieldPascal = f.name.charAt(0).toUpperCase() + f.name.slice(1);
+          // Direct name match OR the lazy field name ends with the output field name (PascalCase suffix)
+          if (f.name === lazyFieldName || lazyFieldPascal.endsWith(outputFieldPascal)) {
+            needsEagerLoad = true;
+            eagerLoadField = { jpaFieldName: lazyInfo.jpaFieldName, fieldPascal: lazyFieldPascal };
+            break;
+          }
+        }
+        if (needsEagerLoad) break;
+      }
+    }
+
+    queryMeta = {
+      aggregateName: aggregateInfo.aggregateName,
+      idFieldAccessor: idAccessor,
+      outputMappings,
+      voMappingImports,
+      needsEagerLoad,
+      eagerLoadField,
+    };
+  }
+
+  return {
+    packageName,
+    moduleName,
+    modulePascalCase,
+    activityPascalCase,
+    activityCategory,
+    categoryType,
+    hasInput,
+    hasOutput,
+    inputFields,
+    outputFields,
+    inputImports: resolveFieldImports(inputFields),
+    outputImports: resolveFieldImports(outputFields),
+    description: activity.description || '',
+    compensation: activity.compensation || null,
+    timeout: activity.timeout || null,
+    shared,
+    targetModule: moduleName,
+    isQueryActivity,
+    queryMeta,
+    ...buildNestedTypesContext(activity, packageName, moduleName, shared, inputFields, outputFields, sharedNestedTypes, existingSharedTypes),
+  };
+}
+
+/**
+ * Extract custom type names referenced in field javaTypes that are NOT
+ * standard Java types (not in JAVA_TYPE_IMPORTS and not primitives).
+ * E.g., `List<OrderItemDetail>` → `OrderItemDetail`.
+ * @param {Array<{javaType: string}>} fields
+ * @returns {Set<string>} custom type names found
+ */
+function extractCustomTypeNames(fields) {
+  const BUILTIN = new Set(['String', 'Integer', 'Long', 'Boolean', 'Double', 'Float', 'int', 'long', 'boolean', 'double', 'float', 'void',
+    ...Object.keys(JAVA_TYPE_IMPORTS)]);
+  const customNames = new Set();
+  const genericRe = /<([A-Z][A-Za-z0-9]*)>/;
+  for (const field of fields) {
+    if (!field.javaType) continue;
+    // Check inside generics: List<OrderItemDetail> → OrderItemDetail
+    const match = field.javaType.match(genericRe);
+    if (match && !BUILTIN.has(match[1])) {
+      customNames.add(match[1]);
+    }
+    // Check bare type: OrderItemDetail (not inside generic)
+    if (!match && !BUILTIN.has(field.javaType) && /^[A-Z]/.test(field.javaType)) {
+      customNames.add(field.javaType);
+    }
+  }
+  return customNames;
+}
+
+/**
+ * Build nestedTypes context from an activity's `nestedTypes` YAML section.
+ * Returns properties to merge into the activity context.
+ * @param {object} activity - Raw activity YAML
+ * @param {string} packageName
+ * @param {string} moduleName
+ * @param {boolean} shared
+ * @param {Array} inputFields - Already-mapped input fields
+ * @param {Array} outputFields - Already-mapped output fields
+ * @returns {object} { nestedTypes, nestedTypeImportLines }
+ */
+function buildNestedTypesContext(activity, packageName, moduleName, shared, inputFields, outputFields, sharedNestedTypes = new Set(), existingSharedTypes = new Map()) {
+  const rawNested = Array.isArray(activity.nestedTypes) ? activity.nestedTypes : [];
+  const rawExternal = Array.isArray(activity.externalTypes) ? activity.externalTypes : [];
+
+  if (rawNested.length === 0 && rawExternal.length === 0) {
+    return { nestedTypes: [], nestedTypeImportLines: [], externalTypeMap: {} };
+  }
+
+  const nestedTypes = rawNested.map((nt) => {
+    const name = toPascalCase(nt.name);
+    const fields = Array.isArray(nt.fields) ? nt.fields.map(mapField) : [];
+    return {
+      name,
+      fields,
+      imports: resolveFieldImports(fields),
+    };
+  });
+
+  // Build external type map: typeName → sourceModule (camelCase)
+  const externalTypeMap = {};
+  for (const ext of rawExternal) {
+    const typeName = toPascalCase(ext.name);
+    const sourceModule = toCamelCase(ext.module);
+    externalTypeMap[typeName] = sourceModule;
+  }
+
+  // Determine which custom types are actually referenced by input/output fields
+  const allFields = [...inputFields, ...outputFields];
+  const referencedNames = extractCustomTypeNames(allFields);
+  const nestedTypeNames = new Set(nestedTypes.map((nt) => nt.name));
+
+  // Build import lines for custom types referenced in input/output
+  const importLines = [];
+  for (const typeName of referencedNames) {
+    if (nestedTypeNames.has(typeName)) {
+      // Check if an identical type already lives in shared/domain/contracts/ — if so, prefer it.
+      const alreadySharedModule = existingSharedTypes.get(typeName);
+      if (sharedNestedTypes.has(typeName) || shared) {
+        // Prefer the module that actually owns the type in shared (first-writer-wins).
+        // This ensures Input/Output files in module B import from module A's contracts
+        // when both declared the same nestedType but A was processed first.
+        const ownerModule = existingSharedTypes.get(typeName) || moduleName;
+        importLines.push(`import ${packageName}.shared.domain.contracts.${ownerModule}.${typeName};`);
+      } else if (alreadySharedModule) {
+        // Type already generated into shared by another activity — point there, not locally.
+        importLines.push(`import ${packageName}.shared.domain.contracts.${alreadySharedModule}.${typeName};`);
+      } else {
+        importLines.push(`import ${packageName}.${moduleName}.application.dtos.temporal.${typeName};`);
+      }
+    } else if (externalTypeMap[typeName]) {
+      // External type — always from source module's shared contracts
+      const sourceModule = externalTypeMap[typeName];
+      importLines.push(`import ${packageName}.shared.domain.contracts.${sourceModule}.${typeName};`);
+    }
+  }
+
+  return {
+    nestedTypes,
+    nestedTypeImportLines: importLines.sort(),
+    externalTypeMap,
+  };
+}
+
+/**
+ * Parse system.yaml and return a Set of activity names that are referenced
+ * cross-module (i.e. appear as activity or compensation in workflow steps).
+ * @param {string} projectDir
+ * @returns {Set<string>} activity names (PascalCase) that are cross-module
+ */
+async function parseCrossModuleActivities(projectDir) {
+  const systemYamlPath = path.join(projectDir, 'system', 'system.yaml');
+  if (!(await fs.pathExists(systemYamlPath))) return new Set();
+
+  const content = await fs.readFile(systemYamlPath, 'utf-8');
+  const data = yaml.load(content);
+  if (!data || !Array.isArray(data.workflows)) return new Set();
+
+  const crossModuleSet = new Set();
+
+  for (const wf of data.workflows) {
+    if (!Array.isArray(wf.steps)) continue;
+    const hostModule = wf.trigger && wf.trigger.module
+      ? toCamelCase(wf.trigger.module)
+      : null;
+    for (const step of wf.steps) {
+      if (step.activity && step.target) {
+        const targetModule = toCamelCase(step.target);
+        // Only mark as cross-module if target differs from the workflow host
+        if (targetModule !== hostModule) {
+          crossModuleSet.add(toPascalCase(step.activity));
+        }
+      }
+      if (step.compensation) {
+        // Compensation targets same module as the step it compensates
+        const compTarget = step.target ? toCamelCase(step.target) : hostModule;
+        if (compTarget !== hostModule) {
+          crossModuleSet.add(toPascalCase(step.compensation));
+        }
+      }
+    }
+  }
+
+  return crossModuleSet;
+}
+
+/**
+ * Generate shared activity contracts (Interface + Input + Output) into
+ * shared/domain/contracts/{module}/. Called by YAML-driven generation
+ * and also exported for use by `eva g temporal-system`.
+ *
+ * @param {object} actCtx  - Activity context from buildActivityContext()
+ * @param {string} sharedBasePath - Path to shared/ Java directory
+ * @param {object} writeOptions
+ * @returns {string[]} list of generated file paths (relative)
+ */
+async function generateSharedContracts(actCtx, sharedBasePath, writeOptions, existingSharedTypes = new Map()) {
+  const templatesDir = path.join(__dirname, '..', '..', 'templates', 'temporal-activity');
+  const contractsDir = path.join(sharedBasePath, 'domain', 'contracts', actCtx.targetModule);
+  const generated = [];
+
+  // 1. Shared Input record
+  if (actCtx.hasInput) {
+    await renderAndWrite(
+      path.join(templatesDir, 'SharedActivityInput.java.ejs'),
+      path.join(contractsDir, `${actCtx.activityPascalCase}Input.java`),
+      { ...actCtx, imports: actCtx.inputImports },
+      writeOptions
+    );
+    generated.push(`shared/domain/contracts/${actCtx.targetModule}/${actCtx.activityPascalCase}Input.java`);
+  }
+
+  // 2. Shared Output record
+  if (actCtx.hasOutput) {
+    await renderAndWrite(
+      path.join(templatesDir, 'SharedActivityOutput.java.ejs'),
+      path.join(contractsDir, `${actCtx.activityPascalCase}Output.java`),
+      { ...actCtx, imports: actCtx.outputImports },
+      writeOptions
+    );
+    generated.push(`shared/domain/contracts/${actCtx.targetModule}/${actCtx.activityPascalCase}Output.java`);
+  }
+
+  // 3. Shared ActivityInterface
+  await renderAndWrite(
+    path.join(templatesDir, 'SharedActivityInterface.java.ejs'),
+    path.join(contractsDir, `${actCtx.activityPascalCase}Activity.java`),
+    actCtx,
+    writeOptions
+  );
+  generated.push(`shared/domain/contracts/${actCtx.targetModule}/${actCtx.activityPascalCase}Activity.java`);
+
+  // 4. Shared NestedType records
+  if (Array.isArray(actCtx.nestedTypes) && actCtx.nestedTypes.length > 0) {
+    for (const nt of actCtx.nestedTypes) {
+      // Skip if an identical type already lives in *another* module's shared contracts.
+      // This prevents incompatible-types errors when the same nestedType is declared
+      // in multiple module YAMLs (e.g. CartItemDetail in carts.yaml AND products.yaml).
+      const existingOwner = existingSharedTypes.get(nt.name);
+      if (existingOwner && existingOwner !== actCtx.targetModule) continue;
+      const ntPath = path.join(contractsDir, `${nt.name}.java`);
+      if (await fs.pathExists(ntPath)) continue; // Deduplicate within same module
+      await renderAndWrite(
+        path.join(templatesDir, 'SharedNestedType.java.ejs'),
+        ntPath,
+        { packageName: actCtx.packageName, targetModule: actCtx.targetModule, typeName: nt.name, fields: nt.fields, imports: nt.imports },
+        writeOptions
+      );
+      generated.push(`shared/domain/contracts/${actCtx.targetModule}/${nt.name}.java`);
+      // Update the map so subsequent activities in the same run see this type as already written.
+      existingSharedTypes.set(nt.name, actCtx.targetModule);
+    }
+  }
+
+  return generated;
+}
+
 async function generateTemporalActivityCommand(moduleName, activityName, options = {}) {
   const projectDir = process.cwd();
 
@@ -46,7 +533,7 @@ 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)
+  // Normalise module name to camelCase
   moduleName = toCamelCase(moduleName);
 
   if (!(await configManager.moduleExists(moduleName))) {
@@ -60,6 +547,349 @@ async function generateTemporalActivityCommand(moduleName, activityName, options
     process.exit(1);
   }
 
+  const moduleBasePath = path.join(projectDir, 'src', 'main', 'java', packagePath, moduleName);
+  const checksumManager = new ChecksumManager(moduleBasePath);
+  await checksumManager.load();
+  const writeOptions = { force: options.force, checksumManager };
+
+  // ── Try YAML-driven generation ──────────────────────────────────────────
+  const domainYamlPath = path.join(moduleBasePath, 'domain.yaml');
+  const yamlActivities = await parseActivitiesFromYaml(domainYamlPath);
+
+  if (yamlActivities) {
+    await generateFromYaml(yamlActivities, activityName, {
+      projectDir, packageName, packagePath, moduleName, moduleBasePath, checksumManager, writeOptions, options,
+    });
+  } else {
+    await generateInteractive(activityName, {
+      projectDir, packageName, packagePath, moduleName, moduleBasePath, checksumManager, writeOptions, options,
+    });
+  }
+
+  await checksumManager.save();
+}
+
+// ─── YAML-driven generation ─────────────────────────────────────────────────
+
+/**
+ * Walk shared/domain/contracts/ and return a Map from PascalCase type simple name
+ * → camelCase sourceModule for every *.java file found.
+ * Used to detect when a local nestedType duplicates a type that already lives in shared.
+ * @param {string} sharedBasePath  - absolute path to shared/ Java root
+ * @returns {Map<string, string>}  simpleName → sourceModule
+ */
+async function scanExistingSharedTypes(sharedBasePath) {
+  const result = new Map();
+  const contractsRoot = path.join(sharedBasePath, 'domain', 'contracts');
+  if (!(await fs.pathExists(contractsRoot))) return result;
+  let moduleDirs;
+  try { moduleDirs = await fs.readdir(contractsRoot); } catch { return result; }
+  for (const mod of moduleDirs) {
+    const modDir = path.join(contractsRoot, mod);
+    let stat;
+    try { stat = await fs.stat(modDir); } catch { continue; }
+    if (!stat.isDirectory()) continue;
+    let files;
+    try { files = await fs.readdir(modDir); } catch { continue; }
+    for (const file of files) {
+      if (!file.endsWith('.java')) continue;
+      const simpleName = file.replace('.java', '');
+      if (!result.has(simpleName)) result.set(simpleName, mod);
+    }
+  }
+  return result;
+}
+
+/**
+ * Scan all module domain.yaml files in the system/ directory for `externalTypes`
+ * references. Returns a Map from sourceModule (camelCase) → Set of type names
+ * (PascalCase) that are referenced externally and thus need shared contracts.
+ */
+async function collectExternalTypeRefs(projectDir) {
+  const systemDir = path.join(projectDir, 'system');
+  if (!(await fs.pathExists(systemDir))) return new Map();
+
+  const refs = new Map();
+  let files;
+  try {
+    files = await fs.readdir(systemDir);
+  } catch {
+    return refs;
+  }
+  for (const file of files) {
+    if (file === 'system.yaml' || !file.endsWith('.yaml')) continue;
+    try {
+      const content = await fs.readFile(path.join(systemDir, file), 'utf-8');
+      const data = yaml.load(content);
+      if (!data || !Array.isArray(data.activities)) continue;
+      for (const act of data.activities) {
+        if (!Array.isArray(act.externalTypes)) continue;
+        for (const et of act.externalTypes) {
+          const sourceModule = toCamelCase(et.module);
+          const typeName = toPascalCase(et.name);
+          if (!refs.has(sourceModule)) refs.set(sourceModule, new Set());
+          refs.get(sourceModule).add(typeName);
+        }
+      }
+    } catch {
+      // Skip malformed YAML files
+    }
+  }
+  return refs;
+}
+
+/**
+ * Inject a `findByIdWith{Field}` method (with JOIN FETCH) into the 3 repository
+ * files when a query activity needs eager loading of a LAZY relationship.
+ * Idempotent: skips injection if the method already exists in the file.
+ *
+ * @param {object} actCtx   - Activity context (must have queryMeta.eagerLoadField)
+ * @param {string} moduleBasePath
+ * @param {string} packageName
+ * @param {string} moduleName
+ */
+async function injectEagerLoadMethods(actCtx, moduleBasePath, packageName, moduleName) {
+  const { aggregateName, eagerLoadField } = actCtx.queryMeta;
+  const { jpaFieldName, fieldPascal } = eagerLoadField;
+  const methodName = `findByIdWith${fieldPascal}`;
+  const entityLower = aggregateName.charAt(0).toLowerCase() + aggregateName.slice(1);
+
+  // 1. domain/repositories/{Entity}Repository.java
+  const repoPath = path.join(moduleBasePath, 'domain', 'repositories', `${aggregateName}Repository.java`);
+  if (await fs.pathExists(repoPath)) {
+    let content = await fs.readFile(repoPath, 'utf-8');
+    if (!content.includes(methodName)) {
+      const lastBrace = content.lastIndexOf('}');
+      const injection = `\n    Optional<${aggregateName}> ${methodName}(String id);\n`;
+      content = content.slice(0, lastBrace) + injection + content.slice(lastBrace);
+      await fs.writeFile(repoPath, content, 'utf-8');
+    }
+  }
+
+  // 2. infrastructure/database/repositories/{Entity}JpaRepository.java
+  const jpaRepoPath = path.join(moduleBasePath, 'infrastructure', 'database', 'repositories', `${aggregateName}JpaRepository.java`);
+  if (await fs.pathExists(jpaRepoPath)) {
+    let content = await fs.readFile(jpaRepoPath, 'utf-8');
+    if (!content.includes(methodName)) {
+      // Inject @Query, @Param, and Optional imports if missing
+      const queryImport = 'import org.springframework.data.jpa.repository.Query;';
+      const paramImport = 'import org.springframework.data.repository.query.Param;';
+      const optionalImport = 'import java.util.Optional;';
+      if (!content.includes(queryImport)) {
+        content = content.replace(/^(import .+;)$/m, `$1\n${queryImport}`);
+      }
+      if (!content.includes(paramImport)) {
+        content = content.replace(/^(import .+;)$/m, `$1\n${paramImport}`);
+      }
+      if (!content.includes(optionalImport)) {
+        content = content.replace(/^(import .+;)$/m, `$1\n${optionalImport}`);
+      }
+      const lastBrace = content.lastIndexOf('}');
+      const queryStr = `SELECT ${entityLower} FROM ${aggregateName}Jpa ${entityLower} JOIN FETCH ${entityLower}.${jpaFieldName} WHERE ${entityLower}.id = :id`;
+      const injection = `\n    @Query("${queryStr}")\n    Optional<${aggregateName}Jpa> ${methodName}(@Param("id") String id);\n`;
+      content = content.slice(0, lastBrace) + injection + content.slice(lastBrace);
+      await fs.writeFile(jpaRepoPath, content, 'utf-8');
+    }
+  }
+
+  // 3. infrastructure/database/repositories/{Entity}RepositoryImpl.java
+  const implPath = path.join(moduleBasePath, 'infrastructure', 'database', 'repositories', `${aggregateName}RepositoryImpl.java`);
+  if (await fs.pathExists(implPath)) {
+    let content = await fs.readFile(implPath, 'utf-8');
+    if (!content.includes(methodName)) {
+      const lastBrace = content.lastIndexOf('}');
+      const injection = [
+        '',
+        '    @Override',
+        `    public Optional<${aggregateName}> ${methodName}(String id) {`,
+        `        return jpaRepository.${methodName}(id).map(mapper::toDomain);`,
+        '    }',
+        '',
+      ].join('\n');
+      content = content.slice(0, lastBrace) + injection + content.slice(lastBrace);
+      await fs.writeFile(implPath, content, 'utf-8');
+    }
+  }
+}
+
+async function generateFromYaml(yamlActivities, activityName, ctx) {
+  const { projectDir, packageName, packagePath, moduleName, moduleBasePath, writeOptions } = ctx;
+
+  // Detect which activities are cross-module from system.yaml
+  const crossModuleSet = await parseCrossModuleActivities(projectDir);
+
+  // Detect nestedTypes from this module that are referenced as externalTypes in other modules
+  const externalTypeRefs = await collectExternalTypeRefs(projectDir);
+  const sharedNestedTypes = externalTypeRefs.get(moduleName) || new Set();
+
+  // Load aggregate info for query activity detection
+  const domainYamlPath = path.join(moduleBasePath, 'domain.yaml');
+  const aggregateInfo = await parseAggregateInfo(domainYamlPath);
+
+  let activitiesToGenerate;
+
+  if (activityName) {
+    const match = yamlActivities.find(
+      (a) => toPascalCase(a.name) === toPascalCase(activityName)
+    );
+    if (!match) {
+      console.error(chalk.red(`❌ Activity '${activityName}' not found in domain.yaml`));
+      console.error(chalk.gray('Available activities: ' + yamlActivities.map((a) => a.name).join(', ')));
+      process.exit(1);
+    }
+    activitiesToGenerate = [match];
+  } else if (ctx.options && ctx.options.generateAll) {
+    // Non-interactive: generate all activities (used by eva build)
+    activitiesToGenerate = yamlActivities;
+  } else {
+    // Prompt: generate all or select
+    const { selection } = await inquirer.prompt([{
+      type: 'list',
+      name: 'selection',
+      message: `Found ${yamlActivities.length} activities in domain.yaml:`,
+      choices: [
+        { name: 'Generate ALL activities', value: 'all' },
+        ...yamlActivities.map((a) => ({ name: `  ${a.name} (${a.type || 'light'})`, value: a.name })),
+      ],
+    }]);
+    activitiesToGenerate = selection === 'all'
+      ? yamlActivities
+      : [yamlActivities.find((a) => a.name === selection)];
+  }
+
+  const spinner = ora(`Generating ${activitiesToGenerate.length} activity(ies)...`).start();
+
+  try {
+    const templatesDir = path.join(__dirname, '..', '..', 'templates', 'temporal-activity');
+    const sharedBasePath = path.join(projectDir, 'src', 'main', 'java', packagePath, 'shared');
+
+    // Scan shared/domain/contracts/ for types already generated by other activities/modules.
+    // Used to prevent local nestedType files that duplicate a shared type (causing import collisions).
+    const existingSharedTypes = await scanExistingSharedTypes(sharedBasePath);
+
+    const generated = [];
+    const sharedGenerated = [];
+
+    for (const activity of activitiesToGenerate) {
+      const isShared = crossModuleSet.has(toPascalCase(activity.name));
+      const actCtx = buildActivityContext(activity, packageName, moduleName, isShared, aggregateInfo, sharedNestedTypes, existingSharedTypes);
+      spinner.text = `Generating ${actCtx.activityPascalCase}Activity${isShared ? ' (shared)' : ''}...`;
+
+      if (isShared) {
+        // Interface + Input + Output → shared/domain/contracts/{module}/
+        // Pass existingSharedTypes so generateSharedContracts can skip cross-module duplicates
+        // and update the map in-place for subsequent activities in the same run.
+        const sharedFiles = await generateSharedContracts(actCtx, sharedBasePath, writeOptions, existingSharedTypes);
+        sharedGenerated.push(...sharedFiles);
+      } else {
+        // Interface + Input + Output → {module}/application/
+        if (actCtx.hasInput) {
+          await renderAndWrite(
+            path.join(templatesDir, 'ActivityInput.java.ejs'),
+            path.join(moduleBasePath, 'application', 'dtos', 'temporal', `${actCtx.activityPascalCase}Input.java`),
+            { ...actCtx, imports: actCtx.inputImports },
+            writeOptions
+          );
+        }
+        if (actCtx.hasOutput) {
+          await renderAndWrite(
+            path.join(templatesDir, 'ActivityOutput.java.ejs'),
+            path.join(moduleBasePath, 'application', 'dtos', 'temporal', `${actCtx.activityPascalCase}Output.java`),
+            { ...actCtx, imports: actCtx.outputImports },
+            writeOptions
+          );
+        }
+        await renderAndWrite(
+          path.join(templatesDir, 'ActivityInterface.java.ejs'),
+          path.join(moduleBasePath, 'application', 'ports', `${actCtx.activityPascalCase}Activity.java`),
+          actCtx,
+          writeOptions
+        );
+        // Local NestedType records (or shared if externally referenced / already in shared)
+        if (Array.isArray(actCtx.nestedTypes) && actCtx.nestedTypes.length > 0) {
+          for (const nt of actCtx.nestedTypes) {
+            if (sharedNestedTypes.has(nt.name)) {
+              // Generate as shared contract — referenced by other modules via externalTypes
+              const contractsDir = path.join(sharedBasePath, 'domain', 'contracts', moduleName);
+              const ntPath = path.join(contractsDir, `${nt.name}.java`);
+              if (await fs.pathExists(ntPath)) continue; // Deduplicate
+              await renderAndWrite(
+                path.join(templatesDir, 'SharedNestedType.java.ejs'),
+                ntPath,
+                { packageName: actCtx.packageName, targetModule: actCtx.moduleName, typeName: nt.name, fields: nt.fields, imports: nt.imports },
+                writeOptions
+              );
+              sharedGenerated.push(`shared/domain/contracts/${moduleName}/${nt.name}.java`);
+            } else if (existingSharedTypes.has(nt.name)) {
+              // A type with the same simple name already lives in shared/domain/contracts/.
+              // Skip writing a local duplicate — the import in Output/Input already points to shared.
+              continue;
+            } else {
+              // Generate locally
+              const ntPath = path.join(moduleBasePath, 'application', 'dtos', 'temporal', `${nt.name}.java`);
+              if (await fs.pathExists(ntPath)) continue; // Deduplicate
+              await renderAndWrite(
+                path.join(templatesDir, 'NestedType.java.ejs'),
+                ntPath,
+                { packageName: actCtx.packageName, moduleName: actCtx.moduleName, typeName: nt.name, fields: nt.fields, imports: nt.imports },
+                writeOptions
+              );
+            }
+          }
+        }
+      }
+
+      // ActivityImpl always goes in the module
+      await renderAndWrite(
+        path.join(templatesDir, 'ActivityImpl.java.ejs'),
+        path.join(moduleBasePath, 'infrastructure', 'adapters', 'activities', `${actCtx.activityPascalCase}ActivityImpl.java`),
+        actCtx,
+        writeOptions
+      );
+
+      // Inject eager-load repository methods when a LAZY relationship is projected
+      if (actCtx.isQueryActivity && actCtx.queryMeta && actCtx.queryMeta.needsEagerLoad) {
+        await injectEagerLoadMethods(actCtx, moduleBasePath, packageName, moduleName);
+      }
+
+      generated.push(actCtx);
+    }
+
+    spinner.succeed(chalk.green(`✅ ${generated.length} activity(ies) generated successfully`));
+
+    if (sharedGenerated.length > 0) {
+      console.log(chalk.blue('\n📁 Shared contracts (cross-module):'));
+      for (const f of sharedGenerated) {
+        console.log(chalk.gray(`  ${f}`));
+      }
+    }
+
+    console.log(chalk.blue('\n📁 Module files:'));
+    for (const actCtx of generated) {
+      const name = actCtx.activityPascalCase;
+      if (!actCtx.shared) {
+        if (actCtx.hasInput) {
+          console.log(chalk.gray(`  ${moduleName}/application/dtos/temporal/${name}Input.java`));
+        }
+        if (actCtx.hasOutput) {
+          console.log(chalk.gray(`  ${moduleName}/application/dtos/temporal/${name}Output.java`));
+        }
+        console.log(chalk.gray(`  ${moduleName}/application/ports/${name}Activity.java`));
+      }
+      console.log(chalk.gray(`  ${moduleName}/infrastructure/adapters/activities/${name}ActivityImpl.java`));
+    }
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to generate temporal activity'));
+    console.error(chalk.red(error.message));
+    process.exit(1);
+  }
+}
+
+// ─── Interactive generation (fallback when no domain.yaml activities) ────────
+
+async function generateInteractive(activityName, ctx) {
+  const { projectDir, packageName, packagePath, moduleName, moduleBasePath, checksumManager, writeOptions, options } = ctx;
+
   // 1. Prompt activity name
   if (!activityName) {
     const answer = await inquirer.prompt([{
@@ -84,35 +914,83 @@ async function generateTemporalActivityCommand(moduleName, activityName, options
     ],
   }]);
 
-  // 3. Discover existing workflows across all modules
+  // 3. Prompt for input fields
+  const inputFields = await promptFields('Input');
+  const hasInput = inputFields.length > 0;
+
+  // 4. Prompt for output fields
+  const outputFields = await promptFields('Output');
+  const hasOutput = outputFields.length > 0;
+
+  // 5. Discover existing workflows across all modules
   const javaRoot = path.join(projectDir, 'src', 'main', 'java', packagePath);
   const workflows = await findExistingWorkflows(javaRoot);
 
-  if (workflows.length === 0) {
-    console.error(chalk.red('❌ No workflows found in this project'));
-    console.error(chalk.gray('Create a workflow first using: eva generate temporal-flow <module>'));
-    process.exit(1);
-  }
+  let selectedWorkflow = null;
+  if (workflows.length > 0) {
+    const { doRegister } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'doRegister',
+      message: 'Register activity in an existing workflow?',
+      default: true,
+    }]);
 
-  const { selectedWorkflow } = await inquirer.prompt([{
-    type: 'list',
-    name: 'selectedWorkflow',
-    message: 'Register activity in workflow:',
-    choices: workflows.map((w) => ({ name: `${w.moduleName} / ${w.implClass}`, value: w })),
-  }]);
+    if (doRegister) {
+      const answer = await inquirer.prompt([{
+        type: 'list',
+        name: 'selectedWorkflow',
+        message: 'Register activity in workflow:',
+        choices: workflows.map((w) => ({ name: `${w.moduleName} / ${w.implClass}`, value: w })),
+      }]);
+      selectedWorkflow = answer.selectedWorkflow;
+    }
+  }
 
-  const moduleBasePath = path.join(projectDir, 'src', 'main', 'java', packagePath, moduleName);
-  const checksumManager = new ChecksumManager(moduleBasePath);
-  await checksumManager.load();
+  const modulePascalCase = toPascalCase(moduleName);
+  const moduleActivityCategory = `${modulePascalCase}${activityCategory}`;
+  const context = {
+    packageName,
+    moduleName,
+    modulePascalCase,
+    activityPascalCase,
+    activityCategory: moduleActivityCategory,
+    categoryType: activityCategory,
+    hasInput,
+    hasOutput,
+    inputFields,
+    outputFields,
+    inputImports: resolveFieldImports(inputFields),
+    outputImports: resolveFieldImports(outputFields),
+  };
 
   const spinner = ora(`Generating ${activityPascalCase}Activity...`).start();
 
   try {
-    const context = { packageName, moduleName, activityPascalCase, activityCategory };
     const templatesDir = path.join(__dirname, '..', '..', 'templates', 'temporal-activity');
-    const writeOptions = { force: options.force, checksumManager };
 
-    // 4. Generate ActivityInterface in application/ports/
+    // Generate Input record
+    if (hasInput) {
+      spinner.text = `Generating ${activityPascalCase}Input...`;
+      await renderAndWrite(
+        path.join(templatesDir, 'ActivityInput.java.ejs'),
+        path.join(moduleBasePath, 'application', 'dtos', 'temporal', `${activityPascalCase}Input.java`),
+        { ...context, imports: context.inputImports },
+        writeOptions
+      );
+    }
+
+    // Generate Output record
+    if (hasOutput) {
+      spinner.text = `Generating ${activityPascalCase}Output...`;
+      await renderAndWrite(
+        path.join(templatesDir, 'ActivityOutput.java.ejs'),
+        path.join(moduleBasePath, 'application', 'dtos', 'temporal', `${activityPascalCase}Output.java`),
+        { ...context, imports: context.outputImports },
+        writeOptions
+      );
+    }
+
+    // Generate ActivityInterface
     spinner.text = `Generating ${activityPascalCase}Activity interface...`;
     await renderAndWrite(
       path.join(templatesDir, 'ActivityInterface.java.ejs'),
@@ -121,7 +999,7 @@ async function generateTemporalActivityCommand(moduleName, activityName, options
       writeOptions
     );
 
-    // 5. Generate ActivityImpl in infrastructure/adapters/activities/
+    // Generate ActivityImpl
     spinner.text = `Generating ${activityPascalCase}ActivityImpl...`;
     await renderAndWrite(
       path.join(templatesDir, 'ActivityImpl.java.ejs'),
@@ -130,25 +1008,29 @@ async function generateTemporalActivityCommand(moduleName, activityName, options
       writeOptions
     );
 
-    // 6. Register activity stub in selected WorkFlowImpl
-    spinner.text = `Registering activity in ${selectedWorkflow.implClass}...`;
-    await registerActivityInWorkflow(
-      selectedWorkflow.filePath,
-      packageName,
-      moduleName,
-      activityPascalCase,
-      activityCategory
-    );
+    // Register activity stub in selected WorkFlowImpl
+    if (selectedWorkflow) {
+      spinner.text = `Registering activity in ${selectedWorkflow.implClass}...`;
+      await registerActivityInWorkflow(
+        selectedWorkflow.filePath,
+        packageName,
+        moduleName,
+        activityPascalCase,
+        activityCategory
+      );
+    }
 
     spinner.succeed(chalk.green(`✅ ${activityPascalCase}Activity generated successfully`));
 
     console.log(chalk.blue('\n📁 Generated files:'));
+    if (hasInput) console.log(chalk.gray(`  ${moduleName}/application/dtos/temporal/${activityPascalCase}Input.java`));
+    if (hasOutput) console.log(chalk.gray(`  ${moduleName}/application/dtos/temporal/${activityPascalCase}Output.java`));
     console.log(chalk.gray(`  ${moduleName}/application/ports/${activityPascalCase}Activity.java`));
     console.log(chalk.gray(`  ${moduleName}/infrastructure/adapters/activities/${activityPascalCase}ActivityImpl.java`));
-    console.log(chalk.blue('\n📝 Updated files:'));
-    console.log(chalk.gray(`  ${selectedWorkflow.moduleName}/application/usecases/${selectedWorkflow.implClass}.java`));
-
-    await checksumManager.save();
+    if (selectedWorkflow) {
+      console.log(chalk.blue('\n📝 Updated files:'));
+      console.log(chalk.gray(`  ${selectedWorkflow.moduleName}/application/usecases/${selectedWorkflow.implClass}.java`));
+    }
   } catch (error) {
     spinner.fail(chalk.red('Failed to generate temporal activity'));
     console.error(chalk.red(error.message));
@@ -156,6 +1038,50 @@ async function generateTemporalActivityCommand(moduleName, activityName, options
   }
 }
 
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+const COMMON_JAVA_TYPES = ['String', 'Integer', 'Long', 'Boolean', 'BigDecimal', 'LocalDateTime', 'LocalDate', 'UUID', 'List'];
+
+async function promptFields(label) {
+  const fields = [];
+  const { addFields } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'addFields',
+    message: `Define ${label} fields?`,
+    default: true,
+  }]);
+
+  if (!addFields) return fields;
+
+  let adding = true;
+  while (adding) {
+    const { fieldName, fieldType, more } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'fieldName',
+        message: `  ${label} field name:`,
+        validate: (v) => (v.trim() ? true : 'Field name is required'),
+      },
+      {
+        type: 'list',
+        name: 'fieldType',
+        message: `  ${label} field type:`,
+        choices: COMMON_JAVA_TYPES,
+      },
+      {
+        type: 'confirm',
+        name: 'more',
+        message: `  Add another ${label} field?`,
+        default: false,
+      },
+    ]);
+    fields.push({ name: fieldName.trim(), javaType: fieldType });
+    adding = more;
+  }
+
+  return fields;
+}
+
 async function findExistingWorkflows(javaRoot) {
   const results = [];
   if (!(await fs.pathExists(javaRoot))) return results;
@@ -229,3 +1155,11 @@ async function registerActivityInWorkflow(workflowImplPath, packageName, moduleN
 }
 
 module.exports = generateTemporalActivityCommand;
+module.exports.generateSharedContracts = generateSharedContracts;
+module.exports.buildActivityContext = buildActivityContext;
+module.exports.scanExistingSharedTypes = scanExistingSharedTypes;
+module.exports.parseActivitiesFromYaml = parseActivitiesFromYaml;
+module.exports.parseCrossModuleActivities = parseCrossModuleActivities;
+module.exports.collectExternalTypeRefs = collectExternalTypeRefs;
+module.exports.resolveFieldImports = resolveFieldImports;
+module.exports.mapField = mapField;