@eventcatalog/sdk 2.14.1 → 2.14.3

package/dist/index.mjs

@@ -435,54 +435,64 @@ 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: catalogDir,
+    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, 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 = fsSync.statSync(catalogDir).mtimeMs;
+    _fileIndexMtimeMs = fsSync.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 = fsSync.statSync(catalogDir).mtimeMs;
+    const currentMtime = fsSync.statSync(canonicalCatalogDir).mtimeMs;
     if (currentMtime !== _fileIndexMtimeMs) {
       buildFileCache(catalogDir);
     }
@@ -494,6 +504,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 = 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) {
@@ -683,7 +734,7 @@ var writeResource = async (catalogDir, resource, options = {
     }
     const document = matter2.stringify(markdown.trim(), frontmatter);
     fsSync2.writeFileSync(lockPath, document);
-    invalidateFileCache();
+    upsertFileCacheEntry(catalogDir, lockPath, document);
   } finally {
     await unlock(lockPath).catch(() => {
     });