@eventcatalog/core 2.13.4 → 2.14.0

package/.github/workflows/test-e2e.yml

@@ -1,29 +1,27 @@
 name: Tests e2e
 on:
   pull_request:
-    branches: [ main, master ]
+    branches: [main, master]
 jobs:
   test:
     timeout-minutes: 60
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-node@v4
-      with:
-        node-version: lts/*
-    - name: Install dependencies
-      run: npm ci
-    - name: Install Playwright Browsers
-      run: npx playwright install --with-deps
-    - name: Build catalog
-      shell: bash
-      run: |
-        cp $PROJECT_DIR/eventcatalog.config.js $CATALOG_DIR/eventcatalog.config.js
-        cp $PROJECT_DIR/eventcatalog.styles.css $CATALOG_DIR/eventcatalog.styles.css
-        npm run build
-      env:
-        PROJECT_DIR: ./examples/default/
-        CATALOG_DIR: ./
-        NODE_ENV: CI # Skip analytics
-    - name: Run tests
-      run: npm run test:e2e
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+      - name: Install dependencies
+        run: npm ci
+      - name: Install Playwright Browsers
+        run: npx playwright install --with-deps
+      - name: Build cli
+        run: npm run build:bin
+      - name: Build catalog
+        run: npx . build
+        env:
+          PROJECT_DIR: ./examples/default/
+          CATALOG_DIR: ./
+          NODE_ENV: CI # Skip analytics
+      - name: Run tests
+        run: npm run test:e2e

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @eventcatalog/core
 
+## 2.14.0
+
+### Minor Changes
+
+- 536511e: chore(core): refactor core logic to simplify the code
+
 ## 2.13.4
 
 ### Patch Changes

package/bin/dist/eventcatalog.cjs

@@ -30,24 +30,462 @@ var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 // bin/eventcatalog.ts
 var import_commander = require("commander");
 var import_node_child_process = require("child_process");
-var import_node_path = require("path");
-var import_fs = __toESM(require("fs"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
+var import_node_path4 = require("path");
+var import_fs2 = __toESM(require("fs"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 var import_node_url = require("url");
-var currentDir = import_node_path2.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
-var program = new import_commander.Command();
-var dir = process.cwd();
-var core = (0, import_node_path.join)(dir, ".eventcatalog-core");
-var eventCatalogDir = (0, import_node_path.join)(currentDir, "../../");
+var import_concurrently = __toESM(require("concurrently"), 1);
+
+// scripts/generate.js
+var import_node_path2 = __toESM(require("path"), 1);
+
+// scripts/eventcatalog-config-file-utils.js
+var import_promises = require("fs/promises");
+var import_node_fs = require("fs");
+var import_promises2 = require("fs/promises");
+var import_node_path = __toESM(require("path"), 1);
+var import_uuid = require("uuid");
+var import_url = require("url");
+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)) {
+    await (0, import_promises.rm)(filePath);
+  }
+}
+var getEventCatalogConfigFile = async (projectDirectory) => {
+  try {
+    let configFilePath = import_node_path.default.join(projectDirectory, "eventcatalog.config.js");
+    const filePath = import_node_path.default.join(projectDirectory, "package.json");
+    const packageJson = JSON.parse(await (0, import_promises.readFile)(filePath, "utf-8"));
+    if (packageJson?.type !== "module") {
+      await (0, import_promises2.copyFile)(configFilePath, import_node_path.default.join(projectDirectory, "eventcatalog.config.mjs"));
+      configFilePath = import_node_path.default.join(projectDirectory, "eventcatalog.config.mjs");
+    }
+    const configFileURL = (0, import_url.pathToFileURL)(configFilePath).href;
+    const config = await import(
+      /* @vite-ignore */
+      configFileURL
+    );
+    return config.default;
+  } finally {
+    await cleanup(projectDirectory);
+  }
+};
+var writeEventCatalogConfigFile = async (projectDirectory, newConfig) => {
+  try {
+    const configFilePath = import_node_path.default.join(projectDirectory, "eventcatalog.config.js");
+    let content = await (0, import_promises.readFile)(configFilePath, "utf8");
+    const startIndex = content.indexOf("export default {");
+    if (startIndex === -1) {
+      return;
+    }
+    Object.entries(newConfig).forEach(([key, value]) => {
+      const valueString = JSON.stringify(value, null, 2).replace(/"/g, "'").replace(/\n/g, "\n  ");
+      const keyRegex = new RegExp(`(${key}\\s*:)([^,}]+)`, "g");
+      if (content.match(keyRegex)) {
+        content = content.replace(keyRegex, `$1 ${valueString}`);
+      } else {
+        const insertPosition = content.indexOf("{", startIndex) + 1;
+        content = content.slice(0, insertPosition) + `
+  ${key}: ${valueString},` + content.slice(insertPosition);
+      }
+    });
+    await (0, import_promises.writeFile)(configFilePath, content);
+  } finally {
+    await cleanup(projectDirectory);
+  }
+};
+var verifyRequiredFieldsAreInCatalogConfigFile = async (projectDirectory) => {
+  try {
+    const config = await getEventCatalogConfigFile(projectDirectory);
+    if (!config.cId) {
+      await writeEventCatalogConfigFile(projectDirectory, { cId: (0, import_uuid.v4)() });
+    }
+  } catch (error) {
+  }
+};
+function addPropertyToFrontMatter(input, newProperty, newValue) {
+  const file = (0, import_gray_matter.default)(input);
+  return import_gray_matter.default.stringify(file.content, { ...file.data, [newProperty]: newValue });
+}
+
+// scripts/generate.js
+function getDefaultExport(importedModule) {
+  if (importedModule === null || typeof importedModule !== "object") {
+    throw new Error("Invalid module");
+  }
+  if (typeof importedModule.default === "object" && importedModule.default !== null) {
+    return importedModule.default.default || importedModule.default;
+  }
+  if (typeof importedModule.default !== "undefined") {
+    return importedModule.default;
+  }
+  return importedModule;
+}
+var generate = async (PROJECT_DIRECTORY) => {
+  try {
+    const config = await getEventCatalogConfigFile(PROJECT_DIRECTORY);
+    const { generators = [] } = config;
+    if (!generators.length) {
+      console.log("No configured generators found, skipping generation");
+      return;
+    }
+    for (const generator of generators) {
+      let plugin = generator[0];
+      const pluginConfig = generator[1];
+      if (plugin.startsWith("./")) {
+        plugin = import_node_path2.default.join(PROJECT_DIRECTORY, plugin);
+      }
+      if (plugin.includes("<rootDir>")) {
+        plugin = plugin.replace("<rootDir>", PROJECT_DIRECTORY);
+      }
+      try {
+        const importedGenerator = await import(plugin);
+        const generator2 = getDefaultExport(importedGenerator);
+        await generator2({ eventCatalogConfig: {} }, pluginConfig);
+      } catch (error) {
+        console.error("Error loading plugin:", error);
+        await cleanup(PROJECT_DIRECTORY);
+        return;
+      }
+    }
+    await cleanup(PROJECT_DIRECTORY);
+  } catch (error) {
+    console.error(error);
+    await cleanup(PROJECT_DIRECTORY);
+  }
+};
+
+// scripts/analytics/analytics.js
+var import_axios = __toESM(require("axios"), 1);
+var import_os = __toESM(require("os"), 1);
+
+// package.json
+var version = "2.14.0";
+
+// scripts/constants.ts
+var VERSION = version;
+
+// scripts/analytics/analytics.js
+async function raiseEvent(eventData) {
+  const url = "https://queue.simpleanalyticscdn.com/events";
+  const userAgent = `@eventcatalog/eventcatalog@${VERSION} (${import_os.default.platform()}; ${import_os.default.arch()}; Node/${process.version})`;
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  const payload = {
+    type: "event",
+    hostname: "eventcatalog.dev",
+    event: "@eventcatalog/eventcatalog",
+    metadata: {
+      ...eventData,
+      t: `t;${(/* @__PURE__ */ new Date()).toISOString()}`,
+      ua: userAgent
+    },
+    ua: userAgent
+  };
+  try {
+    await import_axios.default.post(url, payload, { headers });
+  } catch (error) {
+  }
+}
+
+// scripts/analytics/log-build.js
+var main = async (projectDir) => {
+  if (process.env.NODE_ENV === "CI") return;
+  try {
+    await verifyRequiredFieldsAreInCatalogConfigFile(projectDir);
+    const configFile = await getEventCatalogConfigFile(projectDir);
+    const { cId, organizationName, generators = [] } = configFile;
+    const generatorNames = generators.length > 0 ? generators.map((generator) => generator[0]) : ["none"];
+    await raiseEvent({
+      command: "build",
+      org: organizationName,
+      cId,
+      generators: generatorNames.toString()
+    });
+  } catch (error) {
+  }
+};
+var log_build_default = main;
+
+// scripts/watcher.js
+var import_watcher = __toESM(require("@parcel/watcher"), 1);
+var import_node_fs2 = __toESM(require("fs"), 1);
+
+// scripts/map-catalog-to-astro.js
+var import_node_path3 = __toESM(require("path"), 1);
+var COLLECTION_KEYS = [
+  "events",
+  "commands",
+  "services",
+  "users",
+  "teams",
+  "domains",
+  "flows",
+  "pages",
+  "changelogs",
+  "queries",
+  "channels"
+];
+function mapCatalogToAstro({ filePath, astroDir, projectDir }) {
+  const relativeFilePath = removeBasePath(filePath, projectDir);
+  if (!isCatalogRelated(relativeFilePath)) {
+    return [];
+  }
+  const baseTargetPaths = getBaseTargetPaths(relativeFilePath);
+  const relativeTargetPath = getRelativeTargetPath(relativeFilePath);
+  return baseTargetPaths.map(
+    (base) => import_node_path3.default.join(astroDir, base, relativeTargetPath.replace("index.md", "index.mdx").replace("changelog.md", "changelog.mdx"))
+  );
+}
+function removeBasePath(fullPath, basePath) {
+  const relativePath = import_node_path3.default.relative(basePath, fullPath);
+  return relativePath.startsWith("..") ? fullPath : relativePath;
+}
+function isCollectionKey(key) {
+  return COLLECTION_KEYS.includes(key);
+}
+function isCatalogRelated(filePath) {
+  const filePathArr = filePath.split(import_node_path3.default.sep).filter(Boolean);
+  if ([
+    "eventcatalog.config.js",
+    // config file at root
+    "eventcatalog.styles.css",
+    // custom styles file at root
+    "components",
+    // custom components
+    "public",
+    // public assets
+    ...COLLECTION_KEYS
+  ].includes(filePathArr[0])) {
+    return true;
+  }
+  return false;
+}
+function getBaseTargetPaths(filePath) {
+  const filePathArr = filePath.split(import_node_path3.default.sep).filter(Boolean);
+  if (isCollectionKey(filePathArr[0])) {
+    if (filePathArr[filePathArr.length - 1] == "changelog.md") {
+      return [import_node_path3.default.join("src", "content", "changelogs")];
+    }
+    if (filePathArr[filePathArr.length - 1].match(/\.md$/)) {
+      return [import_node_path3.default.join("src", "content")];
+    }
+    const hasExtension = (str) => /\.[a-zA-Z0-9]{2,}$/.test(str);
+    if (hasExtension(filePath)) {
+      return [import_node_path3.default.join("public", "generated"), import_node_path3.default.join("src", "catalog-files")];
+    }
+    return [import_node_path3.default.join("public", "generated"), import_node_path3.default.join("src", "catalog-files"), import_node_path3.default.join("src", "content")];
+  }
+  if (filePathArr[0] == "components") {
+    return [import_node_path3.default.join("src", "custom-defined-components")];
+  }
+  if (filePathArr[0] == "public") {
+    return [import_node_path3.default.join("public")];
+  }
+  return [import_node_path3.default.join("/")];
+}
+function getRelativeTargetPath(filePath) {
+  const filePathArr = filePath.split(import_node_path3.default.sep).filter(Boolean);
+  if (filePathArr[0] == "public" || filePathArr[0] == "components") {
+    filePathArr.shift();
+  }
+  const relativePath = [];
+  for (let i = filePathArr.length - 1; i >= 0; i--) {
+    relativePath.unshift(filePathArr[i]);
+    if (isCollectionKey(filePathArr[i])) break;
+  }
+  return import_node_path3.default.join(...relativePath);
+}
+
+// scripts/watcher.js
+var import_rimraf = require("rimraf");
+async function watch(projectDirectory, catalogDirectory, callback = void 0) {
+  const subscription = await import_watcher.default.subscribe(
+    projectDirectory,
+    compose(
+      /**
+       * @param {Error|null} err
+       * @param {Event[]} events
+       * @returns {unknown}
+       */
+      (err, events) => {
+        if (err) {
+          return;
+        }
+        for (let event of events) {
+          const { path: filePath, type } = event;
+          const astroPaths = mapCatalogToAstro({
+            filePath,
+            astroDir: catalogDirectory,
+            projectDir: projectDirectory
+          });
+          for (const astroPath of astroPaths) {
+            switch (type) {
+              case "create":
+              case "update":
+                try {
+                  if (astroPath.endsWith(".mdx")) {
+                    const content = import_node_fs2.default.readFileSync(astroPath, "utf-8");
+                    const frontmatter = addPropertyToFrontMatter(content, "pathToFile", filePath);
+                    import_node_fs2.default.writeFileSync(astroPath, frontmatter);
+                  }
+                } catch (error) {
+                }
+                if (import_node_fs2.default.statSync(filePath).isDirectory()) import_node_fs2.default.mkdirSync(astroPath, { recursive: true });
+                else retryEPERM(import_node_fs2.default.cpSync)(filePath, astroPath);
+                break;
+              case "delete":
+                retryEPERM(import_rimraf.rimrafSync)(astroPath);
+                break;
+            }
+          }
+        }
+      },
+      callback
+    ),
+    {
+      ignore: [`**/${catalogDirectory}/!(${projectDirectory})**`]
+    }
+  );
+  return () => subscription.unsubscribe();
+}
+function compose(...fns) {
+  return function(err, events) {
+    fns.filter(Boolean).forEach((fn, i) => {
+      try {
+        fn(err, events);
+      } catch (error) {
+        console.error({ error });
+        throw error;
+      }
+    });
+  };
+}
+var MAX_RETRIES = 5;
+var DELAY_MS = 100;
+function retryEPERM(fn) {
+  return (...args) => {
+    let retries = 0;
+    while (retries < MAX_RETRIES) {
+      try {
+        return fn(...args);
+      } catch (err) {
+        if (err.code !== "EPERM") throw err;
+        setTimeout(() => {
+        }, DELAY_MS);
+        retries += 1;
+      }
+    }
+  };
+}
+
+// scripts/catalog-to-astro-content-directory.js
+var import_glob = require("glob");
+var path4 = __toESM(require("path"), 1);
+var import_fs = __toESM(require("fs"), 1);
+var import_url2 = require("url");
+var import_node_os = __toESM(require("os"), 1);
+var __filename2 = (0, import_url2.fileURLToPath)(importMetaUrl);
+var rootPkg = path4.resolve(
+  path4.dirname(__filename2),
+  /**
+   * TODO: fix me =0
+   *
+   * The following is a workaround until organize the structure to have the correct path
+   * for any value of NODE_ENV
+   *
+   * @author carlosallexandre
+   */
+  process.env.NODE_ENV === "test" ? "../" : "../../"
+);
+var copyFiles = async (source, target) => {
+  const files = await (0, import_glob.glob)(path4.join(source, "**"), {
+    nodir: true,
+    windowsPathsNoEscape: import_node_os.default.platform() == "win32"
+  });
+  for (const file of files) {
+    mapCatalogToAstro({
+      filePath: file,
+      astroDir: target,
+      projectDir: source
+    }).map((astroPath) => {
+      import_fs.default.cpSync(file, astroPath);
+      return { oldPath: file, newPath: astroPath };
+    }).map(({ oldPath, newPath }) => {
+      if (!oldPath.endsWith(".md") && !oldPath.endsWith(".mdx")) return;
+      try {
+        const content = import_fs.default.readFileSync(newPath, "utf-8");
+        const frontmatter = addPropertyToFrontMatter(content, "pathToFile", oldPath);
+        import_fs.default.writeFileSync(newPath, frontmatter);
+      } catch (error) {
+      }
+    });
+  }
+};
+var ensureAstroCollectionNotEmpty = async (astroDir) => {
+  const COLLECTIONS = [
+    "events",
+    "commands",
+    "services",
+    "users",
+    "teams",
+    "domains",
+    "flows",
+    "pages",
+    "changelogs",
+    "queries",
+    "channels"
+  ];
+  const emptyCollections = [];
+  for (const collection of COLLECTIONS) {
+    const markdownFiles = await (0, import_glob.glob)(path4.join(astroDir, "src/content/", collection, "**"), {
+      nodir: true,
+      windowsPathsNoEscape: import_node_os.default.platform() == "win32"
+    });
+    if (markdownFiles.length === 0) emptyCollections.push(collection);
+  }
+  const defaultCollectionFilesDir = path4.join(rootPkg, "default-files-for-collections");
+  for (const collection of emptyCollections) {
+    const defaultFile = path4.join(defaultCollectionFilesDir, `${collection}.md`);
+    const targetDir = path4.join(astroDir, "src/content/", collection);
+    if (!import_fs.default.existsSync(targetDir)) {
+      import_fs.default.mkdirSync(targetDir, { recursive: true });
+    }
+    import_fs.default.cpSync(defaultFile, path4.join(targetDir, `${collection}.md`));
+  }
+};
+var catalogToAstro = async (source, astroDir) => {
+  const astroContentDir = path4.join(astroDir, "src/content/");
+  const astroConfigFile = import_fs.default.readFileSync(path4.join(astroContentDir, "config.ts"));
+  import_fs.default.rmSync(astroContentDir, { recursive: true });
+  import_fs.default.mkdirSync(astroContentDir);
+  import_fs.default.writeFileSync(path4.join(astroContentDir, "config.ts"), astroConfigFile);
+  await verifyRequiredFieldsAreInCatalogConfigFile(source);
+  await copyFiles(source, astroDir);
+  await ensureAstroCollectionNotEmpty(astroDir);
+};
+
+// bin/eventcatalog.ts
+var currentDir = import_node_path5.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
+var program = new import_commander.Command().version(VERSION);
+var dir = import_node_path5.default.resolve(process.env.PROJECT_DIR || process.cwd());
+var core = import_node_path5.default.resolve(process.env.CATALOG_DIR || (0, import_node_path4.join)(dir, ".eventcatalog-core"));
+var eventCatalogDir = import_node_path5.default.resolve((0, import_node_path4.join)(currentDir, "../../"));
 program.name("eventcatalog").description("Documentation tool for event-driven architectures");
 var ensureDir = (dir2) => {
-  if (!import_fs.default.existsSync(dir2)) {
-    import_fs.default.mkdirSync(dir2);
+  if (!import_fs2.default.existsSync(dir2)) {
+    import_fs2.default.mkdirSync(dir2);
   }
 };
 var copyCore = () => {
   ensureDir(core);
-  import_fs.default.cpSync(eventCatalogDir, core, {
+  if (eventCatalogDir === core) {
+    return;
+  }
+  import_fs2.default.cpSync(eventCatalogDir, core, {
     recursive: true,
     filter: (src) => {
       return true;
@@ -55,9 +493,9 @@ var copyCore = () => {
   });
 };
 var clearCore = () => {
-  if (import_fs.default.existsSync(core)) import_fs.default.rmSync(core, { recursive: true });
+  if (import_fs2.default.existsSync(core)) import_fs2.default.rmSync(core, { recursive: true });
 };
-program.command("dev").description("Run development server of EventCatalog").option("-d, --debug", "Output EventCatalog application information into your terminal").option("--force-recreate", "Recreate the eventcatalog-core directory", false).action((options) => {
+program.command("dev").description("Run development server of EventCatalog").option("-d, --debug", "Output EventCatalog application information into your terminal").option("--force-recreate", "Recreate the eventcatalog-core directory", false).action(async (options) => {
   console.log("Setting up EventCatalog....");
   if (options.debug) {
     console.log("Debug mode enabled");
@@ -67,15 +505,33 @@ program.command("dev").description("Run development server of EventCatalog").opt
   if (options.forceRecreate) clearCore();
   copyCore();
   console.log("EventCatalog is starting at http://localhost:3000/docs");
-  (0, import_node_child_process.execSync)(`cross-env PROJECT_DIR='${dir}' CATALOG_DIR='${core}' npm run dev`, {
-    cwd: core,
-    // @ts-ignore
-    stdio: "inherit"
-  });
+  await catalogToAstro(dir, core);
+  let watchUnsub;
+  try {
+    watchUnsub = await watch(dir, core);
+    const { result } = (0, import_concurrently.default)([
+      {
+        name: "astro",
+        command: "npm run dev",
+        cwd: core,
+        env: {
+          PROJECT_DIR: dir,
+          CATALOG_DIR: core
+        }
+      }
+    ]);
+    await result;
+  } catch (err) {
+    console.error(err);
+  } finally {
+    await watchUnsub?.();
+  }
 });
-program.command("build").description("Run build of EventCatalog").action((options) => {
+program.command("build").description("Run build of EventCatalog").action(async (options) => {
   console.log("Building EventCatalog...");
   copyCore();
+  await log_build_default(dir);
+  await catalogToAstro(dir, core);
   (0, import_node_child_process.execSync)(`cross-env PROJECT_DIR='${dir}' CATALOG_DIR='${core}' npm run build`, {
     cwd: core,
     stdio: "inherit"
@@ -96,11 +552,7 @@ program.command("start").description("Serves the contents of your eventcatalog b
   console.log("Starting preview of your build...");
   previewCatalog();
 });
-program.command("generate [siteDir]").description("Start the generator scripts.").action(() => {
-  copyCore();
-  (0, import_node_child_process.execSync)(`cross-env PROJECT_DIR='${dir}' npm run generate`, {
-    cwd: core,
-    stdio: "inherit"
-  });
+program.command("generate [siteDir]").description("Start the generator scripts.").action(async () => {
+  await generate(dir);
 });
-program.parse();
+program.parseAsync();