@eventcatalog/sdk 2.27.0 → 2.27.2

package/dist/index.d.mts

@@ -1349,7 +1349,7 @@ type Cache = {
 };
 type HydrateOptions = {
     outDir: string;
-    localSource: string;
+    localSource?: string;
     fetch: Fetcher;
     modes?: Record<string, 'hydrate' | 'reference'>;
     cache?: Cache;
@@ -3519,10 +3519,11 @@ declare const _default: (path: string) => {
      * ```
      */
     createSnapshot: (options?: SnapshotOptions) => Promise<SnapshotResult>;
-    buildIndex: ({ source, commit, hashContent }: {
+    buildIndex: ({ source, commit, hashContent, includeFederated }: {
         source: string;
         commit: string;
         hashContent?: boolean;
+        includeFederated?: boolean;
     }) => Promise<Index>;
     diffSnapshots: (snapshotAPath: string, snapshotBPath: string) => Promise<SnapshotDiff>;
     listSnapshots: () => Promise<SnapshotMeta[]>;

package/dist/index.d.ts

@@ -1349,7 +1349,7 @@ type Cache = {
 };
 type HydrateOptions = {
     outDir: string;
-    localSource: string;
+    localSource?: string;
     fetch: Fetcher;
     modes?: Record<string, 'hydrate' | 'reference'>;
     cache?: Cache;
@@ -3519,10 +3519,11 @@ declare const _default: (path: string) => {
      * ```
      */
     createSnapshot: (options?: SnapshotOptions) => Promise<SnapshotResult>;
-    buildIndex: ({ source, commit, hashContent }: {
+    buildIndex: ({ source, commit, hashContent, includeFederated }: {
         source: string;
         commit: string;
         hashContent?: boolean;
+        includeFederated?: boolean;
     }) => Promise<Index>;
     diffSnapshots: (snapshotAPath: string, snapshotBPath: string) => Promise<SnapshotDiff>;
     listSnapshots: () => Promise<SnapshotMeta[]>;

package/dist/index.js

@@ -901,6 +901,8 @@ var import_semver4 = require("semver");
 var import_proper_lockfile = require("proper-lockfile");
 var import_node_path2 = require("path");
 var import_node_path3 = __toESM(require("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);
@@ -1046,10 +1048,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) => {
@@ -3805,6 +3809,7 @@ var listSnapshots = (directory) => async () => {
 var import_node_crypto2 = require("crypto");
 var import_promises18 = __toESM(require("fs/promises"));
 var import_node_path26 = __toESM(require("path"));
+var import_gray_matter8 = __toESM(require("gray-matter"));
 var import_ignore = __toESM(require("ignore"));
 var import_semver8 = require("semver");
 
@@ -3867,6 +3872,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) => import_node_path26.default.relative(directory, filePath).split(import_node_path26.default.sep).join("/");
+var isFederatedPath = (directory, filePath) => toCatalogPath(directory, filePath).startsWith("federated/");
 var loadIgnoreRules = async (directory) => {
   try {
     return (0, import_ignore.default)().add(await import_promises18.default.readFile(import_node_path26.default.join(directory, ".eventcatalogignore"), "utf8"));
@@ -3875,6 +3881,17 @@ var loadIgnoreRules = async (directory) => {
     throw error;
   }
 };
+var getFederatedDirectoryResources = async (directory, type, resourceDirectory, ignoreRules) => {
+  const files = await getFiles(import_node_path26.default.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 } = import_gray_matter8.default.read(sourcePath);
+    return { type, resource: data, sourcePath };
+  });
+};
 var normalizeAssets = async (directory, hashContent, ignoreRules) => {
   const collectFiles = async (currentDirectory) => {
     let entries;
@@ -4032,7 +4049,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,
@@ -4068,6 +4086,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 })),
@@ -4092,19 +4114,20 @@ var buildIndex = (directory) => async ({ source, commit, hashContent = true }) =
       resource,
       sourcePath: import_node_path26.default.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(import_node_path26.default.basename(sourcePath))).map(({ sourcePath }) => import_node_path26.default.resolve(import_node_path26.default.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)
@@ -4124,7 +4147,7 @@ var buildIndex = (directory) => async ({ source, commit, hashContent = true }) =
 var import_node_path27 = __toESM(require("path"));
 var import_node_fs10 = __toESM(require("fs"));
 var import_promises19 = __toESM(require("fs/promises"));
-var import_gray_matter8 = __toESM(require("gray-matter"));
+var import_gray_matter9 = __toESM(require("gray-matter"));
 var writeChangelog = (catalogDir) => async (id, changelog, options = {}) => {
   const { version, format = "mdx" } = options;
   const resourceFile = await findFileById(catalogDir, id, version);
@@ -4142,7 +4165,7 @@ var writeChangelog = (catalogDir) => async (id, changelog, options = {}) => {
     delete fm.badges;
   }
   import_node_fs10.default.mkdirSync(resourceDir, { recursive: true });
-  const document = import_gray_matter8.default.stringify(markdown.trim(), fm);
+  const document = import_gray_matter9.default.stringify(markdown.trim(), fm);
   import_node_fs10.default.writeFileSync(changelogPath, document);
   invalidateFileCache();
 };
@@ -4159,7 +4182,7 @@ var appendChangelog = (catalogDir) => async (id, changelog, options = {}) => {
   if (!existingPath) {
     return writeChangelog(catalogDir)(id, changelog, options);
   }
-  const existing = import_gray_matter8.default.read(existingPath);
+  const existing = import_gray_matter9.default.read(existingPath);
   const existingContent = existing.content.trim();
   const newEntry = changelog.markdown.trim();
   const combined = `${newEntry}
@@ -4174,7 +4197,7 @@ ${existingContent}`;
   } else {
     delete fm.badges;
   }
-  const document = import_gray_matter8.default.stringify(combined, fm);
+  const document = import_gray_matter9.default.stringify(combined, fm);
   import_node_fs10.default.writeFileSync(existingPath, document);
   invalidateFileCache();
 };
@@ -4187,7 +4210,7 @@ var getChangelog = (catalogDir) => async (id, options = {}) => {
   const mdPath = import_node_path27.default.join(resourceDir, "changelog.md");
   const changelogPath = import_node_fs10.default.existsSync(mdxPath) ? mdxPath : import_node_fs10.default.existsSync(mdPath) ? mdPath : void 0;
   if (!changelogPath) return void 0;
-  const { data, content } = import_gray_matter8.default.read(changelogPath);
+  const { data, content } = import_gray_matter9.default.read(changelogPath);
   return { ...data, markdown: content.trim() };
 };
 var rmChangelog = (catalogDir) => async (id, options = {}) => {
@@ -4274,10 +4297,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);
@@ -4427,6 +4447,7 @@ var getSourceDirectory = (source) => {
   return `${slug}--${digest}`;
 };
 var getContentHash = (content) => `sha256:${(0, import_node_crypto3.createHash)("sha256").update(content).digest("hex")}`;
+var getHydrationTarget = (artifactPath) => artifactPath.replace(/^(?:federated\/[^/]+\/)+/, "");
 var getArtifactOutputPath = (artifact, outDir) => {
   const allowedDirectory = import_node_path28.default.resolve(artifact.shared ? outDir : import_node_path28.default.join(outDir, getSourceDirectory(artifact.source)));
   const portableTarget = artifact.target.replaceAll("\\", "/");
@@ -4466,7 +4487,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;
@@ -4477,31 +4498,44 @@ async function hydrate(graph, options) {
       commit,
       path: entity.contentPath,
       hash: entity.contentHash,
-      target: entity.contentPath
+      target: getHydrationTarget(entity.contentPath)
     });
     const entityDirectory = import_node_path28.default.posix.dirname(entity.contentPath);
     for (const schema of entity.schemas ?? []) {
       if (!schema.path) continue;
       const artifactPath = import_node_path28.default.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 = import_node_path28.default.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
     });
   }