@eventcatalog/core 4.7.3 → 4.7.5

package/dist/federation/federate.d.cts

@@ -1,5 +1,6 @@
 import { ResolvedGraph, HydrateResult, Conflict } from '@eventcatalog/sdk';
 import { FederationSourceConfig } from '../eventcatalog.config.cjs';
+import { FederationDiagnostic } from './diagnostics.cjs';
 import { PublicAssetCompositionResult } from './public-assets.cjs';
 import { FederationSourceProvider } from './types.cjs';
 
@@ -38,6 +39,7 @@ type FederationProgressEvent = {
 } | {
     type: 'resolved';
     graph: ResolvedGraph;
+    diagnostics: FederationDiagnostic[];
 } | {
     type: 'hydrating';
     outDir: string;
@@ -60,6 +62,7 @@ type FederateCatalogResult = {
     sources: number;
     resources: number;
     graph: ResolvedGraph;
+    diagnostics: FederationDiagnostic[];
     hydrate: HydrateResult;
     public: PublicAssetCompositionResult;
     outDir: string;
@@ -76,6 +79,10 @@ declare class FederationConflictError extends Error {
     conflicts: Conflict[];
     constructor(conflicts: Conflict[]);
 }
+declare class FederationDiagnosticError extends Error {
+    diagnostics: FederationDiagnostic[];
+    constructor(diagnostics: FederationDiagnostic[]);
+}
 declare const federateCatalog: (projectDirectory: string, options?: FederateCatalogOptions) => Promise<FederateCatalogResult | null>;
 
-export { type FederateCatalogResult, FederationConflictError, type FederationProgressEvent, federateCatalog };
+export { type FederateCatalogResult, FederationConflictError, FederationDiagnosticError, type FederationProgressEvent, federateCatalog };

package/dist/federation/federate.d.ts

@@ -1,5 +1,6 @@
 import { ResolvedGraph, HydrateResult, Conflict } from '@eventcatalog/sdk';
 import { FederationSourceConfig } from '../eventcatalog.config.js';
+import { FederationDiagnostic } from './diagnostics.js';
 import { PublicAssetCompositionResult } from './public-assets.js';
 import { FederationSourceProvider } from './types.js';
 
@@ -38,6 +39,7 @@ type FederationProgressEvent = {
 } | {
     type: 'resolved';
     graph: ResolvedGraph;
+    diagnostics: FederationDiagnostic[];
 } | {
     type: 'hydrating';
     outDir: string;
@@ -60,6 +62,7 @@ type FederateCatalogResult = {
     sources: number;
     resources: number;
     graph: ResolvedGraph;
+    diagnostics: FederationDiagnostic[];
     hydrate: HydrateResult;
     public: PublicAssetCompositionResult;
     outDir: string;
@@ -76,6 +79,10 @@ declare class FederationConflictError extends Error {
     conflicts: Conflict[];
     constructor(conflicts: Conflict[]);
 }
+declare class FederationDiagnosticError extends Error {
+    diagnostics: FederationDiagnostic[];
+    constructor(diagnostics: FederationDiagnostic[]);
+}
 declare const federateCatalog: (projectDirectory: string, options?: FederateCatalogOptions) => Promise<FederateCatalogResult | null>;
 
-export { type FederateCatalogResult, FederationConflictError, type FederationProgressEvent, federateCatalog };
+export { type FederateCatalogResult, FederationConflictError, FederationDiagnosticError, type FederationProgressEvent, federateCatalog };

package/dist/federation/federate.js

@@ -1,12 +1,18 @@
 import {
   FederationConflictError,
+  FederationDiagnosticError,
   federateCatalog
-} from "../chunk-ZR6AH5Z2.js";
+} from "../chunk-GYYYAUJD.js";
+import "../chunk-WRNH5C3U.js";
+import "../chunk-5EPNFDT5.js";
+import "../chunk-A2RZR3U4.js";
 import "../chunk-R7Z5ALYI.js";
+import "../chunk-JJPB6EOZ.js";
+import "../chunk-SDZQJTJW.js";
 import "../chunk-352FGP6W.js";
-import "../chunk-5EPNFDT5.js";
 import "../chunk-6QENHZZP.js";
 export {
   FederationConflictError,
+  FederationDiagnosticError,
   federateCatalog
 };

package/dist/federation/filesystem-source-provider.cjs

@@ -0,0 +1,124 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/federation/filesystem-source-provider.ts
+var filesystem_source_provider_exports = {};
+__export(filesystem_source_provider_exports, {
+  createFileSystemSourceProvider: () => createFileSystemSourceProvider
+});
+module.exports = __toCommonJS(filesystem_source_provider_exports);
+var import_node_crypto = require("crypto");
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path = __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_path.default.relative(directory, target);
+  return relativePath === "" || !relativePath.startsWith(`..${import_node_path.default.sep}`) && relativePath !== ".." && !import_node_path.default.isAbsolute(relativePath);
+};
+var assertPortableRelativePath = (filePath, label, allowRoot = true) => {
+  const portablePath = filePath.replaceAll("\\", "/");
+  const normalizedPath = import_node_path.default.posix.normalize(portablePath);
+  const isUnsafe = filePath.includes("\\") || filePath.includes("\0") || import_node_path.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;
+};
+var getSourceRoot = (projectDirectory, source) => {
+  if (!source.source.startsWith(FILESYSTEM_SOURCE_PREFIX)) {
+    throw new Error(`Unsupported federation source "${source.source}". Expected file:path/to/catalog.`);
+  }
+  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_path.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_path.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_promises.default.realpath(sourceRoot), import_promises.default.realpath(catalogDirectory)]);
+    if (!isWithinDirectory(realSourceRoot, realCatalogDirectory)) {
+      throw new Error(`Catalog path "${source.path}" escapes source "${source.id}"`);
+    }
+    if (!(await import_promises.default.stat(realCatalogDirectory)).isDirectory()) {
+      throw new Error(`Filesystem federation source "${source.id}" is not a directory: ${catalogDirectory}`);
+    }
+    return realCatalogDirectory;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Filesystem federation source "${source.id}" does not exist: ${catalogDirectory}`, { cause: error });
+    }
+    throw error;
+  }
+};
+var getArtifactPath = async (catalogDirectory, source, artifactPath) => {
+  const normalizedPath = assertPortableRelativePath(artifactPath, "Federated artifact path", false);
+  const filePath = import_node_path.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_promises.default.realpath(filePath);
+    if (!isWithinDirectory(catalogDirectory, realFilePath)) {
+      throw new Error(`Federated artifact path "${artifactPath}" escapes source "${source.id}"`);
+    }
+    return realFilePath;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Federated artifact not found for "${source.id}": ${artifactPath}`, { cause: error });
+    }
+    throw error;
+  }
+};
+var createFileSystemSourceProvider = (projectDirectory) => ({
+  async resolve(source) {
+    const catalogDirectory = await getCatalogDirectory(projectDirectory, source);
+    const localIndex = await (0, import_sdk.default)(catalogDirectory).buildIndex({
+      source: source.id,
+      commit: "local",
+      includeFederated: false
+    });
+    const snapshot = (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(localIndex)).digest("hex").slice(0, 12);
+    const index = { ...localIndex, commit: `local:${snapshot}` };
+    const bytes = Buffer.from(JSON.stringify(index));
+    return { bytes, index, commit: index.commit, generated: true };
+  },
+  async fetchContent({ source, path: artifactPath }) {
+    const catalogDirectory = await getCatalogDirectory(projectDirectory, source);
+    return import_promises.default.readFile(await getArtifactPath(catalogDirectory, source, artifactPath));
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createFileSystemSourceProvider
+});

package/dist/federation/filesystem-source-provider.d.cts

@@ -0,0 +1,7 @@
+import { FederationSourceProvider } from './types.cjs';
+import '@eventcatalog/sdk';
+import '../eventcatalog.config.cjs';
+
+declare const createFileSystemSourceProvider: (projectDirectory: string) => FederationSourceProvider;
+
+export { createFileSystemSourceProvider };

package/dist/federation/filesystem-source-provider.d.ts

@@ -0,0 +1,7 @@
+import { FederationSourceProvider } from './types.js';
+import '@eventcatalog/sdk';
+import '../eventcatalog.config.js';
+
+declare const createFileSystemSourceProvider: (projectDirectory: string) => FederationSourceProvider;
+
+export { createFileSystemSourceProvider };

package/dist/federation/filesystem-source-provider.js

@@ -0,0 +1,6 @@
+import {
+  createFileSystemSourceProvider
+} from "../chunk-SDZQJTJW.js";
+export {
+  createFileSystemSourceProvider
+};

package/dist/federation/output-transaction.cjs

@@ -0,0 +1,152 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/federation/output-transaction.ts
+var output_transaction_exports = {};
+__export(output_transaction_exports, {
+  withFederationOutputTransaction: () => withFederationOutputTransaction
+});
+module.exports = __toCommonJS(output_transaction_exports);
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var getSafePublicPath = (publicDirectory, relativePath) => {
+  const normalizedPath = import_node_path.default.posix.normalize(relativePath);
+  const unsafe = relativePath.length === 0 || relativePath.includes("\0") || relativePath.includes("\\") || import_node_path.default.posix.isAbsolute(relativePath) || /^[a-zA-Z]:\//.test(relativePath) || normalizedPath !== relativePath || normalizedPath === ".." || normalizedPath.startsWith("../");
+  if (unsafe) return void 0;
+  const destinationPath = import_node_path.default.resolve(publicDirectory, relativePath);
+  const relativeDestinationPath = import_node_path.default.relative(publicDirectory, destinationPath);
+  return relativeDestinationPath !== "" && relativeDestinationPath !== ".." && !relativeDestinationPath.startsWith(`..${import_node_path.default.sep}`) && !import_node_path.default.isAbsolute(relativeDestinationPath) ? destinationPath : void 0;
+};
+var beginFederationOutputTransaction = async (projectDirectory, outDir, relativePublicPaths) => {
+  const transactionDirectory = await import_promises.default.mkdtemp(import_node_path.default.join(projectDirectory, ".eventcatalog-federation-transaction-"));
+  const previousOutDir = import_node_path.default.join(transactionDirectory, "federated");
+  const publicBackupDirectory = import_node_path.default.join(transactionDirectory, "public");
+  const publicDirectory = import_node_path.default.resolve(projectDirectory, "public");
+  const publicSnapshots = [];
+  const missingPublicDirectories = /* @__PURE__ */ new Set();
+  let hadPreviousOutDir = false;
+  try {
+    for (const relativePath of new Set(relativePublicPaths)) {
+      const destinationPath = getSafePublicPath(publicDirectory, relativePath);
+      if (!destinationPath) continue;
+      try {
+        const stat = await import_promises.default.lstat(destinationPath);
+        if (!stat.isFile()) continue;
+        const backupPath = import_node_path.default.join(publicBackupDirectory, `${publicSnapshots.length}`);
+        await import_promises.default.mkdir(import_node_path.default.dirname(backupPath), { recursive: true });
+        await import_promises.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_path.default.dirname(destinationPath);
+        while (directory !== publicDirectory) {
+          try {
+            await import_promises.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_path.default.dirname(directory);
+          }
+        }
+      }
+    }
+    try {
+      await import_promises.default.rename(outDir, previousOutDir);
+      hadPreviousOutDir = true;
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  } catch (error) {
+    await import_promises.default.rm(transactionDirectory, { recursive: true, force: true });
+    throw error;
+  }
+  return {
+    commit: async () => {
+      await import_promises.default.rm(transactionDirectory, { recursive: true, force: true }).catch(() => void 0);
+    },
+    rollback: async () => {
+      const rollbackErrors = [];
+      const attempt = async (operation) => {
+        try {
+          await operation();
+        } catch (error) {
+          rollbackErrors.push(error);
+        }
+      };
+      await attempt(() => import_promises.default.rm(outDir, { recursive: true, force: true }));
+      if (hadPreviousOutDir) await attempt(() => import_promises.default.rename(previousOutDir, outDir));
+      for (const snapshot of publicSnapshots) {
+        if (snapshot.state === "missing") {
+          await attempt(() => import_promises.default.rm(snapshot.destinationPath, { force: true }));
+          continue;
+        }
+        await attempt(async () => {
+          await import_promises.default.mkdir(import_node_path.default.dirname(snapshot.destinationPath), { recursive: true });
+          await import_promises.default.copyFile(snapshot.backupPath, snapshot.destinationPath);
+        });
+      }
+      for (const directory of [...missingPublicDirectories].sort((left, right) => right.length - left.length)) {
+        await attempt(async () => {
+          try {
+            await import_promises.default.rmdir(directory);
+          } catch (error) {
+            if (!["ENOENT", "ENOTEMPTY"].includes(error.code ?? "")) throw error;
+          }
+        });
+      }
+      await attempt(() => import_promises.default.rm(transactionDirectory, { recursive: true, force: true }));
+      if (rollbackErrors.length > 0) throw new AggregateError(rollbackErrors, "Failed to restore the previous federation output");
+    }
+  };
+};
+var withFederationOutputTransaction = async (projectDirectory, outDir, relativePublicPaths, update) => {
+  const transaction = await beginFederationOutputTransaction(projectDirectory, outDir, relativePublicPaths);
+  try {
+    const result = await update();
+    await transaction.commit();
+    return result;
+  } catch (error) {
+    try {
+      await transaction.rollback();
+    } catch (rollbackError) {
+      throw new AggregateError([error, rollbackError], "Federation failed and the previous output could not be restored");
+    }
+    throw error;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  withFederationOutputTransaction
+});

package/dist/federation/output-transaction.d.cts

@@ -0,0 +1,3 @@
+declare const withFederationOutputTransaction: <Result>(projectDirectory: string, outDir: string, relativePublicPaths: Iterable<string>, update: () => Promise<Result>) => Promise<Result>;
+
+export { withFederationOutputTransaction };

package/dist/federation/output-transaction.d.ts

@@ -0,0 +1,3 @@
+declare const withFederationOutputTransaction: <Result>(projectDirectory: string, outDir: string, relativePublicPaths: Iterable<string>, update: () => Promise<Result>) => Promise<Result>;
+
+export { withFederationOutputTransaction };

package/dist/federation/output-transaction.js

@@ -0,0 +1,6 @@
+import {
+  withFederationOutputTransaction
+} from "../chunk-WRNH5C3U.js";
+export {
+  withFederationOutputTransaction
+};