@eventcatalog/cli 0.3.2 → 0.3.4

package/dist/cli/index.mjs

@@ -124,6 +124,7 @@ import { resolve } from "path";
 import open from "open";
 import createSDK3 from "@eventcatalog/sdk";
 var RESOURCE_TYPES = ["event", "command", "query", "service", "domain"];
+var SUPPORTED_RESOURCE_TYPES = RESOURCE_TYPES.join(", ");
 var PLURAL_MAP = {
   events: "event",
   commands: "command",
@@ -131,11 +132,40 @@ var PLURAL_MAP = {
   services: "service",
   domains: "domain"
 };
+var KNOWN_UNSUPPORTED_EXPORT_TYPES = /* @__PURE__ */ new Set([
+  "channel",
+  "channels",
+  "team",
+  "teams",
+  "user",
+  "users",
+  "container",
+  "containers",
+  "data-product",
+  "data-products",
+  "dataproduct",
+  "dataproducts",
+  "diagram",
+  "diagrams",
+  "flow",
+  "flows"
+]);
 function normalizeResourceType(resource) {
   const lower = resource.toLowerCase();
   if (PLURAL_MAP[lower]) return PLURAL_MAP[lower];
   return lower;
 }
+function assertSupportedExportType(resource, type) {
+  const lower = resource.toLowerCase();
+  if (KNOWN_UNSUPPORTED_EXPORT_TYPES.has(lower)) {
+    throw new Error(
+      `Resource type '${resource}' is not yet supported for DSL export. Supported types: ${SUPPORTED_RESOURCE_TYPES}`
+    );
+  }
+  if (!RESOURCE_TYPES.includes(type)) {
+    throw new Error(`Invalid resource type '${resource}'. Must be one of: ${SUPPORTED_RESOURCE_TYPES}`);
+  }
+}
 function getResourceFetcher(sdk, type) {
   switch (type) {
     case "event":
@@ -226,14 +256,14 @@ ${entries.join("\n")}
 async function exportCatalog(options) {
   const { hydrate = false, stdout = false, playground = false, output, dir } = options;
   const sdk = createSDK3(dir);
-  const dslParts = [];
-  for (const type of RESOURCE_TYPES) {
-    const fetcher = getCollectionFetcher(sdk, type);
-    const resources = await fetcher({ latestOnly: true });
-    if (!resources || resources.length === 0) continue;
-    const rawDsl = await sdk.toDSL(resources, { type, hydrate });
-    dslParts.push(rawDsl);
-  }
+  const dslParts = (await Promise.all(
+    RESOURCE_TYPES.map(async (type) => {
+      const fetcher = getCollectionFetcher(sdk, type);
+      const resources = await fetcher({ latestOnly: true });
+      if (!resources || resources.length === 0) return "";
+      return sdk.toDSL(resources, { type, hydrate });
+    })
+  )).filter((dsl2) => Boolean(dsl2));
   if (dslParts.length === 0) {
     throw new Error(`No resources found in catalog at '${dir}'`);
   }
@@ -253,9 +283,9 @@ ${vizBlock}` : grouped;
     const encoded = Buffer.from(dsl).toString("base64");
     const playgroundUrl = `https://playground.eventcatalog.dev/?code=${encoded}`;
     await open(playgroundUrl);
-    lines.push("", `  Opening in playground...`);
+    lines.push("", `  Opening in EventCatalog Modelling...`);
   } else {
-    lines.push("", `  Tip: Use --playground to open in the playground`);
+    lines.push("", `  Tip: Use --playground to open in EventCatalog Modelling`);
   }
   lines.push("");
   return lines.join("\n");
@@ -263,9 +293,7 @@ ${vizBlock}` : grouped;
 async function exportAll(options) {
   const { resource, hydrate = false, stdout = false, playground = false, output, dir } = options;
   const type = normalizeResourceType(resource);
-  if (!RESOURCE_TYPES.includes(type)) {
-    throw new Error(`Invalid resource type '${resource}'. Must be one of: ${RESOURCE_TYPES.join(", ")}`);
-  }
+  assertSupportedExportType(resource, type);
   const plural = pluralize(type);
   const sdk = createSDK3(dir);
   const fetcher = getCollectionFetcher(sdk, type);
@@ -289,9 +317,9 @@ ${vizBlock}` : grouped;
     const encoded = Buffer.from(dsl).toString("base64");
     const playgroundUrl = `https://playground.eventcatalog.dev/?code=${encoded}`;
     await open(playgroundUrl);
-    lines.push("", `  Opening in playground...`);
+    lines.push("", `  Opening in EventCatalog Modelling...`);
   } else {
-    lines.push("", `  Tip: Use --playground to open in the playground`);
+    lines.push("", `  Tip: Use --playground to open in EventCatalog Modelling`);
   }
   lines.push("");
   return lines.join("\n");
@@ -302,9 +330,7 @@ async function exportResource(options) {
     return exportAll(options);
   }
   const type = normalizeResourceType(resource);
-  if (!RESOURCE_TYPES.includes(type)) {
-    throw new Error(`Invalid resource type '${resource}'. Must be one of: ${RESOURCE_TYPES.join(", ")}`);
-  }
+  assertSupportedExportType(resource, type);
   const sdk = createSDK3(dir);
   const fetcher = getResourceFetcher(sdk, type);
   const data = await fetcher(id, version2);
@@ -328,9 +354,9 @@ ${vizBlock}` : grouped;
     const encoded = Buffer.from(dsl).toString("base64");
     const playgroundUrl = `https://playground.eventcatalog.dev/?code=${encoded}`;
     await open(playgroundUrl);
-    lines.push("", `  Opening in playground...`);
+    lines.push("", `  Opening in EventCatalog Modelling...`);
   } else {
-    lines.push("", `  Tip: Use --playground to open in the playground`);
+    lines.push("", `  Tip: Use --playground to open in EventCatalog Modelling`);
   }
   lines.push("");
   return lines.join("\n");
@@ -343,6 +369,20 @@ import { randomUUID } from "crypto";
 import { createInterface } from "readline";
 import matter from "gray-matter";
 import createSDK4 from "@eventcatalog/sdk";
+function normalizeImportedFrontmatter(type, frontmatter) {
+  const normalized = { ...frontmatter };
+  if (type === "container") {
+    if (normalized.container_type === void 0 && normalized.containerType !== void 0) {
+      normalized.container_type = normalized.containerType;
+      delete normalized.containerType;
+    }
+    if (normalized.access_mode === void 0 && normalized.accessMode !== void 0) {
+      normalized.access_mode = normalized.accessMode;
+      delete normalized.accessMode;
+    }
+  }
+  return normalized;
+}
 var RESOURCE_TYPE_FROM_FOLDER = {
   events: "event",
   commands: "command",
@@ -377,7 +417,7 @@ ${messages.join("\n")}`);
     services.shared.workspace.LangiumDocuments.deleteDocument(uri);
   } catch {
   }
-  return outputs;
+  return { outputs, program: program2 };
 }
 function extractResourceTypeFolder(path2) {
   const segments = path2.split("/");
@@ -409,15 +449,17 @@ var MESSAGE_TYPE_FOLDER = {
   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;
+var NO_VERSION_KEY = "__no_version__";
+function getResourceNameKey(type, id) {
+  return `${type}:${id}`;
+}
+function getResourceVersionKey(type, id, version2) {
+  return `${type}:${id}@${version2 || NO_VERSION_KEY}`;
+}
+function hasReferenceStatements(source) {
+  return /\b(?:sends|receives|writes-to|reads-from)\b/.test(source);
+}
+async function extractMessageStubs(program2, compiledIds, nested = false) {
   const stubs = [];
   const stubIds = /* @__PURE__ */ new Set();
   function processDefinitions(definitions, parentPath = "") {
@@ -443,63 +485,143 @@ async function extractMessageStubs(source, compiledIds, nested = false) {
       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: {
+        if (stmt.$type === "SendsStmt" || stmt.$type === "ReceivesStmt") {
+          const msgType = stmt.messageType;
+          const msgName = stmt.messageName;
+          const hasBody = stmt.body && stmt.body.length > 0;
+          const version2 = stmt.version || DEFAULT_STUB_VERSION;
+          if (!hasBody) {
+            const folder = MESSAGE_TYPE_FOLDER[msgType];
+            if (folder) {
+              const key = getResourceVersionKey(msgType, msgName, version2);
+              const anyVersionKey = getResourceNameKey(msgType, msgName);
+              if (!compiledIds.has(key) && !stubIds.has(key) && !(!stmt.version && compiledIds.has(anyVersionKey))) {
+                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 chVersion = ch.channelVersion || DEFAULT_STUB_VERSION;
+              const chKey = getResourceVersionKey("channel", chName, chVersion);
+              const chAnyVersionKey = getResourceNameKey("channel", chName);
+              if (compiledIds.has(chKey) || stubIds.has(chKey)) continue;
+              if (!ch.channelVersion && compiledIds.has(chAnyVersionKey)) continue;
+              const chFolder = nested && parentPath ? `${parentPath}/channels` : "channels";
+              stubIds.add(chKey);
+              stubs.push({
+                type: "channel",
                 id: chName,
-                name: chName,
-                version: chVersion
-              },
-              markdown: "",
-              path: `${chFolder}/${chName}/versioned/${chVersion}/index.md`
-            });
+                version: chVersion,
+                frontmatter: {
+                  id: chName,
+                  name: chName,
+                  version: chVersion
+                },
+                markdown: "",
+                path: `${chFolder}/${chName}/versioned/${chVersion}/index.md`
+              });
+            }
           }
+          continue;
+        }
+        if (stmt.$type === "WritesToStmt" || stmt.$type === "ReadsFromStmt") {
+          const containerName = stmt.ref?.name;
+          if (!containerName) continue;
+          const containerVersion = stmt.ref?.version || DEFAULT_STUB_VERSION;
+          const containerKey = getResourceVersionKey("container", containerName, containerVersion);
+          const containerAnyVersionKey = getResourceNameKey("container", containerName);
+          if (compiledIds.has(containerKey) || stubIds.has(containerKey)) continue;
+          if (!stmt.ref?.version && compiledIds.has(containerAnyVersionKey)) continue;
+          const containerFolder = nested && parentPath ? `${parentPath}/containers` : "containers";
+          stubIds.add(containerKey);
+          stubs.push({
+            type: "container",
+            id: containerName,
+            version: containerVersion,
+            frontmatter: {
+              id: containerName,
+              name: containerName,
+              version: containerVersion
+            },
+            markdown: "",
+            path: `${containerFolder}/${containerName}/versioned/${containerVersion}/index.md`
+          });
         }
       }
     }
   }
   processDefinitions(program2.definitions);
-  try {
-    services.shared.workspace.LangiumDocuments.deleteDocument(uri);
-  } catch {
-  }
   return stubs;
 }
+function getVersionFromBody(body) {
+  if (!body) return void 0;
+  const versionStmt = body.find((stmt) => stmt?.$type === "VersionStmt");
+  return versionStmt?.value;
+}
+function buildServiceOutputPath(serviceName, body, nested, parentPath) {
+  const folder = nested && parentPath ? `${parentPath}/services` : "services";
+  const version2 = getVersionFromBody(body);
+  if (version2) return `${folder}/${serviceName}/versioned/${version2}/index.md`;
+  return `${folder}/${serviceName}/index.md`;
+}
+function extractServiceContainerRefs(program2, nested = false) {
+  const refsByPath = /* @__PURE__ */ new Map();
+  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 body = def.body || [];
+      const writesTo = body.filter((stmt) => stmt.$type === "WritesToStmt" && stmt.ref?.name).map((stmt) => ({
+        id: stmt.ref.name,
+        ...stmt.ref.version ? { version: stmt.ref.version } : {}
+      }));
+      const readsFrom = body.filter((stmt) => stmt.$type === "ReadsFromStmt" && stmt.ref?.name).map((stmt) => ({
+        id: stmt.ref.name,
+        ...stmt.ref.version ? { version: stmt.ref.version } : {}
+      }));
+      if (writesTo.length === 0 && readsFrom.length === 0) continue;
+      const path2 = buildServiceOutputPath(def.name, body, nested, parentPath);
+      refsByPath.set(path2, {
+        ...writesTo.length > 0 ? { writesTo } : {},
+        ...readsFrom.length > 0 ? { readsFrom } : {}
+      });
+    }
+  }
+  processDefinitions(program2.definitions || []);
+  return refsByPath;
+}
 var SDK_WRITER_BASE = {
   event: "events",
   command: "commands",
@@ -508,6 +630,8 @@ var SDK_WRITER_BASE = {
   domain: "domains",
   channel: "channels",
   container: "containers",
+  dataProduct: "data-products",
+  diagram: "diagrams",
   team: "teams",
   user: "users"
 };
@@ -537,6 +661,12 @@ function getWriter(sdk, type) {
       return sdk.writeDomain;
     case "channel":
       return sdk.writeChannel;
+    case "container":
+      return sdk.writeDataStore;
+    case "dataProduct":
+      return sdk.writeDataProduct;
+    case "diagram":
+      return sdk.writeDiagram;
     case "team":
       return sdk.writeTeam;
     case "user":
@@ -559,6 +689,12 @@ function getReader(sdk, type) {
       return sdk.getDomain;
     case "channel":
       return sdk.getChannel;
+    case "container":
+      return sdk.getDataStore;
+    case "dataProduct":
+      return sdk.getDataProduct;
+    case "diagram":
+      return sdk.getDiagram;
     case "team":
       return sdk.getTeam;
     case "user":
@@ -702,26 +838,57 @@ async function importDSL(options) {
       didInit = true;
     }
   }
-  const outputs = await parseDSL(source, { nested });
+  const parsed = await parseDSL(source, { nested });
+  const outputs = parsed.outputs;
   if (outputs.length === 0) {
     throw new Error("No resources found in DSL content");
   }
   const sdk = createSDK4(catalogDir);
   const result = { created: [], updated: [], versioned: [], errors: [] };
+  const readerCache = /* @__PURE__ */ new Map();
+  const readResourceCached = async (reader, type, id, version2) => {
+    if (!reader) return void 0;
+    const cacheKey = getResourceVersionKey(type, id, version2);
+    if (!readerCache.has(cacheKey)) {
+      readerCache.set(
+        cacheKey,
+        reader(id, version2).catch(() => void 0)
+      );
+    }
+    return await readerCache.get(cacheKey);
+  };
+  const invalidateReaderCache = (type, id, version2) => {
+    readerCache.delete(getResourceVersionKey(type, id));
+    readerCache.delete(getResourceVersionKey(type, id, version2));
+  };
   const resources = outputs.map(parseCompiledOutput);
-  const compiledIds = new Set(resources.map((r) => `${r.type}:${r.id}`));
-  const stubs = await extractMessageStubs(source, compiledIds, nested);
+  const serviceContainerRefsByPath = extractServiceContainerRefs(parsed.program, nested);
+  for (const resource of resources) {
+    if (resource.type !== "service") continue;
+    const refs = serviceContainerRefsByPath.get(resource.path);
+    if (!refs) continue;
+    resource.frontmatter = {
+      ...resource.frontmatter,
+      ...refs
+    };
+  }
+  const compiledIds = /* @__PURE__ */ new Set();
+  for (const resource of resources) {
+    compiledIds.add(getResourceNameKey(resource.type, resource.id));
+    compiledIds.add(getResourceVersionKey(resource.type, resource.id, resource.version));
+  }
+  const stubs = hasReferenceStatements(source) ? await extractMessageStubs(parsed.program, 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);
+        const existing = await readResourceCached(reader, resource.type, resource.id, resource.version);
         if (existing) {
           result.updated.push(label);
         } else {
-          const latest = await reader(resource.id).catch(() => void 0);
+          const latest = await readResourceCached(reader, resource.type, resource.id);
           if (latest && latest.version && latest.version !== resource.version) {
             result.versioned.push(`${resource.type} ${resource.id}@${latest.version}`);
           }
@@ -739,20 +906,35 @@ async function importDSL(options) {
     }
     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;
+      const existing = await readResourceCached(reader, resource.type, resource.id, resource.version);
+      const latest = !existing && resource.version ? await readResourceCached(reader, resource.type, resource.id) : void 0;
+      const versionedFrom = !existing && resource.version && latest?.version && latest.version !== resource.version ? latest.version : void 0;
+      const incomingMarkdown = resource.markdown;
+      const hasIncomingMarkdown = incomingMarkdown.trim().length > 0;
+      let markdown = incomingMarkdown;
+      if (!hasIncomingMarkdown) {
+        if (existing?.markdown) {
+          markdown = existing.markdown;
+        } else if (!existing && latest?.markdown) {
+          markdown = latest.markdown;
+        }
+      }
       if (!existing && TYPES_WITH_NODE_GRAPH.has(resource.type)) {
-        markdown = markdown ? `${markdown}
+        if (!markdown) {
+          markdown = "<NodeGraph />";
+        } else if (!markdown.includes("<NodeGraph />")) {
+          markdown = `${markdown}
 
-<NodeGraph />` : "<NodeGraph />";
+<NodeGraph />`;
+        }
       }
       const resourceData = {
-        ...resource.frontmatter,
+        ...normalizeImportedFrontmatter(resource.type, resource.frontmatter),
         markdown
       };
       const writeOptions = {
         override: true,
-        versionExistingContent: true
+        versionExistingContent: Boolean(versionedFrom)
       };
       if (!existing && nested) {
         const sdkPath = extractSdkPath(resource.path, resource.type);
@@ -761,10 +943,14 @@ async function importDSL(options) {
         }
       }
       await writer(resourceData, writeOptions);
+      invalidateReaderCache(resource.type, resource.id, resource.version);
       if (existing) {
         result.updated.push(label);
       } else {
         result.created.push(label);
+        if (versionedFrom) {
+          result.versioned.push(`${resource.type} ${resource.id}@${versionedFrom}`);
+        }
       }
     } catch (error) {
       result.errors.push(`${label}: ${error instanceof Error ? error.message : String(error)}`);
@@ -798,8 +984,11 @@ var TYPE_CONFIG = {
   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 }
+  container: { color: c.white, label: "container", order: 7 },
+  dataProduct: { color: c.white, label: "data product", order: 8 },
+  diagram: { color: c.white, label: "diagram", order: 9 },
+  user: { color: c.blue, label: "user", order: 10 },
+  team: { color: c.blue, label: "team", order: 11 }
 };
 var DEFAULT_TYPE_CONFIG = { color: c.white, label: "resource", order: 99 };
 function parseLabel(label) {
@@ -912,7 +1101,7 @@ program.command("list").description("List all available SDK functions").action((
     process.exit(1);
   }
 });
-program.command("export").description("Export a catalog resource to EventCatalog DSL (.ec) format").option("-a, --all", "Export the entire catalog (all resource types)", false).option("-r, --resource <type>", "Resource type (event, command, query, service, domain)").option("--id <id>", "Resource ID (omit to export all resources of the given type)").option("-v, --version <version>", "Resource version (defaults to latest)").option("--hydrate", "Include referenced resources (messages, channels, owners)", false).option("--stdout", "Print to stdout instead of writing a file", false).option("--playground", "Open the exported DSL in the playground", false).option("-o, --output <path>", "Output file path (defaults to <id>.ec or catalog.ec)").action(async (opts) => {
+program.command("export").description("Export a catalog resource to EventCatalog DSL (.ec) format").option("-a, --all", "Export the entire catalog (all resource types)", false).option("-r, --resource <type>", "Resource type (event, command, query, service, domain)").option("--id <id>", "Resource ID (omit to export all resources of the given type)").option("-v, --version <version>", "Resource version (defaults to latest)").option("--hydrate", "Include referenced resources (messages, channels, owners)", false).option("--stdout", "Print to stdout instead of writing a file", false).option("--playground", "Open the exported DSL in EventCatalog Modelling", false).option("-o, --output <path>", "Output file path (defaults to <id>.ec or catalog.ec)").action(async (opts) => {
   try {
     const globalOpts = program.opts();
     const dir = globalOpts.dir || ".";