eva4j 1.0.13 → 1.0.15

package/src/commands/generate-entities.js

@@ -5,15 +5,86 @@ const fs = require('fs-extra');
 const inquirer = require('inquirer');
 const ConfigManager = require('../utils/config-manager');
 const { isEva4jProject } = require('../utils/validator');
-const { toPackagePath, toCamelCase, toKebabCase, getApplicationClassName } = require('../utils/naming');
-const { renderAndWrite } = require('../utils/template-engine');
+const { toPackagePath, toCamelCase, toKebabCase, toPascalCase, getApplicationClassName, pluralizeWord } = require('../utils/naming');
+const { renderAndWrite, renderTemplate } = require('../utils/template-engine');
 const { parseDomainYaml, generateEntityImports, generateValidationImports } = require('../utils/yaml-to-entity');
+const { createOrUpdateUrlsConfig, ensureUrlsImport } = require('./generate-http-exchange');
 const SharedGenerator = require('../generators/shared-generator');
 const ChecksumManager = require('../utils/checksum-manager');
+const { generateFakeValue, initSeed } = require('../utils/fake-data');
+const { getInstalledBroker, generateSingleKafkaEvent, buildKafkaEventContext, updateKafkaYml,
+        generateEventRecord, createOrUpdateMessageBroker, updateDomainEventHandler } = require('./generate-kafka-event');
 
 // Maximum depth for recursive relationship traversal
 const MAX_DEPTH = 5;
 
