eva4j 1.0.14 → 1.0.16

package/src/commands/generate-http-exchange.js

@@ -307,3 +307,5 @@ async function ensureUrlsImport(projectDir) {
 }
 
 module.exports = generateHttpExchangeCommand;
+module.exports.createOrUpdateUrlsConfig = createOrUpdateUrlsConfig;
+module.exports.ensureUrlsImport = ensureUrlsImport;

package/src/commands/generate-kafka-event.js

@@ -166,9 +166,9 @@ async function generateKafkaEventCommand(moduleName, eventName) {
         }
       }
 
-      const topicNameKebab = toKebabCase(name);
-      const topicNameCamel = toCamelCase(name);
-      const topicNameSnake = toSnakeCase(name).toUpperCase();
+      const topicNameKebab = toKebabCase(stripEventSuffix(name));
+      const topicNameCamel = toCamelCase(stripEventSuffix(name));
+      const topicNameSnake = toSnakeCase(stripEventSuffix(name)).toUpperCase();
       const topicSpringProperty = `\${topics.${topicNameKebab}}`;
       const selectedDomainEvent = domainEventMap[normalizedName] || null;
 
@@ -218,8 +218,8 @@ async function generateKafkaEventCommand(moduleName, eventName) {
 
     if (!isBatch && generated.length === 1) {
       const r = generated[0];
-      const topicSnake = toSnakeCase(eventNames[0]).toUpperCase();
-      const topicKebab = toKebabCase(eventNames[0]);
+      const topicSnake = toSnakeCase(stripEventSuffix(eventNames[0])).toUpperCase();
+      const topicKebab = toKebabCase(stripEventSuffix(eventNames[0]));
       console.log(chalk.blue('\n✅ Kafka event configured successfully!'));
       console.log(chalk.white(`\n   Event: ${r.name}`));
       console.log(chalk.white(`   Topic: ${topicSnake} (${topicKebab})`));
@@ -393,6 +393,15 @@ async function createOrUpdateKafkaMessageBroker(projectDir, packagePath, context
     // Update existing implementation
     let content = await fs.readFile(adapterPath, 'utf-8');
 
+    // If this is a mock impl (generated by build --mock), replace it wholesale
+    // with the real Kafka implementation before proceeding.
+    const isMockImpl = content.includes('ApplicationEventPublisher') && !content.includes('KafkaTemplate');
+    if (isMockImpl) {
+      const templatePath = path.join(__dirname, '..', '..', 'templates', 'kafka-event', 'KafkaMessageBroker.java.ejs');
+      await renderAndWrite(templatePath, adapterPath, context);
+      return;
+    }
+
     // Check if method already exists
     if (content.includes(methodName)) {
       return; // Method already exists
@@ -606,8 +615,10 @@ async function updateDomainEventHandler(projectDir, packagePath, context) {
   }
 
   // 4. Render the mapping call and replace the TODO block
+  // Derive aggregateName from the handler file name (e.g. BikeDomainEventHandler.java → Bike)
+  const aggregateName = handlerFile.replace('DomainEventHandler.java', '');
   const templatePath = path.join(__dirname, '..', '..', 'templates', 'kafka-event', 'DomainEventHandlerMethod.ejs');
-  const mappingLine = await renderTemplate(templatePath, { ...context, domainEventFields: context.eventFields });
+  const mappingLine = await renderTemplate(templatePath, { ...context, domainEventFields: context.eventFields, aggregateName });
 
   const todoRegex = new RegExp(
     `([ \\t]*\/\/ TODO: handle ${domainEventName}[^\\n]*\\n)(?:[ \\t]*\/\/[^\\n]*\\n)*`
@@ -651,6 +662,18 @@ async function getInstalledBroker(configManager) {
   return null;
 }
 
+/**
+ * Strip the conventional Java 'Event' suffix from an event class name
+ * before deriving the Kafka topic name.
+ * ProductPublishedEvent → ProductPublished → PRODUCT_PUBLISHED
+ *
+ * If the event has an explicit `topic:` property in domain.yaml, that takes
+ * precedence and this function is not called.
+ */
+function stripEventSuffix(name) {
+  return name.endsWith('Event') ? name.slice(0, -'Event'.length) : name;
+}
+
 /**
  * Build a Kafka event generation context for a given domain event.
  * Intended for use by `generate-entities.js` to auto-wire broker integration events
@@ -658,7 +681,7 @@ async function getInstalledBroker(configManager) {
  *
  * @param {string} packageName
  * @param {string} moduleName
- * @param {{ name: string, fields: Array }} domainEvent - Domain event from parsed domain.yaml
+ * @param {{ name: string, topic?: string, fields: Array }} domainEvent - Domain event from parsed domain.yaml
  * @param {{ partitions?: number, replicas?: number }} [options]
  * @returns {Object} context ready for generateSingleKafkaEvent()
  */
@@ -667,9 +690,15 @@ function buildKafkaEventContext(packageName, moduleName, domainEvent, { partitio
   const integrationEventClassName = normalizedName.endsWith('IntegrationEvent')
     ? normalizedName
     : `${normalizedName}IntegrationEvent`;
-  const topicNameKebab = toKebabCase(domainEvent.name);
-  const topicNameCamel = toCamelCase(domainEvent.name);
-  const topicNameSnake = toSnakeCase(domainEvent.name).toUpperCase();
+  // If an explicit topic is declared in domain.yaml, use it as source of truth.
+  // Otherwise strip the 'Event' suffix before deriving snake/kebab names so that
+  // ProductPublishedEvent → PRODUCT_PUBLISHED (not PRODUCT_PUBLISHED_EVENT).
+  const topicBase = domainEvent.topic
+    ? domainEvent.topic.trim().toUpperCase().replace(/-/g, '_')
+    : toSnakeCase(stripEventSuffix(domainEvent.name)).toUpperCase();
+  const topicNameSnake = topicBase;
+  const topicNameKebab = topicBase.toLowerCase().replace(/_/g, '-');
+  const topicNameCamel = toCamelCase(topicNameKebab);
   const topicSpringProperty = `\${topics.${topicNameKebab}}`;
   return {
     packageName,
@@ -694,3 +723,7 @@ module.exports = generateKafkaEventCommand;
 module.exports.generateSingleKafkaEvent = generateSingleKafkaEvent;
 module.exports.buildKafkaEventContext = buildKafkaEventContext;
 module.exports.getInstalledBroker = getInstalledBroker;
+module.exports.updateKafkaYml = updateKafkaYml;
+module.exports.generateEventRecord = generateEventRecord;
+module.exports.createOrUpdateMessageBroker = createOrUpdateMessageBroker;
+module.exports.updateDomainEventHandler = updateDomainEventHandler;

package/src/generators/base-generator.js

@@ -63,6 +63,8 @@ class BaseGenerator {
     await fs.ensureDir(resources);
     await fs.ensureDir(path.join(resources, 'static'));
     await fs.ensureDir(path.join(resources, 'templates'));
+    await fs.ensureDir(path.join(this.projectDir, 'system'));
+    await fs.ensureDir(path.join(this.projectDir, '.agents'));
   }
 
   async generateApplication() {
@@ -132,16 +134,14 @@ class BaseGenerator {
       path.join(this.projectDir, 'AGENTS.md'));
     await this.generateFile('root/system.yaml.ejs', 
       path.join(this.projectDir, 'system.yaml'));
-    await this.generateFile('root/skill-build-system-yaml.ejs', 
-      path.join(this.projectDir, '.agents', 'skills', 'build-system-yaml', 'SKILL.md'));
-    await this.generateFile('root/skill-build-domain-yaml.ejs', 
-      path.join(this.projectDir, '.agents', 'skills', 'build-domain-yaml', 'SKILL.md'));
-    await this.generateFile('root/skill-build-domain-yaml-references-generate-entities.md.ejs', 
-      path.join(this.projectDir, '.agents', 'skills', 'build-domain-yaml', 'references', 'GENERATE_ENTITIES.md'));
+    await this.copySkills();
+    await this.copyAgents();
     
     if (this.context.features.includeDocker) {
       await this.generateFile('docker/docker-compose.yaml.ejs', 
         path.join(this.projectDir, 'docker-compose.yaml'));
+      await this.generateFile('docker/Dockerfile.ejs', 
+        path.join(this.projectDir, 'Dockerfile'));
     }
   }
 
@@ -152,6 +152,18 @@ class BaseGenerator {
         `${this.context.applicationClassName}Tests.java`));
   }
 
+  async copySkills() {
+    const srcSkillsDir = path.join(__dirname, '../skills');
+    const destSkillsDir = path.join(this.projectDir, '.agents', 'skills');
+    await fs.copy(srcSkillsDir, destSkillsDir);
+  }
+
+  async copyAgents() {
+    const srcAgentsDir = path.join(__dirname, '../agents');
+    const destAgentsDir = path.join(this.projectDir, '.github', 'agents');
+    await fs.copy(srcAgentsDir, destAgentsDir);
+  }
+
   async generateFile(templateRelPath, destPath) {
     const templatePath = path.join(this.templatesDir, templateRelPath);
     await renderAndWrite(templatePath, destPath, this.context);

package/src/generators/postman-generator.js

@@ -0,0 +1,188 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const crypto = require('crypto');
+
+const { parseDomainYaml } = require('../utils/yaml-to-entity');
+const { renderTemplate } = require('../utils/template-engine');
+const { toKebabCase, toCamelCase, toPackagePath } = require('../utils/naming');
+const { initSeed, generateFakeValue, generateFakeBody, generateFakeId } = require('../utils/fake-data');
+
+const TEMPLATES_DIR = path.join(__dirname, '../../templates/postman');
+
+// Audit / internal fields excluded from command bodies
+const EXCLUDED_FIELDS = new Set([
+  'id', 'createdAt', 'updatedAt', 'createdBy', 'updatedBy', 'deletedAt',
+]);
+
+/**
+ * Determine which aggregate an operation belongs to based on use case naming.
+ * E.g. "CreateProduct" → "Product", "FindAllCategorys" → "Category".
+ *
+ * @param {string} useCase      - e.g. "CreateProduct"
+ * @param {Array}  aggregates   - parsed aggregates with `.name`
+ * @returns {string|null}       - aggregate name or null
+ */
+function resolveOwnerAggregate(useCase, aggregates) {
+  const ucLower = useCase.toLowerCase();
+  // Sort longest name first so "UserProfile" matches before "User"
+  const sorted = [...aggregates].sort((a, b) => b.name.length - a.name.length);
+  for (const agg of sorted) {
+    if (ucLower.includes(agg.name.toLowerCase())) return agg.name;
+  }
+  return null;
+}
+
+/**
+ * Generate a unified Postman collection covering every module in the system.
+ *
+ * @param {Object}   opts
+ * @param {string}   opts.projectDir     - Absolute path to the project root
+ * @param {string}   opts.systemDir      - Absolute path to the system/ directory
+ * @param {string}   opts.packageName    - Full Java package name (e.g. "com.example.myapp")
+ * @param {Object}   opts.systemConfig   - Parsed system.yaml object
+ * @param {Object}   opts.projectConfig  - Parsed .eva4j.json project config
+ * @returns {Promise<string|null>}       - Path to the generated file, or null on error
+ */
+async function generateUnifiedPostmanCollection({
+  projectDir,
+  systemDir,
+  packageName,
+  systemConfig,
+  projectConfig,
+}) {
+  const systemName = systemConfig.system?.name || projectConfig.projectName || projectConfig.artifactId || 'eva4j-app';
+  const port = projectConfig.server?.port || 8040;
+  const modules = systemConfig.modules || [];
+
+  if (!modules.length) return null;
+
+  // Seed faker for deterministic output
+  initSeed(42);
+
+  // ── Collect module contexts ───────────────────────────────────────────────
+  const moduleContexts = [];
+
+  for (const mod of modules) {
+    const yamlPath = path.join(systemDir, `${mod.name}.yaml`);
+    if (!(await fs.pathExists(yamlPath))) continue;
+
+    let parsed;
+    try {
+      parsed = await parseDomainYaml(yamlPath, packageName, mod.name);
+    } catch (err) {
+      console.log(chalk.yellow(`  ⚠️  Could not parse ${mod.name}.yaml for Postman: ${err.message}`));
+      continue;
+    }
+
+    const { aggregates, allEnums, endpoints } = parsed;
+    const aggregateContexts = [];
+
+    for (const agg of aggregates) {
+      const rootEntity = agg.rootEntity;
+      const idField = rootEntity.fields.find(f => f.name === 'id');
+      const idType = idField ? idField.javaType : 'String';
+      const exampleId = generateFakeId(idType);
+      const trackUser = rootEntity.audit?.trackUser === true;
+      const valueObjects = agg.valueObjects || [];
+
+      // Command fields: exclude id, audit, readOnly, deletedAt
+      const commandFields = rootEntity.fields.filter(
+        f => !EXCLUDED_FIELDS.has(f.name) && !f.readOnly
+      );
+
+      // Build fake body for create/update
+      const defaultBody = generateFakeBody(commandFields, [], allEnums, valueObjects);
+
+      if (endpoints && endpoints.versions && endpoints.versions.length > 0) {
+        // ── Endpoint-driven ───────────────────────────────────────────────
+        const operations = [];
+        const bodies = {};
+
+        for (const version of endpoints.versions) {
+          for (const op of version.operations) {
+            // Classify operation → which aggregate it belongs to
+            const owner = resolveOwnerAggregate(op.useCase, aggregates);
+            if (owner && owner !== agg.name) continue;
+            // If no aggregate could be resolved, assign to the first aggregate
+            if (!owner && agg !== aggregates[0]) continue;
+
+            const basePath = endpoints.basePath || '/';
+            operations.push({
+              useCase: op.useCase,
+              method: op.method,
+              path: op.path || '/',
+              basePath,
+              version: version.version,
+            });
+
+            // Generate body for write operations
+            if (op.method === 'POST' || op.method === 'PUT' || op.method === 'PATCH') {
+              // Re-seed per operation so bodies vary
+              bodies[op.useCase] = generateFakeBody(commandFields, [], allEnums, valueObjects);
+            }
+          }
+        }
+
+        aggregateContexts.push({
+          name: agg.name,
+          trackUser,
+          idType,
+          exampleId,
+          resourceNameKebab: toKebabCase(agg.name),
+          operations,
+          defaultCrud: false,
+          bodies,
+        });
+      } else {
+        // ── Default CRUD (no endpoints section) ──────────────────────────
+        aggregateContexts.push({
+          name: agg.name,
+          trackUser,
+          idType,
+          exampleId,
+          resourceNameKebab: toKebabCase(agg.name),
+          operations: null,
+          defaultCrud: true,
+          bodies: { default: defaultBody },
+        });
+      }
+    }
+
+    if (aggregateContexts.length > 0) {
+      moduleContexts.push({
+        name: mod.name,
+        aggregates: aggregateContexts,
+      });
+    }
+  }
+
+  if (!moduleContexts.length) return null;
+
+  // ── Render template ─────────────────────────────────────────────────────
+  const templatePath = path.join(TEMPLATES_DIR, 'UnifiedCollection.json.ejs');
+  const collectionId = crypto.randomUUID();
+
+  const context = {
+    systemName,
+    collectionId,
+    port,
+    modules: moduleContexts,
+  };
+
+  const content = await renderTemplate(templatePath, context);
+
+  // ── Write output ────────────────────────────────────────────────────────
+  const outputDir = path.join(projectDir, 'postman');
+  await fs.ensureDir(outputDir);
+
+  const outputFileName = `${toKebabCase(systemName)}-Postman-Collection.json`;
+  const outputPath = path.join(outputDir, outputFileName);
+  await fs.writeFile(outputPath, content, 'utf-8');
+
+  return outputPath;
+}
+
+module.exports = { generateUnifiedPostmanCollection };

package/src/generators/shared-generator.js

@@ -136,7 +136,7 @@ class SharedGenerator {
 
   async generateAnnotations(basePath) {
     const annotationsPath = path.join(basePath, 'domain', 'annotations');
-    const files = ['ApplicationComponent', 'DomainComponent', 'LogAfter', 'LogBefore', 'LogExceptions', 'LogTimer'];
+    const files = ['ApplicationComponent', 'DomainComponent', 'Loggable', 'LogAfter', 'LogBefore', 'LogExceptions', 'LogLevel', 'LogTimer'];
     
     for (const file of files) {
       await this.generateFile(`annotations/${file}.java.ejs`, 
@@ -170,7 +170,7 @@ class SharedGenerator {
 
   async generateErrorMessages(basePath) {
     const errorMessagePath = path.join(basePath, 'domain', 'errorMessage');
-    const files = ['ErrorMessage', 'FullErrorMessage', 'ShortErrorMessage'];
+    const files = ['ErrorResponse'];
     
     for (const file of files) {
       await this.generateFile(`errorMessage/${file}.java.ejs`, 
@@ -194,6 +194,12 @@ class SharedGenerator {
       path.join(handlerExceptionPath, 'HandlerExceptions.java'));
   }
 
+  async generateMockEvent(basePath) {
+    const destPath = path.join(basePath, 'infrastructure', 'mockEvent', 'MockEvent.java');
+    const templatePath = path.join(__dirname, '../../templates/mock/MockEvent.java.ejs');
+    await renderAndWrite(templatePath, destPath, this.context, { overwrite: false });
+  }
+
   async generateConfigurations(basePath) {
     const configurationsPath = path.join(basePath, 'infrastructure', 'configurations');
     
@@ -209,6 +215,10 @@ class SharedGenerator {
     await this.generateFile('configurations/swaggerConfig/SwaggerConfig.java.ejs', 
       path.join(configurationsPath, 'swaggerConfig', 'SwaggerConfig.java'));
     
+    // Event publication schema fix (Spring Modulith varchar(255) → TEXT)
+    await this.generateFile('configurations/eventPublicationConfig/EventPublicationSchemaConfig.java.ejs', 
+      path.join(configurationsPath, 'eventPublicationConfig', 'EventPublicationSchemaConfig.java'));
+
     // UseCase config
     await this.generateFile('configurations/useCaseConfig/UseCaseAutoRegister.java.ejs', 
       path.join(configurationsPath, 'useCaseConfig', 'UseCaseAutoRegister.java'));