@eventcatalog/sdk 2.14.3 → 2.15.0

package/dist/index.mjs

@@ -3,6 +3,22 @@ import { join as join18 } from "path";
 
 // src/dsl/utils.ts
 import { globSync } from "glob";
+import { satisfies, validRange } from "semver";
+function msgVersionMatches(pointerVersion, messageVersion) {
+  if (!pointerVersion) return true;
+  if (!messageVersion) return false;
+  if (pointerVersion === messageVersion) return true;
+  try {
+    if (validRange(pointerVersion)) {
+      if (satisfies(messageVersion, pointerVersion)) return true;
+    }
+    if (validRange(messageVersion)) {
+      if (satisfies(pointerVersion, messageVersion)) return true;
+    }
+  } catch {
+  }
+  return false;
+}
 function serializeBaseFields(resource, indent = "  ") {
   const lines = [];
   if (resource.version) {
@@ -91,10 +107,12 @@ ${body}
 }
 
 // src/dsl/service.ts
+import { valid as semverValid } from "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) {
@@ -106,18 +124,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 && !semverValid(msg.version) && msgResource.version) {
+          resolvedVersions.set(`${msg.id}@${msg.version}`, msgResource.version);
+        }
       }
     }
   }
+  const resolvePointers = (pointers) => pointers.map((p) => {
+    if (p.version && !semverValid(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) {
@@ -161,6 +191,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}`;
   }
@@ -324,6 +361,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) => {
@@ -339,22 +408,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) {
@@ -372,6 +474,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();
@@ -387,6 +550,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;
@@ -394,6 +558,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(
@@ -402,6 +567,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) {
@@ -421,6 +591,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;
     }
   }
@@ -437,7 +623,7 @@ import fsSync from "fs";
 import { copy } from "fs-extra";
 import { join, dirname, normalize, sep as pathSeparator, resolve, relative } from "path";
 import matter from "gray-matter";
-import { satisfies, validRange } from "semver";
+import { satisfies as satisfies2, validRange as validRange2 } from "semver";
 var _fileIndexCache = null;
 var _fileIndexCatalogDir = null;
 var _matterCache = null;
@@ -569,11 +755,11 @@ var findFileById = async (catalogDir, id, version) => {
   }
   const exactMatch = entries.find((e) => e.version === version);
   if (exactMatch) return exactMatch.path;
-  const semverRange = validRange(version);
+  const semverRange = validRange2(version);
   if (semverRange) {
     const match = entries.find((e) => {
       try {
-        return satisfies(e.version, semverRange);
+        return satisfies2(e.version, semverRange);
       } catch {
         return false;
       }
@@ -659,7 +845,7 @@ import { dirname as dirname2, join as join2 } from "path";
 import matter2 from "gray-matter";
 import fs from "fs/promises";
 import fsSync2 from "fs";
-import { satisfies as satisfies2 } from "semver";
+import { satisfies as satisfies3 } from "semver";
 import { lock, unlock } from "proper-lockfile";
 import { basename as basename2 } from "path";
 import path from "path";
@@ -725,7 +911,7 @@ var writeResource = async (catalogDir, resource, options = {
     if (options.versionExistingContent && !exists) {
       const currentResource = await getResource(catalogDir, resource.id);
       if (currentResource) {
-        if (satisfies2(resource.version, `>${currentResource.version}`)) {
+        if (satisfies3(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}`);
@@ -1399,7 +1585,7 @@ var addMessageToChannel = (directory, collection) => async (id, _message, versio
 // src/messages.ts
 import { dirname as dirname5 } from "path";
 import matter4 from "gray-matter";
-import { satisfies as satisfies3, validRange as validRange2 } from "semver";
+import { satisfies as satisfies4, validRange as validRange3 } from "semver";
 var getMessageBySchemaPath = (directory) => async (path6, options) => {
   const pathToMessage = dirname5(path6);
   try {
@@ -1438,9 +1624,9 @@ var getProducersAndConsumersForMessage = (directory) => async (id, version, opti
   for (const service of services) {
     const servicePublishesMessage = service.sends?.some((_message) => {
       if (_message.version) {
-        const isServiceUsingSemverRange = validRange2(_message.version);
+        const isServiceUsingSemverRange = validRange3(_message.version);
         if (isServiceUsingSemverRange) {
-          return _message.id === message.id && satisfies3(message.version, _message.version);
+          return _message.id === message.id && satisfies4(message.version, _message.version);
         } else {
           return _message.id === message.id && message.version === _message.version;
         }
@@ -1452,9 +1638,9 @@ var getProducersAndConsumersForMessage = (directory) => async (id, version, opti
     });
     const serviceSubscribesToMessage = service.receives?.some((_message) => {
       if (_message.version) {
-        const isServiceUsingSemverRange = validRange2(_message.version);
+        const isServiceUsingSemverRange = validRange3(_message.version);
         if (isServiceUsingSemverRange) {
-          return _message.id === message.id && satisfies3(message.version, _message.version);
+          return _message.id === message.id && satisfies4(message.version, _message.version);
         } else {
           return _message.id === message.id && message.version === _message.version;
         }
@@ -2982,8 +3168,11 @@ var src_default = (path6) => {
       getCommand: getCommand(join18(path6)),
       getQuery: getQuery(join18(path6)),
       getService: getService(join18(path6)),
+      getServices: getServices(join18(path6)),
       getDomain: getDomain(join18(path6, "domains")),
       getChannel: getChannel(join18(path6)),
+      getChannels: getChannels(join18(path6)),
+      getContainer: getDataStore(join18(path6)),
       getTeam: getTeam(join18(path6, "teams")),
       getUser: getUser(join18(path6, "users"))
     })