@crossdelta/cloudevents 0.6.2 → 0.6.4

package/bin/cli.js

@@ -0,0 +1,1226 @@
+#!/usr/bin/env node
+import pluralizeLib from 'pluralize';
+import * as fs from 'fs';
+import { existsSync, readdirSync, statSync } from 'fs';
+import * as path from 'path';
+import { join } from 'path';
+import { createFlow, createGenerationResult, input, initGenerationContext, trackChange, printGenerationSummary, change, runFlow } from '@crossdelta/flowcore';
+import 'url';
+import 'glob';
+import 'zod';
+import { StringCodec, connect } from 'nats';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var pluralize, singularize;
+var init_pluralize = __esm({
+  "src/utils/pluralize.ts"() {
+    pluralize = (word) => pluralizeLib.plural(word);
+    singularize = (word) => pluralizeLib.singular(word);
+  }
+});
+
+// src/utils/index.ts
+var init_utils = __esm({
+  "src/utils/index.ts"() {
+    init_pluralize();
+  }
+});
+
+// src/domain/naming.ts
+var toKebabCase, toPascalCase, validateEventType, isValidEventType, deriveEventNames, getContractPaths, getHandlerPath, parseEventTypeFromContract;
+var init_naming = __esm({
+  "src/domain/naming.ts"() {
+    init_utils();
+    toKebabCase = (str) => str.replace(/\./g, "-").toLowerCase();
+    toPascalCase = (str) => str.split(/[-.]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
+    validateEventType = (eventType) => {
+      const errors = [];
+      if (!eventType) {
+        errors.push("Event type is required");
+        return { valid: false, errors };
+      }
+      if (!eventType.includes(".")) {
+        errors.push("Event type must include a namespace separator (e.g., order.created)");
+      }
+      if (eventType !== eventType.toLowerCase()) {
+        errors.push("Event type must be lowercase");
+      }
+      if (eventType.startsWith(".") || eventType.endsWith(".")) {
+        errors.push("Event type must not start or end with a dot");
+      }
+      if (eventType.includes("..")) {
+        errors.push("Event type must not contain consecutive dots");
+      }
+      const validChars = /^[a-z0-9.-]+$/;
+      if (!validChars.test(eventType)) {
+        errors.push("Event type must only contain lowercase letters, numbers, dots, and dashes");
+      }
+      return {
+        valid: errors.length === 0,
+        errors
+      };
+    };
+    isValidEventType = (eventType) => validateEventType(eventType).valid;
+    deriveEventNames = (eventType) => {
+      const parts = eventType.split(".");
+      const namespace = parts[0];
+      const action = parts.slice(1).join("-");
+      const kebab = toKebabCase(eventType);
+      const pascal = toPascalCase(eventType);
+      const pluralNamespace = pluralize(namespace);
+      const pluralPascal = toPascalCase(`${pluralNamespace}.${action}`);
+      return {
+        eventType,
+        kebab,
+        pascal,
+        schemaName: `${pascal}Schema`,
+        typeName: `${pascal}Data`,
+        contractName: `${pluralPascal}Contract`,
+        handlerFile: `${kebab}.handler.ts`,
+        streamName: pluralNamespace.toUpperCase(),
+        domain: pluralNamespace.toLowerCase(),
+        action,
+        namespace
+      };
+    };
+    getContractPaths = (eventType) => {
+      const { domain, action } = deriveEventNames(eventType);
+      return {
+        relativePath: `events/${domain}/${action}.ts`,
+        folder: domain,
+        filename: action
+      };
+    };
+    getHandlerPath = (eventType) => {
+      const { handlerFile } = deriveEventNames(eventType);
+      return `events/${handlerFile}`;
+    };
+    parseEventTypeFromContract = (path2) => {
+      const cleanPath = path2.replace(/^events\//, "");
+      const match = cleanPath.match(/^([^/]+)\/(.+)\.ts$/);
+      if (!match) return null;
+      const [, folder, filename] = match;
+      const namespace = singularize(folder);
+      return `${namespace}.${filename}`;
+    };
+  }
+});
+var createNodeFileSystem, createMemoryFileSystem;
+var init_types = __esm({
+  "src/generators/types.ts"() {
+    createNodeFileSystem = () => {
+      return {
+        readFile: (filePath) => {
+          try {
+            return fs.readFileSync(filePath, "utf-8");
+          } catch {
+            return null;
+          }
+        },
+        writeFile: (filePath, content) => {
+          const dir = path.dirname(filePath);
+          if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+          }
+          fs.writeFileSync(filePath, content, "utf-8");
+        },
+        exists: (filePath) => fs.existsSync(filePath),
+        mkdir: (dirPath) => fs.mkdirSync(dirPath, { recursive: true })
+      };
+    };
+    createMemoryFileSystem = (initialFiles = {}) => {
+      const files = { ...initialFiles };
+      return {
+        files,
+        readFile: (path2) => files[path2] ?? null,
+        writeFile: (path2, content) => {
+          files[path2] = content;
+        },
+        exists: (path2) => path2 in files,
+        mkdir: () => {
+        }
+      };
+    };
+  }
+});
+var fieldTypeToZod, generateSchemaFields, generateContractContent, getContractFilePath, generateContract;
+var init_contract = __esm({
+  "src/generators/contract.ts"() {
+    init_naming();
+    init_types();
+    fieldTypeToZod = (type, optional) => {
+      const baseTypes = {
+        string: "z.string()",
+        number: "z.number()",
+        boolean: "z.boolean()",
+        date: "z.string().datetime()",
+        datetime: "z.string().datetime()",
+        array: "z.array(z.unknown())",
+        object: "z.record(z.unknown())"
+      };
+      const base = baseTypes[type];
+      return optional ? `${base}.optional()` : base;
+    };
+    generateSchemaFields = (fields) => {
+      if (!fields || fields.length === 0) {
+        return `  id: z.string(),
+  createdAt: z.string(),`;
+      }
+      return fields.map((field) => `  ${field.name}: ${fieldTypeToZod(field.type, field.optional)},`).join("\n");
+    };
+    generateContractContent = (options) => {
+      const { eventType, fields } = options;
+      const names = deriveEventNames(eventType);
+      const schemaFields = generateSchemaFields(fields);
+      const schemaBody = schemaFields ? `{
+${schemaFields}
+}` : "{}";
+      return `import { createContract } from '@crossdelta/cloudevents'
+import { z } from 'zod'
+
+export const ${names.schemaName} = z.object(${schemaBody})
+
+export const ${names.contractName} = createContract({
+  type: '${eventType}',
+  channel: { stream: '${names.streamName}' },
+  schema: ${names.schemaName},
+})
+
+export type ${names.typeName} = z.infer<typeof ${names.contractName}.schema>
+`;
+    };
+    getContractFilePath = (eventType, basePath) => {
+      const paths = getContractPaths(eventType);
+      return `${basePath}/${paths.relativePath}`;
+    };
+    generateContract = (options, fs2 = createNodeFileSystem()) => {
+      const filePath = getContractFilePath(options.eventType, options.basePath);
+      const content = generateContractContent(options);
+      const exists = fs2.exists(filePath);
+      if (!exists) {
+        fs2.writeFile(filePath, content);
+        return change.created(filePath);
+      }
+      if (options.force) {
+        fs2.writeFile(filePath, content);
+        return change.updated(filePath);
+      }
+      return change.skipped("File already exists");
+    };
+  }
+});
+
+// src/generators/exports.ts
+var hasExport, addExportToIndex, ensureDomainExport;
+var init_exports = __esm({
+  "src/generators/exports.ts"() {
+    init_types();
+    hasExport = (content, exportPath) => {
+      const patterns = [
+        new RegExp(`^\\s*export \\* from ['"]${exportPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}['"]`, "m"),
+        new RegExp(`^\\s*export \\* from ['"]${exportPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\.ts['"]`, "m")
+      ];
+      return patterns.some((p) => p.test(content));
+    };
+    addExportToIndex = (options, fs2 = createNodeFileSystem()) => {
+      const { indexPath, exportPath, force } = options;
+      if (!fs2.exists(indexPath)) {
+        fs2.writeFile(indexPath, `export * from '${exportPath}'
+`);
+        return { added: true, path: indexPath };
+      }
+      const content = fs2.readFile(indexPath);
+      if (!content) {
+        fs2.writeFile(indexPath, `export * from '${exportPath}'
+`);
+        return { added: true, path: indexPath };
+      }
+      if (!force && hasExport(content, exportPath)) {
+        return { added: false, path: indexPath, alreadyExists: true };
+      }
+      const commentedExport = new RegExp(`//\\s*export \\* from ['"]${exportPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}['"]`);
+      let newContent;
+      if (commentedExport.test(content)) {
+        newContent = content.replace(commentedExport, `export * from '${exportPath}'`);
+      } else {
+        const trimmed = content.trimEnd();
+        newContent = trimmed.length > 0 ? `${trimmed}
+export * from '${exportPath}'
+` : `export * from '${exportPath}'
+`;
+      }
+      fs2.writeFile(indexPath, newContent);
+      return { added: true, path: indexPath };
+    };
+    ensureDomainExport = (options, fs2 = createNodeFileSystem()) => {
+      const results = [];
+      const { contractsBasePath, domain, eventFile } = options;
+      const eventsIndexPath = `${contractsBasePath}/events/index.ts`;
+      const domainExportResult = addExportToIndex(
+        {
+          indexPath: eventsIndexPath,
+          exportPath: `./${domain}`
+        },
+        fs2
+      );
+      results.push(domainExportResult);
+      const domainIndexPath = `${contractsBasePath}/events/${domain}/index.ts`;
+      const eventExportResult = addExportToIndex(
+        {
+          indexPath: domainIndexPath,
+          exportPath: `./${eventFile}`
+        },
+        fs2
+      );
+      results.push(eventExportResult);
+      const mainIndexPath = `${contractsBasePath}/index.ts`;
+      const mainExportResult = addExportToIndex(
+        {
+          indexPath: mainIndexPath,
+          exportPath: "./events"
+        },
+        fs2
+      );
+      results.push(mainExportResult);
+      return results;
+    };
+  }
+});
+var generateEventHandlerContent, getHandlerFilePath, generateEventHandler;
+var init_handler = __esm({
+  "src/generators/handler.ts"() {
+    init_naming();
+    init_types();
+    generateEventHandlerContent = (options) => {
+      const { eventType, contractsPackage = "@crossdelta/contracts" } = options;
+      const names = deriveEventNames(eventType);
+      return `import { handleEvent } from '@crossdelta/cloudevents'
+import { ${names.contractName}, type ${names.typeName} } from '${contractsPackage}'
+
+export default handleEvent(${names.contractName}, async (data: ${names.typeName}) => {
+  // TODO: Implement event handling logic
+  console.log('Received ${eventType}:', data)
+})
+`;
+    };
+    getHandlerFilePath = (eventType, basePath) => {
+      const handlerPath = getHandlerPath(eventType);
+      return `${basePath}/${handlerPath}`;
+    };
+    generateEventHandler = (options, fs2 = createNodeFileSystem()) => {
+      const filePath = getHandlerFilePath(options.eventType, options.basePath);
+      const content = generateEventHandlerContent(options);
+      const exists = fs2.exists(filePath);
+      if (!exists) {
+        fs2.writeFile(filePath, content);
+        return change.created(filePath);
+      }
+      if (options.force) {
+        fs2.writeFile(filePath, content);
+        return change.updated(filePath);
+      }
+      return change.skipped("File already exists");
+    };
+  }
+});
+var fakerInstance, fakerLoadAttempted, tryLoadFaker, getFaker, initFaker, createFieldGenerators, generateByFieldName, generateByFormat, generateByZodType, generateMockValue, generateMockFields, generateMockContent, getMockFilePath, generateMock, generateDefaultMockFields, processMockField, generateJsonMockData, parseSchemaFromSource, getJsonMockPath, jsonMockExists, loadJsonMock, generateJsonMock, generateJsonMockFromContract;
+var init_mock = __esm({
+  "src/generators/mock.ts"() {
+    init_naming();
+    init_types();
+    fakerInstance = null;
+    fakerLoadAttempted = false;
+    tryLoadFaker = async () => {
+      if (fakerLoadAttempted) return fakerInstance;
+      fakerLoadAttempted = true;
+      try {
+        const { faker } = await import('@faker-js/faker');
+        fakerInstance = faker;
+        return faker;
+      } catch {
+        return null;
+      }
+    };
+    getFaker = () => fakerInstance;
+    initFaker = async () => {
+      const faker = await tryLoadFaker();
+      return faker !== null;
+    };
+    createFieldGenerators = () => [
+      { pattern: "email", generate: () => "user@example.com", fakerGenerate: () => getFaker()?.internet.email(), hint: "email" },
+      { pattern: "id", generate: () => crypto.randomUUID(), fakerGenerate: () => getFaker()?.string.uuid(), hint: "uuid" },
+      { pattern: "firstname", generate: () => "John", fakerGenerate: () => getFaker()?.person.firstName(), hint: "firstName" },
+      { pattern: "lastname", generate: () => "Doe", fakerGenerate: () => getFaker()?.person.lastName(), hint: "lastName" },
+      { pattern: "name", generate: () => "John Doe", fakerGenerate: () => getFaker()?.person.fullName(), hint: "fullName" },
+      { pattern: "phone", generate: () => "+1-555-123-4567", fakerGenerate: () => getFaker()?.phone.number(), hint: "phoneNumber" },
+      { pattern: "address", generate: () => "123 Main St", fakerGenerate: () => getFaker()?.location.streetAddress(), hint: "streetAddress" },
+      { pattern: "street", generate: () => "123 Main St", fakerGenerate: () => getFaker()?.location.streetAddress(), hint: "streetAddress" },
+      { pattern: "city", generate: () => "New York", fakerGenerate: () => getFaker()?.location.city(), hint: "city" },
+      { pattern: "country", generate: () => "USA", fakerGenerate: () => getFaker()?.location.country(), hint: "country" },
+      { pattern: "price", generate: () => 99.99, fakerGenerate: () => getFaker()?.number.float({ min: 10, max: 1e3, fractionDigits: 2 }), hint: "price" },
+      { pattern: "amount", generate: () => 99.99, fakerGenerate: () => getFaker()?.number.float({ min: 10, max: 1e3, fractionDigits: 2 }), hint: "price" },
+      { pattern: "total", generate: () => 99.99, fakerGenerate: () => getFaker()?.number.float({ min: 10, max: 1e3, fractionDigits: 2 }), hint: "price" },
+      { pattern: "quantity", generate: () => 1, fakerGenerate: () => getFaker()?.number.int({ min: 1, max: 10 }), hint: "quantity" },
+      { pattern: "date", generate: () => (/* @__PURE__ */ new Date()).toISOString(), fakerGenerate: () => getFaker()?.date.recent().toISOString(), hint: "date" },
+      { pattern: "createdat", generate: () => (/* @__PURE__ */ new Date()).toISOString(), fakerGenerate: () => getFaker()?.date.recent().toISOString(), hint: "date" },
+      { pattern: "updatedat", generate: () => (/* @__PURE__ */ new Date()).toISOString(), fakerGenerate: () => getFaker()?.date.recent().toISOString(), hint: "date" }
+    ];
+    generateByFieldName = (fieldName, useFaker = false) => {
+      const generators = createFieldGenerators();
+      const lowerField = fieldName.toLowerCase();
+      const matched = generators.find((g) => lowerField.includes(g.pattern));
+      if (!matched) return null;
+      const value = (useFaker ? matched.fakerGenerate?.() : void 0) ?? matched.generate();
+      return { value, hint: matched.hint };
+    };
+    generateByFormat = (format, useFaker = false) => {
+      const faker = getFaker();
+      const formatGenerators = {
+        email: {
+          static: () => "user@example.com",
+          faker: faker ? () => faker.internet.email() : void 0
+        },
+        datetime: {
+          static: () => (/* @__PURE__ */ new Date()).toISOString(),
+          faker: faker ? () => faker.date.recent().toISOString() : void 0
+        },
+        url: {
+          static: () => "https://example.com",
+          faker: faker ? () => faker.internet.url() : void 0
+        },
+        uuid: {
+          static: () => crypto.randomUUID(),
+          faker: faker ? () => faker.string.uuid() : void 0
+        },
+        date: {
+          static: () => (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+          faker: faker ? () => faker.date.recent().toISOString().split("T")[0] : void 0
+        },
+        time: {
+          static: () => (/* @__PURE__ */ new Date()).toISOString().split("T")[1]?.split(".")[0],
+          faker: faker ? () => faker.date.recent().toISOString().split("T")[1]?.split(".")[0] : void 0
+        }
+      };
+      const gen = formatGenerators[format];
+      if (!gen) return "example";
+      return useFaker && gen.faker ? gen.faker() : gen.static();
+    };
+    generateByZodType = (zodType, useFaker = false) => {
+      const faker = getFaker();
+      const typeGenerators = {
+        string: {
+          static: () => "example",
+          faker: faker ? () => faker.lorem.word() : void 0
+        },
+        number: {
+          static: () => 42,
+          faker: faker ? () => faker.number.int({ min: 1, max: 100 }) : void 0
+        },
+        boolean: {
+          static: () => true,
+          faker: faker ? () => faker.datatype.boolean() : void 0
+        }
+      };
+      const gen = typeGenerators[zodType];
+      if (!gen) return void 0;
+      return useFaker && gen.faker ? gen.faker() : gen.static();
+    };
+    generateMockValue = (type) => {
+      const mockValues = {
+        string: "'mock-string'",
+        number: "42",
+        boolean: "true",
+        date: "new Date().toISOString()",
+        datetime: "new Date().toISOString()",
+        array: "[]",
+        object: "{}"
+      };
+      return mockValues[type];
+    };
+    generateMockFields = (fields) => {
+      if (!fields || fields.length === 0) {
+        return `  id: 'mock-id',
+  createdAt: new Date().toISOString(),`;
+      }
+      return fields.filter((field) => !field.optional).map((field) => `  ${field.name}: ${generateMockValue(field.type)},`).join("\n");
+    };
+    generateMockContent = (options) => {
+      const { eventType, fields } = options;
+      const names = deriveEventNames(eventType);
+      return `import type { ${names.typeName} } from '../${names.domain}/${names.action}'
+
+export const mock${names.pascal}: ${names.typeName} = {
+${generateMockFields(fields)}
+}
+
+export const create${names.pascal}Mock = (overrides: Partial<${names.typeName}> = {}): ${names.typeName} => ({
+  ...mock${names.pascal},
+  ...overrides,
+})
+`;
+    };
+    getMockFilePath = (eventType, basePath) => {
+      const names = deriveEventNames(eventType);
+      return `${basePath}/${names.kebab}.mock.ts`;
+    };
+    generateMock = (options, fs2 = createNodeFileSystem()) => {
+      const filePath = getMockFilePath(options.eventType, options.basePath);
+      const content = generateMockContent(options);
+      const exists = fs2.exists(filePath);
+      if (!exists) {
+        fs2.writeFile(filePath, content);
+        return change.created(filePath);
+      }
+      if (options.force) {
+        fs2.writeFile(filePath, content);
+        return change.updated(filePath);
+      }
+      return change.skipped("File already exists");
+    };
+    generateDefaultMockFields = (useFaker) => ({
+      data: {
+        id: (useFaker ? getFaker()?.string.uuid() : void 0) ?? crypto.randomUUID(),
+        createdAt: (useFaker ? getFaker()?.date.recent().toISOString() : void 0) ?? (/* @__PURE__ */ new Date()).toISOString()
+      },
+      faker: { id: "uuid", createdAt: "date" }
+    });
+    processMockField = (field, useFaker, data, fakerHints) => {
+      const byName = generateByFieldName(field.name, useFaker);
+      if (byName) {
+        data[field.name] = byName.value;
+        if (byName.hint) fakerHints[field.name] = byName.hint;
+      } else {
+        data[field.name] = generateByZodType(field.type, useFaker) ?? "example";
+      }
+    };
+    generateJsonMockData = (options = {}) => {
+      const { fields, useFaker = false } = options;
+      if (!fields || fields.length === 0) {
+        return generateDefaultMockFields(useFaker);
+      }
+      const data = {};
+      const fakerHints = {};
+      for (const field of fields) {
+        if (!field.optional) processMockField(field, useFaker, data, fakerHints);
+      }
+      return { data, faker: fakerHints };
+    };
+    parseSchemaFromSource = (schemaBody, useFaker = false) => {
+      const data = {};
+      const fakerHints = {};
+      const fieldRegex = /(\w+):\s*z\.(\w+)\(/g;
+      const matches = Array.from(schemaBody.matchAll(fieldRegex));
+      for (const [, fieldName, zodType] of matches) {
+        if (zodType === "array" || zodType === "object") continue;
+        const byName = generateByFieldName(fieldName, useFaker);
+        if (byName) {
+          data[fieldName] = byName.value;
+          if (byName.hint) fakerHints[fieldName] = byName.hint;
+        } else {
+          data[fieldName] = generateByZodType(zodType, useFaker) ?? "example";
+        }
+      }
+      const chainedRegex = /(\w+):\s*z\.string\(\)\.(datetime|email|url|uuid)\(\)/g;
+      const chainedMatches = Array.from(schemaBody.matchAll(chainedRegex));
+      for (const [, fieldName, method] of chainedMatches) {
+        data[fieldName] = generateByFormat(method, useFaker);
+        fakerHints[fieldName] = method === "datetime" ? "date" : method;
+      }
+      return { data, faker: fakerHints };
+    };
+    getJsonMockPath = (eventType, contractsPath) => {
+      const names = deriveEventNames(eventType);
+      return `${contractsPath}/events/${names.domain}/${names.action}.mock.json`;
+    };
+    jsonMockExists = (eventType, contractsPath, fs2 = createNodeFileSystem()) => fs2.exists(getJsonMockPath(eventType, contractsPath));
+    loadJsonMock = (eventType, contractsPath, fs2 = createNodeFileSystem()) => {
+      const mockPath = getJsonMockPath(eventType, contractsPath);
+      const content = fs2.readFile(mockPath);
+      if (!content) return null;
+      try {
+        return JSON.parse(content);
+      } catch {
+        return null;
+      }
+    };
+    generateJsonMock = (options, fs2 = createNodeFileSystem()) => {
+      const { eventType, contractsPath, fields, force, useFaker = false } = options;
+      const mockPath = getJsonMockPath(eventType, contractsPath);
+      const exists = fs2.exists(mockPath);
+      const { data, faker: fakerHints } = generateJsonMockData({ fields, useFaker });
+      const mockData = {
+        eventName: eventType,
+        description: `Mock data for ${eventType} event`,
+        data
+      };
+      if (Object.keys(fakerHints).length > 0) {
+        mockData.faker = fakerHints;
+      }
+      const content = JSON.stringify(mockData, null, 2);
+      if (!exists) {
+        fs2.writeFile(mockPath, content);
+        return change.created(mockPath);
+      }
+      if (force) {
+        fs2.writeFile(mockPath, content);
+        return change.updated(mockPath);
+      }
+      return change.skipped("File already exists");
+    };
+    generateJsonMockFromContract = (eventType, contractsPath, options = {}, fs2 = createNodeFileSystem()) => {
+      const { useFaker = false } = options;
+      const names = deriveEventNames(eventType);
+      const contractPath = `${contractsPath}/events/${names.domain}/${names.action}.ts`;
+      const contractContent = fs2.readFile(contractPath);
+      if (!contractContent) return null;
+      const schemaMatch = contractContent.match(/export const \w+Schema\s*=\s*z\.object\(\s*\{([\s\S]*?)\}\s*\)/m);
+      if (!schemaMatch) return null;
+      const { data, faker: fakerHints } = parseSchemaFromSource(schemaMatch[1], useFaker);
+      const mockPath = getJsonMockPath(eventType, contractsPath);
+      const mockData = {
+        eventName: eventType,
+        description: `Mock data for ${eventType} event`,
+        data
+      };
+      if (Object.keys(fakerHints).length > 0) {
+        mockData.faker = fakerHints;
+      }
+      const content = JSON.stringify(mockData, null, 2);
+      fs2.writeFile(mockPath, content);
+      return change.created(mockPath);
+    };
+  }
+});
+
+// src/generators/index.ts
+var generators_exports = {};
+__export(generators_exports, {
+  addExportToIndex: () => addExportToIndex,
+  createMemoryFileSystem: () => createMemoryFileSystem,
+  createNodeFileSystem: () => createNodeFileSystem,
+  ensureDomainExport: () => ensureDomainExport,
+  generateContract: () => generateContract,
+  generateContractContent: () => generateContractContent,
+  generateEventHandler: () => generateEventHandler,
+  generateEventHandlerContent: () => generateEventHandlerContent,
+  generateJsonMock: () => generateJsonMock,
+  generateJsonMockFromContract: () => generateJsonMockFromContract,
+  generateMock: () => generateMock,
+  generateMockContent: () => generateMockContent,
+  getContractFilePath: () => getContractFilePath,
+  getHandlerFilePath: () => getHandlerFilePath,
+  getJsonMockPath: () => getJsonMockPath,
+  getMockFilePath: () => getMockFilePath,
+  initFaker: () => initFaker,
+  jsonMockExists: () => jsonMockExists,
+  loadJsonMock: () => loadJsonMock
+});
+var init_generators = __esm({
+  "src/generators/index.ts"() {
+    init_contract();
+    init_exports();
+    init_handler();
+    init_mock();
+    init_types();
+  }
+});
+
+// src/domain/contract-helper.ts
+var init_contract_helper = __esm({
+  "src/domain/contract-helper.ts"() {
+  }
+});
+
+// src/infrastructure/errors.ts
+var ValidationError, createValidationError;
+var init_errors = __esm({
+  "src/infrastructure/errors.ts"() {
+    ValidationError = class extends Error {
+      constructor(eventType, details) {
+        super(`Validation failed for event type: ${eventType}`);
+        this.eventType = eventType;
+        this.details = details;
+        this.name = "ValidationError";
+      }
+      type = "ValidationError";
+    };
+    createValidationError = (eventType, details) => new ValidationError(eventType, details);
+  }
+});
+
+// src/infrastructure/logging.ts
+var LOG_PREFIX, createLogger, logger;
+var init_logging = __esm({
+  "src/infrastructure/logging.ts"() {
+    LOG_PREFIX = "cloudevents";
+    createLogger = (enabled) => {
+      const logWithArgs = (consoleFn, message, args) => {
+        const formattedMessage = `[${LOG_PREFIX}] ${message}`;
+        args !== void 0 ? consoleFn(formattedMessage, args) : consoleFn(formattedMessage);
+      };
+      return {
+        log: (message, args) => enabled && logWithArgs(console.log, message, args),
+        info: (message, args) => enabled && logWithArgs(console.info, message, args),
+        warn: (message, error) => enabled && logWithArgs(console.warn, message, error),
+        error: (message, error) => logWithArgs(console.error, message, error),
+        debug: (message, args) => logWithArgs(console.debug, message, args)
+      };
+    };
+    logger = createLogger(true);
+  }
+});
+
+// src/infrastructure/index.ts
+var init_infrastructure = __esm({
+  "src/infrastructure/index.ts"() {
+    init_errors();
+    init_logging();
+  }
+});
+
+// src/domain/validation.ts
+var hasShape, hasTypeField, extractTypeValue, safeExtractType, extractTypeFromSchema;
+var init_validation = __esm({
+  "src/domain/validation.ts"() {
+    hasShape = (schema) => "shape" in schema && schema.shape !== null && schema.shape !== void 0 && typeof schema.shape === "object";
+    hasTypeField = (shape) => "type" in shape && shape.type !== null && shape.type !== void 0 && typeof shape.type === "object" && "value" in shape.type;
+    extractTypeValue = (typeField) => typeof typeField.value === "string" ? typeField.value : void 0;
+    safeExtractType = (schema) => {
+      if (!hasShape(schema)) return void 0;
+      if (!hasTypeField(schema.shape)) return void 0;
+      return extractTypeValue(schema.shape.type);
+    };
+    extractTypeFromSchema = (schema) => {
+      try {
+        return safeExtractType(schema);
+      } catch {
+        return void 0;
+      }
+    };
+  }
+});
+var init_discovery = __esm({
+  "src/domain/discovery.ts"() {
+    init_infrastructure();
+    init_validation();
+  }
+});
+var init_handler_factory = __esm({
+  "src/domain/handler-factory.ts"() {
+  }
+});
+
+// src/domain/index.ts
+var init_domain = __esm({
+  "src/domain/index.ts"() {
+    init_contract_helper();
+    init_discovery();
+    init_handler_factory();
+    init_naming();
+    init_validation();
+  }
+});
+
+// src/publishing/nats.publisher.ts
+var nats_publisher_exports = {};
+__export(nats_publisher_exports, {
+  __resetNatsPublisher: () => __resetNatsPublisher,
+  closeConnection: () => closeConnection,
+  deriveStreamFromType: () => deriveStreamFromType,
+  deriveSubjectFromType: () => deriveSubjectFromType,
+  publish: () => publish,
+  publishNatsEvent: () => publishNatsEvent,
+  publishNatsRawEvent: () => publishNatsRawEvent
+});
+var sc, natsConnectionPromise, deriveSubjectFromEventType, getNatsConnection, closeConnection, __resetNatsPublisher, deriveSubjectFromType, deriveStreamFromType, publishNatsRawEvent, publishNatsEvent, publish;
+var init_nats_publisher = __esm({
+  "src/publishing/nats.publisher.ts"() {
+    init_domain();
+    init_infrastructure();
+    init_utils();
+    sc = StringCodec();
+    natsConnectionPromise = null;
+    deriveSubjectFromEventType = (eventType) => {
+      const parts = eventType.split(".");
+      if (parts.length < 2) return eventType;
+      const domain = parts[0];
+      const action = parts.slice(1).join(".");
+      const pluralDomain = pluralize(domain);
+      return `${pluralDomain}.${action}`;
+    };
+    getNatsConnection = async (servers) => {
+      if (!natsConnectionPromise) {
+        const url = servers ?? process.env.NATS_URL ?? "nats://localhost:4222";
+        natsConnectionPromise = connect({ servers: url }).then((connection) => {
+          logger.debug(`[NATS] connected to ${url}`);
+          return connection;
+        }).catch((error) => {
+          logger.error("[NATS] connection error", error);
+          natsConnectionPromise = null;
+          throw error;
+        });
+      }
+      return natsConnectionPromise;
+    };
+    closeConnection = async () => {
+      if (natsConnectionPromise) {
+        try {
+          const nc = await natsConnectionPromise;
+          if (nc && typeof nc.drain === "function") {
+            await nc.drain();
+            logger.debug("[NATS] connection closed");
+          }
+        } catch {
+        } finally {
+          natsConnectionPromise = null;
+        }
+      }
+    };
+    __resetNatsPublisher = async () => {
+      await closeConnection();
+    };
+    deriveSubjectFromType = (eventType, config) => {
+      if (!config?.typeToSubjectMap) {
+        return config?.defaultSubjectPrefix ? `${config.defaultSubjectPrefix}.${eventType}` : eventType;
+      }
+      const sortedPrefixes = Object.keys(config.typeToSubjectMap).sort((a, b) => b.length - a.length);
+      for (const prefix of sortedPrefixes) {
+        if (eventType.startsWith(prefix)) {
+          const suffix = eventType.slice(prefix.length);
+          const mappedPrefix = config.typeToSubjectMap[prefix];
+          const cleanSuffix = suffix.startsWith(".") ? suffix.slice(1) : suffix;
+          return cleanSuffix ? `${mappedPrefix}.${cleanSuffix}` : mappedPrefix;
+        }
+      }
+      return config.defaultSubjectPrefix ? `${config.defaultSubjectPrefix}.${eventType}` : eventType;
+    };
+    deriveStreamFromType = (eventType, config) => {
+      if (!config?.typeToStreamMap) return void 0;
+      const sortedPrefixes = Object.keys(config.typeToStreamMap).sort((a, b) => b.length - a.length);
+      for (const prefix of sortedPrefixes) {
+        if (eventType.startsWith(prefix)) {
+          return config.typeToStreamMap[prefix];
+        }
+      }
+      return void 0;
+    };
+    publishNatsRawEvent = async (subjectName, eventType, eventData, options) => {
+      const cloudEvent = {
+        specversion: "1.0",
+        type: eventType,
+        source: options?.source || "hono-service",
+        id: crypto.randomUUID(),
+        time: (/* @__PURE__ */ new Date()).toISOString(),
+        datacontenttype: "application/json",
+        data: eventData,
+        ...options?.subject && { subject: options.subject },
+        ...options?.tenantId && { tenantid: options.tenantId }
+      };
+      const data = JSON.stringify(cloudEvent);
+      const nc = await getNatsConnection(options?.servers);
+      nc.publish(subjectName, sc.encode(data));
+      logger.debug(`Published CloudEvent ${eventType} to NATS subject ${subjectName} (id=${cloudEvent.id})`);
+      if (options?.closeAfterPublish) {
+        await closeConnection();
+      }
+      return cloudEvent.id;
+    };
+    publishNatsEvent = async (subjectName, schema, eventData, options) => {
+      const eventType = extractTypeFromSchema(schema);
+      if (!eventType) {
+        throw new Error("Could not extract event type from schema. Make sure your schema has proper metadata.");
+      }
+      const validationResult = schema.safeParse(eventData);
+      if (!validationResult.success) {
+        const validationDetails = validationResult.error.issues.map((issue) => ({
+          code: issue.code,
+          message: issue.message,
+          path: issue.path.filter((p) => typeof p !== "symbol"),
+          expected: "expected" in issue ? String(issue.expected) : void 0,
+          received: "received" in issue ? String(issue.received) : void 0
+        }));
+        const handlerValidationError = {
+          handlerName: `NatsPublisher:${eventType}`,
+          validationErrors: validationDetails
+        };
+        throw createValidationError(eventType, [handlerValidationError]);
+      }
+      return publishNatsRawEvent(subjectName, eventType, validationResult.data, options);
+    };
+    publish = async (eventTypeOrContract, eventData, options) => {
+      const eventType = typeof eventTypeOrContract === "string" ? eventTypeOrContract : eventTypeOrContract.type;
+      const natsSubject = typeof eventTypeOrContract === "string" ? deriveSubjectFromEventType(eventTypeOrContract) : eventTypeOrContract.channel?.subject ?? eventTypeOrContract.type;
+      return publishNatsRawEvent(natsSubject, eventType, eventData, options);
+    };
+  }
+});
+
+// src/flows/create-event.flow.ts
+init_naming();
+
+// src/effects/types.ts
+var streamWired = (stream, servicePath) => ({
+  kind: "stream.wired",
+  stream,
+  servicePath
+});
+var contractCreated = (path2, eventType) => ({
+  kind: "contract.created",
+  path: path2,
+  eventType
+});
+var handlerCreated = (path2, eventType, servicePath) => ({
+  kind: "handler.created",
+  path: path2,
+  eventType,
+  servicePath
+});
+
+// src/flows/create-event.flow.ts
+init_generators();
+var parseField = (field) => {
+  const [nameWithOptional, type = "string"] = field.split(":").map((s) => s.trim());
+  const optional = nameWithOptional.endsWith("?");
+  const name = optional ? nameWithOptional.slice(0, -1) : nameWithOptional;
+  return { name, type, optional };
+};
+var parseFieldsInput = (input2) => input2.trim() === "" ? [] : input2.split(",").map((f) => f.trim()).filter(Boolean).map(parseField);
+var generateContractTask = (ctx) => {
+  const generation = initGenerationContext(ctx);
+  const result = generateContract(
+    {
+      eventType: ctx.eventType,
+      basePath: ctx.config.contractsPath,
+      fields: ctx.fields ?? [],
+      force: ctx.force ?? false
+    },
+    ctx._fs
+  );
+  trackChange(result).record(generation.artifacts, "Contract").onCreated((path2) => {
+    generation.addEffect(contractCreated(path2, ctx.eventType));
+  });
+};
+var addExportsTask = (ctx) => {
+  const names = deriveEventNames(ctx.eventType);
+  ensureDomainExport(
+    {
+      contractsBasePath: ctx.config.contractsPath,
+      domain: names.domain,
+      eventFile: names.action
+    },
+    ctx._fs
+  );
+};
+var generateMockTask = (ctx) => {
+  const generation = initGenerationContext(ctx);
+  const result = generateJsonMock(
+    {
+      eventType: ctx.eventType,
+      contractsPath: ctx.config.contractsPath,
+      fields: ctx.fields ?? [],
+      force: ctx.force ?? false
+    },
+    ctx._fs
+  );
+  trackChange(result).record(generation.artifacts, "Mock");
+};
+var generateHandlerTask = (ctx) => {
+  if (!ctx.servicePath) return;
+  const generation = initGenerationContext(ctx);
+  const names = deriveEventNames(ctx.eventType);
+  const handlerBasePath = ctx.servicePath.endsWith("/src") ? ctx.servicePath : `${ctx.servicePath}/src`;
+  const result = generateEventHandler(
+    {
+      eventType: ctx.eventType,
+      basePath: handlerBasePath,
+      contractsPackage: ctx.config.contractsPackage ?? "",
+      force: ctx.force ?? false
+    },
+    ctx._fs
+  );
+  trackChange(result).record(generation.artifacts, "Handler").onCreated((path2) => {
+    if (ctx.servicePath) {
+      generation.addEffect(handlerCreated(path2, ctx.eventType, ctx.servicePath));
+      generation.addEffect(streamWired(names.streamName, ctx.servicePath));
+    }
+  });
+};
+var flow = createFlow();
+var isInvalidEventType = (ctx) => !isValidEventType(ctx.eventType);
+var getEventTypeErrorMessage = (ctx) => `Invalid event type: ${validateEventType(ctx.eventType).errors.join(", ")}`;
+var ensureInfraStep = flow.ensure("_fs", (ctx) => ctx.config.fs ?? createNodeFileSystem()).build();
+var ensureGenerationStep = flow.ensure("_generation", () => createGenerationResult()).build();
+var eventTypeStep = flow.input("eventType").prompt({
+  title: "Event Type",
+  message: "Enter event type (e.g., order.created):"
+}).validateBy(validateEventType).skipIfSet().build();
+var validateEventTypeStep = flow.abortIf(isInvalidEventType, getEventTypeErrorMessage).build();
+var schemaFieldsStep = input("fieldsInput").prompt({
+  title: "Schema Fields",
+  message: "Schema fields (e.g., orderId:string,total:number) or leave empty:"
+}).mapTo("fields", parseFieldsInput).skipWhen((ctx) => ctx.fields !== void 0).build();
+var serviceSelectionStep = flow.select("servicePath").title("Service Selection").prompt("Select service to create handler in:").choicesFrom((ctx) => (ctx.availableServices ?? []).map((s) => ({ name: s, value: s }))).optional("Skip handler creation").skipIfSet().build();
+var generateFilesStep = flow.task("Generate files").steps([generateContractTask, addExportsTask, generateMockTask, generateHandlerTask]).produces("fields", "_generation").build();
+var printSummary = (ctx) => {
+  printGenerationSummary(initGenerationContext(ctx));
+};
+var printSummaryStep = flow.task("Print summary").steps([printSummary]).build();
+var createEventFlowSteps = [
+  ensureInfraStep,
+  ensureGenerationStep,
+  eventTypeStep,
+  validateEventTypeStep,
+  schemaFieldsStep,
+  serviceSelectionStep,
+  generateFilesStep,
+  printSummaryStep
+];
+
+// src/flows/list-events.flow.ts
+init_naming();
+var isContractFile = (filename) => filename.endsWith(".ts") && !filename.endsWith(".test.ts") && filename !== "index.ts";
+var makeRelativePath = (contractsPath, fullPath) => fullPath.replace(`${contractsPath}/`, "").replace(/\\/g, "/");
+var safeReadDir = (dir) => {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+};
+var safeStat = (path2) => {
+  try {
+    const stat = statSync(path2);
+    return { isDirectory: stat.isDirectory() };
+  } catch {
+    return null;
+  }
+};
+var processEntry = (dir, entry, contractsPath) => {
+  const fullPath = join(dir, entry);
+  const stat = safeStat(fullPath);
+  if (!stat) return [];
+  if (stat.isDirectory) {
+    return findContractFiles(fullPath, contractsPath);
+  }
+  if (isContractFile(entry)) {
+    return [makeRelativePath(contractsPath, fullPath)];
+  }
+  return [];
+};
+var findContractFiles = (dir, contractsPath) => safeReadDir(dir).flatMap((entry) => processEntry(dir, entry, contractsPath));
+var parseEventType = (filePath) => parseEventTypeFromContract(filePath);
+var matchesPattern = (pattern) => (eventType) => !pattern || pattern.trim() === "" || eventType.includes(pattern);
+var discoverEventTypes = (contractsPath, pattern) => {
+  const eventsDir = join(contractsPath, "events");
+  if (!existsSync(eventsDir)) {
+    return [];
+  }
+  return findContractFiles(eventsDir, contractsPath).map(parseEventType).filter((eventType) => eventType !== null).filter(matchesPattern(pattern)).sort();
+};
+var flow2 = createFlow();
+var listEventsFlowSteps = [
+  flow2.input("pattern").prompt({
+    title: "Filter Pattern",
+    message: "Filter by pattern (leave empty for all):"
+  }).skipWhen((ctx) => ctx.pattern != null).build(),
+  flow2.task("Discover events").steps([
+    (ctx) => {
+      const filterPattern = ctx.pattern && ctx.pattern.trim() !== "" ? ctx.pattern : void 0;
+      ctx.eventTypes = discoverEventTypes(ctx.config.contractsPath, filterPattern);
+    }
+  ]).produces("eventTypes").build()
+];
+
+// src/flows/publish-event.flow.ts
+init_naming();
+init_generators();
+var parseDataInput = (input2) => {
+  if (!input2.trim()) return {};
+  try {
+    return JSON.parse(input2);
+  } catch {
+    return null;
+  }
+};
+var loadDataFromInput = async (ctx) => {
+  if (ctx.dataInput !== void 0 && ctx.dataInput.trim() !== "") {
+    const parsed = parseDataInput(ctx.dataInput);
+    if (parsed === null) {
+      throw new Error("Invalid JSON data");
+    }
+    ctx.data = parsed;
+    return;
+  }
+  const { loadJsonMock: loadJsonMock2 } = await Promise.resolve().then(() => (init_generators(), generators_exports));
+  const mock = loadJsonMock2(ctx.eventType, ctx.config.contractsPath);
+  if (mock?.data) {
+    ctx.data = mock.data;
+    ctx.usedMock = true;
+    return;
+  }
+  ctx.data = {};
+};
+var publishToNats = async (ctx) => {
+  const { publish: publish2 } = await Promise.resolve().then(() => (init_nats_publisher(), nats_publisher_exports));
+  await publish2(ctx.eventType, ctx.data ?? {}, {
+    source: "pf-cli",
+    closeAfterPublish: true
+  });
+  ctx.published = true;
+  const mockHint = ctx.usedMock ? " (using mock data)" : "";
+  console.log(`\u2705 Published ${ctx.eventType}${mockHint}`);
+};
+var hasExplicitData = (ctx) => ctx.data !== void 0 || jsonMockExists(ctx.eventType, ctx.config.contractsPath);
+var isInvalidEventType2 = (ctx) => !isValidEventType(ctx.eventType);
+var getEventTypeErrorMessage2 = (ctx) => `Invalid event type: ${validateEventType(ctx.eventType).errors.join(", ")}`;
+var flow3 = createFlow();
+var publishEventFlowSteps = [
+  flow3.input("eventType").prompt({
+    title: "Event Type",
+    message: "Event type to publish (e.g., order.created):"
+  }).validateBy(validateEventType).skipIfSet().build(),
+  flow3.abortIf(isInvalidEventType2, getEventTypeErrorMessage2).build(),
+  flow3.input("dataInput").prompt({
+    title: "Event Data",
+    message: "Event data as JSON (or leave empty for mock data):"
+  }).skipWhen(hasExplicitData).build(),
+  flow3.task("Publish event").steps([
+    loadDataFromInput,
+    publishToNats
+  ]).produces("data", "published", "usedMock").build()
+];
+
+// src/api.ts
+var createEvent = async (eventType, options = {}) => {
+  const { fields, service, contractsPath, mocksPath, force } = options;
+  const result = await runFlow(createEventFlowSteps, {
+    initialContext: {
+      eventType,
+      fields: typeof fields === "string" ? parseFieldsInput(fields) : fields,
+      servicePath: service,
+      availableServices: [],
+      // No services in simple API
+      force,
+      config: {
+        contractsPath: contractsPath ?? "packages/contracts/src",
+        mocksPath
+      }
+    },
+    inputs: {},
+    // Non-interactive mode
+    exitOnError: true
+  });
+  if (!result.success) {
+    throw new Error(result.abortReason ?? "Failed to create event");
+  }
+  return {
+    created: result.context._generation?.created ?? [],
+    skipped: result.context._generation?.skipped ?? [],
+    effects: result.context._generation?.effects ?? []
+  };
+};
+var listEvents = async (options = {}) => {
+  const { pattern, contractsPath } = options;
+  const result = await runFlow(listEventsFlowSteps, {
+    initialContext: {
+      pattern: pattern ?? "",
+      config: {
+        contractsPath: contractsPath ?? "packages/contracts/src"
+      }
+    },
+    exitOnError: true
+  });
+  if (!result.success) {
+    throw new Error(result.abortReason ?? "Failed to list events");
+  }
+  return result.context.eventTypes ?? [];
+};
+var publishEvent = async (eventType, data, options = {}) => {
+  const { natsUrl, contractsPath } = options;
+  const result = await runFlow(publishEventFlowSteps, {
+    initialContext: {
+      eventType,
+      data,
+      config: {
+        contractsPath: contractsPath ?? "packages/contracts/src",
+        natsUrl: natsUrl ?? "nats://localhost:4222"
+      },
+      published: false
+    },
+    exitOnError: true
+  });
+  if (!result.success) {
+    throw new Error(result.abortReason ?? "Failed to publish event");
+  }
+  return { success: true };
+};
+
+// src/cli.ts
+var showUsage = () => {
+  console.log("Usage: cloudevents <command> [options]\n");
+  console.log("Commands:");
+  console.log("  list                    List all event types");
+  console.log("  create <type>           Create event contract with Zod schema");
+  console.log("  publish <type> <data>   Publish event (data as JSON string)");
+};
+var handleList = async () => {
+  const events = await listEvents();
+  console.log("\u{1F4CB} Available event types:\n");
+  events.forEach((event) => {
+    console.log(`  \u2022 ${event}`);
+  });
+};
+var handleCreate = async ([type]) => {
+  if (!type) {
+    console.error("\u274C Error: Event type required");
+    console.log("Usage: cloudevents create <type>");
+    process.exit(1);
+  }
+  await createEvent(type);
+  console.log(`\u2705 Created event contract: ${type}`);
+};
+var handlePublish = async ([type, dataJson]) => {
+  if (!type || !dataJson) {
+    console.error("\u274C Error: Type and data required");
+    console.log("Usage: cloudevents publish <type> <data>");
+    console.log(`Example: cloudevents publish order.created '{"orderId":"123"}'`);
+    process.exit(1);
+  }
+  const data = JSON.parse(dataJson);
+  await publishEvent(type, data);
+  console.log(`\u2705 Published event: ${type}`);
+};
+var commands = {
+  list: handleList,
+  create: handleCreate,
+  publish: handlePublish
+};
+var runCommand = async (command, args) => {
+  const handler = commands[command];
+  if (!handler) {
+    console.error(`\u274C Unknown command: ${command}`);
+    process.exit(1);
+  }
+  await handler(args);
+};
+var handleError = (error) => {
+  console.error("\u274C Error:", error.message);
+  process.exit(1);
+};
+var main = async () => {
+  const [, , command, ...args] = process.argv;
+  if (!command) {
+    showUsage();
+    process.exit(1);
+  }
+  await runCommand(command, args).catch(handleError);
+};
+main();