@eventcatalog/sdk 2.13.2 → 2.14.1

package/dist/index.mjs

@@ -1,50 +1,533 @@
 // src/index.ts
 import { join as join18 } from "path";
 
+// src/dsl/utils.ts
+import { globSync } from "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 buildMessageTypeIndex(catalogDir) {
+  const index = /* @__PURE__ */ new Map();
+  const types = ["events", "commands", "queries"];
+  const typeMap = { events: "event", commands: "command", queries: "query" };
+  for (const type of types) {
+    const matches = globSync(`**/${type}/*/index.{md,mdx}`, { cwd: catalogDir });
+    for (const match of matches) {
+      const parts = match.replace(/\\/g, "/").split("/");
+      const typeIdx = parts.lastIndexOf(type);
+      if (typeIdx !== -1 && typeIdx + 1 < parts.length) {
+        const id = parts[typeIdx + 1];
+        if (!index.has(id)) index.set(id, typeMap[type]);
+      }
+    }
+  }
+  return index;
+}
+function resolveMessageType(catalogDirOrIndex, id) {
+  if (typeof catalogDirOrIndex !== "string") {
+    return catalogDirOrIndex.get(id);
+  }
+  if (globSync(`**/events/${id}/index.{md,mdx}`, { cwd: catalogDirOrIndex }).length > 0) return "event";
+  if (globSync(`**/commands/${id}/index.{md,mdx}`, { cwd: catalogDirOrIndex }).length > 0) return "command";
+  if (globSync(`**/queries/${id}/index.{md,mdx}`, { cwd: catalogDirOrIndex }).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, catalogDirOrIndex, indent = "  ") {
+  const lines = [];
+  for (const item of items) {
+    const msgType = resolveMessageType(catalogDirOrIndex, 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 msgIndex = options._msgIndex || buildMessageTypeIndex(catalogDir);
+  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(msgIndex, 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", msgIndex);
+    if (sendsStr) lines.push(sendsStr);
+  }
+  if (resource.receives && resource.receives.length > 0) {
+    const recvStr = serializeMessagePointers(resource.receives, "receives", msgIndex);
+    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 msgIndex = options._msgIndex || buildMessageTypeIndex(catalogDir);
+  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, _msgIndex: msgIndex }, 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(msgIndex, 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", msgIndex);
+    if (sendsStr) lines.push(sendsStr);
+  }
+  if (resource.receives && resource.receives.length > 0) {
+    const recvStr = serializeMessagePointers(resource.receives, "receives", msgIndex);
+    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, _msgIndex: msgIndex },
+            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 msgIndex = options._msgIndex || buildMessageTypeIndex(catalogDir);
+  const result = await buildDomainBody(resource, { catalogDir, hydrate, _seen, _msgIndex: msgIndex }, resolvers, "domain");
+  const parts = [...result.topLevelParts, result.block];
+  return parts.join("\n\n");
+}
+
+// src/dsl/index.ts
+function getMessage(resolvers, msgIndex) {
+  return async (id, version) => {
+    const msgType = resolveMessageType(msgIndex, 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 = [];
+  const msgIndex = buildMessageTypeIndex(catalogDir);
+  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, _msgIndex: msgIndex },
+            getMessage(resolvers, msgIndex)
+          )
+        );
+        break;
+      case "domain":
+        if (options.hydrate) {
+          await hydrateOwners2(res.owners, resolvers, seen, parts);
+        }
+        parts.push(
+          await domainToDSL(
+            res,
+            { catalogDir, hydrate: options.hydrate, _seen: seen, _msgIndex: msgIndex },
+            {
+              getService: resolvers.getService,
+              getDomain: resolvers.getDomain,
+              getMessage: getMessage(resolvers, msgIndex),
+              getChannel: resolvers.getChannel,
+              getTeam: resolvers.getTeam,
+              getUser: resolvers.getUser
+            }
+          )
+        );
+        break;
+    }
+  }
+  return parts.join("\n\n");
+};
+
 // src/events.ts
 import fs2 from "fs/promises";
 import { join as join3 } from "path";
 
 // src/internal/utils.ts
-import { globSync } from "glob";
+import { globSync as globSync2 } from "glob";
 import fsSync from "fs";
 import { copy } from "fs-extra";
 import { join, dirname, normalize, resolve, relative } from "path";
 import matter from "gray-matter";
 import { satisfies, validRange } from "semver";
