@eventcatalog/sdk 2.27.1 → 2.27.3

package/dist/index.mjs

@@ -636,7 +636,7 @@ function buildFileCache(catalogDir) {
   const canonicalCatalogDir = toCanonicalPath(catalogDir);
   const files = globSync2("**/index.{md,mdx}", {
     cwd: canonicalCatalogDir,
-    ignore: ["node_modules/**"],
+    ignore: ["node_modules/**", "dist/**", ".eventcatalog-core/**"],
     absolute: true,
     nodir: true
   }).map(normalize);
@@ -779,7 +779,7 @@ var getFiles = async (pattern, ignore2 = "") => {
     const ignoreList = Array.isArray(ignore2) ? ignore2 : [ignore2];
     const files = globSync2(relativePattern, {
       cwd: absoluteBaseDir,
-      ignore: ["node_modules/**", ...ignoreList],
+      ignore: ["node_modules/**", "dist/**", ".eventcatalog-core/**", ...ignoreList],
       absolute: true,
       nodir: true
     });
@@ -861,6 +861,8 @@ import { satisfies as satisfies3 } from "semver";
 import { lock, unlock } from "proper-lockfile";
 import { basename as basename2 } from "path";
 import path from "path";
+var resourceSourcePaths = /* @__PURE__ */ new WeakMap();
+var getResourceSourcePath = (resource) => resourceSourcePaths.get(resource);
 var versionResource = async (catalogDir, id) => {
   const files = await getFiles(`${catalogDir}/**/index.{md,mdx}`);
   const matchedFiles = await searchFilesForId(files, id);
@@ -1006,10 +1008,12 @@ var getResources = async (catalogDir, {
         }
       }
     }
-    return {
+    const resource = {
       ...data,
       markdown: content.trim()
     };
+    resourceSourcePaths.set(resource, file);
+    return resource;
   });
 };
 var rmResourceById = async (catalogDir, id, version, options) => {
@@ -3765,6 +3769,7 @@ var listSnapshots = (directory) => async () => {
 import { createHash as createHash2 } from "crypto";
 import fs21 from "fs/promises";
 import path8 from "path";
+import matter8 from "gray-matter";
 import ignore from "ignore";
 import { rcompare, valid as valid2 } from "semver";
 
@@ -3827,6 +3832,7 @@ var compareVersions = (left, right) => {
 };
 var compareIndexResources = (left, right) => compareText(left.type, right.type) || compareText(left.id, right.id) || compareVersions(left.version, right.version);
 var toCatalogPath = (directory, filePath) => path8.relative(directory, filePath).split(path8.sep).join("/");
+var isFederatedPath = (directory, filePath) => toCatalogPath(directory, filePath).startsWith("federated/");
 var loadIgnoreRules = async (directory) => {
   try {
     return ignore().add(await fs21.readFile(path8.join(directory, ".eventcatalogignore"), "utf8"));
@@ -3835,6 +3841,17 @@ var loadIgnoreRules = async (directory) => {
     throw error;
   }
 };
+var getFederatedDirectoryResources = async (directory, type, resourceDirectory, ignoreRules) => {
+  const files = await getFiles(path8.join(directory, "federated", "**", resourceDirectory, "*.{md,mdx}"));
+  const resourcePathPattern = new RegExp(`^(?:federated/[^/]+/)+${resourceDirectory}/[^/]+\\.mdx?$`, "i");
+  return files.filter((file) => {
+    const catalogPath = toCatalogPath(directory, file);
+    return resourcePathPattern.test(catalogPath) && !ignoreRules?.ignores(catalogPath);
+  }).map((sourcePath) => {
+    const { data } = matter8.read(sourcePath);
+    return { type, resource: data, sourcePath };
+  });
+};
 var normalizeAssets = async (directory, hashContent, ignoreRules) => {
   const collectFiles = async (currentDirectory) => {
     let entries;
@@ -3992,7 +4009,8 @@ var toIndexResource = async (directory, type, resource, hashContent, sourcePath,
     ...resource.members === void 0 ? {} : { members: resource.members }
   };
 };
-var buildIndex = (directory) => async ({ source, commit, hashContent = true }) => {
+var buildIndex = (directory) => async ({ source, commit, hashContent = true, includeFederated = true }) => {
+  const ignoreRules = await loadIgnoreRules(directory);
   const [
     domains,
     channels,
@@ -4028,6 +4046,10 @@ var buildIndex = (directory) => async ({ source, commit, hashContent = true }) =
     getUsers(directory)(),
     getDiagrams(directory)()
   ]);
+  const federatedDirectoryResources = includeFederated ? await Promise.all([
+    getFederatedDirectoryResources(directory, "team", "teams", ignoreRules),
+    getFederatedDirectoryResources(directory, "user", "users", ignoreRules)
+  ]) : [];
   const indexableResources = [
     ...(domains ?? []).map((resource) => ({ type: "domain", resource })),
     ...(channels ?? []).map((resource) => ({ type: "channel", resource })),
@@ -4052,19 +4074,20 @@ var buildIndex = (directory) => async ({ source, commit, hashContent = true }) =
       resource,
       sourcePath: path8.join(directory, "users", `${resource.id}.mdx`)
     })),
+    ...federatedDirectoryResources.flat(),
     ...(diagrams ?? []).map((resource) => ({ type: "diagram", resource }))
   ];
-  const locatedResources = await Promise.all(
+  const locatedResources = (await Promise.all(
     indexableResources.map(async (entry) => {
-      const sourcePath = entry.sourcePath ?? (await getResourcePath(directory, entry.resource.id, entry.resource.version))?.fullPath;
+      const sourcePath = entry.sourcePath ?? (includeFederated ? void 0 : getResourceSourcePath(entry.resource)) ?? (await getResourcePath(directory, entry.resource.id, entry.resource.version))?.fullPath;
       if (!sourcePath) throw new Error(`Cannot find ${entry.type} ${entry.resource.id} (${entry.resource.version})`);
+      if (!includeFederated && isFederatedPath(directory, sourcePath)) return void 0;
       return { ...entry, sourcePath };
     })
-  );
+  )).filter((entry) => entry !== void 0);
   const resourceDirectories = new Set(
     locatedResources.filter(({ sourcePath }) => /^index\.mdx?$/i.test(path8.basename(sourcePath))).map(({ sourcePath }) => path8.resolve(path8.dirname(sourcePath)))
   );
-  const ignoreRules = await loadIgnoreRules(directory);
   const resources = await Promise.all(
     locatedResources.map(
       ({ type, resource, sourcePath }) => toIndexResource(directory, type, resource, hashContent, sourcePath, resourceDirectories, ignoreRules)
@@ -4084,7 +4107,7 @@ var buildIndex = (directory) => async ({ source, commit, hashContent = true }) =
 import path9, { dirname as dirname7 } from "path";
 import fsSync8 from "fs";
 import fs22 from "fs/promises";
-import matter8 from "gray-matter";
+import matter9 from "gray-matter";
 var writeChangelog = (catalogDir) => async (id, changelog, options = {}) => {
   const { version, format = "mdx" } = options;
   const resourceFile = await findFileById(catalogDir, id, version);
@@ -4102,7 +4125,7 @@ var writeChangelog = (catalogDir) => async (id, changelog, options = {}) => {
     delete fm.badges;
   }
   fsSync8.mkdirSync(resourceDir, { recursive: true });
-  const document = matter8.stringify(markdown.trim(), fm);
+  const document = matter9.stringify(markdown.trim(), fm);
   fsSync8.writeFileSync(changelogPath, document);
   invalidateFileCache();
 };
@@ -4119,7 +4142,7 @@ var appendChangelog = (catalogDir) => async (id, changelog, options = {}) => {
   if (!existingPath) {
     return writeChangelog(catalogDir)(id, changelog, options);
   }
-  const existing = matter8.read(existingPath);
+  const existing = matter9.read(existingPath);
   const existingContent = existing.content.trim();
   const newEntry = changelog.markdown.trim();
   const combined = `${newEntry}
@@ -4134,7 +4157,7 @@ ${existingContent}`;
   } else {
     delete fm.badges;
   }
-  const document = matter8.stringify(combined, fm);
+  const document = matter9.stringify(combined, fm);
   fsSync8.writeFileSync(existingPath, document);
   invalidateFileCache();
 };
@@ -4147,7 +4170,7 @@ var getChangelog = (catalogDir) => async (id, options = {}) => {
   const mdPath = path9.join(resourceDir, "changelog.md");
   const changelogPath = fsSync8.existsSync(mdxPath) ? mdxPath : fsSync8.existsSync(mdPath) ? mdPath : void 0;
   if (!changelogPath) return void 0;
-  const { data, content } = matter8.read(changelogPath);
+  const { data, content } = matter9.read(changelogPath);
   return { ...data, markdown: content.trim() };
 };
 var rmChangelog = (catalogDir) => async (id, options = {}) => {
@@ -4234,10 +4257,7 @@ var resolve2 = (indexes) => {
   const assets = [];
   const warnings = [];
   for (const [assetPath, candidates] of assetCandidatesByPath) {
-    candidates.sort(
-      (left, right) => compareText2(left.resolvedFrom.source, right.resolvedFrom.source) || compareText2(left.resolvedFrom.commit, right.resolvedFrom.commit)
-    );
-    const [winner] = candidates;
+    const winner = candidates[candidates.length - 1];
     const sources = [...new Set(candidates.map((candidate) => candidate.resolvedFrom.source))].sort(compareText2);
     const hashes = new Set(candidates.map((candidate) => candidate.hash));
     const hashesCanBeCompared = candidates.every((candidate) => candidate.hash !== void 0);
@@ -4387,6 +4407,7 @@ var getSourceDirectory = (source) => {
   return `${slug}--${digest}`;
 };
 var getContentHash = (content) => `sha256:${createHash3("sha256").update(content).digest("hex")}`;
+var getHydrationTarget = (artifactPath) => artifactPath.replace(/^(?:federated\/[^/]+\/)+/, "");
 var getArtifactOutputPath = (artifact, outDir) => {
   const allowedDirectory = path10.resolve(artifact.shared ? outDir : path10.join(outDir, getSourceDirectory(artifact.source)));
   const portableTarget = artifact.target.replaceAll("\\", "/");
@@ -4426,7 +4447,7 @@ async function hydrate(graph, options) {
   const artifacts = [];
   for (const entity of graph.entities) {
     const { source, commit } = entity.resolvedFrom;
-    if (source === options.localSource) continue;
+    if (options.localSource !== void 0 && source === options.localSource) continue;
     if (options.modes?.[source] === "reference") {
       result.referenced++;
       continue;
@@ -4437,31 +4458,44 @@ async function hydrate(graph, options) {
       commit,
       path: entity.contentPath,
       hash: entity.contentHash,
-      target: entity.contentPath
+      target: getHydrationTarget(entity.contentPath)
     });
     const entityDirectory = path10.posix.dirname(entity.contentPath);
     for (const schema of entity.schemas ?? []) {
       if (!schema.path) continue;
       const artifactPath = path10.posix.join(entityDirectory, schema.path);
-      artifacts.push({ source, commit, path: artifactPath, hash: schema.hash, target: artifactPath });
+      artifacts.push({ source, commit, path: artifactPath, hash: schema.hash, target: getHydrationTarget(artifactPath) });
     }
     for (const specification of entity.specifications ?? []) {
       const artifactPath = path10.posix.join(entityDirectory, specification.path);
-      artifacts.push({ source, commit, path: artifactPath, hash: specification.hash, target: artifactPath });
+      artifacts.push({
+        source,
+        commit,
+        path: artifactPath,
+        hash: specification.hash,
+        target: getHydrationTarget(artifactPath)
+      });
     }
     for (const sidecar of entity.sidecars ?? []) {
-      artifacts.push({ source, commit, path: sidecar.path, hash: sidecar.hash, target: sidecar.path });
+      artifacts.push({
+        source,
+        commit,
+        path: sidecar.path,
+        hash: sidecar.hash,
+        target: getHydrationTarget(sidecar.path)
+      });
     }
   }
   for (const asset of graph.assets) {
     const { source, commit } = asset.resolvedFrom;
-    if (source === options.localSource || options.modes?.[source] === "reference") continue;
+    if (options.localSource !== void 0 && source === options.localSource || options.modes?.[source] === "reference")
+      continue;
     artifacts.push({
       source,
       commit,
       path: asset.path,
       hash: asset.hash,
-      target: asset.path,
+      target: getHydrationTarget(asset.path),
       shared: true
     });
   }