@eventcatalog/cli 0.3.1 → 0.3.2

package/dist/cli/index.js

@@ -25,8 +25,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 // src/cli/index.ts
 var import_commander = require("commander");
-var import_node_fs3 = require("fs");
-var import_node_path2 = require("path");
+var import_node_fs4 = require("fs");
+var import_node_path3 = require("path");
 
 // src/cli/executor.ts
 var import_node_fs = require("fs");
@@ -352,11 +352,568 @@ ${vizBlock}` : grouped;
   return lines.join("\n");
 }
 
+// src/cli/import.ts
+var import_node_fs3 = require("fs");
+var import_node_path2 = require("path");
+var import_node_crypto = require("crypto");
+var import_node_readline = require("readline");
+var import_gray_matter = __toESM(require("gray-matter"));
+var import_sdk4 = __toESM(require("@eventcatalog/sdk"));
+var RESOURCE_TYPE_FROM_FOLDER = {
+  events: "event",
+  commands: "command",
+  queries: "query",
+  services: "service",
+  domains: "domain",
+  channels: "channel",
+  flows: "flow",
+  containers: "container",
+  "data-products": "dataProduct",
+  diagrams: "diagram",
+  users: "user",
+  teams: "team"
+};
+async function parseDSL(source, options) {
+  const { createEcServices, compile } = await import("@eventcatalog/language-server");
+  const { EmptyFileSystem, URI } = await import("langium");
+  const services = createEcServices(EmptyFileSystem);
+  const uri = URI.parse(`file:///import-${Date.now()}.ec`);
+  const document = services.shared.workspace.LangiumDocumentFactory.fromString(source, uri);
+  services.shared.workspace.LangiumDocuments.addDocument(document);
+  await services.shared.workspace.DocumentBuilder.build([document]);
+  const parserErrors = document.parseResult.parserErrors;
+  if (parserErrors.length > 0) {
+    const messages = parserErrors.map((e) => `  Line ${e.token?.startLine ?? "?"}: ${e.message}`);
+    throw new Error(`Parse errors:
+${messages.join("\n")}`);
+  }
+  const program2 = document.parseResult.value;
+  const outputs = compile(program2, { nested: options?.nested });
+  try {
+    services.shared.workspace.LangiumDocuments.deleteDocument(uri);
+  } catch {
+  }
+  return outputs;
+}
+function extractResourceTypeFolder(path) {
+  const segments = path.split("/");
+  let lastTypeFolder = segments[0];
+  for (const seg of segments) {
+    if (RESOURCE_TYPE_FROM_FOLDER[seg]) {
+      lastTypeFolder = seg;
+    }
+  }
+  return lastTypeFolder;
+}
+function parseCompiledOutput(output) {
+  const { data: frontmatter, content: markdown } = (0, import_gray_matter.default)(output.content);
+  const typeFolder = extractResourceTypeFolder(output.path);
+  const type = RESOURCE_TYPE_FROM_FOLDER[typeFolder] || typeFolder;
+  return {
+    type,
+    id: frontmatter.id,
+    version: frontmatter.version,
+    frontmatter,
+    markdown: markdown.trim(),
+    path: output.path
+  };
+}
+var MESSAGE_TYPE_FOLDER = {
+  event: "events",
+  command: "commands",
+  query: "queries",
+  channel: "channels"
+};
+var DEFAULT_STUB_VERSION = "0.0.1";
+async function extractMessageStubs(source, compiledIds, nested = false) {
+  const { createEcServices } = await import("@eventcatalog/language-server");
+  const { EmptyFileSystem, URI } = await import("langium");
+  const services = createEcServices(EmptyFileSystem);
+  const uri = URI.parse(`file:///stub-extract-${Date.now()}.ec`);
+  const document = services.shared.workspace.LangiumDocumentFactory.fromString(source, uri);
+  services.shared.workspace.LangiumDocuments.addDocument(document);
+  await services.shared.workspace.DocumentBuilder.build([document]);
+  const program2 = document.parseResult.value;
+  const stubs = [];
+  const stubIds = /* @__PURE__ */ new Set();
+  function processDefinitions(definitions, parentPath = "") {
+    for (const def of definitions) {
+      if (def.$type === "VisualizerDef" && def.body) {
+        processDefinitions(def.body, parentPath);
+        continue;
+      }
+      if (def.$type === "DomainDef") {
+        const domainPath = nested ? `domains/${def.name}` : "";
+        const domainBody = def.body || [];
+        const domainServices = domainBody.filter((d) => d.$type === "ServiceDef");
+        processDefinitions(domainServices, domainPath);
+        const subdomains = domainBody.filter((d) => d.$type === "SubdomainDef");
+        for (const sub of subdomains) {
+          const subPath = nested ? `domains/${def.name}/subdomains/${sub.name}` : "";
+          const subServices = (sub.body || []).filter((d) => d.$type === "ServiceDef");
+          processDefinitions(subServices, subPath);
+        }
+        continue;
+      }
+      if (def.$type !== "ServiceDef") continue;
+      const servicePath = nested ? parentPath ? `${parentPath}/services/${def.name}` : `services/${def.name}` : "";
+      const body = def.body || [];
+      for (const stmt of body) {
+        if (stmt.$type !== "SendsStmt" && stmt.$type !== "ReceivesStmt") continue;
+        const msgType = stmt.messageType;
+        const msgName = stmt.messageName;
+        const hasBody = stmt.body && stmt.body.length > 0;
+        if (hasBody) continue;
+        const key = `${msgType}:${msgName}`;
+        if (compiledIds.has(key) || stubIds.has(key)) continue;
+        const folder = MESSAGE_TYPE_FOLDER[msgType];
+        if (!folder) continue;
+        const version2 = stmt.version || DEFAULT_STUB_VERSION;
+        const stubFolder = nested && servicePath ? `${servicePath}/${folder}` : folder;
+        stubIds.add(key);
+        stubs.push({
+          type: msgType,
+          id: msgName,
+          version: version2,
+          frontmatter: {
+            id: msgName,
+            name: msgName,
+            version: version2
+          },
+          markdown: "",
+          path: `${stubFolder}/${msgName}/versioned/${version2}/index.md`
+        });
+        if (stmt.channelClause) {
+          const channels = stmt.channelClause.channels || [];
+          for (const ch of channels) {
+            const chName = ch.channelName;
+            const chKey = `channel:${chName}`;
+            if (compiledIds.has(chKey) || stubIds.has(chKey)) continue;
+            const chVersion = ch.channelVersion || DEFAULT_STUB_VERSION;
+            const chFolder = nested && parentPath ? `${parentPath}/channels` : "channels";
+            stubIds.add(chKey);
+            stubs.push({
+              type: "channel",
+              id: chName,
+              version: chVersion,
+              frontmatter: {
+                id: chName,
+                name: chName,
+                version: chVersion
+              },
+              markdown: "",
+              path: `${chFolder}/${chName}/versioned/${chVersion}/index.md`
+            });
+          }
+        }
+      }
+    }
+  }
+  processDefinitions(program2.definitions);
+  try {
+    services.shared.workspace.LangiumDocuments.deleteDocument(uri);
+  } catch {
+  }
+  return stubs;
+}
+var SDK_WRITER_BASE = {
+  event: "events",
+  command: "commands",
+  query: "queries",
+  service: "services",
+  domain: "domains",
+  channel: "channels",
+  container: "containers",
+  team: "teams",
+  user: "users"
+};
+function extractSdkPath(compiledPath, resourceType) {
+  const dirPath = compiledPath.replace(/\/versioned\/[^/]+\/index\.md$/, "").replace(/\/index\.md$/, "").replace(/\.md$/, "");
+  const baseFolder = SDK_WRITER_BASE[resourceType];
+  if (!baseFolder) return "";
+  if (dirPath.startsWith(`${baseFolder}/`)) {
+    const relative = dirPath.slice(baseFolder.length + 1);
+    if (!relative.includes("/")) return "";
+    return relative;
+  }
+  return `../${dirPath}`;
+}
+var TYPES_WITH_NODE_GRAPH = /* @__PURE__ */ new Set(["event", "command", "query", "service", "domain", "channel", "flow"]);
+function getWriter(sdk, type) {
+  switch (type) {
+    case "event":
+      return sdk.writeEvent;
+    case "command":
+      return sdk.writeCommand;
+    case "query":
+      return sdk.writeQuery;
+    case "service":
+      return sdk.writeService;
+    case "domain":
+      return sdk.writeDomain;
+    case "channel":
+      return sdk.writeChannel;
+    case "team":
+      return sdk.writeTeam;
+    case "user":
+      return sdk.writeUser;
+    default:
+      return null;
+  }
+}
+function getReader(sdk, type) {
+  switch (type) {
+    case "event":
+      return sdk.getEvent;
+    case "command":
+      return sdk.getCommand;
+    case "query":
+      return sdk.getQuery;
+    case "service":
+      return sdk.getService;
+    case "domain":
+      return sdk.getDomain;
+    case "channel":
+      return sdk.getChannel;
+    case "team":
+      return sdk.getTeam;
+    case "user":
+      return sdk.getUser;
+    default:
+      return null;
+  }
+}
+function promptConfirm(message) {
+  return new Promise((resolve4) => {
+    const rl = (0, import_node_readline.createInterface)({ input: process.stdin, output: process.stdout });
+    rl.question(`${message} `, (answer) => {
+      rl.close();
+      const normalized = answer.trim().toLowerCase();
+      resolve4(normalized === "" || normalized === "y" || normalized === "yes");
+    });
+  });
+}
+function promptInput(message, defaultValue) {
+  return new Promise((resolve4) => {
+    const rl = (0, import_node_readline.createInterface)({ input: process.stdin, output: process.stdout });
+    rl.question(`${message} `, (answer) => {
+      rl.close();
+      resolve4(answer.trim() || defaultValue);
+    });
+  });
+}
+function initCatalog(dir, organizationName = "My Organization") {
+  const catalogDir = (0, import_node_path2.resolve)(dir);
+  (0, import_node_fs3.mkdirSync)(catalogDir, { recursive: true });
+  const packageJson = {
+    name: "my-catalog",
+    version: "0.1.0",
+    private: true,
+    scripts: {
+      dev: "eventcatalog dev",
+      build: "eventcatalog build",
+      start: "eventcatalog start",
+      preview: "eventcatalog preview",
+      generate: "eventcatalog generate",
+      lint: "eventcatalog-linter",
+      test: 'echo "Error: no test specified" && exit 1'
+    },
+    dependencies: {
+      "@eventcatalog/core": "latest",
+      "@eventcatalog/linter": "latest"
+    }
+  };
+  (0, import_node_fs3.writeFileSync)((0, import_node_path2.join)(catalogDir, "package.json"), JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
+  const cId = (0, import_node_crypto.randomUUID)();
+  const config = `/** @type {import('@eventcatalog/core/bin/eventcatalog.config').Config} */
+export default {
+  title: 'EventCatalog',
+  tagline: 'Discover, Explore and Document your Event Driven Architectures',
+  organizationName: '${organizationName}',
+  homepageLink: 'https://eventcatalog.dev/',
+  output: 'static',
+  trailingSlash: false,
+  base: '/',
+  logo: {
+    alt: 'EventCatalog Logo',
+    src: '/logo.png',
+    text: 'EventCatalog',
+  },
+  cId: '${cId}',
+};
+`;
+  (0, import_node_fs3.writeFileSync)((0, import_node_path2.join)(catalogDir, "eventcatalog.config.js"), config, "utf-8");
+  const gitignore = `# Dependencies
+/node_modules
+
+# Production
+/build
+
+# Generated files
+.astro
+out
+dist
+
+# Misc
+.DS_Store
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+.eventcatalog-core
+
+.env
+.env-*
+`;
+  (0, import_node_fs3.writeFileSync)((0, import_node_path2.join)(catalogDir, ".gitignore"), gitignore, "utf-8");
+  const envFile = `# EventCatalog Scale License Key, if you want to unlock the scale features
+# You can get a 14 day trial license key from https://eventcatalog.cloud
+
+EVENTCATALOG_SCALE_LICENSE_KEY=
+
+# Optional key if you are using EventCatalog Chat with OpenAI Models.
+# You need to set \`output\` to \`server\` in your eventcatalog.config.js file.
+# See documentation for more details: https://www.eventcatalog.dev/features/ai-assistant
+OPENAI_API_KEY=
+`;
+  (0, import_node_fs3.writeFileSync)((0, import_node_path2.join)(catalogDir, ".env"), envFile, "utf-8");
+  (0, import_node_fs3.writeFileSync)((0, import_node_path2.join)(catalogDir, ".npmrc"), "strict-peer-dependencies=false\n", "utf-8");
+  (0, import_node_fs3.mkdirSync)((0, import_node_path2.join)(catalogDir, "public"), { recursive: true });
+  (0, import_node_fs3.copyFileSync)((0, import_node_path2.join)(__dirname, "logo.png"), (0, import_node_path2.join)(catalogDir, "public", "logo.png"));
+}
+async function importDSL(options) {
+  const { files, stdin = false, dryRun = false, flat = false, noInit = false, dir } = options;
+  const nested = !flat;
+  let source;
+  if (stdin) {
+    source = await readStdin();
+  } else if (files && files.length > 0) {
+    const parts = [];
+    for (const file of files) {
+      const filepath = (0, import_node_path2.resolve)(file);
+      if (!(0, import_node_fs3.existsSync)(filepath)) {
+        throw new Error(`File not found: ${filepath}`);
+      }
+      parts.push((0, import_node_fs3.readFileSync)(filepath, "utf-8"));
+    }
+    source = parts.join("\n\n");
+  } else {
+    throw new Error("Either provide .ec file paths or use --stdin");
+  }
+  if (!source.trim()) {
+    throw new Error("No DSL content to import");
+  }
+  const catalogDir = (0, import_node_path2.resolve)(dir);
+  let didInit = false;
+  if (!noInit && !(0, import_node_fs3.existsSync)((0, import_node_path2.join)(catalogDir, "eventcatalog.config.js")) && process.stdin.isTTY) {
+    const confirmed = await promptConfirm(`Initialize a new EventCatalog at ${catalogDir}? (Y/n)`);
+    if (confirmed) {
+      const organizationName = await promptInput("Organization name (My Organization):", "My Organization");
+      initCatalog(dir, organizationName);
+      didInit = true;
+    }
+  }
+  const outputs = await parseDSL(source, { nested });
+  if (outputs.length === 0) {
+    throw new Error("No resources found in DSL content");
+  }
+  const sdk = (0, import_sdk4.default)(catalogDir);
+  const result = { created: [], updated: [], versioned: [], errors: [] };
+  const resources = outputs.map(parseCompiledOutput);
+  const compiledIds = new Set(resources.map((r) => `${r.type}:${r.id}`));
+  const stubs = await extractMessageStubs(source, compiledIds, nested);
+  resources.push(...stubs);
+  for (const resource of resources) {
+    const label = resource.version ? `${resource.type} ${resource.id}@${resource.version}` : `${resource.type} ${resource.id}`;
+    if (dryRun) {
+      const reader = getReader(sdk, resource.type);
+      if (reader) {
+        const existing = await reader(resource.id, resource.version).catch(() => void 0);
+        if (existing) {
+          result.updated.push(label);
+        } else {
+          const latest = await reader(resource.id).catch(() => void 0);
+          if (latest && latest.version && latest.version !== resource.version) {
+            result.versioned.push(`${resource.type} ${resource.id}@${latest.version}`);
+          }
+          result.created.push(label);
+        }
+      } else {
+        result.created.push(label);
+      }
+      continue;
+    }
+    const writer = getWriter(sdk, resource.type);
+    if (!writer) {
+      result.errors.push(`${label}: unsupported resource type '${resource.type}'`);
+      continue;
+    }
+    try {
+      const reader = getReader(sdk, resource.type);
+      const existing = reader ? await reader(resource.id, resource.version).catch(() => void 0) : void 0;
+      let markdown = resource.markdown;
+      if (!existing && TYPES_WITH_NODE_GRAPH.has(resource.type)) {
+        markdown = markdown ? `${markdown}
+
+<NodeGraph />` : "<NodeGraph />";
+      }
+      const resourceData = {
+        ...resource.frontmatter,
+        markdown
+      };
+      const writeOptions = {
+        override: true,
+        versionExistingContent: true
+      };
+      if (!existing && nested) {
+        const sdkPath = extractSdkPath(resource.path, resource.type);
+        if (sdkPath) {
+          writeOptions.path = sdkPath;
+        }
+      }
+      await writer(resourceData, writeOptions);
+      if (existing) {
+        result.updated.push(label);
+      } else {
+        result.created.push(label);
+      }
+    } catch (error) {
+      result.errors.push(`${label}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  let output = formatResult(result, dryRun);
+  if (didInit) {
+    output += `  Tip: Run 'npm install' in ${catalogDir} to install dependencies
+`;
+  }
+  return output;
+}
+var c = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  red: "\x1B[31m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m"
+};
+var TYPE_CONFIG = {
+  domain: { color: c.magenta, label: "domain", order: 0 },
+  service: { color: c.blue, label: "service", order: 1 },
+  event: { color: c.green, label: "event", order: 2 },
+  command: { color: c.yellow, label: "command", order: 3 },
+  query: { color: c.cyan, label: "query", order: 4 },
+  channel: { color: c.gray, label: "channel", order: 5 },
+  flow: { color: c.white, label: "flow", order: 6 },
+  user: { color: c.blue, label: "user", order: 7 },
+  team: { color: c.blue, label: "team", order: 8 }
+};
+var DEFAULT_TYPE_CONFIG = { color: c.white, label: "resource", order: 99 };
+function parseLabel(label) {
+  const spaceIdx = label.indexOf(" ");
+  if (spaceIdx === -1) return { type: "", name: label };
+  return { type: label.slice(0, spaceIdx), name: label.slice(spaceIdx + 1) };
+}
+function groupByType(labels) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const label of labels) {
+    const { type, name } = parseLabel(label);
+    if (!groups.has(type)) groups.set(type, []);
+    groups.get(type).push(name);
+  }
+  const sorted = new Map(
+    [...groups.entries()].sort((a, b) => {
+      const orderA = (TYPE_CONFIG[a[0]] || DEFAULT_TYPE_CONFIG).order;
+      const orderB = (TYPE_CONFIG[b[0]] || DEFAULT_TYPE_CONFIG).order;
+      return orderA - orderB;
+    })
+  );
+  for (const [, names] of sorted) {
+    names.sort();
+  }
+  return sorted;
+}
+function typeBadge(type) {
+  const cfg = TYPE_CONFIG[type] || DEFAULT_TYPE_CONFIG;
+  const padded = ` ${cfg.label} `;
+  return `${cfg.color}\x1B[7m${padded}${c.reset}`;
+}
+function formatResourceList(labels) {
+  const lines = [];
+  const groups = groupByType(labels);
+  for (const [type, names] of groups) {
+    const cfg = TYPE_CONFIG[type] || DEFAULT_TYPE_CONFIG;
+    const plural = names.length === 1 ? cfg.label : `${cfg.label}s`;
+    lines.push("");
+    lines.push(`   ${typeBadge(type)} ${c.dim}${names.length} ${plural}${c.reset}`);
+    for (const name of names) {
+      lines.push(`   ${cfg.color}\u2502${c.reset}  ${name}`);
+    }
+  }
+  return lines;
+}
+function formatResult(result, dryRun) {
+  const lines = [""];
+  const prefix = dryRun ? `${c.yellow}${c.bold}DRY RUN${c.reset} ` : "";
+  const total = result.created.length + result.updated.length + result.versioned.length;
+  if (total > 0 || result.errors.length > 0) {
+    lines.push(`  ${prefix}${c.bold}Import complete${c.reset}`);
+    lines.push(`  ${c.dim}${"\u2500".repeat(40)}${c.reset}`);
+  }
+  if (result.created.length > 0) {
+    const verb = dryRun ? "Would create" : "Created";
+    lines.push("");
+    lines.push(`  ${c.green}${c.bold}+ ${verb} ${result.created.length} resource(s)${c.reset}`);
+    lines.push(...formatResourceList(result.created));
+  }
+  if (result.updated.length > 0) {
+    const verb = dryRun ? "Would update" : "Updated";
+    lines.push("");
+    lines.push(`  ${c.blue}${c.bold}~ ${verb} ${result.updated.length} resource(s)${c.reset}`);
+    lines.push(...formatResourceList(result.updated));
+  }
+  if (result.versioned.length > 0) {
+    const verb = dryRun ? "Would version" : "Versioned";
+    lines.push("");
+    lines.push(`  ${c.yellow}${c.bold}\u2191 ${verb} ${result.versioned.length} existing resource(s)${c.reset}`);
+    lines.push(...formatResourceList(result.versioned));
+  }
+  if (result.errors.length > 0) {
+    lines.push("");
+    lines.push(`  ${c.red}${c.bold}\u2718 ${result.errors.length} error(s)${c.reset}`);
+    for (const e of result.errors) {
+      lines.push(`   ${c.red}\u2502${c.reset}  ${c.red}${e}${c.reset}`);
+    }
+  }
+  if (result.created.length === 0 && result.updated.length === 0 && result.errors.length === 0) {
+    lines.push(`  ${c.dim}No resources to write.${c.reset}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function readStdin() {
+  return new Promise((resolve4, reject) => {
+    const chunks = [];
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => resolve4(Buffer.concat(chunks).toString("utf-8")));
+    process.stdin.on("error", reject);
+  });
+}
+
 // src/cli/index.ts
 var version = "1.0.0";
 try {
-  const packageJsonPath = (0, import_node_path2.resolve)(__dirname, "../../package.json");
-  const packageJson = JSON.parse((0, import_node_fs3.readFileSync)(packageJsonPath, "utf-8"));
+  const packageJsonPath = (0, import_node_path3.resolve)(__dirname, "../../package.json");
+  const packageJson = JSON.parse((0, import_node_fs4.readFileSync)(packageJsonPath, "utf-8"));
   version = packageJson.version;
 } catch {
 }
@@ -406,6 +963,24 @@ import_commander.program.command("export").description("Export a catalog resourc
     process.exit(1);
   }
 });
+import_commander.program.command("import [files...]").description("Import EventCatalog DSL (.ec) files into catalog markdown").option("--stdin", "Read DSL from stdin", false).option("--dry-run", "Preview resources without writing", false).option("--flat", "Write resources in flat structure (no nesting under domains/services)", false).option("--no-init", "Skip catalog initialization prompt").action(async (files, opts) => {
+  try {
+    const globalOpts = import_commander.program.opts();
+    const dir = globalOpts.dir || ".";
+    const result = await importDSL({
+      files: files.length > 0 ? files : void 0,
+      stdin: opts.stdin,
+      dryRun: opts.dryRun,
+      flat: opts.flat,
+      noInit: !opts.init,
+      dir
+    });
+    console.log(result);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
 import_commander.program.arguments("<function> [args...]").action(async (functionName, args) => {
   try {
     const options = import_commander.program.opts();