@eventcatalog/core 4.11.2 → 4.12.0-beta.2

package/dist/federation/federate.cjs

@@ -36,18 +36,22 @@ __export(federate_exports, {
 });
 module.exports = __toCommonJS(federate_exports);
 var import_node_crypto4 = require("crypto");
-var import_promises7 = __toESM(require("fs/promises"), 1);
-var import_node_path7 = __toESM(require("path"), 1);
+var import_promises8 = __toESM(require("fs/promises"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
 var import_sdk3 = __toESM(require("@eventcatalog/sdk"), 1);
 
 // src/eventcatalog-config-file-utils.js
+var import_promises2 = require("fs/promises");
+var import_node_path2 = __toESM(require("path"), 1);
+var import_uuid = require("uuid");
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+
+// eventcatalog/integrations/config-loader.mjs
 var import_promises = require("fs/promises");
 var import_node_fs = require("fs");
 var import_node_path = __toESM(require("path"), 1);
-var import_uuid = require("uuid");
-var import_url = require("url");
+var import_node_url = require("url");
 var import_node_os = require("os");
-var import_gray_matter = __toESM(require("gray-matter"), 1);
 async function cleanup(projectDirectory) {
   const filePath = import_node_path.default.join(projectDirectory, "eventcatalog.config.mjs");
   if ((0, import_node_fs.existsSync)(filePath)) {
@@ -95,7 +99,7 @@ var getEventCatalogConfigFile = async (projectDirectory) => {
       configFilePath = import_node_path.default.join(tempDir, "eventcatalog.config.mjs");
       await (0, import_promises.copyFile)(import_node_path.default.join(projectDirectory, "eventcatalog.config.js"), configFilePath);
     }
-    const configFileURL = `${(0, import_url.pathToFileURL)(configFilePath).href}?t=${Date.now()}`;
+    const configFileURL = `${(0, import_node_url.pathToFileURL)(configFilePath).href}?t=${Date.now()}`;
     const config = await import(
       /* @vite-ignore */
       configFileURL
@@ -111,21 +115,21 @@ var getEventCatalogConfigFile = async (projectDirectory) => {
 
 // src/federation/content-cache.ts
 var import_node_crypto = require("crypto");
-var import_promises2 = __toESM(require("fs/promises"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
 var getContentHash = (content) => `sha256:${(0, import_node_crypto.createHash)("sha256").update(content).digest("hex")}`;
 var isContentHash = (key) => /^sha256:[a-f0-9]{64}$/i.test(key);
 var createFederationContentCache = (projectDirectory, options = {}) => {
-  const cacheDirectory = import_node_path2.default.join(projectDirectory, ".eventcatalog-cache", "federation", "content");
-  const getCachePath = (key) => import_node_path2.default.join(cacheDirectory, encodeURIComponent(key));
+  const cacheDirectory = import_node_path3.default.join(projectDirectory, ".eventcatalog-cache", "federation", "content");
+  const getCachePath = (key) => import_node_path3.default.join(cacheDirectory, encodeURIComponent(key));
   return {
     async get(key) {
       if (options.read === false || !isContentHash(key)) return void 0;
       const cachePath = getCachePath(key);
       try {
-        const content = await import_promises2.default.readFile(cachePath);
+        const content = await import_promises3.default.readFile(cachePath);
         if (getContentHash(content) !== key) {
-          await import_promises2.default.rm(cachePath, { force: true });
+          await import_promises3.default.rm(cachePath, { force: true });
           return void 0;
         }
         options.onHit?.(key);
@@ -137,14 +141,14 @@ var createFederationContentCache = (projectDirectory, options = {}) => {
     },
     async set(key, content) {
       if (!isContentHash(key) || getContentHash(content) !== key) return;
-      await import_promises2.default.mkdir(cacheDirectory, { recursive: true });
+      await import_promises3.default.mkdir(cacheDirectory, { recursive: true });
       const cachePath = getCachePath(key);
       const temporaryPath = `${cachePath}.tmp-${process.pid}-${(0, import_node_crypto.randomUUID)()}`;
       try {
-        await import_promises2.default.writeFile(temporaryPath, content);
-        await import_promises2.default.rename(temporaryPath, cachePath);
+        await import_promises3.default.writeFile(temporaryPath, content);
+        await import_promises3.default.rename(temporaryPath, cachePath);
       } finally {
-        await import_promises2.default.rm(temporaryPath, { force: true });
+        await import_promises3.default.rm(temporaryPath, { force: true });
       }
     }
   };
@@ -299,21 +303,21 @@ var import_license = require("@eventcatalog/license");
 var isFederationEnabled = () => (0, import_license.isEventCatalogEnterpriseEnabled)();
 
 // src/federation/output-transaction.ts
-var import_promises3 = __toESM(require("fs/promises"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
+var import_promises4 = __toESM(require("fs/promises"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 var getSafePublicPath = (publicDirectory, relativePath) => {
-  const normalizedPath = import_node_path3.default.posix.normalize(relativePath);
-  const unsafe = relativePath.length === 0 || relativePath.includes("\0") || relativePath.includes("\\") || import_node_path3.default.posix.isAbsolute(relativePath) || /^[a-zA-Z]:\//.test(relativePath) || normalizedPath !== relativePath || normalizedPath === ".." || normalizedPath.startsWith("../");
+  const normalizedPath = import_node_path4.default.posix.normalize(relativePath);
+  const unsafe = relativePath.length === 0 || relativePath.includes("\0") || relativePath.includes("\\") || import_node_path4.default.posix.isAbsolute(relativePath) || /^[a-zA-Z]:\//.test(relativePath) || normalizedPath !== relativePath || normalizedPath === ".." || normalizedPath.startsWith("../");
   if (unsafe) return void 0;
-  const destinationPath = import_node_path3.default.resolve(publicDirectory, relativePath);
-  const relativeDestinationPath = import_node_path3.default.relative(publicDirectory, destinationPath);
-  return relativeDestinationPath !== "" && relativeDestinationPath !== ".." && !relativeDestinationPath.startsWith(`..${import_node_path3.default.sep}`) && !import_node_path3.default.isAbsolute(relativeDestinationPath) ? destinationPath : void 0;
+  const destinationPath = import_node_path4.default.resolve(publicDirectory, relativePath);
+  const relativeDestinationPath = import_node_path4.default.relative(publicDirectory, destinationPath);
+  return relativeDestinationPath !== "" && relativeDestinationPath !== ".." && !relativeDestinationPath.startsWith(`..${import_node_path4.default.sep}`) && !import_node_path4.default.isAbsolute(relativeDestinationPath) ? destinationPath : void 0;
 };
 var beginFederationOutputTransaction = async (projectDirectory, outDir, relativePublicPaths) => {
-  const transactionDirectory = await import_promises3.default.mkdtemp(import_node_path3.default.join(projectDirectory, ".eventcatalog-federation-transaction-"));
-  const previousOutDir = import_node_path3.default.join(transactionDirectory, "federated");
-  const publicBackupDirectory = import_node_path3.default.join(transactionDirectory, "public");
-  const publicDirectory = import_node_path3.default.resolve(projectDirectory, "public");
+  const transactionDirectory = await import_promises4.default.mkdtemp(import_node_path4.default.join(projectDirectory, ".eventcatalog-federation-transaction-"));
+  const previousOutDir = import_node_path4.default.join(transactionDirectory, "federated");
+  const publicBackupDirectory = import_node_path4.default.join(transactionDirectory, "public");
+  const publicDirectory = import_node_path4.default.resolve(projectDirectory, "public");
   const publicSnapshots = [];
   const missingPublicDirectories = /* @__PURE__ */ new Set();
   let hadPreviousOutDir = false;
@@ -322,45 +326,45 @@ var beginFederationOutputTransaction = async (projectDirectory, outDir, relative
       const destinationPath = getSafePublicPath(publicDirectory, relativePath);
       if (!destinationPath) continue;
       try {
-        const stat = await import_promises3.default.lstat(destinationPath);
+        const stat = await import_promises4.default.lstat(destinationPath);
         if (!stat.isFile()) continue;
-        const backupPath = import_node_path3.default.join(publicBackupDirectory, `${publicSnapshots.length}`);
-        await import_promises3.default.mkdir(import_node_path3.default.dirname(backupPath), { recursive: true });
-        await import_promises3.default.copyFile(destinationPath, backupPath);
+        const backupPath = import_node_path4.default.join(publicBackupDirectory, `${publicSnapshots.length}`);
+        await import_promises4.default.mkdir(import_node_path4.default.dirname(backupPath), { recursive: true });
+        await import_promises4.default.copyFile(destinationPath, backupPath);
         publicSnapshots.push({ backupPath, destinationPath, state: "file" });
       } catch (error) {
         const code = error.code;
         if (code === "ENOTDIR") continue;
         if (code !== "ENOENT") throw error;
         publicSnapshots.push({ destinationPath, state: "missing" });
-        let directory = import_node_path3.default.dirname(destinationPath);
+        let directory = import_node_path4.default.dirname(destinationPath);
         while (directory !== publicDirectory) {
           try {
-            await import_promises3.default.lstat(directory);
+            await import_promises4.default.lstat(directory);
             break;
           } catch (directoryError) {
             const directoryCode = directoryError.code;
             if (directoryCode === "ENOTDIR") break;
             if (directoryCode !== "ENOENT") throw directoryError;
             missingPublicDirectories.add(directory);
-            directory = import_node_path3.default.dirname(directory);
+            directory = import_node_path4.default.dirname(directory);
           }
         }
       }
     }
     try {
-      await import_promises3.default.rename(outDir, previousOutDir);
+      await import_promises4.default.rename(outDir, previousOutDir);
       hadPreviousOutDir = true;
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
     }
   } catch (error) {
-    await import_promises3.default.rm(transactionDirectory, { recursive: true, force: true });
+    await import_promises4.default.rm(transactionDirectory, { recursive: true, force: true });
     throw error;
   }
   return {
     commit: async () => {
-      await import_promises3.default.rm(transactionDirectory, { recursive: true, force: true }).catch(() => void 0);
+      await import_promises4.default.rm(transactionDirectory, { recursive: true, force: true }).catch(() => void 0);
     },
     rollback: async () => {
       const rollbackErrors = [];
@@ -371,28 +375,28 @@ var beginFederationOutputTransaction = async (projectDirectory, outDir, relative
           rollbackErrors.push(error);
         }
       };
-      await attempt(() => import_promises3.default.rm(outDir, { recursive: true, force: true }));
-      if (hadPreviousOutDir) await attempt(() => import_promises3.default.rename(previousOutDir, outDir));
+      await attempt(() => import_promises4.default.rm(outDir, { recursive: true, force: true }));
+      if (hadPreviousOutDir) await attempt(() => import_promises4.default.rename(previousOutDir, outDir));
       for (const snapshot of publicSnapshots) {
         if (snapshot.state === "missing") {
-          await attempt(() => import_promises3.default.rm(snapshot.destinationPath, { force: true }));
+          await attempt(() => import_promises4.default.rm(snapshot.destinationPath, { force: true }));
           continue;
         }
         await attempt(async () => {
-          await import_promises3.default.mkdir(import_node_path3.default.dirname(snapshot.destinationPath), { recursive: true });
-          await import_promises3.default.copyFile(snapshot.backupPath, snapshot.destinationPath);
+          await import_promises4.default.mkdir(import_node_path4.default.dirname(snapshot.destinationPath), { recursive: true });
+          await import_promises4.default.copyFile(snapshot.backupPath, snapshot.destinationPath);
         });
       }
       for (const directory of [...missingPublicDirectories].sort((left, right) => right.length - left.length)) {
         await attempt(async () => {
           try {
-            await import_promises3.default.rmdir(directory);
+            await import_promises4.default.rmdir(directory);
           } catch (error) {
             if (!["ENOENT", "ENOTEMPTY"].includes(error.code ?? "")) throw error;
           }
         });
       }
-      await attempt(() => import_promises3.default.rm(transactionDirectory, { recursive: true, force: true }));
+      await attempt(() => import_promises4.default.rm(transactionDirectory, { recursive: true, force: true }));
       if (rollbackErrors.length > 0) throw new AggregateError(rollbackErrors, "Failed to restore the previous federation output");
     }
   };
@@ -415,26 +419,26 @@ var withFederationOutputTransaction = async (projectDirectory, outDir, relativeP
 
 // src/federation/public-assets.ts
 var import_node_crypto2 = require("crypto");
-var import_promises4 = __toESM(require("fs/promises"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
+var import_promises5 = __toESM(require("fs/promises"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 var getContentHash2 = (content) => `sha256:${(0, import_node_crypto2.createHash)("sha256").update(content).digest("hex")}`;
 var getFileHash = async (filePath) => {
   try {
-    const stat = await import_promises4.default.lstat(filePath);
-    return stat.isFile() ? getContentHash2(await import_promises4.default.readFile(filePath)) : void 0;
+    const stat = await import_promises5.default.lstat(filePath);
+    return stat.isFile() ? getContentHash2(await import_promises5.default.readFile(filePath)) : void 0;
   } catch (error) {
     if (error.code === "ENOENT") return void 0;
     throw error;
   }
 };
 var getSafePath = (directory, relativePath) => {
-  const normalizedPath = import_node_path4.default.posix.normalize(relativePath);
-  const unsafe = relativePath.length === 0 || relativePath.includes("\0") || relativePath.includes("\\") || import_node_path4.default.posix.isAbsolute(relativePath) || /^[a-zA-Z]:\//.test(relativePath) || normalizedPath !== relativePath || normalizedPath === ".." || normalizedPath.startsWith("../");
+  const normalizedPath = import_node_path5.default.posix.normalize(relativePath);
+  const unsafe = relativePath.length === 0 || relativePath.includes("\0") || relativePath.includes("\\") || import_node_path5.default.posix.isAbsolute(relativePath) || /^[a-zA-Z]:\//.test(relativePath) || normalizedPath !== relativePath || normalizedPath === ".." || normalizedPath.startsWith("../");
   if (unsafe) return void 0;
-  const resolvedDirectory = import_node_path4.default.resolve(directory);
-  const resolvedPath = import_node_path4.default.resolve(resolvedDirectory, relativePath);
-  const relativeResolvedPath = import_node_path4.default.relative(resolvedDirectory, resolvedPath);
-  if (relativeResolvedPath === "" || relativeResolvedPath === ".." || relativeResolvedPath.startsWith(`..${import_node_path4.default.sep}`) || import_node_path4.default.isAbsolute(relativeResolvedPath)) {
+  const resolvedDirectory = import_node_path5.default.resolve(directory);
+  const resolvedPath = import_node_path5.default.resolve(resolvedDirectory, relativePath);
+  const relativeResolvedPath = import_node_path5.default.relative(resolvedDirectory, resolvedPath);
+  if (relativeResolvedPath === "" || relativeResolvedPath === ".." || relativeResolvedPath.startsWith(`..${import_node_path5.default.sep}`) || import_node_path5.default.isAbsolute(relativeResolvedPath)) {
     return void 0;
   }
   return resolvedPath;
@@ -442,23 +446,23 @@ var getSafePath = (directory, relativePath) => {
 var listFiles = async (directory, relativeDirectory = "") => {
   let entries;
   try {
-    entries = await import_promises4.default.readdir(import_node_path4.default.join(directory, relativeDirectory), { withFileTypes: true });
+    entries = await import_promises5.default.readdir(import_node_path5.default.join(directory, relativeDirectory), { withFileTypes: true });
   } catch (error) {
     if (error.code === "ENOENT") return [];
     throw error;
   }
   const files = await Promise.all(
     entries.map(async (entry) => {
-      const relativePath = import_node_path4.default.join(relativeDirectory, entry.name);
+      const relativePath = import_node_path5.default.join(relativeDirectory, entry.name);
       if (entry.isDirectory()) return listFiles(directory, relativePath);
-      return entry.isFile() ? [relativePath.split(import_node_path4.default.sep).join("/")] : [];
+      return entry.isFile() ? [relativePath.split(import_node_path5.default.sep).join("/")] : [];
     })
   );
   return files.flat().sort();
 };
 var pathExists = async (filePath) => {
   try {
-    await import_promises4.default.lstat(filePath);
+    await import_promises5.default.lstat(filePath);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") return false;
@@ -466,27 +470,27 @@ var pathExists = async (filePath) => {
   }
 };
 var hasBlockingParent = async (publicDirectory, destinationPath) => {
-  let currentPath = import_node_path4.default.dirname(destinationPath);
+  let currentPath = import_node_path5.default.dirname(destinationPath);
   while (currentPath !== publicDirectory) {
     try {
-      if (!(await import_promises4.default.lstat(currentPath)).isDirectory()) return true;
+      if (!(await import_promises5.default.lstat(currentPath)).isDirectory()) return true;
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
     }
-    currentPath = import_node_path4.default.dirname(currentPath);
+    currentPath = import_node_path5.default.dirname(currentPath);
   }
   return false;
 };
 var pruneEmptyDirectories = async (publicDirectory, filePath) => {
-  let currentPath = import_node_path4.default.dirname(filePath);
+  let currentPath = import_node_path5.default.dirname(filePath);
   while (currentPath !== publicDirectory) {
     try {
-      await import_promises4.default.rmdir(currentPath);
+      await import_promises5.default.rmdir(currentPath);
     } catch (error) {
       if (!["ENOENT", "ENOTEMPTY"].includes(error.code ?? "")) throw error;
       if (error.code === "ENOTEMPTY") return;
     }
-    currentPath = import_node_path4.default.dirname(currentPath);
+    currentPath = import_node_path5.default.dirname(currentPath);
   }
 };
 var composePublicAssets = async ({
@@ -496,8 +500,8 @@ var composePublicAssets = async ({
   previousFiles = {},
   collisionPaths = /* @__PURE__ */ new Set()
 }) => {
-  const publicDirectory = import_node_path4.default.resolve(projectDirectory, "public");
-  const federatedPublicDirectory = import_node_path4.default.resolve(federatedDirectory, "public");
+  const publicDirectory = import_node_path5.default.resolve(projectDirectory, "public");
+  const federatedPublicDirectory = import_node_path5.default.resolve(federatedDirectory, "public");
   const sourceFiles = await listFiles(federatedPublicDirectory);
   const sourceFileSet = new Set(sourceFiles);
   const managedFiles = /* @__PURE__ */ new Set();
@@ -510,7 +514,7 @@ var composePublicAssets = async ({
     if (sourceFileSet.has(relativePath)) continue;
     const destinationPath = getSafePath(publicDirectory, relativePath);
     if (!destinationPath) continue;
-    await import_promises4.default.rm(destinationPath, { force: true });
+    await import_promises5.default.rm(destinationPath, { force: true });
     await pruneEmptyDirectories(publicDirectory, destinationPath);
     removed += 1;
   }
@@ -532,31 +536,31 @@ var composePublicAssets = async ({
     }
     const asset = publicAssetsByPath.get(relativePath);
     if (!asset) throw new Error(`Cannot identify the source of federated public asset "${relativePath}"`);
-    const content = await import_promises4.default.readFile(sourcePath);
-    await import_promises4.default.mkdir(import_node_path4.default.dirname(destinationPath), { recursive: true });
-    await import_promises4.default.writeFile(destinationPath, content);
+    const content = await import_promises5.default.readFile(sourcePath);
+    await import_promises5.default.mkdir(import_node_path5.default.dirname(destinationPath), { recursive: true });
+    await import_promises5.default.writeFile(destinationPath, content);
     files[relativePath] = { source: asset.resolvedFrom.source, hash: getContentHash2(content) };
     copied += 1;
     if (collisionPaths.has(`public/${relativePath}`)) overwritten += 1;
   }
-  await import_promises4.default.rm(federatedPublicDirectory, { recursive: true, force: true });
+  await import_promises5.default.rm(federatedPublicDirectory, { recursive: true, force: true });
   return { files, copied, skipped, overwritten, removed };
 };
 
 // src/federation/filesystem-source-provider.ts
 var import_node_crypto3 = require("crypto");
-var import_promises5 = __toESM(require("fs/promises"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
+var import_promises6 = __toESM(require("fs/promises"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
 var import_sdk = __toESM(require("@eventcatalog/sdk"), 1);
 var FILESYSTEM_SOURCE_PREFIX = "file:";
 var isWithinDirectory = (directory, target) => {
-  const relativePath = import_node_path5.default.relative(directory, target);
-  return relativePath === "" || !relativePath.startsWith(`..${import_node_path5.default.sep}`) && relativePath !== ".." && !import_node_path5.default.isAbsolute(relativePath);
+  const relativePath = import_node_path6.default.relative(directory, target);
+  return relativePath === "" || !relativePath.startsWith(`..${import_node_path6.default.sep}`) && relativePath !== ".." && !import_node_path6.default.isAbsolute(relativePath);
 };
 var assertPortableRelativePath = (filePath, label, allowRoot = true) => {
   const portablePath = filePath.replaceAll("\\", "/");
-  const normalizedPath = import_node_path5.default.posix.normalize(portablePath);
-  const isUnsafe = filePath.includes("\\") || filePath.includes("\0") || import_node_path5.default.posix.isAbsolute(normalizedPath) || /^[a-zA-Z]:\//.test(normalizedPath) || normalizedPath === ".." || normalizedPath.startsWith("../") || !allowRoot && (normalizedPath === "." || normalizedPath === "");
+  const normalizedPath = import_node_path6.default.posix.normalize(portablePath);
+  const isUnsafe = filePath.includes("\\") || filePath.includes("\0") || import_node_path6.default.posix.isAbsolute(normalizedPath) || /^[a-zA-Z]:\//.test(normalizedPath) || normalizedPath === ".." || normalizedPath.startsWith("../") || !allowRoot && (normalizedPath === "." || normalizedPath === "");
   if (isUnsafe) throw new Error(`${label} "${filePath}" escapes its filesystem source`);
   return normalizedPath;
 };
@@ -566,22 +570,22 @@ var getSourceRoot = (projectDirectory, source) => {
   }
   const locator = source.source.slice(FILESYSTEM_SOURCE_PREFIX.length);
   if (!locator.trim()) throw new Error(`Filesystem federation source "${source.id}" requires a path after "file:".`);
-  return import_node_path5.default.resolve(projectDirectory, locator);
+  return import_node_path6.default.resolve(projectDirectory, locator);
 };
 var getCatalogDirectory = async (projectDirectory, source) => {
   if (source.ref) throw new Error(`Filesystem federation source "${source.id}" does not support "ref".`);
   const sourceRoot = getSourceRoot(projectDirectory, source);
   const catalogPath = assertPortableRelativePath(source.path ?? ".", "Catalog path");
-  const catalogDirectory = import_node_path5.default.resolve(sourceRoot, ...catalogPath.split("/"));
+  const catalogDirectory = import_node_path6.default.resolve(sourceRoot, ...catalogPath.split("/"));
   if (!isWithinDirectory(sourceRoot, catalogDirectory)) {
     throw new Error(`Catalog path "${source.path}" escapes source "${source.id}"`);
   }
   try {
-    const [realSourceRoot, realCatalogDirectory] = await Promise.all([import_promises5.default.realpath(sourceRoot), import_promises5.default.realpath(catalogDirectory)]);
+    const [realSourceRoot, realCatalogDirectory] = await Promise.all([import_promises6.default.realpath(sourceRoot), import_promises6.default.realpath(catalogDirectory)]);
     if (!isWithinDirectory(realSourceRoot, realCatalogDirectory)) {
       throw new Error(`Catalog path "${source.path}" escapes source "${source.id}"`);
     }
-    if (!(await import_promises5.default.stat(realCatalogDirectory)).isDirectory()) {
+    if (!(await import_promises6.default.stat(realCatalogDirectory)).isDirectory()) {
       throw new Error(`Filesystem federation source "${source.id}" is not a directory: ${catalogDirectory}`);
     }
     return realCatalogDirectory;
@@ -594,12 +598,12 @@ var getCatalogDirectory = async (projectDirectory, source) => {
 };
 var getArtifactPath = async (catalogDirectory, source, artifactPath) => {
   const normalizedPath = assertPortableRelativePath(artifactPath, "Federated artifact path", false);
-  const filePath = import_node_path5.default.resolve(catalogDirectory, ...normalizedPath.split("/"));
+  const filePath = import_node_path6.default.resolve(catalogDirectory, ...normalizedPath.split("/"));
   if (!isWithinDirectory(catalogDirectory, filePath)) {
     throw new Error(`Federated artifact path "${artifactPath}" escapes source "${source.id}"`);
   }
   try {
-    const realFilePath = await import_promises5.default.realpath(filePath);
+    const realFilePath = await import_promises6.default.realpath(filePath);
     if (!isWithinDirectory(catalogDirectory, realFilePath)) {
       throw new Error(`Federated artifact path "${artifactPath}" escapes source "${source.id}"`);
     }
@@ -626,15 +630,15 @@ var createFileSystemSourceProvider = (projectDirectory) => ({
   },
   async fetchContent({ source, path: artifactPath }) {
     const catalogDirectory = await getCatalogDirectory(projectDirectory, source);
-    return import_promises5.default.readFile(await getArtifactPath(catalogDirectory, source, artifactPath));
+    return import_promises6.default.readFile(await getArtifactPath(catalogDirectory, source, artifactPath));
   }
 });
 
 // src/federation/github-source-provider.ts
 var import_node_child_process = require("child_process");
-var import_promises6 = __toESM(require("fs/promises"), 1);
+var import_promises7 = __toESM(require("fs/promises"), 1);
 var import_node_os2 = __toESM(require("os"), 1);
-var import_node_path6 = __toESM(require("path"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 var import_node_util = require("util");
 var import_sdk2 = __toESM(require("@eventcatalog/sdk"), 1);
 var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
@@ -645,8 +649,8 @@ var parseGitHubSource = (source) => {
 };
 var assertSafeCatalogPath = (source) => {
   const catalogPath = source.path ?? ".";
-  const normalized = import_node_path6.default.posix.normalize(catalogPath.replaceAll("\\", "/"));
-  if (catalogPath.includes("\\") || import_node_path6.default.posix.isAbsolute(normalized) || normalized === ".." || normalized.startsWith("../")) {
+  const normalized = import_node_path7.default.posix.normalize(catalogPath.replaceAll("\\", "/"));
+  if (catalogPath.includes("\\") || import_node_path7.default.posix.isAbsolute(normalized) || normalized === ".." || normalized.startsWith("../")) {
     throw new Error(`Catalog path "${catalogPath}" escapes source "${source.id}"`);
   }
 };
@@ -689,8 +693,8 @@ var getGitEnvironment = (token) => {
 };
 var createCheckout = (executeFile, token) => async (source, ref, callback) => {
   const { owner, repository } = parseGitHubSource(source);
-  const catalogPath = import_node_path6.default.posix.normalize(source.path ?? ".");
-  const directory = await import_promises6.default.mkdtemp(import_node_path6.default.join(import_node_os2.default.tmpdir(), "eventcatalog-federation-"));
+  const catalogPath = import_node_path7.default.posix.normalize(source.path ?? ".");
+  const directory = await import_promises7.default.mkdtemp(import_node_path7.default.join(import_node_os2.default.tmpdir(), "eventcatalog-federation-"));
   const env = getGitEnvironment(token);
   try {
     const git = (args) => executeFile("git", args, { cwd: directory, env, encoding: "utf8" });
@@ -704,22 +708,22 @@ var createCheckout = (executeFile, token) => async (source, ref, callback) => {
     await git(["checkout", "--quiet", "--detach", "FETCH_HEAD"]);
     return await callback(directory);
   } finally {
-    await import_promises6.default.rm(directory, { recursive: true, force: true });
+    await import_promises7.default.rm(directory, { recursive: true, force: true });
   }
 };
 var generateIndex = async (source, ref, checkout, executeFile) => checkout(source, ref, async (directory) => {
   const { stdout } = await executeFile("git", ["rev-parse", "HEAD"], { cwd: directory, encoding: "utf8" });
   const commit = stdout.trim();
-  const catalogDirectory = import_node_path6.default.resolve(directory, source.path ?? ".");
-  const relativeCatalogDirectory = import_node_path6.default.relative(directory, catalogDirectory);
-  if (relativeCatalogDirectory.startsWith("..") || import_node_path6.default.isAbsolute(relativeCatalogDirectory)) {
+  const catalogDirectory = import_node_path7.default.resolve(directory, source.path ?? ".");
+  const relativeCatalogDirectory = import_node_path7.default.relative(directory, catalogDirectory);
+  if (relativeCatalogDirectory.startsWith("..") || import_node_path7.default.isAbsolute(relativeCatalogDirectory)) {
     throw new Error(`Catalog path "${source.path}" escapes source "${source.id}"`);
   }
   const index = await (0, import_sdk2.default)(catalogDirectory).buildIndex({ source: source.id, commit });
   return { bytes: Buffer.from(JSON.stringify(index)), index, commit, generated: true };
 });
 var fetchPublishedIndex = async (source, ref, fetcher, token) => {
-  const indexPath = import_node_path6.default.posix.join(source.path ?? ".", "catalog.index.json");
+  const indexPath = import_node_path7.default.posix.join(source.path ?? ".", "catalog.index.json");
   const bytes = await fetchBytes(source, ref, indexPath, fetcher, token);
   if (!bytes) return void 0;
   const index = (0, import_sdk2.parseIndex)(JSON.parse(bytes.toString("utf8")));
@@ -742,7 +746,7 @@ var createGitHubSourceProvider = (options = {}) => {
     },
     async fetchContent({ source, commit, path: artifactPath }) {
       assertSafeCatalogPath(source);
-      const catalogPath = import_node_path6.default.posix.join(source.path ?? ".", artifactPath);
+      const catalogPath = import_node_path7.default.posix.join(source.path ?? ".", artifactPath);
       const content = await fetchBytes(source, commit, catalogPath, fetcher, token);
       if (!content) throw new Error(`Federated artifact not found for "${source.id}": ${artifactPath}`);
       return content;
@@ -828,16 +832,16 @@ var createDiagnosticGraph = (graph, ownershipGraph, remoteSourceIds, localSource
 var writeLock = async (lockPath, lock) => {
   const temporaryPath = `${lockPath}.tmp-${process.pid}`;
   try {
-    await import_promises7.default.writeFile(temporaryPath, `${JSON.stringify(lock, null, 2)}
+    await import_promises8.default.writeFile(temporaryPath, `${JSON.stringify(lock, null, 2)}
 `, "utf8");
-    await import_promises7.default.rename(temporaryPath, lockPath);
+    await import_promises8.default.rename(temporaryPath, lockPath);
   } finally {
-    await import_promises7.default.rm(temporaryPath, { force: true });
+    await import_promises8.default.rm(temporaryPath, { force: true });
   }
 };
 var readLock = async (lockPath) => {
   try {
-    return JSON.parse(await import_promises7.default.readFile(lockPath, "utf8"));
+    return JSON.parse(await import_promises8.default.readFile(lockPath, "utf8"));
   } catch (error) {
     if (error.code === "ENOENT") return void 0;
     throw new Error(`Cannot read federation lock at "${lockPath}"`, { cause: error });
@@ -845,7 +849,7 @@ var readLock = async (lockPath) => {
 };
 var pathExists2 = async (filePath) => {
   try {
-    await import_promises7.default.access(filePath);
+    await import_promises8.default.access(filePath);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") return false;
@@ -853,8 +857,8 @@ var pathExists2 = async (filePath) => {
   }
 };
 var cleanupPreviousFederation = async (projectDirectory, onProgress) => {
-  const outDir = import_node_path7.default.join(projectDirectory, "federated");
-  const lockPath = import_node_path7.default.join(projectDirectory, "eventcatalog.lock");
+  const outDir = import_node_path8.default.join(projectDirectory, "federated");
+  const lockPath = import_node_path8.default.join(projectDirectory, "eventcatalog.lock");
   const previousLock = await readLock(lockPath);
   const hadFederatedOutput = await pathExists2(outDir);
   const hadLock = previousLock !== void 0;
@@ -870,7 +874,7 @@ var cleanupPreviousFederation = async (projectDirectory, onProgress) => {
         assets: [],
         previousFiles: previousLock?.publicFiles
       });
-      await import_promises7.default.rm(lockPath, { force: true });
+      await import_promises8.default.rm(lockPath, { force: true });
       return result;
     }
   );
@@ -919,8 +923,8 @@ var federateCatalog = async (projectDirectory, options = {}) => {
       throw new Error(`Failed to federate source "${source.id}": ${message}`, { cause: error });
     }
   }
-  const outDir = import_node_path7.default.join(projectDirectory, "federated");
-  const lockPath = import_node_path7.default.join(projectDirectory, "eventcatalog.lock");
+  const outDir = import_node_path8.default.join(projectDirectory, "federated");
+  const lockPath = import_node_path8.default.join(projectDirectory, "eventcatalog.lock");
   const previousLock = await readLock(lockPath);
   const resources = resolvedSources.reduce((total, source) => total + source.resolved.index.resources.length, 0);
   const remoteIndexes = resolvedSources.map(({ resolved }) => resolved.index);

package/dist/federation/federate.js

@@ -2,16 +2,16 @@ import {
   FederationConflictError,
   FederationDiagnosticError,
   federateCatalog
-} from "../chunk-2YJRF4ZX.js";
+} from "../chunk-RYPZGCRN.js";
 import "../chunk-WRNH5C3U.js";
 import "../chunk-5EPNFDT5.js";
 import "../chunk-A2RZR3U4.js";
-import "../chunk-SDZQJTJW.js";
-import "../chunk-352FGP6W.js";
 import "../chunk-R7Z5ALYI.js";
 import "../chunk-JJPB6EOZ.js";
 import "../chunk-FV56YFM4.js";
-import "../chunk-6QENHZZP.js";
+import "../chunk-SDZQJTJW.js";
+import "../chunk-352FGP6W.js";
+import "../chunk-JE6RX7SJ.js";
 export {
   FederationConflictError,
   FederationDiagnosticError,

package/dist/generate.cjs

@@ -33,16 +33,20 @@ __export(generate_exports, {
   generate: () => generate
 });
 module.exports = __toCommonJS(generate_exports);
-var import_node_path2 = __toESM(require("path"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
 
 // src/eventcatalog-config-file-utils.js
+var import_promises2 = require("fs/promises");
+var import_node_path2 = __toESM(require("path"), 1);
+var import_uuid = require("uuid");
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+
+// eventcatalog/integrations/config-loader.mjs
 var import_promises = require("fs/promises");
 var import_node_fs = require("fs");
 var import_node_path = __toESM(require("path"), 1);
-var import_uuid = require("uuid");
-var import_url = require("url");
+var import_node_url = require("url");
 var import_node_os = require("os");
-var import_gray_matter = __toESM(require("gray-matter"), 1);
 async function cleanup(projectDirectory) {
   const filePath = import_node_path.default.join(projectDirectory, "eventcatalog.config.mjs");
   if ((0, import_node_fs.existsSync)(filePath)) {
@@ -90,7 +94,7 @@ var getEventCatalogConfigFile = async (projectDirectory) => {
       configFilePath = import_node_path.default.join(tempDir, "eventcatalog.config.mjs");
       await (0, import_promises.copyFile)(import_node_path.default.join(projectDirectory, "eventcatalog.config.js"), configFilePath);
     }
-    const configFileURL = `${(0, import_url.pathToFileURL)(configFilePath).href}?t=${Date.now()}`;
+    const configFileURL = `${(0, import_node_url.pathToFileURL)(configFilePath).href}?t=${Date.now()}`;
     const config = await import(
       /* @vite-ignore */
       configFileURL
@@ -108,7 +112,7 @@ var getEventCatalogConfigFile = async (projectDirectory) => {
 var import_picocolors = __toESM(require("picocolors"), 1);
 
 // package.json
-var version = "4.11.2";
+var version = "4.12.0-beta.2";
 
 // src/constants.ts
 var VERSION = version;
@@ -201,7 +205,7 @@ var generate = async (PROJECT_DIRECTORY) => {
       let plugin = generator[0];
       const pluginConfig = generator[1];
       if (plugin.startsWith("./")) {
-        plugin = import_node_path2.default.join(PROJECT_DIRECTORY, plugin);
+        plugin = import_node_path3.default.join(PROJECT_DIRECTORY, plugin);
       }
       if (plugin.includes("<rootDir>")) {
         plugin = plugin.replace("<rootDir>", PROJECT_DIRECTORY);

package/dist/generate.js

@@ -1,9 +1,9 @@
 import {
   generate
-} from "./chunk-Z6OKCHWL.js";
-import "./chunk-XMRPNDXB.js";
-import "./chunk-LAWEGSJH.js";
-import "./chunk-6QENHZZP.js";
+} from "./chunk-C326DCDM.js";
+import "./chunk-FZEJ62MJ.js";
+import "./chunk-SETCQKS3.js";
+import "./chunk-JE6RX7SJ.js";
 export {
   generate
 };