@eventcatalog/sdk 2.14.2 → 2.15.0

package/dist/index.js

@@ -37,6 +37,22 @@ var import_node_path20 = require("path");
 
 // src/dsl/utils.ts
 var import_glob = require("glob");
+var import_semver = require("semver");
+function msgVersionMatches(pointerVersion, messageVersion) {
+  if (!pointerVersion) return true;
+  if (!messageVersion) return false;
+  if (pointerVersion === messageVersion) return true;
+  try {
+    if ((0, import_semver.validRange)(pointerVersion)) {
+      if ((0, import_semver.satisfies)(messageVersion, pointerVersion)) return true;
+    }
+    if ((0, import_semver.validRange)(messageVersion)) {
+      if ((0, import_semver.satisfies)(pointerVersion, messageVersion)) return true;
+    }
+  } catch {
+  }
+  return false;
+}
 function serializeBaseFields(resource, indent = "  ") {
   const lines = [];
   if (resource.version) {
@@ -125,10 +141,12 @@ ${body}
 }
 
 // src/dsl/service.ts
+var import_semver2 = require("semver");
 async function serviceToDSL(resource, options, getMessageFn) {
   const { catalogDir, hydrate = false, _seen = /* @__PURE__ */ new Set() } = options;
   const msgIndex = options._msgIndex || buildMessageTypeIndex(catalogDir);
   const parts = [];
+  const resolvedVersions = /* @__PURE__ */ new Map();
   if (hydrate && getMessageFn) {
     const allMessages = [...resource.sends || [], ...resource.receives || []];
     for (const msg of allMessages) {
@@ -140,18 +158,30 @@ async function serviceToDSL(resource, options, getMessageFn) {
       const msgResource = await getMessageFn(msg.id, msg.version);
       if (msgResource) {
         parts.push(messageToDSL(msgResource, msgType));
+        if (msg.version && !(0, import_semver2.valid)(msg.version) && msgResource.version) {
+          resolvedVersions.set(`${msg.id}@${msg.version}`, msgResource.version);
+        }
       }
     }
   }
+  const resolvePointers = (pointers) => pointers.map((p) => {
+    if (p.version && !(0, import_semver2.valid)(p.version)) {
+      const resolved = resolvedVersions.get(`${p.id}@${p.version}`);
+      if (resolved) return { ...p, version: resolved };
+    }
+    return p;
+  });
+  const sends = resource.sends ? resolvePointers(resource.sends) : void 0;
+  const receives = resource.receives ? resolvePointers(resource.receives) : void 0;
   const lines = [];
   const baseFields = serializeBaseFields(resource);
   if (baseFields) lines.push(baseFields);
-  if (resource.sends && resource.sends.length > 0) {
-    const sendsStr = serializeMessagePointers(resource.sends, "sends", msgIndex);
+  if (sends && sends.length > 0) {
+    const sendsStr = serializeMessagePointers(sends, "sends", msgIndex);
     if (sendsStr) lines.push(sendsStr);
   }
-  if (resource.receives && resource.receives.length > 0) {
-    const recvStr = serializeMessagePointers(resource.receives, "receives", msgIndex);
+  if (receives && receives.length > 0) {
+    const recvStr = serializeMessagePointers(receives, "receives", msgIndex);
     if (recvStr) lines.push(recvStr);
   }
   if (resource.writesTo && resource.writesTo.length > 0) {
@@ -195,6 +225,13 @@ function channelToDSL(resource) {
   if (resource.summary) {
     lines.push(`  summary "${resource.summary.trim()}"`);
   }
+  if (resource.routes && resource.routes.length > 0) {
+    for (const route of resource.routes) {
+      let ref = route.id;
+      if (route.version) ref += `@${route.version}`;
+      lines.push(`  route ${ref}`);
+    }
+  }
   if (!lines.length) {
     return `channel ${resource.id}`;
   }
@@ -358,6 +395,38 @@ async function domainToDSL(resource, options, resolvers) {
   return parts.join("\n\n");
 }
 
+// src/dsl/container.ts
+function containerToDSL(resource) {
+  const lines = [];
+  const baseFields = serializeBaseFields(resource);
+  if (baseFields) lines.push(baseFields);
+  if (resource.container_type) {
+    lines.push(`  container-type ${resource.container_type}`);
+  }
+  if (resource.technology) {
+    lines.push(`  technology "${resource.technology}"`);
+  }
+  if (resource.authoritative === true) {
+    lines.push(`  authoritative true`);
+  }
+  if (resource.access_mode) {
+    lines.push(`  access-mode ${resource.access_mode}`);
+  }
+  if (resource.classification) {
+    lines.push(`  classification ${resource.classification}`);
+  }
+  if (resource.residency) {
+    lines.push(`  residency "${resource.residency}"`);
+  }
+  if (resource.retention) {
+    lines.push(`  retention "${resource.retention}"`);
+  }
+  const body = lines.join("\n");
+  return `container ${resource.id} {
+${body}
+}`;
+}
+
 // src/dsl/index.ts
 function getMessage(resolvers, msgIndex) {
   return async (id, version) => {
@@ -373,22 +442,55 @@ function getMessage(resolvers, msgIndex) {
     }
   };
 }
+async function hydrateChannel(channelId, channelVersion, resolvers, seen, parts) {
+  const key = `channel:${channelId}@${channelVersion || "latest"}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+  const channel = await resolvers.getChannel(channelId, channelVersion);
+  if (!channel) return;
+  if (channel.routes && channel.routes.length > 0) {
+    for (const route of channel.routes) {
+      await hydrateChannel(route.id, route.version, resolvers, seen, parts);
+    }
+  }
+  const allChannels = await resolvers.getChannels({ latestOnly: false }) || [];
+  const targetVersion = channelVersion || channel.version;
+  for (const upstream of allChannels) {
+    if (!upstream.routes) continue;
+    const routesToThis = upstream.routes.some((route) => {
+      if (route.id !== channelId) return false;
+      if (!route.version) {
+        return !channelVersion;
+      }
+      return msgVersionMatches(route.version, targetVersion);
+    });
+    if (routesToThis) {
+      await hydrateChannel(upstream.id, upstream.version, resolvers, seen, parts);
+    }
+  }
+  parts.push(channelToDSL(channel));
+}
 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));
-      }
+      await hydrateChannel(ch.id, ch.version, resolvers, seen, parts);
     }
   }
 }
+async function hydrateContainers(resource, resolvers, seen, parts) {
+  const allContainers = [...resource.writesTo || [], ...resource.readsFrom || []];
+  for (const ref of allContainers) {
+    const key = `container:${ref.id}@${ref.version || "latest"}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const container = await resolvers.getContainer(ref.id, ref.version);
+    if (!container) continue;
+    parts.push(containerToDSL(container));
+  }
+}
 async function hydrateOwners2(owners, resolvers, seen, parts) {
   if (!owners) return;
   for (const ownerId of owners) {
@@ -406,6 +508,67 @@ async function hydrateOwners2(owners, resolvers, seen, parts) {
     }
   }
 }
+async function hydrateMessageServices(messageId, messageVersion, resolvers, seen, parts, catalogDir, msgIndex) {
+  const services = await resolvers.getServices({ latestOnly: false }) || [];
+  for (const service of services) {
+    const key = `service:${service.id}@${service.version || "latest"}`;
+    if (seen.has(key)) continue;
+    const referencesMessage = [...service.sends || [], ...service.receives || []].some(
+      (msg) => msg.id === messageId && msgVersionMatches(msg.version, messageVersion)
+    );
+    if (referencesMessage) {
+      seen.add(key);
+      const matchMsg = (msg) => msg.id === messageId && msgVersionMatches(msg.version, messageVersion);
+      const resolvePointerVersion = (msg) => {
+        if (msg.id === messageId && msg.version && msg.version !== messageVersion && messageVersion) {
+          return { ...msg, version: messageVersion };
+        }
+        return msg;
+      };
+      const filtered = {
+        ...service,
+        sends: service.sends?.filter(matchMsg).map(resolvePointerVersion),
+        receives: service.receives?.filter(matchMsg).map(resolvePointerVersion)
+      };
+      await hydrateChannels(filtered, resolvers, seen, parts);
+      parts.push(await serviceToDSL(filtered, { catalogDir, hydrate: false, _seen: new Set(seen), _msgIndex: msgIndex }));
+    }
+  }
+}
+async function hydrateRelatedServices(messages, direction, resolvers, seen, parts, catalogDir, msgIndex) {
+  if (!messages.length) return;
+  const referencesHydratedMessage = (msg) => messages.some((input) => msg.id === input.id && msgVersionMatches(msg.version, input.version));
+  const services = await resolvers.getServices({ latestOnly: false }) || [];
+  for (const service of services) {
+    const key = `service:${service.id}@${service.version || "latest"}`;
+    if (seen.has(key)) continue;
+    if (direction === "sends") {
+      const matchedPointers = (service.sends || []).filter(referencesHydratedMessage);
+      if (matchedPointers.length > 0) {
+        seen.add(key);
+        const filtered = {
+          ...service,
+          sends: matchedPointers,
+          receives: void 0
+        };
+        await hydrateChannels(filtered, resolvers, seen, parts);
+        parts.push(await serviceToDSL(filtered, { catalogDir, hydrate: false, _seen: new Set(seen), _msgIndex: msgIndex }));
+      }
+    } else {
+      const matchedPointers = (service.receives || []).filter(referencesHydratedMessage);
+      if (matchedPointers.length > 0) {
+        seen.add(key);
+        const filtered = {
+          ...service,
+          sends: void 0,
+          receives: matchedPointers
+        };
+        await hydrateChannels(filtered, resolvers, seen, parts);
+        parts.push(await serviceToDSL(filtered, { catalogDir, hydrate: false, _seen: new Set(seen), _msgIndex: msgIndex }));
+      }
+    }
+  }
+}
 var toDSL = (catalogDir, resolvers) => async (resource, options) => {
   const resources = Array.isArray(resource) ? resource : [resource];
   const seen = /* @__PURE__ */ new Set();
@@ -421,6 +584,7 @@ var toDSL = (catalogDir, resolvers) => async (resource, options) => {
       case "query":
         if (options.hydrate) {
           await hydrateOwners2(res.owners, resolvers, seen, parts);
+          await hydrateMessageServices(res.id, res.version, resolvers, seen, parts, catalogDir, msgIndex);
         }
         parts.push(messageToDSL(res, options.type));
         break;
@@ -428,6 +592,7 @@ var toDSL = (catalogDir, resolvers) => async (resource, options) => {
         if (options.hydrate) {
           await hydrateOwners2(res.owners, resolvers, seen, parts);
           await hydrateChannels(res, resolvers, seen, parts);
+          await hydrateContainers(res, resolvers, seen, parts);
         }
         parts.push(
           await serviceToDSL(
@@ -436,6 +601,11 @@ var toDSL = (catalogDir, resolvers) => async (resource, options) => {
             getMessage(resolvers, msgIndex)
           )
         );
+        if (options.hydrate) {
+          const svc = res;
+          await hydrateRelatedServices(svc.sends || [], "receives", resolvers, seen, parts, catalogDir, msgIndex);
+          await hydrateRelatedServices(svc.receives || [], "sends", resolvers, seen, parts, catalogDir, msgIndex);
+        }
         break;
       case "domain":
         if (options.hydrate) {
@@ -455,6 +625,22 @@ var toDSL = (catalogDir, resolvers) => async (resource, options) => {
             }
           )
         );
+        if (options.hydrate) {
+          const domain = res;
+          const allSends = [];
+          const allReceives = [];
+          if (domain.services?.length) {
+            for (const svcRef of domain.services) {
+              const svc = await resolvers.getService(svcRef.id, svcRef.version);
+              if (svc) {
+                allSends.push(...svc.sends || []);
+                allReceives.push(...svc.receives || []);
+              }
+            }
+          }
+          await hydrateRelatedServices(allSends, "receives", resolvers, seen, parts, catalogDir, msgIndex);
+          await hydrateRelatedServices(allReceives, "sends", resolvers, seen, parts, catalogDir, msgIndex);
+        }
         break;
     }
   }
@@ -471,7 +657,7 @@ var import_node_fs = __toESM(require("fs"));
 var import_fs_extra = require("fs-extra");
 var import_node_path = require("path");
 var import_gray_matter = __toESM(require("gray-matter"));
-var import_semver = require("semver");
+var import_semver3 = require("semver");
 var _fileIndexCache = null;
 var _fileIndexCatalogDir = null;
 var _matterCache = null;
@@ -603,11 +789,11 @@ var findFileById = async (catalogDir, id, version) => {
   }
   const exactMatch = entries.find((e) => e.version === version);
   if (exactMatch) return exactMatch.path;
-  const semverRange = (0, import_semver.validRange)(version);
+  const semverRange = (0, import_semver3.validRange)(version);
   if (semverRange) {
     const match = entries.find((e) => {
       try {
-        return (0, import_semver.satisfies)(e.version, semverRange);
+        return (0, import_semver3.satisfies)(e.version, semverRange);
       } catch {
         return false;
       }
@@ -693,7 +879,7 @@ var import_path = require("path");
 var import_gray_matter2 = __toESM(require("gray-matter"));
 var import_promises = __toESM(require("fs/promises"));
 var import_node_fs2 = __toESM(require("fs"));
-var import_semver2 = require("semver");
+var import_semver4 = require("semver");
 var import_proper_lockfile = require("proper-lockfile");
 var import_node_path2 = require("path");
 var import_node_path3 = __toESM(require("path"));
@@ -759,7 +945,7 @@ var writeResource = async (catalogDir, resource, options = {
     if (options.versionExistingContent && !exists) {
       const currentResource = await getResource(catalogDir, resource.id);
       if (currentResource) {
-        if ((0, import_semver2.satisfies)(resource.version, `>${currentResource.version}`)) {
+        if ((0, import_semver4.satisfies)(resource.version, `>${currentResource.version}`)) {
           await versionResource(catalogDir, resource.id);
         } else {
           throw new Error(`New version ${resource.version} is not greater than current version ${currentResource.version}`);
@@ -1433,7 +1619,7 @@ var addMessageToChannel = (directory, collection) => async (id, _message, versio
 // src/messages.ts
 var import_node_path10 = require("path");
 var import_gray_matter4 = __toESM(require("gray-matter"));
-var import_semver3 = require("semver");
+var import_semver5 = require("semver");
 var getMessageBySchemaPath = (directory) => async (path6, options) => {
   const pathToMessage = (0, import_node_path10.dirname)(path6);
   try {
@@ -1472,9 +1658,9 @@ var getProducersAndConsumersForMessage = (directory) => async (id, version, opti
   for (const service of services) {
     const servicePublishesMessage = service.sends?.some((_message) => {
       if (_message.version) {
-        const isServiceUsingSemverRange = (0, import_semver3.validRange)(_message.version);
+        const isServiceUsingSemverRange = (0, import_semver5.validRange)(_message.version);
         if (isServiceUsingSemverRange) {
-          return _message.id === message.id && (0, import_semver3.satisfies)(message.version, _message.version);
+          return _message.id === message.id && (0, import_semver5.satisfies)(message.version, _message.version);
         } else {
           return _message.id === message.id && message.version === _message.version;
         }
@@ -1486,9 +1672,9 @@ var getProducersAndConsumersForMessage = (directory) => async (id, version, opti
     });
     const serviceSubscribesToMessage = service.receives?.some((_message) => {
       if (_message.version) {
-        const isServiceUsingSemverRange = (0, import_semver3.validRange)(_message.version);
+        const isServiceUsingSemverRange = (0, import_semver5.validRange)(_message.version);
         if (isServiceUsingSemverRange) {
-          return _message.id === message.id && (0, import_semver3.satisfies)(message.version, _message.version);
+          return _message.id === message.id && (0, import_semver5.satisfies)(message.version, _message.version);
         } else {
           return _message.id === message.id && message.version === _message.version;
         }
@@ -3016,8 +3202,11 @@ var src_default = (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)),
+      getServices: getServices((0, import_node_path20.join)(path6)),
       getDomain: getDomain((0, import_node_path20.join)(path6, "domains")),
       getChannel: getChannel((0, import_node_path20.join)(path6)),
+      getChannels: getChannels((0, import_node_path20.join)(path6)),
+      getContainer: getDataStore((0, import_node_path20.join)(path6)),
       getTeam: getTeam((0, import_node_path20.join)(path6, "teams")),
       getUser: getUser((0, import_node_path20.join)(path6, "users"))
     })