+var _fileIndexCache = null;
+var _fileIndexCatalogDir = null;
+var _matterCache = null;
+var _fileIndexMtimeMs = 0;
+function buildFileCache(catalogDir) {
+  const files = globSync2("**/index.{md,mdx}", {
+    cwd: catalogDir,
+    ignore: ["node_modules/**"],
+    absolute: true,
+    nodir: true
+  }).map(normalize);
+  const index = /* @__PURE__ */ new Map();
+  const matterResults = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const content = fsSync.readFileSync(file, "utf-8");
+    const parsed = matter(content);
+    matterResults.set(file, parsed);
+    const id = parsed.data.id;
+    if (!id) continue;
+    const version = parsed.data.version || "";
+    const isVersioned = file.includes("versioned");
+    const entry = { path: file, id, version: String(version), isVersioned };
+    const existing = index.get(id);
+    if (existing) {
+      existing.push(entry);
+    } else {
+      index.set(id, [entry]);
+    }
+  }
+  _fileIndexCache = index;
+  _fileIndexCatalogDir = catalogDir;
+  _matterCache = matterResults;
+  try {
+    _fileIndexMtimeMs = fsSync.statSync(catalogDir).mtimeMs;
+  } catch {
+    _fileIndexMtimeMs = 0;
+  }
+}
+function ensureFileCache(catalogDir) {
+  if (!_fileIndexCache || _fileIndexCatalogDir !== catalogDir) {
+    buildFileCache(catalogDir);
+    return;
+  }
+  try {
+    const currentMtime = fsSync.statSync(catalogDir).mtimeMs;
+    if (currentMtime !== _fileIndexMtimeMs) {
+      buildFileCache(catalogDir);
+    }
+  } catch {
+    buildFileCache(catalogDir);
+  }
+}
+function invalidateFileCache() {
+  _fileIndexCache = null;
+  _fileIndexCatalogDir = null;
+  _matterCache = null;
+}
+function cachedMatterRead(filePath) {
+  if (_matterCache) {
+    const cached = _matterCache.get(filePath);
+    if (cached) return cached;
+  }
+  return matter.read(filePath);
+}
 var versionExists = async (catalogDir, id, version) => {
-  const files = await getFiles(`${catalogDir}/**/index.{md,mdx}`);
-  const matchedFiles = await searchFilesForId(files, id, version) || [];
-  return matchedFiles.length > 0;
+  ensureFileCache(catalogDir);
+  const entries = _fileIndexCache.get(id);
+  if (!entries) return false;
+  return entries.some((e) => e.version === version);
 };
 var findFileById = async (catalogDir, id, version) => {
-  const files = await getFiles(`${catalogDir}/**/index.{md,mdx}`);
-  const matchedFiles = await searchFilesForId(files, id) || [];
-  const latestVersion = matchedFiles.find((path6) => !path6.includes("versioned"));
-  if (!version) {
-    return latestVersion;
-  }
-  const parsedFiles = matchedFiles.map((path6) => {
-    const { data } = matter.read(path6);
-    return { ...data, path: path6 };
-  });
-  if (version === "latest") {
-    return latestVersion;
-  }
-  const exactMatch = parsedFiles.find((c) => c.version === version);
-  if (exactMatch) {
-    return exactMatch.path;
+  ensureFileCache(catalogDir);
+  const entries = _fileIndexCache.get(id);
+  if (!entries || entries.length === 0) return void 0;
+  const latestEntry = entries.find((e) => !e.isVersioned);
+  if (!version || version === "latest") {
+    return latestEntry?.path;
   }
+  const exactMatch = entries.find((e) => e.version === version);
+  if (exactMatch) return exactMatch.path;
   const semverRange = validRange(version);
   if (semverRange) {
-    const match = parsedFiles.filter((c) => {
+    const match = entries.find((e) => {
       try {
-        return satisfies(c.version, semverRange);
-      } catch (error) {
+        return satisfies(e.version, semverRange);
+      } catch {
         return false;
       }
     });
-    return match.length > 0 ? match[0].path : void 0;
+    return match?.path;
   }
   return void 0;
 };
@@ -57,7 +540,7 @@ var getFiles = async (pattern, ignore = "") => {
     let relativePattern = relative(absoluteBaseDir, normalizedInputPattern);
     relativePattern = relativePattern.replace(/\\/g, "/");
     const ignoreList = Array.isArray(ignore) ? ignore : [ignore];
-    const files = globSync(relativePattern, {
+    const files = globSync2(relativePattern, {
       cwd: absoluteBaseDir,
       ignore: ["node_modules/**", ...ignoreList],
       absolute: true,
@@ -160,6 +643,7 @@ var versionResource = async (catalogDir, id) => {
       })
     );
   });
+  invalidateFileCache();
 };
 var writeResource = async (catalogDir, resource, options = {
   path: "",
@@ -199,6 +683,7 @@ var writeResource = async (catalogDir, resource, options = {
     }
     const document = matter2.stringify(markdown.trim(), frontmatter);
     fsSync2.writeFileSync(lockPath, document);
+    invalidateFileCache();
   } finally {
     await unlock(lockPath).catch(() => {
     });
@@ -208,7 +693,7 @@ var getResource = async (catalogDir, id, version, options, filePath) => {
   const attachSchema = options?.attachSchema || false;
   const file = filePath || (id ? await findFileById(catalogDir, id, version) : void 0);
   if (!file || !fsSync2.existsSync(file)) return;
-  const { data, content } = matter2.read(file);
+  const { data, content } = cachedMatterRead(file);
   if (attachSchema && data?.schemaPath) {
     const resourceDirectory = dirname2(file);
     const pathToSchema = join2(resourceDirectory, data.schemaPath);
@@ -259,7 +744,7 @@ var getResources = async (catalogDir, {
   const files = await getFiles(filePattern, [ignoreList, ...ignore]);
   if (files.length === 0) return;
   return files.map((file) => {
-    const { data, content } = matter2.read(file);
+    const { data, content } = cachedMatterRead(file);
     if (attachSchema && data?.schemaPath) {
       const resourceDirectory = dirname2(file);
       const pathToSchema = join2(resourceDirectory, data.schemaPath);
@@ -300,6 +785,7 @@ var rmResourceById = async (catalogDir, id, version, options) => {
       })
     );
   }
+  invalidateFileCache();
 };
 var waitForFileRemoval = async (path6, maxRetries = 50, delay = 10) => {
   for (let i = 0; i < maxRetries; i++) {
@@ -365,6 +851,7 @@ var writeEventToService = (directory) => async (event, service, options = { path
 };
 var rmEvent = (directory) => async (path6) => {
   await fs2.rm(join3(directory, path6), { recursive: true });
+  invalidateFileCache();
 };
 var rmEventById = (directory) => async (id, version, persistFiles) => {
   await rmResourceById(directory, id, version, { type: "event", persistFiles });
@@ -401,6 +888,7 @@ var writeCommandToService = (directory) => async (command, service, options = {
 };
 var rmCommand = (directory) => async (path6) => {
   await fs3.rm(join4(directory, path6), { recursive: true });
+  invalidateFileCache();
 };
 var rmCommandById = (directory) => async (id, version, persistFiles) => rmResourceById(directory, id, version, { type: "command", persistFiles });
 var versionCommand = (directory) => async (id) => versionResource(directory, id);
@@ -435,6 +923,7 @@ var writeQueryToService = (directory) => async (query, service, options = { path
 };
 var rmQuery = (directory) => async (path6) => {
   await fs4.rm(join5(directory, path6), { recursive: true });
+  invalidateFileCache();
 };
 var rmQueryById = (directory) => async (id, version, persistFiles) => {
   await rmResourceById(directory, id, version, { type: "query", persistFiles });
@@ -459,7 +948,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 = {
@@ -489,6 +989,7 @@ var writeServiceToDomain = (directory) => async (service, domain, options = { pa
 var versionService = (directory) => async (id) => versionResource(directory, id);
 var rmService = (directory) => async (path6) => {
   await fs5.rm(join6(directory, path6), { recursive: true });
+  invalidateFileCache();
 };
 var rmServiceById = (directory) => async (id, version, persistFiles) => {
   await rmResourceById(directory, id, version, { type: "service", persistFiles });
@@ -665,6 +1166,7 @@ var writeDomain = (directory) => async (domain, options = {
 var versionDomain = (directory) => async (id) => versionResource(directory, id);
 var rmDomain = (directory) => async (path6) => {
   await fs6.rm(join7(directory, path6), { recursive: true });
+  invalidateFileCache();
 };
 var rmDomainById = (directory) => async (id, version, persistFiles) => rmResourceById(directory, id, version, { type: "domain", persistFiles });
 var addFileToDomain = (directory) => async (id, file, version) => addFileToResource(directory, id, file, version);
@@ -796,6 +1298,7 @@ var getChannels = (directory) => async (options) => getResources(directory, { ty
 var writeChannel = (directory) => async (channel, options = { path: "" }) => writeResource(directory, { ...channel }, { ...options, type: "channel" });
 var rmChannel = (directory) => async (path6) => {
   await fs7.rm(join8(directory, path6), { recursive: true });
+  invalidateFileCache();
 };
 var rmChannelById = (directory) => async (id, version, persistFiles) => rmResourceById(directory, id, version, { type: "channel", persistFiles });
 var versionChannel = (directory) => async (id) => versionResource(directory, id);
@@ -822,8 +1325,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 = extname2(messagePath?.fullPath || "");
   if (!message) throw new Error(`Message ${_message.id} with version ${_message.version} not found`);
@@ -968,10 +1471,12 @@ var writeCustomDoc = (directory) => async (customDoc, options = { path: "" }) =>
   fsSync4.mkdirSync(path3.dirname(fullPath), { recursive: true });
   const document = matter5.stringify(customDoc.markdown.trim(), rest);
   fsSync4.writeFileSync(fullPath, document);
+  invalidateFileCache();
 };
 var rmCustomDoc = (directory) => async (filePath) => {
   const withExtension = filePath.endsWith(".mdx") ? filePath : `${filePath}.mdx`;
   await fs8.rm(join10(directory, withExtension), { recursive: true });
+  invalidateFileCache();
 };
 
 // src/teams.ts
@@ -1023,9 +1528,11 @@ var writeUser = (catalogDir) => async (user, options = {}) => {
   const document = matter6.stringify(markdown, frontmatter);
   fsSync5.mkdirSync(join11(catalogDir, ""), { recursive: true });
   fsSync5.writeFileSync(join11(catalogDir, "", `${resource.id}.mdx`), document);
+  invalidateFileCache();
 };
 var rmUserById = (catalogDir) => async (id) => {
   fsSync5.rmSync(join11(catalogDir, `${id}.mdx`), { recursive: true });
+  invalidateFileCache();
 };
 
 // src/teams.ts
@@ -1065,9 +1572,11 @@ var writeTeam = (catalogDir) => async (team, options = {}) => {
   const document = matter7.stringify(markdown, frontmatter);
   fsSync6.mkdirSync(join12(catalogDir, ""), { recursive: true });
   fsSync6.writeFileSync(join12(catalogDir, "", `${resource.id}.mdx`), document);
+  invalidateFileCache();
 };
 var rmTeamById = (catalogDir) => async (id) => {
   await fs9.rm(join12(catalogDir, `${id}.mdx`), { recursive: true });
+  invalidateFileCache();
 };
 var getOwnersForResource = (catalogDir) => async (id, version) => {
   const resource = await getResource(catalogDir, id, version);
@@ -1197,6 +1706,7 @@ var writeEntity = (directory) => async (entity, options = {
 }) => writeResource(directory, { ...entity }, { ...options, type: "entity" });
 var rmEntity = (directory) => async (path6) => {
   await fs11.rm(join14(directory, path6), { recursive: true });
+  invalidateFileCache();
 };
 var rmEntityById = (directory) => async (id, version, persistFiles) => {
   await rmResourceById(directory, id, version, { type: "entity", persistFiles });
@@ -1220,6 +1730,7 @@ var writeContainer = (directory) => async (data, options = {
 var versionContainer = (directory) => async (id) => versionResource(directory, id);
 var rmContainer = (directory) => async (path6) => {
   await fs12.rm(join15(directory, path6), { recursive: true });
+  invalidateFileCache();
 };
 var rmContainerById = (directory) => async (id, version, persistFiles) => {
   await rmResourceById(directory, id, version, { type: "container", persistFiles });
@@ -1267,6 +1778,7 @@ var writeDataProductToDomain = (directory) => async (dataProduct, domain, option
 };
 var rmDataProduct = (directory) => async (path6) => {
   await fs13.rm(join16(directory, path6), { recursive: true });
+  invalidateFileCache();
 };
 var rmDataProductById = (directory) => async (id, version, persistFiles) => {
   await rmResourceById(directory, id, version, { type: "data-product", persistFiles });
@@ -1290,6 +1802,7 @@ var writeDiagram = (directory) => async (diagram, options = {
 }) => writeResource(directory, { ...diagram }, { ...options, type: "diagram" });
 var rmDiagram = (directory) => async (path6) => {
   await fs14.rm(join17(directory, path6), { recursive: true });
+  invalidateFileCache();
 };
 var rmDiagramById = (directory) => async (id, version, persistFiles) => {
   await rmResourceById(directory, id, version, { type: "diagram", persistFiles });
@@ -2394,7 +2907,35 @@ var src_default = (path6) => {
      * @param version - Optional version of the diagram to add the file to
      * @returns
      */
-    addFileToDiagram: addFileToDiagram(join18(path6))
+    addFileToDiagram: addFileToDiagram(join18(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(join18(path6), {
+      getEvent: getEvent(join18(path6)),
+      getCommand: getCommand(join18(path6)),
+      getQuery: getQuery(join18(path6)),
+      getService: getService(join18(path6)),
+      getDomain: getDomain(join18(path6, "domains")),
+      getChannel: getChannel(join18(path6)),
+      getTeam: getTeam(join18(path6, "teams")),
+      getUser: getUser(join18(path6, "users"))
+    })
   };
 };
 export {