+/**
+ * Create or update {Module}KafkaMessageBroker with a mock implementation that
+ * uses ApplicationEventPublisher + MockEvent instead of Kafka.
+ * Mirrors the logic of createOrUpdateKafkaMessageBroker but uses mock templates.
+ */
+async function createOrUpdateMockMessageBroker(projectDir, packagePath, context) {
+  const adapterPath = path.join(
+    projectDir, 'src', 'main', 'java', packagePath,
+    context.moduleName, 'infrastructure', 'adapters', 'kafkaMessageBroker',
+    `${context.kafkaMessageBrokerClassName}.java`
+  );
+
+  const methodName = `publish${context.eventClassName}`;
+  const mockTemplatesDir = path.join(__dirname, '..', '..', 'templates', 'mock');
+
+  if (await fs.pathExists(adapterPath)) {
+    let content = await fs.readFile(adapterPath, 'utf-8');
+
+    // If this file is still a Kafka implementation, replace it wholesale
+    const isKafkaImpl = content.includes('KafkaTemplate') || content.includes('kafkaTemplate');
+    if (isKafkaImpl) {
+      // Re-create from mock template (overwrite)
+      await renderAndWrite(
+        path.join(mockTemplatesDir, 'MockMessageBrokerImpl.java.ejs'),
+        adapterPath,
+        { ...context, topicName: context.topicNameSnake },
+        { force: true }
+      );
+      return;
+    }
+
+    // Already a mock impl — check if method already exists
+    if (content.includes(methodName)) {
+      return;
+    }
+
+    // Inject event import if missing
+    const eventImport = `import ${context.packageName}.${context.moduleName}.application.events.${context.eventClassName};`;
+    if (!content.includes(eventImport)) {
+      const pkgMatch = content.match(/(package\s+[\w.]+;\s*\n)/);
+      if (pkgMatch) {
+        const imports = [...content.matchAll(/import\s+[\w.]+;\s*\n/g)];
+        const insertPos = imports.length
+          ? imports[imports.length - 1].index + imports[imports.length - 1][0].length
+          : pkgMatch.index + pkgMatch[0].length;
+        content = content.slice(0, insertPos) + eventImport + '\n' + content.slice(insertPos);
+      }
+    }
+
+    // Append mock method before the last closing brace
+    const methodSnippet = await renderTemplate(
+      path.join(mockTemplatesDir, 'MockMessageBrokerImplMethod.java.ejs'),
+      { ...context, topicName: context.topicNameSnake }
+    );
+    const lastBrace = content.lastIndexOf('}');
+    content = content.slice(0, lastBrace) + '\n' + methodSnippet + '\n}\n';
+    await fs.writeFile(adapterPath, content, 'utf-8');
+  } else {
+    // Create new mock broker from template
+    await renderAndWrite(
+      path.join(mockTemplatesDir, 'MockMessageBrokerImpl.java.ejs'),
+      adapterPath,
+      { ...context, topicName: context.topicNameSnake }
+    );
+  }
+}
+
 /**
  * Build a relationship graph for secondary entities
  * @param {Array} secondaryEntities - Array of secondary entities
@@ -173,7 +244,7 @@ async function generateEntitiesCommand(moduleName, options = {}) {
 
   try {
     // Parse domain.yaml
-    const { aggregates, allEnums } = await parseDomainYaml(domainYamlPath, packageName, moduleName);
+    const { aggregates, allEnums, endpoints, listeners, ports } = await parseDomainYaml(domainYamlPath, packageName, moduleName);
     
     spinner.succeed(chalk.green(`Found ${aggregates.length} aggregate(s) and ${allEnums.length} enum(s)`));
     
@@ -201,6 +272,15 @@ async function generateEntitiesCommand(moduleName, options = {}) {
       await sharedGenerator.generateDomainEvent(sharedBasePath);
     }
 
+    // Detect installed message broker for auto-wiring integration events
+    const installedBroker = (hasDomainEventsInModule || (listeners && listeners.length > 0))
+      ? await getInstalledBroker(configManager)
+      : null;
+    // When brokerMode:'mock' is requested AND a broker is installed, use mock Spring-Events adapter
+    const broker = (options.brokerMode === 'mock' && installedBroker)
+      ? 'mock'
+      : installedBroker;
+
     // Generate audit-related shared components if needed
     if (hasAuditableEntities || hasTrackUserEntities) {
       
@@ -299,7 +379,9 @@ async function generateEntitiesCommand(moduleName, options = {}) {
         valueObjects,
         aggregateMethods: aggregate.aggregateMethods,
         auditable: rootEntity.auditable,
-        domainEvents: aggregate.domainEvents || []
+        hasSoftDelete: rootEntity.hasSoftDelete || false,
+        domainEvents: aggregate.domainEvents || [],
+        triggeredEventsMap: aggregate.triggeredEventsMap || {}
       };
 
       await renderAndWrite(
@@ -322,7 +404,8 @@ async function generateEntitiesCommand(moduleName, options = {}) {
         valueObjects,
         enums: allEnums,
         auditable: rootEntity.auditable,
-        audit: rootEntity.audit
+        audit: rootEntity.audit,
+        hasSoftDelete: rootEntity.hasSoftDelete || false
       };
 
       await renderAndWrite(
@@ -439,7 +522,9 @@ async function generateEntitiesCommand(moduleName, options = {}) {
       const repoContext = {
         packageName,
         moduleName,
-        rootEntity
+        rootEntity,
+        hasSoftDelete: rootEntity.hasSoftDelete || false,
+        findByOps: []
       };
 
       await renderAndWrite(
@@ -465,7 +550,9 @@ async function generateEntitiesCommand(moduleName, options = {}) {
         moduleName,
         aggregateName,
         rootEntity,
-        hasDomainEvents: (aggregate.domainEvents || []).length > 0
+        hasDomainEvents: (aggregate.domainEvents || []).length > 0,
+        hasSoftDelete: rootEntity.hasSoftDelete || false,
+        findByOps: []
       };
 
       await renderAndWrite(
@@ -503,8 +590,11 @@ async function generateEntitiesCommand(moduleName, options = {}) {
           packageName,
           moduleName,
           aggregateName,
-          domainEvents: aggregateDomainEvents,
-          hasKafkaEvents: aggregateDomainEvents.some(e => e.kafka)
+          domainEvents: aggregateDomainEvents.map(e => ({
+            ...e,
+            integrationEventClassName: `${e.name}IntegrationEvent`
+          })),
+          broker
         };
         await renderAndWrite(
           path.join(__dirname, '..', '..', 'templates', 'aggregate', 'DomainEventHandler.java.ejs'),
@@ -513,11 +603,475 @@ async function generateEntitiesCommand(moduleName, options = {}) {
           writeOptions
         );
         generatedFiles.push({ type: 'Domain Event Handler', name: `${aggregateName}DomainEventHandler`, path: `${moduleName}/application/usecases/${aggregateName}DomainEventHandler.java` });
+
+        // ── Auto-wire broker integration events ────────────────────────────────
+        // When a message broker is installed, generate the complete integration
+        // event layer (XIntegrationEvent record, MessageBroker port method,
+        // KafkaMessageBroker impl method, topic config, KafkaConfig bean) for
+        // every domain event declared in this aggregate.
+        if (broker === 'kafka') {
+          const STANDARD_EVENT_TYPES = new Set([
+            'String','Integer','Long','Double','Float','Boolean',
+            'BigDecimal','LocalDate','LocalDateTime','LocalTime','Instant','UUID'
+          ]);
+          for (const event of aggregateDomainEvents) {
+            const kafkaCtx = buildKafkaEventContext(packageName, moduleName, event);
+            await generateSingleKafkaEvent(projectDir, packagePath, kafkaCtx);
+            generatedFiles.push({
+              type: 'Integration Event',
+              name: kafkaCtx.eventClassName,
+              path: `${moduleName}/application/events/${kafkaCtx.eventClassName}.java`
+            });
+
+            // Generate stub records for custom collection element types
+            // e.g. List<OrderItemSnapshot> → generate OrderItemSnapshot.java
+            const customElementTypes = [...new Set(
+              (event.fields || [])
+                .filter(f => f.isCollection && f.collectionElementType && !STANDARD_EVENT_TYPES.has(f.collectionElementType))
+                .map(f => f.collectionElementType)
+            )];
+            for (const typeName of customElementTypes) {
+              const stubPath = path.join(moduleBasePath, 'domain', 'models', 'events', `${typeName}.java`);
+              await renderAndWrite(
+                path.join(__dirname, '..', '..', 'templates', 'aggregate', 'DomainEventSnapshot.java.ejs'),
+                stubPath,
+                { packageName, moduleName, name: typeName, fields: [] },
+                { ...writeOptions, overwrite: false }
+              );
+              generatedFiles.push({
+                type: 'Event Snapshot Type',
+                name: typeName,
+                path: `${moduleName}/domain/models/events/${typeName}.java`
+              });
+            }
+          }
+          generatedFiles.push({
+            type: 'Integration Event',
+            name: `${toPascalCase(moduleName)}KafkaMessageBroker (updated)`,
+            path: `${moduleName}/infrastructure/adapters/kafkaMessageBroker/${toPascalCase(moduleName)}KafkaMessageBroker.java`
+          });
+          generatedFiles.push({
+            type: 'Integration Event',
+            name: 'MessageBroker (updated)',
+            path: `${moduleName}/application/ports/MessageBroker.java`
+          });
+        } else if (broker === 'mock') {
+          // ── Mock broker: Spring ApplicationEventPublisher instead of Kafka ──
+          // Generate MockEvent record in shared once (idempotent)
+          await sharedGenerator.generateMockEvent(sharedBasePath);
+
+          for (const event of aggregateDomainEvents) {
+            const kafkaCtx = buildKafkaEventContext(packageName, moduleName, event);
+            // 1. Integration Event record (same as Kafka — only the adapter differs)
+            await generateEventRecord(projectDir, packagePath, kafkaCtx);
+            generatedFiles.push({
+              type: 'Integration Event',
+              name: kafkaCtx.eventClassName,
+              path: `${moduleName}/application/events/${kafkaCtx.eventClassName}.java`
+            });
+            // 2. MessageBroker port interface (same as Kafka)
+            await createOrUpdateMessageBroker(projectDir, packagePath, kafkaCtx);
+            // 3. Mock KafkaMessageBroker impl (uses ApplicationEventPublisher)
+            await createOrUpdateMockMessageBroker(projectDir, packagePath, kafkaCtx);
+            // 4. DomainEventHandler (same as Kafka — calls messageBroker.publishX)
+            await updateDomainEventHandler(projectDir, packagePath, kafkaCtx);
+            // 5. NO kafka.yaml update and NO KafkaConfig update in mock mode
+          }
+          generatedFiles.push({
+            type: 'Integration Event',
+            name: `${toPascalCase(moduleName)}KafkaMessageBroker (mock)`,
+            path: `${moduleName}/infrastructure/adapters/kafkaMessageBroker/${toPascalCase(moduleName)}KafkaMessageBroker.java`
+          });
+          generatedFiles.push({
+            type: 'Integration Event',
+            name: 'MessageBroker (updated)',
+            path: `${moduleName}/application/ports/MessageBroker.java`
+          });
+        }
       }
     }
 
     spinner.succeed(chalk.green(`Generated ${generatedFiles.length} files! ✨`));
 
+    // ── Generate listeners (integration events CONSUMED from external producers) ──
+    if (listeners && listeners.length > 0) {
+      if (broker === 'kafka') {
+        spinner.start(`Generating ${listeners.length} Kafka listener(s)...`);
+        for (const listener of listeners) {
+          // Validate topic presence (mandatory for standalone modules)
+          if (!listener.topic) {
+            spinner.warn(chalk.yellow(`⚠ listener '${listener.event}': topic is required when there is no system.yaml. Skipping.`));
+            continue;
+          }
+
+          // Strip any prefix before the last dot (e.g. "test-eva.ORDER_PLACED" → "ORDER_PLACED")
+          const topicRaw = listener.topic;
+          const topicSuffix = topicRaw.includes('.') ? topicRaw.slice(topicRaw.lastIndexOf('.') + 1) : topicRaw;
+          const topicKey = topicSuffix.toLowerCase().replace(/_/g, '-');
+          const listenerContext = {
+            packageName,
+            moduleName,
+            ...listener,
+            topicConstant: topicRaw,
+            topicSpringProperty: `\${topics.${topicKey}}`,
+            topicVariableName: toCamelCase(topicSuffix.toLowerCase())
+          };
+
+          // 0. Nested type records (auxiliary value objects for object-typed fields)
+          for (const nt of (listener.nestedTypes || [])) {
+            const ntPath = path.join(
+              moduleBasePath, 'application', 'events',
+              `${nt.name}.java`
+            );
+            await renderAndWrite(
+              path.join(__dirname, '..', '..', 'templates', 'kafka-listener', 'ListenerNestedType.java.ejs'),
+              ntPath,
+              { packageName, moduleName, name: nt.name, fields: nt.fields },
+              writeOptions
+            );
+            generatedFiles.push({
+              type: 'Listener Nested Type',
+              name: nt.name,
+              path: `${moduleName}/application/events/${nt.name}.java`
+            });
+          }
+
+          // 1. Integration Event record
+          const integrationEventPath = path.join(
+            moduleBasePath, 'application', 'events',
+            `${listener.integrationEventClassName}.java`
+          );
+          await renderAndWrite(
+            path.join(__dirname, '..', '..', 'templates', 'kafka-listener', 'ListenerIntegrationEvent.java.ejs'),
+            integrationEventPath,
+            listenerContext,
+            writeOptions
+          );
+          generatedFiles.push({
+            type: 'Listener Integration Event',
+            name: listener.integrationEventClassName,
+            path: `${moduleName}/application/events/${listener.integrationEventClassName}.java`
+          });
+
+          // 2. Kafka listener class
+          // If the file is currently a mock Spring listener, force overwrite with the real Kafka impl
+          const kafkaListenerPath = path.join(
+            moduleBasePath, 'infrastructure', 'kafkaListener',
+            `${listener.listenerClassName}.java`
+          );
+          let kafkaListenerWriteOpts = writeOptions;
+          if (await fs.pathExists(kafkaListenerPath)) {
+            const existing = await fs.readFile(kafkaListenerPath, 'utf-8');
+            if (existing.includes('@EventListener') && !existing.includes('@KafkaListener')) {
+              kafkaListenerWriteOpts = { ...writeOptions, force: true };
+            }
+          }
+          await renderAndWrite(
+            path.join(__dirname, '..', '..', 'templates', 'kafka-listener', 'ListenerClass.java.ejs'),
+            kafkaListenerPath,
+            listenerContext,
+            kafkaListenerWriteOpts
+          );
+          generatedFiles.push({
+            type: 'Kafka Listener',
+            name: listener.listenerClassName,
+            path: `${moduleName}/infrastructure/kafkaListener/${listener.listenerClassName}.java`
+          });
+
+          // 3. Register topic in kafka.yaml (all environments)
+          await updateKafkaYml(projectDir, topicKey, listener.topic);
+
+          // 4. Typed Command dispatched from the listener
+          const commandPath = path.join(
+            moduleBasePath, 'application', 'commands',
+            `${listener.commandClassName}.java`
+          );
+          await renderAndWrite(
+            path.join(__dirname, '..', '..', 'templates', 'kafka-listener', 'ListenerCommand.java.ejs'),
+            commandPath,
+            listenerContext,
+            writeOptions
+          );
+          generatedFiles.push({
+            type: 'Listener Command',
+            name: listener.commandClassName,
+            path: `${moduleName}/application/commands/${listener.commandClassName}.java`
+          });
+
+          // 5. Use case handler that processes the command
+          const handlerPath = path.join(
+            moduleBasePath, 'application', 'usecases',
+            `${listener.useCase}CommandHandler.java`
+          );
+          await renderAndWrite(
+            path.join(__dirname, '..', '..', 'templates', 'kafka-listener', 'ListenerCommandHandler.java.ejs'),
+            handlerPath,
+            listenerContext,
+            writeOptions
+          );
+          generatedFiles.push({
+            type: 'Handler',
+            name: `${listener.useCase}CommandHandler`,
+            path: `${moduleName}/application/usecases/${listener.useCase}CommandHandler.java`
+          });
+        }
+        spinner.succeed(chalk.green(`Kafka listeners generated! ✨`));
+      } else if (broker === 'mock') {
+        // ── Mock listeners: @EventListener instead of @KafkaListener ──────────
+        spinner.start(`Generating ${listeners.length} Spring Event listener(s) (mock mode)...`);
+
+        // Ensure MockEvent is available in shared
+        await sharedGenerator.generateMockEvent(sharedBasePath);
+
+        for (const listener of listeners) {
+          if (!listener.topic) {
+            spinner.warn(chalk.yellow(`⚠ listener '${listener.event}': topic is required. Skipping.`));
+            continue;
+          }
+
+          const topicRaw = listener.topic;
+          const topicSuffix = topicRaw.includes('.') ? topicRaw.slice(topicRaw.lastIndexOf('.') + 1) : topicRaw;
+          const topicKey = topicSuffix.toLowerCase().replace(/_/g, '-');
+          const listenerContext = {
+            packageName,
+            moduleName,
+            ...listener,
+            topicConstant: topicRaw,
+            topicSpringProperty: `\${topics.${topicKey}}`,
+            topicVariableName: toCamelCase(topicSuffix.toLowerCase())
+          };
+
+          // 0. Nested type records
+          for (const nt of (listener.nestedTypes || [])) {
+            const ntPath = path.join(moduleBasePath, 'application', 'events', `${nt.name}.java`);
+            await renderAndWrite(
+              path.join(__dirname, '..', '..', 'templates', 'kafka-listener', 'ListenerNestedType.java.ejs'),
+              ntPath,
+              { packageName, moduleName, name: nt.name, fields: nt.fields },
+              writeOptions
+            );
+            generatedFiles.push({ type: 'Listener Nested Type', name: nt.name, path: `${moduleName}/application/events/${nt.name}.java` });
+          }
+
+          // 1. Integration Event record (same as Kafka)
+          const integrationEventPath = path.join(moduleBasePath, 'application', 'events', `${listener.integrationEventClassName}.java`);
+          await renderAndWrite(
+            path.join(__dirname, '..', '..', 'templates', 'kafka-listener', 'ListenerIntegrationEvent.java.ejs'),
+            integrationEventPath,
+            listenerContext,
+            writeOptions
+          );
+          generatedFiles.push({ type: 'Listener Integration Event', name: listener.integrationEventClassName, path: `${moduleName}/application/events/${listener.integrationEventClassName}.java` });
+
+          // 2. Spring @EventListener class (mock — same file path as Kafka listener)
+          const listenerPath = path.join(moduleBasePath, 'infrastructure', 'kafkaListener', `${listener.listenerClassName}.java`);
+          await renderAndWrite(
+            path.join(__dirname, '..', '..', 'templates', 'mock', 'SpringEventListener.java.ejs'),
+            listenerPath,
+            listenerContext,
+            { ...writeOptions, force: true }
+          );
+          generatedFiles.push({ type: 'Spring Listener (mock)', name: listener.listenerClassName, path: `${moduleName}/infrastructure/kafkaListener/${listener.listenerClassName}.java` });
+
+          // 3. NO kafka.yaml update in mock mode
+
+          // 4. Typed Command dispatched from the listener
+          const mockCommandPath = path.join(moduleBasePath, 'application', 'commands', `${listener.commandClassName}.java`);
+          await renderAndWrite(
+            path.join(__dirname, '..', '..', 'templates', 'kafka-listener', 'ListenerCommand.java.ejs'),
+            mockCommandPath,
+            listenerContext,
+            writeOptions
+          );
+          generatedFiles.push({ type: 'Listener Command', name: listener.commandClassName, path: `${moduleName}/application/commands/${listener.commandClassName}.java` });
+
+          // 5. Use case handler stub
+          const mockHandlerPath = path.join(moduleBasePath, 'application', 'usecases', `${listener.useCase}CommandHandler.java`);
+          await renderAndWrite(
+            path.join(__dirname, '..', '..', 'templates', 'kafka-listener', 'ListenerCommandHandler.java.ejs'),
+            mockHandlerPath,
+            listenerContext,
+            writeOptions
+          );
+          generatedFiles.push({ type: 'Handler', name: `${listener.useCase}CommandHandler`, path: `${moduleName}/application/usecases/${listener.useCase}CommandHandler.java` });
+        }
+        spinner.succeed(chalk.green(`Spring Event listeners generated (mock mode)! ✨`));
+      } else if (listeners.length > 0) {
+        console.log(chalk.yellow(`⚠ listeners: section found but no broker is installed. Run 'eva add kafka-client' to generate listener classes.`));
+      }
+    }
+
+    // ── Generate ports (HTTP clients for synchronous communication) ──────────
+    if (ports && ports.length > 0) {
+      spinner.start(`Generating ${ports.length} HTTP port(s)...`);
+
+      for (const portGroup of ports) {
+        const {
+          serviceName,
+          serviceNameCamelCase,
+          target,
+          baseUrl,
+          baseUrlProperty,
+          feignClientName,
+          feignClientClassName,
+          feignAdapterClassName,
+          feignConfigClassName,
+          adapterPackage,
+          methods,
+          nestedTypes,
+          domainModels
+        } = portGroup;
+
+        const adapterDir = path.join(moduleBasePath, 'infrastructure', 'adapters', adapterPackage);
+
+        const portContext = {
+          packageName,
+          moduleName,
+          serviceName,
+          serviceNameCamelCase,
+          target,
+          baseUrl,
+          baseUrlProperty,
+          feignClientName,
+          feignClientClassName,
+          feignAdapterClassName,
+          feignConfigClassName,
+          adapterPackage,
+          methods,
+          nestedTypes,
+          domainModels
+        };
+
+        // 0. Nested type records (shared across methods in the same service)
+        for (const nt of nestedTypes) {
+          const ntPath = path.join(
+            moduleBasePath, 'application', 'dtos', `${nt.name}.java`
+          );
+          await renderAndWrite(
+            path.join(__dirname, '..', '..', 'templates', 'ports', 'PortNestedType.java.ejs'),
+            ntPath,
+            { packageName, moduleName, name: nt.name, fields: nt.fields },
+            writeOptions
+          );
+          generatedFiles.push({
+            type: 'Port DTO',
+            name: nt.name,
+            path: `${moduleName}/application/dtos/${nt.name}.java`
+          });
+        }
+
+        // 1a. Domain models in domain/models/{adapterPackage}/ (ACL: domain-side abstraction)
+        for (const dm of (domainModels || [])) {
+          const dmPath = path.join(moduleBasePath, 'domain', 'models', adapterPackage, `${dm.name}.java`);
+          await renderAndWrite(
+            path.join(__dirname, '..', '..', 'templates', 'ports', 'PortDomainModel.java.ejs'),
+            dmPath,
+            { packageName, moduleName, name: dm.name, fields: dm.fields, target, serviceName, adapterPackage },
+            writeOptions
+          );
+          generatedFiles.push({
+            type: 'Port Domain Model',
+            name: dm.name,
+            path: `${moduleName}/domain/models/${adapterPackage}/${dm.name}.java`
+          });
+        }
+
+        // 1b. Infra DTOs (one per method that has fields:) — live in infrastructure/adapters/{service}/
+        for (const method of methods.filter(m => m.hasResponse)) {
+          const infraDtoPath = path.join(adapterDir, `${method.infraDtoName}.java`);
+          await renderAndWrite(
+            path.join(__dirname, '..', '..', 'templates', 'ports', 'PortResponseDto.java.ejs'),
+            infraDtoPath,
+            { packageName, moduleName, dtoName: method.infraDtoName, fields: method.fields, adapterPackage },
+            writeOptions
+          );
+          generatedFiles.push({
+            type: 'Port Infra DTO',
+            name: method.infraDtoName,
+            path: `${moduleName}/infrastructure/adapters/${adapterPackage}/${method.infraDtoName}.java`
+          });
+        }
+
+        // 2. Request DTOs (one per method that has body:)
+        for (const method of methods.filter(m => m.hasBody)) {
+          const reqPath = path.join(
+            moduleBasePath, 'application', 'dtos', `${method.requestDtoName}.java`
+          );
+          await renderAndWrite(
+            path.join(__dirname, '..', '..', 'templates', 'ports', 'PortRequestDto.java.ejs'),
+            reqPath,
+            { packageName, moduleName, dtoName: method.requestDtoName, bodyFields: method.bodyFields, nestedTypes: method.nestedTypes },
+            writeOptions
+          );
+          generatedFiles.push({
+            type: 'Port DTO',
+            name: method.requestDtoName,
+            path: `${moduleName}/application/dtos/${method.requestDtoName}.java`
+          });
+        }
+
+        // 3. Port interface (domain/repositories/)
+        await renderAndWrite(
+          path.join(__dirname, '..', '..', 'templates', 'ports', 'PortInterface.java.ejs'),
+          path.join(moduleBasePath, 'domain', 'repositories', `${serviceName}.java`),
+          portContext,
+          writeOptions
+        );
+        generatedFiles.push({
+          type: 'HTTP Port',
+          name: serviceName,
+          path: `${moduleName}/domain/repositories/${serviceName}.java`
+        });
+
+        // 4. Feign Client interface
+        await renderAndWrite(
+          path.join(__dirname, '..', '..', 'templates', 'ports', 'PortFeignClient.java.ejs'),
+          path.join(adapterDir, `${feignClientClassName}.java`),
+          portContext,
+          writeOptions
+        );
+        generatedFiles.push({
+          type: 'HTTP Port',
+          name: feignClientClassName,
+          path: `${moduleName}/infrastructure/adapters/${adapterPackage}/${feignClientClassName}.java`
+        });
+
+        // 5. Feign Adapter (@Component implementation)
+        await renderAndWrite(
+          path.join(__dirname, '..', '..', 'templates', 'ports', 'PortFeignAdapter.java.ejs'),
+          path.join(adapterDir, `${feignAdapterClassName}.java`),
+          portContext,
+          writeOptions
+        );
+        generatedFiles.push({
+          type: 'HTTP Port',
+          name: feignAdapterClassName,
+          path: `${moduleName}/infrastructure/adapters/${adapterPackage}/${feignAdapterClassName}.java`
+        });
+
+        // 6. Feign Config
+        await renderAndWrite(
+          path.join(__dirname, '..', '..', 'templates', 'ports', 'PortFeignConfig.java.ejs'),
+          path.join(adapterDir, `${feignConfigClassName}.java`),
+          portContext,
+          writeOptions
+        );
+        generatedFiles.push({
+          type: 'HTTP Port',
+          name: feignConfigClassName,
+          path: `${moduleName}/infrastructure/adapters/${adapterPackage}/${feignConfigClassName}.java`
+        });
+
+        // 7. Register base URL in parameters/*/urls.yaml
+        await createOrUpdateUrlsConfig(projectDir, baseUrlProperty, baseUrl);
+      }
+
+      // Ensure urls.yaml is imported in all application-*.yaml files
+      await ensureUrlsImport(projectDir);
+
+      spinner.succeed(chalk.green(`HTTP ports generated! ✨`));
+    }
+
     console.log(chalk.blue('\n📦 Generated files:'));
     const groupedFiles = generatedFiles.reduce((acc, file) => {
       if (!acc[file.type]) acc[file.type] = [];
@@ -541,15 +1095,87 @@ async function generateEntitiesCommand(moduleName, options = {}) {
     // Persist checksums to disk before asking about CRUD
     await checksumManager.save();
 
-    // Ask user if they want to generate CRUD resources
-    const { generateCrud } = await inquirer.prompt([
-      {
-        type: 'confirm',
-        name: 'generateCrud',
-        message: 'Do you want to generate CRUD resources for aggregate roots?',
-        default: true
+    if (endpoints) {
+      // ── endpoints: section declared → skip CRUD prompt, auto-generate ──
+      spinner.start('Generating endpoint-driven resources...');
+
+      // Pre-classify all operations ONCE against all aggregates so that
+      // each per-aggregate pass never overwrites a classification that
+      // belongs to a different aggregate (multi-aggregate modules).
+      for (const version of endpoints.versions) {
+        for (const op of version.operations) {
+          for (const agg of aggregates) {
+            const cl = classifyUseCase(op, agg.name, agg);
+            if (cl.category !== 'scaffold') {
+              op._ownerAggregate = agg.name;
+              op._classification = cl;
+              break;
+            }
+          }
+          if (!op._ownerAggregate) {
+            // True scaffold: heuristic — find aggregate whose name appears inside the use case name
+            const matched = aggregates.find(agg =>
+              op.useCase.toLowerCase().includes(agg.name.toLowerCase())
+            );
+            const owner = matched || aggregates[0];
+            op._ownerAggregate = owner.name;
+            op._classification = { category: 'scaffold' };
+          }
+        }
+      }
+
+      const sharedGeneratedUseCases = new Set();
+      for (const aggregate of aggregates) {
+        await generateEndpointsResources(
+          aggregate,
+          endpoints,
+          moduleName,
+          moduleBasePath,
+          packageName,
+          generatedFiles,
+          writeOptions,
+          sharedGeneratedUseCases
+        );
       }
-    ]);
+
+      spinner.succeed(chalk.green('Endpoint-driven resources generated! ✨'));
+
+      const epFiles = generatedFiles.filter(f =>
+        f.type.includes('Command') || f.type.includes('Query') ||
+        f.type.includes('Handler') || f.type.includes('DTO') ||
+        f.type.includes('Controller') || f.type.includes('Mapper')
+      );
+      console.log(chalk.blue('\n📄 Generated endpoint files:'));
+      const groupedEp = epFiles.reduce((acc, file) => {
+        if (!acc[file.type]) acc[file.type] = [];
+        acc[file.type].push(file);
+        return acc;
+      }, {});
+      Object.keys(groupedEp).forEach(type => {
+        console.log(chalk.gray(`\n  ${type}:`));
+        groupedEp[type].forEach(file => {
+          console.log(chalk.gray(`    ├── ${file.name}`));
+        });
+      });
+
+      // Collect versions for summary
+      const versionList = endpoints.versions.map(v => v.version).join(', ');
+      const totalOps = endpoints.versions.reduce((sum, v) => sum + v.operations.length, 0);
+      console.log(chalk.blue(`\n✅ Generated ${totalOps} endpoint(s) across version(s): ${versionList}`));
+
+      await checksumManager.save();
+
+    } else {
+      // ── No endpoints section → original interactive CRUD flow ────────
+      // Ask user if they want to generate CRUD resources
+      const { generateCrud } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'generateCrud',
+          message: 'Do you want to generate CRUD resources for aggregate roots?',
+          default: true
+        }
+      ]);
 
     if (generateCrud) {
       // Ask for API version
@@ -583,22 +1209,24 @@ async function generateEntitiesCommand(moduleName, options = {}) {
           writeOptions
         );
         
-        // Generate Postman Collection for this aggregate
-        const collectionPath = await generatePostmanCollection(
-          aggregate,
-          moduleName,
-          moduleBasePath,
-          projectDir,
-          packageName,
-          apiVersion,
-          projectConfig,
-          allEnums,
-          writeOptions
-        );
-        postmanCollections.push({
-          name: aggregate.name,
-          path: path.relative(projectDir, collectionPath)
-        });
+        // Generate Postman Collection for this aggregate (skip when called from eva build)
+        if (!options.skipPostman) {
+          const collectionPath = await generatePostmanCollection(
+            aggregate,
+            moduleName,
+            moduleBasePath,
+            projectDir,
+            packageName,
+            apiVersion,
+            projectConfig,
+            allEnums,
+            writeOptions
+          );
+          postmanCollections.push({
+            name: aggregate.name,
+            path: path.relative(projectDir, collectionPath)
+          });
+        }
       }
 
       spinner.succeed(chalk.green('CRUD resources generated! ✨'));
@@ -641,6 +1269,8 @@ async function generateEntitiesCommand(moduleName, options = {}) {
       await checksumManager.save();
     }
 
+    } // end else (no endpoints section)
+
     console.log();
 
   } catch (error) {
@@ -686,20 +1316,659 @@ function transformRelsForApp(rels, validatedVoNames) {
   }));
 }
 
