@eventcatalog/sdk 2.14.1 → 2.14.2

package/dist/index.js

@@ -475,48 +475,58 @@ 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: catalogDir,
+    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, version: String(version), isVersioned };
-    const existing = index.get(id);
+    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(id, [entry]);
+      index.set(resourceId, [entry]);
     }
   }
   _fileIndexCache = index;
-  _fileIndexCatalogDir = catalogDir;
+  _fileIndexCatalogDir = canonicalCatalogDir;
   _matterCache = matterResults;
+  _filePathToIdCache = pathToId;
   try {
-    _fileIndexMtimeMs = import_node_fs.default.statSync(catalogDir).mtimeMs;
+    _fileIndexMtimeMs = import_node_fs.default.statSync(canonicalCatalogDir).mtimeMs;
   } catch {
     _fileIndexMtimeMs = 0;
   }
 }
 function ensureFileCache(catalogDir) {
-  if (!_fileIndexCache || _fileIndexCatalogDir !== catalogDir) {
+  const canonicalCatalogDir = toCanonicalPath(catalogDir);
+  if (!_fileIndexCache || _fileIndexCatalogDir !== canonicalCatalogDir) {
     buildFileCache(catalogDir);
     return;
   }
   try {
-    const currentMtime = import_node_fs.default.statSync(catalogDir).mtimeMs;
+    const currentMtime = import_node_fs.default.statSync(canonicalCatalogDir).mtimeMs;
     if (currentMtime !== _fileIndexMtimeMs) {
       buildFileCache(catalogDir);
     }
@@ -528,6 +538,47 @@ 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) {
@@ -717,7 +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);
-    invalidateFileCache();
+    upsertFileCacheEntry(catalogDir, lockPath, document);
   } finally {
     await (0, import_proper_lockfile.unlock)(lockPath).catch(() => {
     });