@eventcatalog/sdk 2.14.0 → 2.14.2

package/dist/index.mjs

@@ -27,10 +27,30 @@ function serializeBaseFields(resource, indent = "  ") {
   }
   return lines.join("\n");
 }
-function resolveMessageType(catalogDir, id) {
-  if (globSync(`**/events/${id}/index.{md,mdx}`, { cwd: catalogDir }).length > 0) return "event";
-  if (globSync(`**/commands/${id}/index.{md,mdx}`, { cwd: catalogDir }).length > 0) return "command";
-  if (globSync(`**/queries/${id}/index.{md,mdx}`, { cwd: catalogDir }).length > 0) return "query";
+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) {
@@ -38,10 +58,10 @@ function serializeChannelRef(channel) {
   if (channel.version) ref += `@${channel.version}`;
   return ref;
 }
-function serializeMessagePointers(items, direction, catalogDir, indent = "  ") {
+function serializeMessagePointers(items, direction, catalogDirOrIndex, indent = "  ") {
   const lines = [];
   for (const item of items) {
-    const msgType = resolveMessageType(catalogDir, item.id);
+    const msgType = resolveMessageType(catalogDirOrIndex, item.id);
     if (!msgType) continue;
     let ref = `${item.id}`;
     if (item.version) ref += `@${item.version}`;
@@ -73,6 +93,7 @@ ${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 || []];
@@ -80,7 +101,7 @@ async function serviceToDSL(resource, options, getMessageFn) {
       const key = `${msg.id}@${msg.version || "latest"}`;
       if (_seen.has(key)) continue;
       _seen.add(key);
-      const msgType = resolveMessageType(catalogDir, msg.id);
+      const msgType = resolveMessageType(msgIndex, msg.id);
       if (!msgType) continue;
       const msgResource = await getMessageFn(msg.id, msg.version);
       if (msgResource) {
@@ -92,11 +113,11 @@ async function serviceToDSL(resource, options, getMessageFn) {
   const baseFields = serializeBaseFields(resource);
   if (baseFields) lines.push(baseFields);
   if (resource.sends && resource.sends.length > 0) {
-    const sendsStr = serializeMessagePointers(resource.sends, "sends", catalogDir);
+    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", catalogDir);
+    const recvStr = serializeMessagePointers(resource.receives, "receives", msgIndex);
     if (recvStr) lines.push(recvStr);
   }
   if (resource.writesTo && resource.writesTo.length > 0) {
@@ -209,6 +230,7 @@ async function hydrateChannelsFromMessages(messages, resolvers, seen, parts) {
 }
 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) {
@@ -221,7 +243,7 @@ async function buildDomainBody(resource, options, resolvers, keyword) {
           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);
+          const svcDsl = await serviceToDSL(svc, { catalogDir, hydrate: true, _seen, _msgIndex: msgIndex }, resolvers.getMessage);
           topLevelParts.push(svcDsl);
         }
       }
@@ -233,7 +255,7 @@ async function buildDomainBody(resource, options, resolvers, keyword) {
         const key = `${msg.id}@${msg.version || "latest"}`;
         if (_seen.has(key)) continue;
         _seen.add(key);
-        const msgType = resolveMessageType(catalogDir, msg.id);
+        const msgType = resolveMessageType(msgIndex, msg.id);
         if (!msgType) continue;
         const msgResource = await resolvers.getMessage(msg.id, msg.version);
         if (msgResource) {
@@ -253,11 +275,11 @@ async function buildDomainBody(resource, options, resolvers, keyword) {
     }
   }
   if (resource.sends && resource.sends.length > 0) {
-    const sendsStr = serializeMessagePointers(resource.sends, "sends", catalogDir);
+    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", catalogDir);
+    const recvStr = serializeMessagePointers(resource.receives, "receives", msgIndex);
     if (recvStr) lines.push(recvStr);
   }
   if (resource.domains && resource.domains.length > 0) {
@@ -269,7 +291,12 @@ async function buildDomainBody(resource, options, resolvers, keyword) {
         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");
+          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);
@@ -291,15 +318,16 @@ ${body}
 }
 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 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, catalogDir) {
+function getMessage(resolvers, msgIndex) {
   return async (id, version) => {
-    const msgType = resolveMessageType(catalogDir, id);
+    const msgType = resolveMessageType(msgIndex, id);
     if (!msgType) return void 0;
     switch (msgType) {
       case "event":
@@ -348,6 +376,7 @@ 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;
@@ -369,8 +398,8 @@ var toDSL = (catalogDir, resolvers) => async (resource, options) => {
         parts.push(
           await serviceToDSL(
             res,
-            { catalogDir, hydrate: options.hydrate, _seen: seen },
-            getMessage(resolvers, catalogDir)
+            { catalogDir, hydrate: options.hydrate, _seen: seen, _msgIndex: msgIndex },
+            getMessage(resolvers, msgIndex)
           )
         );
         break;
@@ -381,11 +410,11 @@ var toDSL = (catalogDir, resolvers) => async (resource, options) => {
         parts.push(
           await domainToDSL(
             res,
-            { catalogDir, hydrate: options.hydrate, _seen: seen },
+            { catalogDir, hydrate: options.hydrate, _seen: seen, _msgIndex: msgIndex },
             {
               getService: resolvers.getService,
               getDomain: resolvers.getDomain,
-              getMessage: getMessage(resolvers, catalogDir),
+              getMessage: getMessage(resolvers, msgIndex),
               getChannel: resolvers.getChannel,
               getTeam: resolvers.getTeam,
               getUser: resolvers.getUser
@@ -406,42 +435,150 @@ import { join as join3 } from "path";
 import { globSync as globSync2 } from "glob";
 import fsSync from "fs";
 import { copy } from "fs-extra";
-import { join, dirname, normalize, resolve, relative } from "path";
+import { join, dirname, normalize, sep as pathSeparator, resolve, relative } from "path";
 import matter from "gray-matter";
 import { satisfies, validRange } from "semver";
+var _fileIndexCache = null;
+var _fileIndexCatalogDir = null;
+var _matterCache = null;
+var _filePathToIdCache = null;
+var _fileIndexMtimeMs = 0;
+function toCanonicalPath(inputPath) {
+  return normalize(resolve(inputPath));
+}
+function buildFileCache(catalogDir) {
+  const canonicalCatalogDir = toCanonicalPath(catalogDir);
+  const files = globSync2("**/index.{md,mdx}", {
+    cwd: canonicalCatalogDir,
+    ignore: ["node_modules/**"],
+    absolute: true,
+    nodir: true
+  }).map(normalize);
+  const index = /* @__PURE__ */ new Map();
+  const matterResults = /* @__PURE__ */ new Map();
+  const pathToId = /* @__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 resourceId = String(id);
+    const version = parsed.data.version || "";
+    const isVersioned = file.includes("versioned");
+    const entry = { path: file, id: resourceId, version: String(version), isVersioned };
+    pathToId.set(file, resourceId);
+    const existing = index.get(resourceId);
+    if (existing) {
+      existing.push(entry);
+    } else {
+      index.set(resourceId, [entry]);
+    }
+  }
+  _fileIndexCache = index;
+  _fileIndexCatalogDir = canonicalCatalogDir;
+  _matterCache = matterResults;
+  _filePathToIdCache = pathToId;
+  try {
+    _fileIndexMtimeMs = fsSync.statSync(canonicalCatalogDir).mtimeMs;
+  } catch {
+    _fileIndexMtimeMs = 0;
+  }
+}
+function ensureFileCache(catalogDir) {
+  const canonicalCatalogDir = toCanonicalPath(catalogDir);
+  if (!_fileIndexCache || _fileIndexCatalogDir !== canonicalCatalogDir) {
+    buildFileCache(catalogDir);
+    return;
+  }
+  try {
+    const currentMtime = fsSync.statSync(canonicalCatalogDir).mtimeMs;
+    if (currentMtime !== _fileIndexMtimeMs) {
+      buildFileCache(catalogDir);
+    }
+  } catch {
+    buildFileCache(catalogDir);
+  }
+}
+function invalidateFileCache() {
+  _fileIndexCache = null;
+  _fileIndexCatalogDir = null;
+  _matterCache = null;
+  _filePathToIdCache = null;
+}
+function upsertFileCacheEntry(catalogDir, filePath, rawContent) {
+  const canonicalCatalogDir = toCanonicalPath(catalogDir);
+  if (!_fileIndexCache || !_matterCache || !_filePathToIdCache || _fileIndexCatalogDir !== canonicalCatalogDir) {
+    return;
+  }
+  const normalizedPath = toCanonicalPath(filePath);
+  const parsed = matter(rawContent);
+  const previousId = _filePathToIdCache.get(normalizedPath);
+  if (previousId) {
+    const previousEntries = _fileIndexCache.get(previousId) || [];
+    const nextEntries = previousEntries.filter((entry2) => entry2.path !== normalizedPath);
+    if (nextEntries.length === 0) {
+      _fileIndexCache.delete(previousId);
+    } else {
+      _fileIndexCache.set(previousId, nextEntries);
+    }
+    _filePathToIdCache.delete(normalizedPath);
+  }
+  _matterCache.set(normalizedPath, parsed);
+  const id = parsed.data.id;
+  if (!id) {
+    _filePathToIdCache.delete(normalizedPath);
+    return;
+  }
+  const resourceId = String(id);
+  const entry = {
+    path: normalizedPath,
+    id: resourceId,
+    version: String(parsed.data.version || ""),
+    isVersioned: normalizedPath.includes(`${pathSeparator}versioned${pathSeparator}`)
+  };
+  const entries = _fileIndexCache.get(resourceId) || [];
+  entries.push(entry);
+  _fileIndexCache.set(resourceId, entries);
+  _filePathToIdCache.set(normalizedPath, resourceId);
+  try {
+    _fileIndexMtimeMs = fsSync.statSync(canonicalCatalogDir).mtimeMs;
+  } catch {
+  }
+}
+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;
 };
@@ -557,6 +694,7 @@ var versionResource = async (catalogDir, id) => {
       })
     );
   });
+  invalidateFileCache();
 };
 var writeResource = async (catalogDir, resource, options = {
   path: "",
@@ -596,6 +734,7 @@ var writeResource = async (catalogDir, resource, options = {
     }
     const document = matter2.stringify(markdown.trim(), frontmatter);
     fsSync2.writeFileSync(lockPath, document);
+    upsertFileCacheEntry(catalogDir, lockPath, document);
   } finally {
     await unlock(lockPath).catch(() => {
     });
@@ -605,7 +744,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);
@@ -656,7 +795,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);
@@ -697,6 +836,7 @@ var rmResourceById = async (catalogDir, id, version, options) => {
       })
     );
   }
+  invalidateFileCache();
 };
 var waitForFileRemoval = async (path6, maxRetries = 50, delay = 10) => {
   for (let i = 0; i < maxRetries; i++) {
@@ -762,6 +902,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 });
@@ -798,6 +939,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);
@@ -832,6 +974,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 });
@@ -897,6 +1040,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 });
@@ -1073,6 +1217,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);
@@ -1204,6 +1349,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);
@@ -1376,10 +1522,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
@@ -1431,9 +1579,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
@@ -1473,9 +1623,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);
@@ -1605,6 +1757,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 });
@@ -1628,6 +1781,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 });
@@ -1675,6 +1829,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 });
@@ -1698,6 +1853,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 });