@eventcatalog/sdk 2.13.2 → 2.14.0

package/dist/index.js

@@ -35,12 +35,409 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 var import_node_path20 = require("path");
 
+// src/dsl/utils.ts
+var import_glob = require("glob");
+function serializeBaseFields(resource, indent = "  ") {
+  const lines = [];
+  if (resource.version) {
+    lines.push(`${indent}version ${resource.version}`);
+  }
+  if (resource.name) {
+    lines.push(`${indent}name "${resource.name}"`);
+  }
+  if (resource.summary) {
+    lines.push(`${indent}summary "${resource.summary.trim()}"`);
+  }
+  if (resource.owners && resource.owners.length > 0) {
+    for (const owner of resource.owners) {
+      lines.push(`${indent}owner ${owner}`);
+    }
+  }
+  if (resource.deprecated === true) {
+    lines.push(`${indent}deprecated true`);
+  }
+  if (resource.draft === true) {
+    lines.push(`${indent}draft true`);
+  }
+  return lines.join("\n");
+}
+function resolveMessageType(catalogDir, id) {
+  if ((0, import_glob.globSync)(`**/events/${id}/index.{md,mdx}`, { cwd: catalogDir }).length > 0) return "event";
+  if ((0, import_glob.globSync)(`**/commands/${id}/index.{md,mdx}`, { cwd: catalogDir }).length > 0) return "command";
+  if ((0, import_glob.globSync)(`**/queries/${id}/index.{md,mdx}`, { cwd: catalogDir }).length > 0) return "query";
+  return void 0;
+}
+function serializeChannelRef(channel) {
+  let ref = channel.id;
+  if (channel.version) ref += `@${channel.version}`;
+  return ref;
+}
+function serializeMessagePointers(items, direction, catalogDir, indent = "  ") {
+  const lines = [];
+  for (const item of items) {
+    const msgType = resolveMessageType(catalogDir, item.id);
+    if (!msgType) continue;
+    let ref = `${item.id}`;
+    if (item.version) ref += `@${item.version}`;
+    const channels = direction === "sends" ? item.to : item.from;
+    const channelKeyword = direction === "sends" ? "to" : "from";
+    if (channels && channels.length === 1) {
+      lines.push(`${indent}${direction} ${msgType} ${ref} ${channelKeyword} ${serializeChannelRef(channels[0])}`);
+    } else if (channels && channels.length > 1) {
+      const channelRefs = channels.map(serializeChannelRef).join(", ");
+      lines.push(`${indent}${direction} ${msgType} ${ref} ${channelKeyword} ${channelRefs}`);
+    } else {
+      lines.push(`${indent}${direction} ${msgType} ${ref}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/dsl/message.ts
+function messageToDSL(resource, type) {
+  const body = serializeBaseFields(resource);
+  if (!body) {
+    return `${type} ${resource.id}`;
+  }
+  return `${type} ${resource.id} {
+${body}
+}`;
+}
+
+// src/dsl/service.ts
+async function serviceToDSL(resource, options, getMessageFn) {
+  const { catalogDir, hydrate = false, _seen = /* @__PURE__ */ new Set() } = options;
+  const parts = [];
+  if (hydrate && getMessageFn) {
+    const allMessages = [...resource.sends || [], ...resource.receives || []];
+    for (const msg of allMessages) {
+      const key = `${msg.id}@${msg.version || "latest"}`;
+      if (_seen.has(key)) continue;
+      _seen.add(key);
+      const msgType = resolveMessageType(catalogDir, msg.id);
+      if (!msgType) continue;
+      const msgResource = await getMessageFn(msg.id, msg.version);
+      if (msgResource) {
+        parts.push(messageToDSL(msgResource, msgType));
+      }
+    }
+  }
+  const lines = [];
+  const baseFields = serializeBaseFields(resource);
+  if (baseFields) lines.push(baseFields);
+  if (resource.sends && resource.sends.length > 0) {
+    const sendsStr = serializeMessagePointers(resource.sends, "sends", catalogDir);
+    if (sendsStr) lines.push(sendsStr);
+  }
+  if (resource.receives && resource.receives.length > 0) {
+    const recvStr = serializeMessagePointers(resource.receives, "receives", catalogDir);
+    if (recvStr) lines.push(recvStr);
+  }
+  if (resource.writesTo && resource.writesTo.length > 0) {
+    for (const container of resource.writesTo) {
+      let ref = container.id;
+      if (container.version) ref += `@${container.version}`;
+      lines.push(`  writes-to container ${ref}`);
+    }
+  }
+  if (resource.readsFrom && resource.readsFrom.length > 0) {
+    for (const container of resource.readsFrom) {
+      let ref = container.id;
+      if (container.version) ref += `@${container.version}`;
+      lines.push(`  reads-from container ${ref}`);
+    }
+  }
+  const body = lines.join("\n");
+  parts.push(`service ${resource.id} {
+${body}
+}`);
+  return parts.join("\n\n");
+}
+
+// src/dsl/channel.ts
+function channelToDSL(resource) {
+  const lines = [];
+  if (resource.version) {
+    lines.push(`  version ${resource.version}`);
+  }
+  if (resource.name) {
+    lines.push(`  name "${resource.name}"`);
+  }
+  if (resource.address) {
+    lines.push(`  address "${resource.address}"`);
+  }
+  if (resource.protocols && resource.protocols.length > 0) {
+    for (const protocol of resource.protocols) {
+      lines.push(`  protocol "${protocol}"`);
+    }
+  }
+  if (resource.summary) {
+    lines.push(`  summary "${resource.summary.trim()}"`);
+  }
+  if (!lines.length) {
+    return `channel ${resource.id}`;
+  }
+  return `channel ${resource.id} {
+${lines.join("\n")}
+}`;
+}
+
+// src/dsl/owner.ts
+function teamToDSL(team) {
+  const lines = [];
+  if (team.name) lines.push(`  name "${team.name}"`);
+  if (team.avatarUrl) lines.push(`  avatar "${team.avatarUrl}"`);
+  if (team.role) lines.push(`  role "${team.role}"`);
+  if (team.summary) lines.push(`  summary "${team.summary}"`);
+  if (team.email) lines.push(`  email "${team.email}"`);
+  if (team.slackDirectMessageUrl) lines.push(`  slack "${team.slackDirectMessageUrl}"`);
+  return `team ${team.id} {
+${lines.join("\n")}
+}`;
+}
+function userToDSL(user) {
+  const lines = [];
+  if (user.name) lines.push(`  name "${user.name}"`);
+  if (user.avatarUrl) lines.push(`  avatar "${user.avatarUrl}"`);
+  if (user.role) lines.push(`  role "${user.role}"`);
+  if (user.email) lines.push(`  email "${user.email}"`);
+  if (user.slackDirectMessageUrl) lines.push(`  slack "${user.slackDirectMessageUrl}"`);
+  return `user ${user.id} {
+${lines.join("\n")}
+}`;
+}
+
+// src/dsl/domain.ts
+async function hydrateOwners(owners, resolvers, seen, parts) {
+  if (!owners || !resolvers.getTeam || !resolvers.getUser) return;
+  for (const ownerId of owners) {
+    const key = `owner:${ownerId}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const team = await resolvers.getTeam(ownerId);
+    if (team) {
+      parts.push(teamToDSL(team));
+      continue;
+    }
+    const user = await resolvers.getUser(ownerId);
+    if (user) {
+      parts.push(userToDSL(user));
+    }
+  }
+}
+async function hydrateChannelsFromMessages(messages, resolvers, seen, parts) {
+  if (!resolvers.getChannel) return;
+  for (const msg of messages) {
+    const channels = msg.to || msg.from;
+    if (!channels) continue;
+    for (const ch of channels) {
+      const key = `channel:${ch.id}@${ch.version || "latest"}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const channel = await resolvers.getChannel(ch.id, ch.version);
+      if (channel) {
+        parts.push(channelToDSL(channel));
+      }
+    }
+  }
+}
+async function buildDomainBody(resource, options, resolvers, keyword) {
+  const { catalogDir, hydrate = false, _seen = /* @__PURE__ */ new Set() } = options;
+  const topLevelParts = [];
+  if (hydrate && resolvers) {
+    if (resource.services && resource.services.length > 0 && resolvers.getService) {
+      for (const svcRef of resource.services) {
+        const svcKey = `service:${svcRef.id}@${svcRef.version || "latest"}`;
+        if (_seen.has(svcKey)) continue;
+        _seen.add(svcKey);
+        const svc = await resolvers.getService(svcRef.id, svcRef.version);
+        if (svc) {
+          await hydrateOwners(svc.owners, resolvers, _seen, topLevelParts);
+          const svcMessages = [...svc.sends || [], ...svc.receives || []];
+          await hydrateChannelsFromMessages(svcMessages, resolvers, _seen, topLevelParts);
+          const svcDsl = await serviceToDSL(svc, { catalogDir, hydrate: true, _seen }, resolvers.getMessage);
+          topLevelParts.push(svcDsl);
+        }
+      }
+    }
+    const domainMessages = [...resource.sends || [], ...resource.receives || []];
+    await hydrateChannelsFromMessages(domainMessages, resolvers, _seen, topLevelParts);
+    if (resolvers.getMessage) {
+      for (const msg of domainMessages) {
+        const key = `${msg.id}@${msg.version || "latest"}`;
+        if (_seen.has(key)) continue;
+        _seen.add(key);
+        const msgType = resolveMessageType(catalogDir, msg.id);
+        if (!msgType) continue;
+        const msgResource = await resolvers.getMessage(msg.id, msg.version);
+        if (msgResource) {
+          topLevelParts.push(messageToDSL(msgResource, msgType));
+        }
+      }
+    }
+  }
+  const lines = [];
+  const baseFields = serializeBaseFields(resource);
+  if (baseFields) lines.push(baseFields);
+  if (resource.services && resource.services.length > 0) {
+    for (const svc of resource.services) {
+      let ref = svc.id;
+      if (svc.version) ref += `@${svc.version}`;
+      lines.push(`  service ${ref}`);
+    }
+  }
+  if (resource.sends && resource.sends.length > 0) {
+    const sendsStr = serializeMessagePointers(resource.sends, "sends", catalogDir);
+    if (sendsStr) lines.push(sendsStr);
+  }
+  if (resource.receives && resource.receives.length > 0) {
+    const recvStr = serializeMessagePointers(resource.receives, "receives", catalogDir);
+    if (recvStr) lines.push(recvStr);
+  }
+  if (resource.domains && resource.domains.length > 0) {
+    if (hydrate && resolvers?.getDomain) {
+      for (const subRef of resource.domains) {
+        const subKey = `domain:${subRef.id}@${subRef.version || "latest"}`;
+        if (_seen.has(subKey)) continue;
+        _seen.add(subKey);
+        const subDomain = await resolvers.getDomain(subRef.id, subRef.version);
+        if (subDomain) {
+          await hydrateOwners(subDomain.owners, resolvers, _seen, topLevelParts);
+          const sub = await buildDomainBody(subDomain, { catalogDir, hydrate, _seen }, resolvers, "subdomain");
+          topLevelParts.push(...sub.topLevelParts);
+          const indented = sub.block.split("\n").map((line) => `  ${line}`).join("\n");
+          lines.push(indented);
+        }
+      }
+    } else {
+      for (const sub of resource.domains) {
+        let ref = sub.id;
+        if (sub.version) ref += `@${sub.version}`;
+        lines.push(`  subdomain ${ref}`);
+      }
+    }
+  }
+  const body = lines.join("\n");
+  const block = `${keyword} ${resource.id} {
+${body}
+}`;
+  return { topLevelParts, block };
+}
+async function domainToDSL(resource, options, resolvers) {
+  const { catalogDir, hydrate = false, _seen = /* @__PURE__ */ new Set() } = options;
+  const result = await buildDomainBody(resource, { catalogDir, hydrate, _seen }, resolvers, "domain");
+  const parts = [...result.topLevelParts, result.block];
+  return parts.join("\n\n");
+}
+
+// src/dsl/index.ts
+function getMessage(resolvers, catalogDir) {
+  return async (id, version) => {
+    const msgType = resolveMessageType(catalogDir, id);
+    if (!msgType) return void 0;
+    switch (msgType) {
+      case "event":
+        return resolvers.getEvent(id, version);
+      case "command":
+        return resolvers.getCommand(id, version);
+      case "query":
+        return resolvers.getQuery(id, version);
+    }
+  };
+}
+async function hydrateChannels(resource, resolvers, seen, parts) {
+  const allMessages = [...resource.sends || [], ...resource.receives || []];
+  for (const msg of allMessages) {
+    const channels = "to" in msg ? msg.to : "from" in msg ? msg.from : void 0;
+    if (!channels) continue;
+    for (const ch of channels) {
+      const key = `channel:${ch.id}@${ch.version || "latest"}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const channel = await resolvers.getChannel(ch.id, ch.version);
+      if (channel) {
+        parts.push(channelToDSL(channel));
+      }
+    }
+  }
+}
+async function hydrateOwners2(owners, resolvers, seen, parts) {
+  if (!owners) return;
+  for (const ownerId of owners) {
+    const key = `owner:${ownerId}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const team = await resolvers.getTeam(ownerId);
+    if (team) {
+      parts.push(teamToDSL(team));
+      continue;
+    }
+    const user = await resolvers.getUser(ownerId);
+    if (user) {
+      parts.push(userToDSL(user));
+    }
+  }
+}
+var toDSL = (catalogDir, resolvers) => async (resource, options) => {
+  const resources = Array.isArray(resource) ? resource : [resource];
+  const seen = /* @__PURE__ */ new Set();
+  const parts = [];
+  for (const res of resources) {
+    const key = `${options.type}:${res.id}@${res.version || "latest"}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    switch (options.type) {
+      case "event":
+      case "command":
+      case "query":
+        if (options.hydrate) {
+          await hydrateOwners2(res.owners, resolvers, seen, parts);
+        }
+        parts.push(messageToDSL(res, options.type));
+        break;
+      case "service":
+        if (options.hydrate) {
+          await hydrateOwners2(res.owners, resolvers, seen, parts);
+          await hydrateChannels(res, resolvers, seen, parts);
+        }
+        parts.push(
+          await serviceToDSL(
+            res,
+            { catalogDir, hydrate: options.hydrate, _seen: seen },
+            getMessage(resolvers, catalogDir)
+          )
+        );
+        break;
+      case "domain":
+        if (options.hydrate) {
+          await hydrateOwners2(res.owners, resolvers, seen, parts);
+        }
+        parts.push(
+          await domainToDSL(
+            res,
+            { catalogDir, hydrate: options.hydrate, _seen: seen },
+            {
+              getService: resolvers.getService,
+              getDomain: resolvers.getDomain,
+              getMessage: getMessage(resolvers, catalogDir),
+              getChannel: resolvers.getChannel,
+              getTeam: resolvers.getTeam,
+              getUser: resolvers.getUser
+            }
+          )
+        );
+        break;
+    }
+  }
+  return parts.join("\n\n");
+};
+
 // src/events.ts
 var import_promises2 = __toESM(require("fs/promises"));
 var import_node_path4 = require("path");
 
 // src/internal/utils.ts
-var import_glob = require("glob");
+var import_glob2 = require("glob");
 var import_node_fs = __toESM(require("fs"));
 var import_fs_extra = require("fs-extra");
 var import_node_path = require("path");
@@ -91,7 +488,7 @@ var getFiles = async (pattern, ignore = "") => {
     let relativePattern = (0, import_node_path.relative)(absoluteBaseDir, normalizedInputPattern);
     relativePattern = relativePattern.replace(/\\/g, "/");
     const ignoreList = Array.isArray(ignore) ? ignore : [ignore];
-    const files = (0, import_glob.globSync)(relativePattern, {
+    const files = (0, import_glob2.globSync)(relativePattern, {
       cwd: absoluteBaseDir,
       ignore: ["node_modules/**", ...ignoreList],
       absolute: true,
@@ -493,7 +890,18 @@ var getServiceByPath = (directory) => async (path6) => {
 };
 var getServices = (directory) => async (options) => getResources(directory, {
   type: "services",
-  ignore: ["**/events/**", "**/commands/**", "**/queries/**", "**/entities/**", "**/subdomains/**/entities/**"],
+  ignore: [
+    "**/events/**",
+    "**/commands/**",
+    "**/queries/**",
+    "**/entities/**",
+    "**/channels/**",
+    "**/containers/**",
+    "**/data-products/**",
+    "**/data-stores/**",
+    "**/flows/**",
+    "**/subdomains/**/entities/**"
+  ],
   ...options
 });
 var writeService = (directory) => async (service, options = {
@@ -856,8 +1264,8 @@ var addMessageToChannel = (directory, collection) => async (id, _message, versio
       writeMessage: writeQuery
     }
   };
-  const { getMessage, rmMessageById, writeMessage } = functions[collection];
-  const message = await getMessage(directory)(_message.id, _message.version);
+  const { getMessage: getMessage2, rmMessageById, writeMessage } = functions[collection];
+  const message = await getMessage2(directory)(_message.id, _message.version);
   const messagePath = await getResourcePath(directory, _message.id, _message.version);
   const extension = (0, import_node_path9.extname)(messagePath?.fullPath || "");
   if (!message) throw new Error(`Message ${_message.id} with version ${_message.version} not found`);
@@ -2428,7 +2836,35 @@ var src_default = (path6) => {
      * @param version - Optional version of the diagram to add the file to
      * @returns
      */
-    addFileToDiagram: addFileToDiagram((0, import_node_path20.join)(path6))
+    addFileToDiagram: addFileToDiagram((0, import_node_path20.join)(path6)),
+    /**
+     * ================================
+     *            DSL
+     * ================================
+     */
+    /**
+     * Converts catalog resources to EventCatalog DSL (.ec) format strings.
+     *
+     * @param resource - A resource or array of resources to convert
+     * @param options - Options including type ('event'|'command'|'query'|'service'|'domain') and optional hydrate flag
+     * @returns A DSL string representation
+     *
+     * @example
+     * ```ts
+     * const dsl = await sdk.toDSL(event, { type: 'event' });
+     * const dsl = await sdk.toDSL(services, { type: 'service', hydrate: true });
+     * ```
+     */
+    toDSL: toDSL((0, import_node_path20.join)(path6), {
+      getEvent: getEvent((0, import_node_path20.join)(path6)),
+      getCommand: getCommand((0, import_node_path20.join)(path6)),
+      getQuery: getQuery((0, import_node_path20.join)(path6)),
+      getService: getService((0, import_node_path20.join)(path6)),
+      getDomain: getDomain((0, import_node_path20.join)(path6, "domains")),
+      getChannel: getChannel((0, import_node_path20.join)(path6)),
+      getTeam: getTeam((0, import_node_path20.join)(path6, "teams")),
+      getUser: getUser((0, import_node_path20.join)(path6, "users"))
+    })
   };
 };
 //# sourceMappingURL=index.js.map