@eventcatalog/sdk 2.14.0 → 2.14.2

package/dist/index.js

@@ -61,10 +61,30 @@ function serializeBaseFields(resource, indent = "  ") {
   }
   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";
+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 = (0, import_glob.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 ((0, import_glob.globSync)(`**/events/${id}/index.{md,mdx}`, { cwd: catalogDirOrIndex }).length > 0) return "event";
+  if ((0, import_glob.globSync)(`**/commands/${id}/index.{md,mdx}`, { cwd: catalogDirOrIndex }).length > 0) return "command";
+  if ((0, import_glob.globSync)(`**/queries/${id}/index.{md,mdx}`, { cwd: catalogDirOrIndex }).length > 0) return "query";
   return void 0;
 }
 function serializeChannelRef(channel) {
@@ -72,10 +92,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}`;
@@ -107,6 +127,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 || []];
@@ -114,7 +135,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) {
@@ -126,11 +147,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) {
@@ -243,6 +264,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) {
@@ -255,7 +277,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);
         }
       }
@@ -267,7 +289,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) {
@@ -287,11 +309,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) {
@@ -303,7 +325,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);
@@ -325,15 +352,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":
@@ -382,6 +410,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;
@@ -403,8 +432,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;
@@ -415,11 +444,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
@@ -443,39 +472,147 @@ 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 _fileIndexCache = null;
+var _fileIndexCatalogDir = null;
+var _matterCache = null;
+var _filePathToIdCache = null;
+var _fileIndexMtimeMs = 0;
+function toCanonicalPath(inputPath) {
+  return (0, import_node_path.normalize)((0, import_node_path.resolve)(inputPath));
+}
+function buildFileCache(catalogDir) {
+  const canonicalCatalogDir = toCanonicalPath(catalogDir);
+  const files = (0, import_glob2.globSync)("**/index.{md,mdx}", {
+    cwd: canonicalCatalogDir,
+    ignore: ["node_modules/**"],
+    absolute: true,
+    nodir: true
+  }).map(import_node_path.normalize);
+  const index = /* @__PURE__ */ new Map();
+  const matterResults = /* @__PURE__ */ new Map();
+  const pathToId = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const content = import_node_fs.default.readFileSync(file, "utf-8");
+    const parsed = (0, import_gray_matter.default)(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 = import_node_fs.default.statSync(canonicalCatalogDir).mtimeMs;
+  } catch {
+    _fileIndexMtimeMs = 0;
+  }
+}
+function ensureFileCache(catalogDir) {
+  const canonicalCatalogDir = toCanonicalPath(catalogDir);
+  if (!_fileIndexCache || _fileIndexCatalogDir !== canonicalCatalogDir) {
+    buildFileCache(catalogDir);
+    return;
+  }
+  try {
+    const currentMtime = import_node_fs.default.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 = (0, import_gray_matter.default)(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(`${import_node_path.sep}versioned${import_node_path.sep}`)
+  };
+  const entries = _fileIndexCache.get(resourceId) || [];
+  entries.push(entry);
+  _fileIndexCache.set(resourceId, entries);
+  _filePathToIdCache.set(normalizedPath, resourceId);
+  try {
+    _fileIndexMtimeMs = import_node_fs.default.statSync(canonicalCatalogDir).mtimeMs;
+  } catch {
+  }
+}
+function cachedMatterRead(filePath) {
+  if (_matterCache) {
+    const cached = _matterCache.get(filePath);
+    if (cached) return cached;
+  }
+  return import_gray_matter.default.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 } = import_gray_matter.default.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 = (0, import_semver.validRange)(version);
   if (semverRange) {
-    const match = parsedFiles.filter((c) => {
+    const match = entries.find((e) => {
       try {
-        return (0, import_semver.satisfies)(c.version, semverRange);
-      } catch (error) {
+        return (0, import_semver.satisfies)(e.version, semverRange);
+      } catch {
         return false;
       }
     });
-    return match.length > 0 ? match[0].path : void 0;
+    return match?.path;
   }
   return void 0;
 };
@@ -591,6 +728,7 @@ var versionResource = async (catalogDir, id) => {
       })
     );
   });
+  invalidateFileCache();
 };
 var writeResource = async (catalogDir, resource, options = {
   path: "",
@@ -630,6 +768,7 @@ var writeResource = async (catalogDir, resource, options = {
     }
     const document = import_gray_matter2.default.stringify(markdown.trim(), frontmatter);
     import_node_fs2.default.writeFileSync(lockPath, document);
+    upsertFileCacheEntry(catalogDir, lockPath, document);
   } finally {
     await (0, import_proper_lockfile.unlock)(lockPath).catch(() => {
     });
@@ -639,7 +778,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 || !import_node_fs2.default.existsSync(file)) return;
-  const { data, content } = import_gray_matter2.default.read(file);
+  const { data, content } = cachedMatterRead(file);
   if (attachSchema && data?.schemaPath) {
     const resourceDirectory = (0, import_path.dirname)(file);
     const pathToSchema = (0, import_path.join)(resourceDirectory, data.schemaPath);
@@ -690,7 +829,7 @@ var getResources = async (catalogDir, {
   const files = await getFiles(filePattern, [ignoreList, ...ignore]);
   if (files.length === 0) return;
   return files.map((file) => {
-    const { data, content } = import_gray_matter2.default.read(file);
+    const { data, content } = cachedMatterRead(file);
     if (attachSchema && data?.schemaPath) {
       const resourceDirectory = (0, import_path.dirname)(file);
       const pathToSchema = (0, import_path.join)(resourceDirectory, data.schemaPath);
@@ -731,6 +870,7 @@ var rmResourceById = async (catalogDir, id, version, options) => {
       })
     );
   }
+  invalidateFileCache();
 };
 var waitForFileRemoval = async (path6, maxRetries = 50, delay = 10) => {
   for (let i = 0; i < maxRetries; i++) {
@@ -796,6 +936,7 @@ var writeEventToService = (directory) => async (event, service, options = { path
 };
 var rmEvent = (directory) => async (path6) => {
   await import_promises2.default.rm((0, import_node_path4.join)(directory, path6), { recursive: true });
+  invalidateFileCache();
 };
 var rmEventById = (directory) => async (id, version, persistFiles) => {
   await rmResourceById(directory, id, version, { type: "event", persistFiles });
@@ -832,6 +973,7 @@ var writeCommandToService = (directory) => async (command, service, options = {
 };
 var rmCommand = (directory) => async (path6) => {
   await import_promises3.default.rm((0, import_node_path5.join)(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);
@@ -866,6 +1008,7 @@ var writeQueryToService = (directory) => async (query, service, options = { path
 };
 var rmQuery = (directory) => async (path6) => {
   await import_promises4.default.rm((0, import_node_path6.join)(directory, path6), { recursive: true });
+  invalidateFileCache();
 };
 var rmQueryById = (directory) => async (id, version, persistFiles) => {
   await rmResourceById(directory, id, version, { type: "query", persistFiles });
@@ -931,6 +1074,7 @@ var writeServiceToDomain = (directory) => async (service, domain, options = { pa
 var versionService = (directory) => async (id) => versionResource(directory, id);
 var rmService = (directory) => async (path6) => {
   await import_promises5.default.rm((0, import_node_path7.join)(directory, path6), { recursive: true });
+  invalidateFileCache();
 };
 var rmServiceById = (directory) => async (id, version, persistFiles) => {
   await rmResourceById(directory, id, version, { type: "service", persistFiles });
@@ -1107,6 +1251,7 @@ var writeDomain = (directory) => async (domain, options = {
 var versionDomain = (directory) => async (id) => versionResource(directory, id);
 var rmDomain = (directory) => async (path6) => {
   await import_promises6.default.rm((0, import_node_path8.join)(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);
@@ -1238,6 +1383,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 import_promises7.default.rm((0, import_node_path9.join)(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);
@@ -1410,10 +1556,12 @@ var writeCustomDoc = (directory) => async (customDoc, options = { path: "" }) =>
   import_node_fs4.default.mkdirSync(import_node_path11.default.dirname(fullPath), { recursive: true });
   const document = import_gray_matter5.default.stringify(customDoc.markdown.trim(), rest);
   import_node_fs4.default.writeFileSync(fullPath, document);
+  invalidateFileCache();
 };
 var rmCustomDoc = (directory) => async (filePath) => {
   const withExtension = filePath.endsWith(".mdx") ? filePath : `${filePath}.mdx`;
   await import_promises8.default.rm((0, import_node_path11.join)(directory, withExtension), { recursive: true });
+  invalidateFileCache();
 };
 
 // src/teams.ts
@@ -1465,9 +1613,11 @@ var writeUser = (catalogDir) => async (user, options = {}) => {
   const document = import_gray_matter6.default.stringify(markdown, frontmatter);
   import_node_fs5.default.mkdirSync((0, import_node_path12.join)(catalogDir, ""), { recursive: true });
   import_node_fs5.default.writeFileSync((0, import_node_path12.join)(catalogDir, "", `${resource.id}.mdx`), document);
+  invalidateFileCache();
 };
 var rmUserById = (catalogDir) => async (id) => {
   import_node_fs5.default.rmSync((0, import_node_path12.join)(catalogDir, `${id}.mdx`), { recursive: true });
+  invalidateFileCache();
 };
 
 // src/teams.ts
@@ -1507,9 +1657,11 @@ var writeTeam = (catalogDir) => async (team, options = {}) => {
   const document = import_gray_matter7.default.stringify(markdown, frontmatter);
   import_node_fs6.default.mkdirSync((0, import_node_path13.join)(catalogDir, ""), { recursive: true });
   import_node_fs6.default.writeFileSync((0, import_node_path13.join)(catalogDir, "", `${resource.id}.mdx`), document);
+  invalidateFileCache();
 };
 var rmTeamById = (catalogDir) => async (id) => {
   await import_promises9.default.rm((0, import_node_path13.join)(catalogDir, `${id}.mdx`), { recursive: true });
+  invalidateFileCache();
 };
 var getOwnersForResource = (catalogDir) => async (id, version) => {
   const resource = await getResource(catalogDir, id, version);
@@ -1639,6 +1791,7 @@ var writeEntity = (directory) => async (entity, options = {
 }) => writeResource(directory, { ...entity }, { ...options, type: "entity" });
 var rmEntity = (directory) => async (path6) => {
   await import_promises10.default.rm((0, import_node_path16.join)(directory, path6), { recursive: true });
+  invalidateFileCache();
 };
 var rmEntityById = (directory) => async (id, version, persistFiles) => {
   await rmResourceById(directory, id, version, { type: "entity", persistFiles });
@@ -1662,6 +1815,7 @@ var writeContainer = (directory) => async (data, options = {
 var versionContainer = (directory) => async (id) => versionResource(directory, id);
 var rmContainer = (directory) => async (path6) => {
   await import_promises11.default.rm((0, import_node_path17.join)(directory, path6), { recursive: true });
+  invalidateFileCache();
 };
 var rmContainerById = (directory) => async (id, version, persistFiles) => {
   await rmResourceById(directory, id, version, { type: "container", persistFiles });
@@ -1709,6 +1863,7 @@ var writeDataProductToDomain = (directory) => async (dataProduct, domain, option
 };
 var rmDataProduct = (directory) => async (path6) => {
   await import_promises12.default.rm((0, import_node_path18.join)(directory, path6), { recursive: true });
+  invalidateFileCache();
 };
 var rmDataProductById = (directory) => async (id, version, persistFiles) => {
   await rmResourceById(directory, id, version, { type: "data-product", persistFiles });
@@ -1732,6 +1887,7 @@ var writeDiagram = (directory) => async (diagram, options = {
 }) => writeResource(directory, { ...diagram }, { ...options, type: "diagram" });
 var rmDiagram = (directory) => async (path6) => {
   await import_promises13.default.rm((0, import_node_path19.join)(directory, path6), { recursive: true });
+  invalidateFileCache();
 };
 var rmDiagramById = (directory) => async (id, version, persistFiles) => {
   await rmResourceById(directory, id, version, { type: "diagram", persistFiles });