eva4j 1.0.14 → 1.0.16

package/src/commands/generate-entities.js

@@ -5,16 +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, toPascalCase, 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 { getInstalledBroker, generateSingleKafkaEvent, buildKafkaEventContext } = require('./generate-kafka-event');
+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
@@ -174,7 +244,7 @@ async function generateEntitiesCommand(moduleName, options = {}) {
 
   try {
     // Parse domain.yaml
-    const { aggregates, allEnums, endpoints } = 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)`));
     
@@ -203,7 +273,13 @@ async function generateEntitiesCommand(moduleName, options = {}) {
     }
 
     // Detect installed message broker for auto-wiring integration events
-    const broker = hasDomainEventsInModule ? await getInstalledBroker(configManager) : null;
+    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) {
@@ -303,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(
@@ -326,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(
@@ -444,6 +523,7 @@ async function generateEntitiesCommand(moduleName, options = {}) {
         packageName,
         moduleName,
         rootEntity,
+        hasSoftDelete: rootEntity.hasSoftDelete || false,
         findByOps: []
       };
 
@@ -471,6 +551,7 @@ async function generateEntitiesCommand(moduleName, options = {}) {
         aggregateName,
         rootEntity,
         hasDomainEvents: (aggregate.domainEvents || []).length > 0,
+        hasSoftDelete: rootEntity.hasSoftDelete || false,
         findByOps: []
       };
 
@@ -529,6 +610,10 @@ async function generateEntitiesCommand(moduleName, options = {}) {
         // 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);
@@ -537,6 +622,28 @@ async function generateEntitiesCommand(moduleName, options = {}) {
               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',
@@ -548,12 +655,423 @@ async function generateEntitiesCommand(moduleName, options = {}) {
             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] = [];
@@ -581,6 +1099,32 @@ async function generateEntitiesCommand(moduleName, options = {}) {
       // ── 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,
@@ -589,7 +1133,8 @@ async function generateEntitiesCommand(moduleName, options = {}) {
           moduleBasePath,
           packageName,
           generatedFiles,
-          writeOptions
+          writeOptions,
+          sharedGeneratedUseCases
         );
       }
 
@@ -664,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! ✨'));
@@ -769,6 +1316,35 @@ 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:
@@ -781,12 +1357,13 @@ function transformRelsForApp(rels, validatedVoNames) {
  */
 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${aggregateName}s`]: 'findAll'