+/**
+ * Enrich fields with @Schema(example) values for Swagger UI.
+ * Uses the same fake-data heuristics as the Postman collection generator.
+ */
+function enrichFieldsWithSchemaExamples(fields, allEnums, valueObjects) {
+  return fields.map(f => {
+    // Skip VOs (nested DTOs describe themselves), collections, and already-enriched
+    if (f.originalVoType || f.isValueObject || f.isCollection) return f;
+    const example = generateFakeValue(f, allEnums, valueObjects);
+    if (example === null || example === undefined || typeof example === 'object') return f;
+    return { ...f, schemaExample: String(example) };
+  });
+}
+
+/**
+ * Recursively enrich relationship fields with schema examples.
+ */
+function enrichRelsWithSchemaExamples(rels, allEnums, valueObjects) {
+  return (rels || []).map(rel => ({
+    ...rel,
+    fields: enrichFieldsWithSchemaExamples(rel.fields || [], allEnums, valueObjects),
+    nestedRelationships: enrichRelsWithSchemaExamples(rel.nestedRelationships, allEnums, valueObjects),
+    nestedOneToOneRelationships: (rel.nestedOneToOneRelationships || []).map(otoRel => ({
+      ...otoRel,
+      fields: enrichFieldsWithSchemaExamples(otoRel.fields || [], allEnums, valueObjects)
+    }))
+  }));
+}
+
+/**
+ * Classify an endpoint operation into a semantic category.
+ * Returns { category, ...metadata } where category is one of:
+ *   'standard'        → matches the 5 CRUD patterns exactly
+ *   'transition'      → matches {MethodPascal}{Aggregate} for an enum transition
+ *   'subEntityAdd'    → matches Add{EntityName} for a OneToMany secondary entity
+ *   'subEntityRemove' → matches Remove{EntityName} for a OneToMany secondary entity
+ *   'findBy'          → matches FindAll{Aggregate}sBy{FieldPascal} for a root field
+ *   'scaffold'        → no semantic pattern matched
+ */
+function classifyUseCase(op, aggregateName, aggregate) {
+  // 1. Standard CRUD
+  const aggregateNamePlural = pluralizeWord(aggregateName);
+  const standardMap = {
+    [`Create${aggregateName}`]: 'create',
+    [`Update${aggregateName}`]: 'update',
+    [`Delete${aggregateName}`]: 'delete',
+    [`Get${aggregateName}`]: 'getById',
+    [`FindAll${aggregateNamePlural}`]: 'findAll'
+  };
+  if (standardMap[op.useCase]) {
+    return { category: 'standard', variant: standardMap[op.useCase] };
+  }
+
+  const rootEntity = aggregate.rootEntity;
+  const enums = aggregate.enums || [];
+
+  // 2. Enum transitions — pattern: {MethodPascal}{Aggregate}
+  for (const enumDef of enums) {
+    for (const transition of (enumDef.transitions || [])) {
+      const methodPascal = toPascalCase(transition.method);
+      if (op.useCase === `${methodPascal}${aggregateName}`) {
+        return {
+          category: 'transition',
+          domainMethod: transition.method,
+          enumName: enumDef.name,
+          targetStatus: Array.isArray(transition.to) ? transition.to[0] : transition.to
+        };
+      }
+    }
+  }
+
+  // 3. Sub-entity operations — pattern: Add{Entity} / Remove{Entity} (OneToMany only)
+  const oneToManyRels = (rootEntity.relationships || []).filter(r =>
+    r.type === 'OneToMany' && !r.isInverse
+  );
+  for (const rel of oneToManyRels) {
+    if (op.useCase === `Add${rel.target}`) {
+      const targetEntity = (aggregate.secondaryEntities || []).find(e => e.name === rel.target);
+      const entityFields = targetEntity
+        ? targetEntity.fields.filter(f =>
+            f.name !== 'id' && f.name !== 'createdAt' && f.name !== 'updatedAt' &&
+            f.name !== 'createdBy' && f.name !== 'updatedBy' && !f.readOnly
+          )
+        : [];
+      return {
+        category: 'subEntityAdd',
+        entityName: rel.target,
+        fieldName: rel.fieldName,
+        addMethodName: `add${rel.target}`,
+        entityFields,
+        entityImports: targetEntity ? (targetEntity.imports || []) : []
+      };
+    }
+    if (op.useCase === `Remove${rel.target}`) {
+      return {
+        category: 'subEntityRemove',
+        entityName: rel.target,
+        fieldName: rel.fieldName,
+        removeMethodName: `remove${rel.target}ById`
+      };
+    }
+  }
+
+  // 4. FindBy field — pattern: FindAll{Aggregate}sBy{FieldPascal}
+  for (const field of (rootEntity.fields || [])) {
+    const fieldPascal = toPascalCase(field.name);
+    const aggregateNamePlural = pluralizeWord(aggregateName);
+    if (op.useCase === `FindAll${aggregateNamePlural}By${fieldPascal}`) {
+      return {
+        category: 'findBy',
+        fieldName: field.name,
+        fieldPascal,
+        fieldJavaType: field.javaType,
+        jpaMethodName: `findBy${fieldPascal}`
+      };
+    }
+  }
+
+  return { category: 'scaffold' };
+}
+
+/**
+ * Enrich a single endpoint operation with derived properties for template rendering.
+ * Expects op._classification to be set by classifyUseCase() before this call.
+ */
+function enrichEndpointOperation(op, aggregateName, idType) {
+  const httpAnnotationMap = {
+    GET: 'GetMapping', POST: 'PostMapping',
+    PUT: 'PutMapping', PATCH: 'PatchMapping', DELETE: 'DeleteMapping'
+  };
+  const hasPathVar = Boolean(op.path && op.path.includes('{'));
+  const pathVarMatch = hasPathVar ? op.path.match(/\{([^}]+)\}/) : null;
+  const pathVarName = pathVarMatch ? pathVarMatch[1] : 'id';
+
+  const cl = op._classification || { category: 'scaffold' };
+  const isStandard = cl.category === 'standard';
+  const standardType = isStandard ? cl.variant : null;
+
+  // Infer type from HTTP method when not explicitly declared: GET → query, everything else → command
+  const resolvedType = op.type || (op.method === 'GET' ? 'query' : 'command');
+
+  let returnType = 'void';
+  if (standardType === 'getById') returnType = `${aggregateName}ResponseDto`;
+  else if (standardType === 'findAll') returnType = `PagedResponse<${aggregateName}ResponseDto>`;
+  else if (cl.category === 'findBy') returnType = `PagedResponse<${aggregateName}ResponseDto>`;
+  else if (cl.category === 'scaffold' && resolvedType === 'query') returnType = `${aggregateName}ResponseDto`;
+
+  let httpStatus = 'HttpStatus.OK';
+  if (standardType === 'create') httpStatus = 'HttpStatus.CREATED';
+  else if (standardType === 'update') httpStatus = 'HttpStatus.NO_CONTENT';
+  else if (cl.category === 'transition') httpStatus = 'HttpStatus.NO_CONTENT';
+  else if (cl.category === 'subEntityAdd') httpStatus = 'HttpStatus.CREATED';
+  else if (cl.category === 'subEntityRemove') httpStatus = 'HttpStatus.NO_CONTENT';
+
+  return {
+    ...op,
+    type: resolvedType,
+    httpAnnotation: httpAnnotationMap[op.method] || 'PostMapping',
+    methodName: toCamelCase(op.useCase),
+    hasPathVar,
+    pathVarName,
+    isStandard,
+    standardType,
+    classifiedType: cl.category,
+    classification: cl,
+    returnType,
+    httpStatus,
+    idType
+  };
+}
+
+/**
+ * Generate endpoint-driven resources (use cases + versioned controllers)
+ * for an aggregate when domain.yaml declares an `endpoints:` section.
+ */
+async function generateEndpointsResources(aggregate, endpoints, moduleName, moduleBasePath, packageName, generatedFiles, writeOptions = {}, sharedGeneratedUseCases = null) {
+  const { name: aggregateName, rootEntity, secondaryEntities, valueObjects = [] } = aggregate;
+  const aggregateNamePlural = pluralizeWord(aggregateName);
+  const templatesDir = path.join(__dirname, '..', '..', 'templates', 'crud');
+
+  const idField = rootEntity.fields[0];
+  const idType = idField.javaType;
+
+  const commandFields = rootEntity.fields.filter(f =>
+    f.name !== 'id' && f.name !== 'createdAt' && f.name !== 'updatedAt' &&
+    f.name !== 'createdBy' && f.name !== 'updatedBy' && f.name !== 'deletedAt' && !f.readOnly
+  );
+
+  const validatedVos = valueObjects.filter(vo =>
+    vo.fields.some(f => f.validationAnnotations && f.validationAnnotations.length > 0)
+  );
+  const validatedVoNames = new Set(validatedVos.map(vo => vo.name));
+
+  const oneToManyRelationships = enrichRelationshipsRecursively(rootEntity, secondaryEntities, 0, new Set());
+  const oneToOneRels = rootEntity.relationships?.filter(r => r.type === 'OneToOne' && !r.isInverse) || [];
+  const oneToOneRelationships = oneToOneRels.map(rel => {
+    const targetEntity = secondaryEntities.find(e => e.name === rel.target);
+    if (!targetEntity) return { targetEntityName: rel.target, fieldName: rel.fieldName, type: rel.type, fields: [] };
+    const targetFields = targetEntity.fields.filter(f =>
+      f.name !== 'id' && f.name !== 'createdAt' && f.name !== 'updatedAt' &&
+      f.name !== 'createdBy' && f.name !== 'updatedBy'
+    );
+    return { targetEntityName: rel.target, fieldName: rel.fieldName, type: rel.type, fields: targetFields, entity: targetEntity };
+  });
+
+  const hasValueObjects = rootEntity.fields.some(f => f.isValueObject);
+  const hasEnums = rootEntity.enums && rootEntity.enums.length > 0;
+  const resourceNameCamel = toCamelCase(aggregateName);
+  const resourceNameKebab = toKebabCase(aggregateName);
+
+  const responseFields = rootEntity.fields.filter(f =>
+    f.name !== 'createdBy' && f.name !== 'updatedBy' && f.name !== 'deletedAt' && !f.hidden
+  );
+  const responseSecondaryEntities = secondaryEntities.map(entity => ({
+    ...entity,
+    responseFields: entity.fields.filter(f => f.name !== 'createdBy' && f.name !== 'updatedBy' && !f.hidden),
+    nestedRelationships: enrichRelationshipsRecursively(entity, secondaryEntities, 0, new Set()),
+    forwardOneToOneRels: (entity.relationships || [])
+      .filter(r => r.type === 'OneToOne' && !r.isInverse)
+      .map(r => ({ targetEntityName: r.target, fieldName: r.fieldName }))
+  }));
+
+  // Schema examples for Swagger UI (same heuristics as Postman generator)
+  const localAllEnums = [...(aggregate.enums || []), ...(rootEntity.enums || [])];
+  initSeed(42);
+
+  const commandFieldsApp = enrichFieldsWithSchemaExamples(
+    transformFieldsForApp(commandFields, validatedVoNames), localAllEnums, valueObjects);
+  const oneToOneRelationshipsApp = oneToOneRelationships.map(rel => ({
+    ...rel,
+    fields: enrichFieldsWithSchemaExamples(
+      transformFieldsForApp(rel.fields || [], validatedVoNames), localAllEnums, valueObjects)
+  }));
+  const oneToManyRelationshipsApp = enrichRelsWithSchemaExamples(
+    transformRelsForApp(oneToManyRelationships, validatedVoNames), localAllEnums, valueObjects);
+
+  const baseContext = {
+    packageName, moduleName, aggregateName, aggregateNamePlural, rootEntity, secondaryEntities,
+    responseFields, responseSecondaryEntities, idType,
+    commandFields: commandFieldsApp, oneToManyRelationships, oneToOneRelationships,
+    hasValueObjects, hasEnums, imports: rootEntity.imports,
+    resourceNameCamel, resourceNameKebab,
+    hasSoftDelete: rootEntity.hasSoftDelete || false
+  };
+
+  // ── Step 1: Validated VO Dtos ────────────────────────────────────────
+  for (const vo of validatedVos) {
+    const voDtoContext = {
+      packageName, moduleName, voName: vo.name,
+      fields: enrichFieldsWithSchemaExamples(vo.fields, localAllEnums, valueObjects),
+      hasEnums: (vo.imports || []).some(i => i.includes('.enums.')),
+      imports: [...(vo.imports || []), ...generateValidationImports(vo.fields)]
+    };
+    await renderAndWrite(
+      path.join(templatesDir, 'CreateValueObjectDto.java.ejs'),
+      path.join(moduleBasePath, 'application', 'dtos', `Create${vo.name}Dto.java`),
+      voDtoContext, writeOptions
+    );
+    generatedFiles.push({ type: 'DTO', name: `Create${vo.name}Dto`, path: `${moduleName}/application/dtos/Create${vo.name}Dto.java` });
+  }
+
+  // ── Step 2: ApplicationMapper ────────────────────────────────────────
+  // Only emit Create{Aggregate}Command import and fromCommand() when a
+  // standard CreateOrder operation is declared — other POST use cases
+  // (e.g. PlaceOrder) are scaffolds and never produce that command class.
+  const hasCreateOperation = endpoints.versions.some(v =>
+    v.operations.some(op => op.useCase === `Create${aggregateName}`)
+  );
+  await renderAndWrite(
+    path.join(templatesDir, 'ApplicationMapper.java.ejs'),
+    path.join(moduleBasePath, 'application', 'mappers', `${aggregateName}ApplicationMapper.java`),
+    { ...baseContext, commandFields: commandFieldsApp, oneToOneRelationships: oneToOneRelationshipsApp, oneToManyRelationships: oneToManyRelationshipsApp, validatedVos, hasCreateOperation },
+    writeOptions
+  );
+  generatedFiles.push({ type: 'Application Mapper', name: `${aggregateName}ApplicationMapper`, path: `${moduleName}/application/mappers/${aggregateName}ApplicationMapper.java` });
+
+  // ── Step 3: ResponseDto ──────────────────────────────────────────────
+  const responseDtoContext = {
+    ...baseContext,
+    allFields: rootEntity.fields.filter(f => f.name !== 'createdBy' && f.name !== 'updatedBy' && f.name !== 'deletedAt' && !f.hidden),
+    relationships: rootEntity.relationships.filter(r => (r.type === 'OneToMany' || r.type === 'OneToOne') && !r.isInverse)
+  };
+  await renderAndWrite(
+    path.join(templatesDir, 'ResponseDto.java.ejs'),
+    path.join(moduleBasePath, 'application', 'dtos', `${aggregateName}ResponseDto.java`),
+    responseDtoContext, writeOptions
+  );
+  generatedFiles.push({ type: 'DTO', name: `${aggregateName}ResponseDto`, path: `${moduleName}/application/dtos/${aggregateName}ResponseDto.java` });
+
+  // ── Step 4: Secondary entity DTOs ───────────────────────────────────
+  for (const entity of secondaryEntities) {
+    const nestedRelationships = enrichRelationshipsRecursively(entity, secondaryEntities, 0, new Set());
+    const forwardOoO = (entity.relationships || []).filter(r => r.type === 'OneToOne' && !r.isInverse)
+      .map(r => ({ targetEntityName: r.target, fieldName: r.fieldName }));
+
+    await renderAndWrite(
+      path.join(templatesDir, 'SecondaryEntityDto.java.ejs'),
+      path.join(moduleBasePath, 'application', 'dtos', `${entity.name}Dto.java`),
+      { packageName, moduleName, entityName: entity.name,
+        fields: entity.fields.filter(f => f.name !== 'createdBy' && f.name !== 'updatedBy' && !f.hidden),
+        nestedRelationships, hasNestedRelationships: nestedRelationships.length > 0,
+        forwardOneToOneRels: forwardOoO,
+        hasValueObjects: entity.fields.some(f => f.isValueObject),
+        hasEnums: entity.enums && entity.enums.length > 0, imports: entity.imports },
+      writeOptions
+    );
+    generatedFiles.push({ type: 'DTO', name: `${entity.name}Dto`, path: `${moduleName}/application/dtos/${entity.name}Dto.java` });
+
+    const createFields = entity.fields.filter(f =>
+      f.name !== 'id' && f.name !== 'createdAt' && f.name !== 'updatedAt' &&
+      f.name !== 'createdBy' && f.name !== 'updatedBy' && !f.readOnly
+    );
+    const entityNestedRels = enrichRelationshipsRecursively(entity, secondaryEntities, 0, new Set());
+    const createFieldsApp = enrichFieldsWithSchemaExamples(
+      transformFieldsForApp(createFields, validatedVoNames), localAllEnums, valueObjects);
+    const dtoVoDtoImports = validatedVos.filter(vo => createFieldsApp.some(f => f.originalVoType === vo.name))
+      .map(vo => `import ${packageName}.${moduleName}.application.dtos.Create${vo.name}Dto;`);
+    const createDtoImports = [...new Set([
+      ...(entity.imports || []), ...generateValidationImports(createFieldsApp), ...dtoVoDtoImports,
+      ...(createFieldsApp.some(f => f.originalVoType) ? ['import jakarta.validation.Valid;'] : [])
+    ])];
+    const fwdOoO = (entity.relationships || []).filter(r => r.type === 'OneToOne' && !r.isInverse)
+      .map(r => ({ targetEntityName: r.target, fieldName: r.fieldName }));
+
+    await renderAndWrite(
+      path.join(templatesDir, 'CreateItemDto.java.ejs'),
+      path.join(moduleBasePath, 'application', 'dtos', `Create${entity.name}Dto.java`),
+      { packageName, moduleName, entityName: entity.name, fields: createFieldsApp,
+        nestedRelationships: entityNestedRels, hasNestedRelationships: entityNestedRels.length > 0,
+        forwardOneToOneRels: fwdOoO,
+        hasValueObjects: entity.fields.some(f => f.isValueObject),
+        hasEnums: entity.enums && entity.enums.length > 0, imports: createDtoImports },
+      writeOptions
+    );
+    generatedFiles.push({ type: 'DTO', name: `Create${entity.name}Dto`, path: `${moduleName}/application/dtos/Create${entity.name}Dto.java` });
+  }
+
+  // ── Step 5: Generate declared use cases (anti-duplicate across versions) ─
+  const commandVoDtoImports = validatedVos
+    .filter(vo => commandFieldsApp.some(f => f.originalVoType === vo.name))
+    .map(vo => `import ${packageName}.${moduleName}.application.dtos.Create${vo.name}Dto;`);
+  const commandAppImports = [...new Set([
+    ...(rootEntity.imports || []), ...generateValidationImports(commandFieldsApp), ...commandVoDtoImports,
+    ...(commandFieldsApp.some(f => f.originalVoType) ? ['import jakarta.validation.Valid;'] : [])
+  ])];
+
+  // Defensive: classify ops not yet assigned by the outer pre-pass
+  // (single-aggregate modules or direct calls without a shared set).
+  for (const version of endpoints.versions) {
+    for (const op of version.operations) {
+      if (!op._classification) {
+        op._classification = classifyUseCase(op, aggregateName, aggregate);
+        op._ownerAggregate = op._ownerAggregate || aggregateName;
+      }
+    }
+  }
+
+  const generatedUseCases = sharedGeneratedUseCases ?? new Set();
+  const findByOps = []; // collect FindBy ops for repository re-generation
+
+  for (const version of endpoints.versions) {
+    for (const op of version.operations) {
+      // Skip operations owned by a different aggregate (multi-aggregate endpoints section)
+      // MUST come before the shared-set check so foreign ops don't poison the set.
+      if (op._ownerAggregate !== aggregateName) continue;
+
+      if (generatedUseCases.has(op.useCase)) continue; // anti-duplicate (same use case across versions)
+      generatedUseCases.add(op.useCase);
+
+      const cl = op._classification;
+
+      if (cl.category === 'standard') {
+        const isStandard = true;
+        if (cl.variant === 'create') {
+          await renderAndWrite(
+            path.join(templatesDir, 'CreateCommand.java.ejs'),
+            path.join(moduleBasePath, 'application', 'commands', `Create${aggregateName}Command.java`),
+            { ...baseContext, imports: commandAppImports }, writeOptions
+          );
+          generatedFiles.push({ type: 'Command', name: `Create${aggregateName}Command`, path: `${moduleName}/application/commands/Create${aggregateName}Command.java` });
+
+          await renderAndWrite(
+            path.join(templatesDir, 'CreateCommandHandler.java.ejs'),
+            path.join(moduleBasePath, 'application', 'usecases', `Create${aggregateName}CommandHandler.java`),
+            { ...baseContext, commandFields: commandFieldsApp, oneToOneRelationships: oneToOneRelationshipsApp, oneToManyRelationships: oneToManyRelationshipsApp, validatedVos }, writeOptions
+          );
+          generatedFiles.push({ type: 'Handler', name: `Create${aggregateName}CommandHandler`, path: `${moduleName}/application/usecases/Create${aggregateName}CommandHandler.java` });
+
+        } else if (cl.variant === 'update') {
+          await renderAndWrite(
+            path.join(templatesDir, 'UpdateCommand.java.ejs'),
+            path.join(moduleBasePath, 'application', 'commands', `Update${aggregateName}Command.java`),
+            { ...baseContext, imports: commandAppImports }, writeOptions
+          );
+          generatedFiles.push({ type: 'Command', name: `Update${aggregateName}Command`, path: `${moduleName}/application/commands/Update${aggregateName}Command.java` });
+
+          await renderAndWrite(
+            path.join(templatesDir, 'UpdateCommandHandler.java.ejs'),
+            path.join(moduleBasePath, 'application', 'usecases', `Update${aggregateName}CommandHandler.java`),
+            baseContext, writeOptions
+          );
+          generatedFiles.push({ type: 'Handler', name: `Update${aggregateName}CommandHandler`, path: `${moduleName}/application/usecases/Update${aggregateName}CommandHandler.java` });
+
+        } else if (cl.variant === 'delete') {
+          await renderAndWrite(
+            path.join(templatesDir, 'DeleteCommand.java.ejs'),
+            path.join(moduleBasePath, 'application', 'commands', `Delete${aggregateName}Command.java`),
+            baseContext, writeOptions
+          );
+          generatedFiles.push({ type: 'Command', name: `Delete${aggregateName}Command`, path: `${moduleName}/application/commands/Delete${aggregateName}Command.java` });
+
+          await renderAndWrite(
+            path.join(templatesDir, 'DeleteCommandHandler.java.ejs'),
+            path.join(moduleBasePath, 'application', 'usecases', `Delete${aggregateName}CommandHandler.java`),
+            baseContext, writeOptions
+          );
+          generatedFiles.push({ type: 'Handler', name: `Delete${aggregateName}CommandHandler`, path: `${moduleName}/application/usecases/Delete${aggregateName}CommandHandler.java` });
+
+        } else if (cl.variant === 'getById') {
+          await renderAndWrite(
+            path.join(templatesDir, 'GetQuery.java.ejs'),
+            path.join(moduleBasePath, 'application', 'queries', `Get${aggregateName}Query.java`),
+            baseContext, writeOptions
+          );
+          generatedFiles.push({ type: 'Query', name: `Get${aggregateName}Query`, path: `${moduleName}/application/queries/Get${aggregateName}Query.java` });
+
+          await renderAndWrite(
+            path.join(templatesDir, 'GetQueryHandler.java.ejs'),
+            path.join(moduleBasePath, 'application', 'usecases', `Get${aggregateName}QueryHandler.java`),
+            baseContext, writeOptions
+          );
+          generatedFiles.push({ type: 'Handler', name: `Get${aggregateName}QueryHandler`, path: `${moduleName}/application/usecases/Get${aggregateName}QueryHandler.java` });
+
+        } else if (cl.variant === 'findAll') {
+          await renderAndWrite(
+            path.join(templatesDir, 'ListQuery.java.ejs'),
+            path.join(moduleBasePath, 'application', 'queries', `FindAll${aggregateNamePlural}Query.java`),
+            baseContext, writeOptions
+          );
+          generatedFiles.push({ type: 'Query', name: `FindAll${aggregateNamePlural}Query`, path: `${moduleName}/application/queries/FindAll${aggregateNamePlural}Query.java` });
+
+          await renderAndWrite(
+            path.join(templatesDir, 'ListQueryHandler.java.ejs'),
+            path.join(moduleBasePath, 'application', 'usecases', `FindAll${aggregateNamePlural}QueryHandler.java`),
+            baseContext, writeOptions
+          );
+          generatedFiles.push({ type: 'Handler', name: `FindAll${aggregateNamePlural}QueryHandler`, path: `${moduleName}/application/usecases/FindAll${aggregateNamePlural}QueryHandler.java` });
+        }
+
+      } else if (cl.category === 'transition') {
+        // Transition: {MethodPascal}{Aggregate} → findById → entity.{method}() → save
+        const transitionContext = {
+          packageName, moduleName, aggregateName,
+          useCaseName: op.useCase,
+          idType,
+          domainMethod: cl.domainMethod
+        };
+        await renderAndWrite(
+          path.join(templatesDir, 'TransitionCommand.java.ejs'),
+          path.join(moduleBasePath, 'application', 'commands', `${op.useCase}Command.java`),
+          transitionContext, writeOptions
+        );
+        generatedFiles.push({ type: 'Command', name: `${op.useCase}Command`, path: `${moduleName}/application/commands/${op.useCase}Command.java` });
+
+        await renderAndWrite(
+          path.join(templatesDir, 'TransitionCommandHandler.java.ejs'),
+          path.join(moduleBasePath, 'application', 'usecases', `${op.useCase}CommandHandler.java`),
+          transitionContext, writeOptions
+        );
+        generatedFiles.push({ type: 'Handler', name: `${op.useCase}CommandHandler`, path: `${moduleName}/application/usecases/${op.useCase}CommandHandler.java` });
+
+      } else if (cl.category === 'subEntityAdd') {
+        // SubEntityAdd: Add{EntityName} → findById → entity.add{Entity}(...) → save
+        const addContext = {
+          packageName, moduleName, aggregateName,
+          useCaseName: op.useCase,
+          idType,
+          entityName: cl.entityName,
+          entityFields: enrichFieldsWithSchemaExamples(cl.entityFields || [], localAllEnums, valueObjects),
+          addMethodName: cl.addMethodName,
+          imports: cl.entityImports
+        };
+        await renderAndWrite(
+          path.join(templatesDir, 'SubEntityAddCommand.java.ejs'),
+          path.join(moduleBasePath, 'application', 'commands', `${op.useCase}Command.java`),
+          addContext, writeOptions
+        );
+        generatedFiles.push({ type: 'Command', name: `${op.useCase}Command`, path: `${moduleName}/application/commands/${op.useCase}Command.java` });
+
+        await renderAndWrite(
+          path.join(templatesDir, 'SubEntityAddCommandHandler.java.ejs'),
+          path.join(moduleBasePath, 'application', 'usecases', `${op.useCase}CommandHandler.java`),
+          addContext, writeOptions
+        );
+        generatedFiles.push({ type: 'Handler', name: `${op.useCase}CommandHandler`, path: `${moduleName}/application/usecases/${op.useCase}CommandHandler.java` });
+
+      } else if (cl.category === 'subEntityRemove') {
+        // SubEntityRemove: Remove{EntityName} → findById → entity.remove{Entity}ById(itemId) → save
+        const removeContext = {
+          packageName, moduleName, aggregateName,
+          useCaseName: op.useCase,
+          idType,
+          entityName: cl.entityName,
+          removeMethodName: cl.removeMethodName
+        };
+        await renderAndWrite(
+          path.join(templatesDir, 'SubEntityRemoveCommand.java.ejs'),
+          path.join(moduleBasePath, 'application', 'commands', `${op.useCase}Command.java`),
+          removeContext, writeOptions
+        );
+        generatedFiles.push({ type: 'Command', name: `${op.useCase}Command`, path: `${moduleName}/application/commands/${op.useCase}Command.java` });
+
+        await renderAndWrite(
+          path.join(templatesDir, 'SubEntityRemoveCommandHandler.java.ejs'),
+          path.join(moduleBasePath, 'application', 'usecases', `${op.useCase}CommandHandler.java`),
+          removeContext, writeOptions
+        );
+        generatedFiles.push({ type: 'Handler', name: `${op.useCase}CommandHandler`, path: `${moduleName}/application/usecases/${op.useCase}CommandHandler.java` });
+
+      } else if (cl.category === 'findBy') {
+        // FindBy: FindAll{Aggregate}sBy{Field} → paginated query on a root field
+        findByOps.push(cl); // collected for repository re-generation after the loop
+        const findByContext = {
+          packageName, moduleName, aggregateName,
+          useCaseName: op.useCase,
+          idType,
+          fieldName: cl.fieldName,
+          fieldPascal: cl.fieldPascal,
+          fieldJavaType: cl.fieldJavaType,
+          jpaMethodName: cl.jpaMethodName
+        };
+        await renderAndWrite(
+          path.join(templatesDir, 'FindByQuery.java.ejs'),
+          path.join(moduleBasePath, 'application', 'queries', `${op.useCase}Query.java`),
+          findByContext, writeOptions
+        );
+        generatedFiles.push({ type: 'Query', name: `${op.useCase}Query`, path: `${moduleName}/application/queries/${op.useCase}Query.java` });
+
+        await renderAndWrite(
+          path.join(templatesDir, 'FindByQueryHandler.java.ejs'),
+          path.join(moduleBasePath, 'application', 'usecases', `${op.useCase}QueryHandler.java`),
+          findByContext, writeOptions
+        );
+        generatedFiles.push({ type: 'Handler', name: `${op.useCase}QueryHandler`, path: `${moduleName}/application/usecases/${op.useCase}QueryHandler.java` });
+
+      } else {
+        // Scaffold: no semantic pattern matched → generate stub with TODO
+        const scaffoldContext = { packageName, moduleName, aggregateName, useCaseName: op.useCase };
+        const scaffoldType = op.type || (op.method === 'GET' ? 'query' : 'command');
+        if (scaffoldType === 'command') {
+          await renderAndWrite(
+            path.join(templatesDir, 'ScaffoldCommand.java.ejs'),
+            path.join(moduleBasePath, 'application', 'commands', `${op.useCase}Command.java`),
+            scaffoldContext, writeOptions
+          );
+          generatedFiles.push({ type: 'Command', name: `${op.useCase}Command`, path: `${moduleName}/application/commands/${op.useCase}Command.java` });
+
+          await renderAndWrite(
+            path.join(templatesDir, 'ScaffoldCommandHandler.java.ejs'),
+            path.join(moduleBasePath, 'application', 'usecases', `${op.useCase}CommandHandler.java`),
+            scaffoldContext, writeOptions
+          );
+          generatedFiles.push({ type: 'Handler', name: `${op.useCase}CommandHandler`, path: `${moduleName}/application/usecases/${op.useCase}CommandHandler.java` });
+        } else {
+          await renderAndWrite(
+            path.join(templatesDir, 'ScaffoldQuery.java.ejs'),
+            path.join(moduleBasePath, 'application', 'queries', `${op.useCase}Query.java`),
+            scaffoldContext, writeOptions
+          );
+          generatedFiles.push({ type: 'Query', name: `${op.useCase}Query`, path: `${moduleName}/application/queries/${op.useCase}Query.java` });
+
+          await renderAndWrite(
+            path.join(templatesDir, 'ScaffoldQueryHandler.java.ejs'),
+            path.join(moduleBasePath, 'application', 'usecases', `${op.useCase}QueryHandler.java`),
+            scaffoldContext, writeOptions
+          );
+          generatedFiles.push({ type: 'Handler', name: `${op.useCase}QueryHandler`, path: `${moduleName}/application/usecases/${op.useCase}QueryHandler.java` });
+        }
+      }
+    }
+  }
+
+  // ── Step 5b: Re-generate repository files when FindBy ops are present ────
+  // Checksum protection still applies: manually modified files are skipped.
+  if (findByOps.length > 0) {
+    const aggregateTemplatesDir = path.join(__dirname, '..', '..', 'templates', 'aggregate');
+    const repoContext = { packageName, moduleName, rootEntity, findByOps };
+    const repoImplContext = {
+      packageName, moduleName, aggregateName, rootEntity,
+      hasDomainEvents: (aggregate.domainEvents || []).length > 0,
+      findByOps
+    };
+    await renderAndWrite(
+      path.join(aggregateTemplatesDir, 'AggregateRepository.java.ejs'),
+      path.join(moduleBasePath, 'domain', 'repositories', `${rootEntity.name}Repository.java`),
+      repoContext, writeOptions
+    );
+    await renderAndWrite(
+      path.join(aggregateTemplatesDir, 'JpaRepository.java.ejs'),
+      path.join(moduleBasePath, 'infrastructure', 'database', 'repositories', `${rootEntity.name}JpaRepository.java`),
+      repoContext, writeOptions
+    );
+    await renderAndWrite(
+      path.join(aggregateTemplatesDir, 'AggregateRepositoryImpl.java.ejs'),
+      path.join(moduleBasePath, 'infrastructure', 'database', 'repositories', `${rootEntity.name}RepositoryImpl.java`),
+      repoImplContext, writeOptions
+    );
+  }
+
+  // ── Step 6: Versioned controllers ────────────────────────────────────
+  for (const version of endpoints.versions) {
+    const versionCap = version.version.charAt(0).toUpperCase() + version.version.slice(1);
+    const controllerName = `${aggregateName}${versionCap}Controller`;
+    const enrichedOps = version.operations
+      .filter(op => op._ownerAggregate === aggregateName)
+      .map(op => enrichEndpointOperation(op, aggregateName, idType));
+
+    const controllerContext = {
+      ...baseContext,
+      apiVersion: version.version,
+      controllerName,
+      operations: enrichedOps,
+      basePath: endpoints.basePath,
+      commandFields: commandFieldsApp,
+      oneToManyRelationships,
+      oneToOneRelationships
+    };
+
+    await renderAndWrite(
+      path.join(templatesDir, 'EndpointsController.java.ejs'),
+      path.join(moduleBasePath, 'infrastructure', 'rest', 'controllers', resourceNameCamel, version.version, `${controllerName}.java`),
+      controllerContext, writeOptions
+    );
+    generatedFiles.push({ type: 'Controller', name: controllerName, path: `${moduleName}/infrastructure/rest/controllers/${resourceNameCamel}/${version.version}/${controllerName}.java` });
+  }
+}
+
 /**
  * Generate CRUD resources for an aggregate root
  */
 async function generateCrudResources(aggregate, moduleName, moduleBasePath, packageName, apiVersion, generatedFiles, writeOptions = {}) {
   const { name: aggregateName, rootEntity, secondaryEntities, valueObjects = [] } = aggregate;
+  const aggregateNamePlural = pluralizeWord(aggregateName);
   const templatesDir = path.join(__dirname, '..', '..', 'templates', 'crud');
   
   // Get ID field and type
   const idField = rootEntity.fields[0];
   const idType = idField.javaType;
   
-  // Filter command fields (exclude id, audit fields, and readOnly fields)
+  // Filter command fields (exclude id, audit fields, soft-delete fields, and readOnly fields)
   const commandFields = rootEntity.fields.filter(f => 
-    f.name !== 'id' && f.name !== 'createdAt' && f.name !== 'updatedAt' && f.name !== 'createdBy' && f.name !== 'updatedBy' && !f.readOnly
+    f.name !== 'id' && f.name !== 'createdAt' && f.name !== 'updatedAt' &&
+    f.name !== 'createdBy' && f.name !== 'updatedBy' && f.name !== 'deletedAt' && !f.readOnly
   );
 
   // Validated VOs: VOs where any field has validation annotations
@@ -764,9 +2033,9 @@ async function generateCrudResources(aggregate, moduleName, moduleBasePath, pack
   const resourceNameCamel = toCamelCase(aggregateName);
   const resourceNameKebab = toKebabCase(aggregateName);
   
-  // Filter audit user fields and hidden fields from response DTOs
+  // Filter audit user fields, soft-delete fields, and hidden fields from response DTOs
   const responseFields = rootEntity.fields.filter(f => 
-    f.name !== 'createdBy' && f.name !== 'updatedBy' && !f.hidden
+    f.name !== 'createdBy' && f.name !== 'updatedBy' && f.name !== 'deletedAt' && !f.hidden
   );
   
   const responseSecondaryEntities = secondaryEntities.map(entity => ({
@@ -781,18 +2050,26 @@ async function generateCrudResources(aggregate, moduleName, moduleBasePath, pack
   }));
   
   // Apply app-layer field transformation (VO fields become Create<Vo>Dto types)
-  const commandFieldsApp = transformFieldsForApp(commandFields, validatedVoNames);
+  // Schema examples for Swagger UI (same heuristics as Postman generator)
+  const localAllEnums = [...(aggregate.enums || []), ...(rootEntity.enums || [])];
+  initSeed(42);
+
+  const commandFieldsApp = enrichFieldsWithSchemaExamples(
+    transformFieldsForApp(commandFields, validatedVoNames), localAllEnums, valueObjects);
   const oneToOneRelationshipsApp = oneToOneRelationships.map(rel => ({
     ...rel,
-    fields: transformFieldsForApp(rel.fields || [], validatedVoNames)
+    fields: enrichFieldsWithSchemaExamples(
+      transformFieldsForApp(rel.fields || [], validatedVoNames), localAllEnums, valueObjects)
   }));
-  const oneToManyRelationshipsApp = transformRelsForApp(oneToManyRelationships, validatedVoNames);
+  const oneToManyRelationshipsApp = enrichRelsWithSchemaExamples(
+    transformRelsForApp(oneToManyRelationships, validatedVoNames), localAllEnums, valueObjects);
 
   // Base context for all templates
   const baseContext = {
     packageName,
     moduleName,
     aggregateName,
+    aggregateNamePlural,
     rootEntity,
     secondaryEntities,
     responseFields,
@@ -806,7 +2083,9 @@ async function generateCrudResources(aggregate, moduleName, moduleBasePath, pack
     imports: rootEntity.imports,
     apiVersion,
     resourceNameCamel,
-    resourceNameKebab
+    resourceNameKebab,
+    hasSoftDelete: rootEntity.hasSoftDelete || false,
+    hasCreateOperation: true  // In interactive CRUD flow, Create is always generated
   };
 
   // 0. Generate Create<VoName>Dto for validated Value Objects
@@ -815,7 +2094,7 @@ async function generateCrudResources(aggregate, moduleName, moduleBasePath, pack
       packageName,
       moduleName,
       voName: vo.name,
-      fields: vo.fields,
+      fields: enrichFieldsWithSchemaExamples(vo.fields, localAllEnums, valueObjects),
       hasEnums: (vo.imports || []).some(i => i.includes('.enums.')),
       imports: [...(vo.imports || []), ...generateValidationImports(vo.fields)]
     };
@@ -837,7 +2116,8 @@ async function generateCrudResources(aggregate, moduleName, moduleBasePath, pack
       commandFields: commandFieldsApp,
       oneToOneRelationships: oneToOneRelationshipsApp,
       oneToManyRelationships: oneToManyRelationshipsApp,
-      validatedVos
+      validatedVos,
+      hasCreateOperation: true
     },
     writeOptions
   );
@@ -888,11 +2168,11 @@ async function generateCrudResources(aggregate, moduleName, moduleBasePath, pack
   
   await renderAndWrite(
     path.join(templatesDir, 'ListQuery.java.ejs'),
-    path.join(moduleBasePath, 'application', 'queries', `FindAll${aggregateName}sQuery.java`),
+    path.join(moduleBasePath, 'application', 'queries', `FindAll${aggregateNamePlural}Query.java`),
     baseContext,
     writeOptions
   );
-  generatedFiles.push({ type: 'Query', name: `FindAll${aggregateName}sQuery`, path: `${moduleName}/application/queries/FindAll${aggregateName}sQuery.java` });
+  generatedFiles.push({ type: 'Query', name: `FindAll${aggregateNamePlural}Query`, path: `${moduleName}/application/queries/FindAll${aggregateNamePlural}Query.java` });
   
   // 4. Generate Handlers
   await renderAndWrite(
@@ -919,11 +2199,11 @@ async function generateCrudResources(aggregate, moduleName, moduleBasePath, pack
   
   await renderAndWrite(
     path.join(templatesDir, 'ListQueryHandler.java.ejs'),
-    path.join(moduleBasePath, 'application', 'usecases', `FindAll${aggregateName}sQueryHandler.java`),
+    path.join(moduleBasePath, 'application', 'usecases', `FindAll${aggregateNamePlural}QueryHandler.java`),
     baseContext,
     writeOptions
   );
-  generatedFiles.push({ type: 'Handler', name: `FindAll${aggregateName}sQueryHandler`, path: `${moduleName}/application/usecases/FindAll${aggregateName}sQueryHandler.java` });
+  generatedFiles.push({ type: 'Handler', name: `FindAll${aggregateNamePlural}QueryHandler`, path: `${moduleName}/application/usecases/FindAll${aggregateNamePlural}QueryHandler.java` });
   
   await renderAndWrite(
     path.join(templatesDir, 'DeleteCommandHandler.java.ejs'),
@@ -944,7 +2224,7 @@ async function generateCrudResources(aggregate, moduleName, moduleBasePath, pack
   // 5. Generate DTOs
   const responseDtoContext = {
     ...baseContext,
-    allFields: rootEntity.fields.filter(f => f.name !== 'createdBy' && f.name !== 'updatedBy' && !f.hidden),
+    allFields: rootEntity.fields.filter(f => f.name !== 'createdBy' && f.name !== 'updatedBy' && f.name !== 'deletedAt' && !f.hidden),
     relationships: rootEntity.relationships.filter(r => (r.type === 'OneToMany' || r.type === 'OneToOne') && !r.isInverse)
   };
   
@@ -1008,7 +2288,8 @@ async function generateCrudResources(aggregate, moduleName, moduleBasePath, pack
       new Set()
     );
     
-    const createFieldsApp = transformFieldsForApp(createFields, validatedVoNames);
+    const createFieldsApp = enrichFieldsWithSchemaExamples(
+      transformFieldsForApp(createFields, validatedVoNames), localAllEnums, valueObjects);
     const dtoVoDtoImports = validatedVos
       .filter(vo => createFieldsApp.some(f => f.originalVoType === vo.name))
       .map(vo => `import ${packageName}.${moduleName}.application.dtos.Create${vo.name}Dto;`);
@@ -1099,6 +2380,7 @@ async function generatePostmanCollection(
   
   const context = {
     aggregateName,
+    aggregateNamePlural: pluralizeWord(aggregateName),
     moduleName,
     resourceNameKebab,
     apiVersion,