@eventcatalog/core 4.7.3 → 4.7.5

package/dist/chunk-WRNH5C3U.js

@@ -0,0 +1,118 @@
+// src/federation/output-transaction.ts
+import fs from "fs/promises";
+import path from "path";
+var getSafePublicPath = (publicDirectory, relativePath) => {
+  const normalizedPath = path.posix.normalize(relativePath);
+  const unsafe = relativePath.length === 0 || relativePath.includes("\0") || relativePath.includes("\\") || path.posix.isAbsolute(relativePath) || /^[a-zA-Z]:\//.test(relativePath) || normalizedPath !== relativePath || normalizedPath === ".." || normalizedPath.startsWith("../");
+  if (unsafe) return void 0;
+  const destinationPath = path.resolve(publicDirectory, relativePath);
+  const relativeDestinationPath = path.relative(publicDirectory, destinationPath);
+  return relativeDestinationPath !== "" && relativeDestinationPath !== ".." && !relativeDestinationPath.startsWith(`..${path.sep}`) && !path.isAbsolute(relativeDestinationPath) ? destinationPath : void 0;
+};
+var beginFederationOutputTransaction = async (projectDirectory, outDir, relativePublicPaths) => {
+  const transactionDirectory = await fs.mkdtemp(path.join(projectDirectory, ".eventcatalog-federation-transaction-"));
+  const previousOutDir = path.join(transactionDirectory, "federated");
+  const publicBackupDirectory = path.join(transactionDirectory, "public");
+  const publicDirectory = path.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 fs.lstat(destinationPath);
+        if (!stat.isFile()) continue;
+        const backupPath = path.join(publicBackupDirectory, `${publicSnapshots.length}`);
+        await fs.mkdir(path.dirname(backupPath), { recursive: true });
+        await fs.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 = path.dirname(destinationPath);
+        while (directory !== publicDirectory) {
+          try {
+            await fs.lstat(directory);
+            break;
+          } catch (directoryError) {
+            const directoryCode = directoryError.code;
+            if (directoryCode === "ENOTDIR") break;
+            if (directoryCode !== "ENOENT") throw directoryError;
+            missingPublicDirectories.add(directory);
+            directory = path.dirname(directory);
+          }
+        }
+      }
+    }
+    try {
+      await fs.rename(outDir, previousOutDir);
+      hadPreviousOutDir = true;
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  } catch (error) {
+    await fs.rm(transactionDirectory, { recursive: true, force: true });
+    throw error;
+  }
+  return {
+    commit: async () => {
+      await fs.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(() => fs.rm(outDir, { recursive: true, force: true }));
+      if (hadPreviousOutDir) await attempt(() => fs.rename(previousOutDir, outDir));
+      for (const snapshot of publicSnapshots) {
+        if (snapshot.state === "missing") {
+          await attempt(() => fs.rm(snapshot.destinationPath, { force: true }));
+          continue;
+        }
+        await attempt(async () => {
+          await fs.mkdir(path.dirname(snapshot.destinationPath), { recursive: true });
+          await fs.copyFile(snapshot.backupPath, snapshot.destinationPath);
+        });
+      }
+      for (const directory of [...missingPublicDirectories].sort((left, right) => right.length - left.length)) {
+        await attempt(async () => {
+          try {
+            await fs.rmdir(directory);
+          } catch (error) {
+            if (!["ENOENT", "ENOTEMPTY"].includes(error.code ?? "")) throw error;
+          }
+        });
+      }
+      await attempt(() => fs.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;
+  }
+};
+
+export {
+  withFederationOutputTransaction
+};

package/dist/{chunk-V4FAVGI7.js → chunk-ZBPMCEXS.js}

@@ -1,5 +1,5 @@
 // package.json
-var version = "4.7.3";
+var version = "4.7.5";
 
 // src/constants.ts
 var VERSION = version;

package/dist/constants.cjs

@@ -25,7 +25,7 @@ __export(constants_exports, {
 module.exports = __toCommonJS(constants_exports);
 
 // package.json
-var version = "4.7.3";
+var version = "4.7.5";
 
 // src/constants.ts
 var VERSION = version;

package/dist/constants.js

@@ -1,6 +1,6 @@
 import {
   VERSION
-} from "./chunk-V4FAVGI7.js";
+} from "./chunk-ZBPMCEXS.js";
 export {
   VERSION
 };