+    [`FindAll${aggregateNamePlural}`]: 'findAll'
   };
   if (standardMap[op.useCase]) {
     return { category: 'standard', variant: standardMap[op.useCase] };
@@ -845,7 +1422,8 @@ function classifyUseCase(op, aggregateName, aggregate) {
   // 4. FindBy field — pattern: FindAll{Aggregate}sBy{FieldPascal}
   for (const field of (rootEntity.fields || [])) {
     const fieldPascal = toPascalCase(field.name);
-    if (op.useCase === `FindAll${aggregateName}sBy${fieldPascal}`) {
+    const aggregateNamePlural = pluralizeWord(aggregateName);
+    if (op.useCase === `FindAll${aggregateNamePlural}By${fieldPascal}`) {
       return {
         category: 'findBy',
         fieldName: field.name,
@@ -883,7 +1461,7 @@ function enrichEndpointOperation(op, aggregateName, idType) {
   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 = 'Object';
+  else if (cl.category === 'scaffold' && resolvedType === 'query') returnType = `${aggregateName}ResponseDto`;
 
   let httpStatus = 'HttpStatus.OK';
   if (standardType === 'create') httpStatus = 'HttpStatus.CREATED';
@@ -913,8 +1491,9 @@ function enrichEndpointOperation(op, aggregateName, 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 = {}) {
+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];
@@ -922,7 +1501,7 @@ async function generateEndpointsResources(aggregate, endpoints, moduleName, modu
 
   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 !== 'createdBy' && f.name !== 'updatedBy' && f.name !== 'deletedAt' && !f.readOnly
   );
 
   const validatedVos = valueObjects.filter(vo =>
@@ -948,7 +1527,7 @@ async function generateEndpointsResources(aggregate, endpoints, moduleName, modu
   const resourceNameKebab = toKebabCase(aggregateName);
 
   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 => ({
     ...entity,
@@ -959,25 +1538,34 @@ async function generateEndpointsResources(aggregate, endpoints, moduleName, modu
       .map(r => ({ targetEntityName: r.target, fieldName: r.fieldName }))
   }));
 
-  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);
 
   const baseContext = {
-    packageName, moduleName, aggregateName, rootEntity, secondaryEntities,
+    packageName, moduleName, aggregateName, aggregateNamePlural, rootEntity, secondaryEntities,
     responseFields, responseSecondaryEntities, idType,
     commandFields: commandFieldsApp, oneToManyRelationships, oneToOneRelationships,
     hasValueObjects, hasEnums, imports: rootEntity.imports,
-    resourceNameCamel, resourceNameKebab
+    resourceNameCamel, resourceNameKebab,
+    hasSoftDelete: rootEntity.hasSoftDelete || false
   };
 
   // ── Step 1: Validated VO Dtos ────────────────────────────────────────
   for (const vo of validatedVos) {
     const voDtoContext = {
-      packageName, moduleName, voName: vo.name, fields: vo.fields,
+      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)]
     };
@@ -990,10 +1578,16 @@ async function generateEndpointsResources(aggregate, endpoints, moduleName, modu
   }
 
   // ── 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 },
+    { ...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` });
@@ -1001,7 +1595,7 @@ async function generateEndpointsResources(aggregate, endpoints, moduleName, modu
   // ── Step 3: ResponseDto ──────────────────────────────────────────────
   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)
   };
   await renderAndWrite(
@@ -1035,7 +1629,8 @@ async function generateEndpointsResources(aggregate, endpoints, moduleName, modu
       f.name !== 'createdBy' && f.name !== 'updatedBy' && !f.readOnly
     );
     const entityNestedRels = enrichRelationshipsRecursively(entity, secondaryEntities, 0, 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;`);
     const createDtoImports = [...new Set([
@@ -1067,20 +1662,27 @@ async function generateEndpointsResources(aggregate, endpoints, moduleName, modu
     ...(commandFieldsApp.some(f => f.originalVoType) ? ['import jakarta.validation.Valid;'] : [])
   ])];
 
-  // Pre-classify ALL operations (including cross-version duplicates) so that
-  // enrichEndpointOperation() can read op._classification in step 6.
+  // 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) {
-      op._classification = classifyUseCase(op, aggregateName, aggregate);
+      if (!op._classification) {
+        op._classification = classifyUseCase(op, aggregateName, aggregate);
+        op._ownerAggregate = op._ownerAggregate || aggregateName;
+      }
     }
   }
 
-  const generatedUseCases = new Set();
+  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) {
-      if (generatedUseCases.has(op.useCase)) continue; // anti-duplicate
+      // 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;
@@ -1150,17 +1752,17 @@ async function generateEndpointsResources(aggregate, endpoints, moduleName, modu
         } else if (cl.variant === 'findAll') {
           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` });
 
           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` });
         }
 
       } else if (cl.category === 'transition') {
@@ -1192,7 +1794,7 @@ async function generateEndpointsResources(aggregate, endpoints, moduleName, modu
           useCaseName: op.useCase,
           idType,
           entityName: cl.entityName,
-          entityFields: cl.entityFields,
+          entityFields: enrichFieldsWithSchemaExamples(cl.entityFields || [], localAllEnums, valueObjects),
           addMethodName: cl.addMethodName,
           imports: cl.entityImports
         };
@@ -1327,7 +1929,9 @@ async function generateEndpointsResources(aggregate, endpoints, moduleName, modu
   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.map(op => enrichEndpointOperation(op, aggregateName, idType));
+    const enrichedOps = version.operations
+      .filter(op => op._ownerAggregate === aggregateName)
+      .map(op => enrichEndpointOperation(op, aggregateName, idType));
 
     const controllerContext = {
       ...baseContext,
@@ -1354,15 +1958,17 @@ async function generateEndpointsResources(aggregate, endpoints, moduleName, modu
  */
 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
@@ -1427,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 => ({
@@ -1444,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,
@@ -1469,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
@@ -1478,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)]
     };
@@ -1500,7 +2116,8 @@ async function generateCrudResources(aggregate, moduleName, moduleBasePath, pack
       commandFields: commandFieldsApp,
       oneToOneRelationships: oneToOneRelationshipsApp,
       oneToManyRelationships: oneToManyRelationshipsApp,
-      validatedVos
+      validatedVos,
+      hasCreateOperation: true
     },
     writeOptions
   );
@@ -1551,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(
@@ -1582,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'),
@@ -1607,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)
   };
   
@@ -1671,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;`);
@@ -1762,6 +2380,7 @@ async function generatePostmanCollection(
   
   const context = {
     aggregateName,
+    aggregateNamePlural: pluralizeWord(aggregateName),
     moduleName,
     resourceNameKebab,
     apiVersion,