@eventcatalog/core 2.16.1 → 2.16.2

package/bin/dist/eventcatalog.js

@@ -0,0 +1,531 @@
+#!/usr/bin/env node
+
+// bin/eventcatalog.ts
+import { Command } from "commander";
+import { execSync } from "node:child_process";
+import { join as join2 } from "node:path";
+import fs3 from "fs";
+import path5 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import concurrently from "concurrently";
+
+// scripts/generate.js
+import path2 from "node:path";
+
+// scripts/eventcatalog-config-file-utils.js
+import { readFile, writeFile, rm } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { copyFile } from "node:fs/promises";
+import path from "node:path";
+import { v4 as uuidV4 } from "uuid";
+import { pathToFileURL } from "url";
+import matter from "gray-matter";
+async function cleanup(projectDirectory) {
+  const filePath = path.join(projectDirectory, "eventcatalog.config.mjs");
+  if (existsSync(filePath)) {
+    await rm(filePath);
+  }
+}
+var getEventCatalogConfigFile = async (projectDirectory) => {
+  try {
+    let configFilePath = path.join(projectDirectory, "eventcatalog.config.js");
+    const filePath = path.join(projectDirectory, "package.json");
+    const packageJson = JSON.parse(await readFile(filePath, "utf-8"));
+    if (packageJson?.type !== "module") {
+      await copyFile(configFilePath, path.join(projectDirectory, "eventcatalog.config.mjs"));
+      configFilePath = path.join(projectDirectory, "eventcatalog.config.mjs");
+    }
+    const configFileURL = 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 = path.join(projectDirectory, "eventcatalog.config.js");
+    let content = await 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 writeFile(configFilePath, content);
+  } finally {
+    await cleanup(projectDirectory);
+  }
+};
+var verifyRequiredFieldsAreInCatalogConfigFile = async (projectDirectory) => {
+  try {
+    const config = await getEventCatalogConfigFile(projectDirectory);
+    if (!config.cId) {
+      await writeEventCatalogConfigFile(projectDirectory, { cId: uuidV4() });
+    }
+  } catch (error) {
+  }
+};
+function addPropertyToFrontMatter(input, newProperty, newValue) {
+  const file = matter(input);
+  return matter.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 = path2.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
+import axios from "axios";
+import os from "os";
+
+// package.json
+var version = "2.14.3";
+
+// 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} (${os.platform()}; ${os.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 axios.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
+import watcher from "@parcel/watcher";
+import fs from "node:fs";
+
+// scripts/map-catalog-to-astro.js
+import path3 from "node:path";
+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) => path3.join(astroDir, base, relativeTargetPath.replace("index.md", "index.mdx").replace("changelog.md", "changelog.mdx"))
+  );
+}
+function removeBasePath(fullPath, basePath) {
+  const relativePath = path3.relative(basePath, fullPath);
+  return relativePath.startsWith("..") ? fullPath : relativePath;
+}
+function isCollectionKey(key) {
+  return COLLECTION_KEYS.includes(key);
+}
+function isCatalogRelated(filePath) {
+  const filePathArr = filePath.split(path3.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(path3.sep).filter(Boolean);
+  if (isCollectionKey(filePathArr[0])) {
+    if (filePathArr[filePathArr.length - 1] == "changelog.md") {
+      return [path3.join("src", "content", "changelogs")];
+    }
+    if (filePathArr[filePathArr.length - 1].match(/\.md$/)) {
+      return [path3.join("src", "content")];
+    }
+    const hasExtension = (str) => /\.[a-zA-Z0-9]{2,}$/.test(str);
+    if (hasExtension(filePath)) {
+      return [path3.join("public", "generated"), path3.join("src", "catalog-files")];
+    }
+    return [path3.join("public", "generated"), path3.join("src", "catalog-files"), path3.join("src", "content")];
+  }
+  if (filePathArr[0] == "components") {
+    return [path3.join("src", "custom-defined-components")];
+  }
+  if (filePathArr[0] == "public") {
+    return [path3.join("public")];
+  }
+  return [path3.join("/")];
+}
+function getRelativeTargetPath(filePath) {
+  const filePathArr = filePath.split(path3.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 path3.join(...relativePath);
+}
+
+// scripts/watcher.js
+import { rimrafSync } from "rimraf";
+async function watch(projectDirectory, catalogDirectory, callback = void 0) {
+  const subscription = await watcher.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 = fs.readFileSync(astroPath, "utf-8");
+                    const frontmatter = addPropertyToFrontMatter(content, "pathToFile", filePath);
+                    fs.writeFileSync(astroPath, frontmatter);
+                  }
+                } catch (error) {
+                }
+                if (fs.statSync(filePath).isDirectory()) fs.mkdirSync(astroPath, { recursive: true });
+                else retryEPERM(fs.cpSync)(filePath, astroPath);
+                break;
+              case "delete":
+                retryEPERM(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
+import { glob } from "glob";
+import * as path4 from "node:path";
+import fs2 from "fs";
+import { fileURLToPath } from "url";
+import os2 from "node:os";
+var __filename2 = fileURLToPath(import.meta.url);
+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 glob(path4.join(source, "**"), {
+    nodir: true,
+    windowsPathsNoEscape: os2.platform() == "win32"
+  });
+  for (const file of files) {
+    mapCatalogToAstro({
+      filePath: file,
+      astroDir: target,
+      projectDir: source
+    }).map((astroPath) => {
+      fs2.cpSync(file, astroPath);
+      return { oldPath: file, newPath: astroPath };
+    }).map(({ oldPath, newPath }) => {
+      if (!oldPath.endsWith(".md") && !oldPath.endsWith(".mdx")) return;
+      try {
+        const content = fs2.readFileSync(newPath, "utf-8");
+        const frontmatter = addPropertyToFrontMatter(content, "pathToFile", oldPath);
+        fs2.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 glob(path4.join(astroDir, "src/content/", collection, "**"), {
+      nodir: true,
+      windowsPathsNoEscape: os2.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 (!fs2.existsSync(targetDir)) {
+      fs2.mkdirSync(targetDir, { recursive: true });
+    }
+    fs2.cpSync(defaultFile, path4.join(targetDir, `${collection}.md`));
+  }
+};
+var catalogToAstro = async (source, astroDir) => {
+  const astroContentDir = path4.join(astroDir, "src/content/");
+  const astroConfigFile = fs2.readFileSync(path4.join(astroContentDir, "config.ts"));
+  fs2.rmSync(astroContentDir, { recursive: true });
+  fs2.mkdirSync(astroContentDir);
+  fs2.writeFileSync(path4.join(astroContentDir, "config.ts"), astroConfigFile);
+  await verifyRequiredFieldsAreInCatalogConfigFile(source);
+  await copyFiles(source, astroDir);
+  await ensureAstroCollectionNotEmpty(astroDir);
+};
+
+// bin/eventcatalog.ts
+var currentDir = path5.dirname(fileURLToPath2(import.meta.url));
+var program = new Command().version(VERSION);
+var dir = path5.resolve(process.env.PROJECT_DIR || process.cwd());
+var core = path5.resolve(process.env.CATALOG_DIR || join2(dir, ".eventcatalog-core"));
+var eventCatalogDir = path5.resolve(join2(currentDir, "../../eventcatalog/"));
+program.name("eventcatalog").description("Documentation tool for event-driven architectures");
+var ensureDir = (dir2) => {
+  if (!fs3.existsSync(dir2)) {
+    fs3.mkdirSync(dir2);
+  }
+};
+var copyCore = () => {
+  ensureDir(core);
+  if (eventCatalogDir === core) {
+    return;
+  }
+  fs3.cpSync(eventCatalogDir, core, {
+    recursive: true,
+    filter: (src) => {
+      return true;
+    }
+  });
+};
+var clearCore = () => {
+  if (fs3.existsSync(core)) fs3.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(async (options) => {
+  console.log("Setting up EventCatalog....");
+  if (options.debug) {
+    console.log("Debug mode enabled");
+    console.log("PROJECT_DIR", dir);
+    console.log("CATALOG_DIR", core);
+  }
+  if (options.forceRecreate) clearCore();
+  copyCore();
+  console.log("EventCatalog is starting at http://localhost:3000/docs");
+  await catalogToAstro(dir, core);
+  let watchUnsub;
+  try {
+    watchUnsub = await watch(dir, core);
+    const { result } = concurrently([
+      {
+        name: "astro",
+        command: "npx astro 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(async (options) => {
+  console.log("Building EventCatalog...");
+  copyCore();
+  await log_build_default(dir);
+  await catalogToAstro(dir, core);
+  execSync(`cross-env PROJECT_DIR='${dir}' CATALOG_DIR='${core}' npx astro build`, {
+    cwd: core,
+    stdio: "inherit"
+  });
+});
+var previewCatalog = () => {
+  copyCore();
+  execSync(`cross-env PROJECT_DIR='${dir}' CATALOG_DIR='${core}' npx astro preview --root ${dir} --port 3000`, {
+    cwd: core,
+    stdio: "inherit"
+  });
+};
+program.command("preview").description("Serves the contents of your eventcatalog build directory").action((options) => {
+  console.log("Starting preview of your build...");
+  previewCatalog();
+});
+program.command("start").description("Serves the contents of your eventcatalog build directory").action((options) => {
+  console.log("Starting preview of your build...");
+  previewCatalog();
+});
+program.command("generate [siteDir]").description("Start the generator scripts.").action(async () => {
+  await generate(dir);
+});
+program.parseAsync();

package/dist/analytics/analytics.cjs

@@ -37,7 +37,7 @@ var import_axios = __toESM(require("axios"), 1);
 var import_os = __toESM(require("os"), 1);
 
 // package.json
-var version = "2.16.1";
+var version = "2.16.2";
 
 // src/constants.ts
 var VERSION = version;

package/dist/analytics/analytics.js

@@ -1,7 +1,7 @@
 import {
   raiseEvent
-} from "../chunk-J5H7ICLD.js";
-import "../chunk-GEPV3ACK.js";
+} from "../chunk-7V6DXP63.js";
+import "../chunk-5K2SMJL6.js";
 export {
   raiseEvent
 };

package/dist/analytics/log-build.cjs

@@ -106,7 +106,7 @@ var import_axios = __toESM(require("axios"), 1);
 var import_os = __toESM(require("os"), 1);
 
 // package.json
-var version = "2.16.1";
+var version = "2.16.2";
 
 // src/constants.ts
 var VERSION = version;

package/dist/analytics/log-build.js

@@ -1,8 +1,8 @@
 import {
   log_build_default
-} from "../chunk-A3QFF66M.js";
-import "../chunk-J5H7ICLD.js";
-import "../chunk-GEPV3ACK.js";
+} from "../chunk-D5BKFMHD.js";
+import "../chunk-7V6DXP63.js";
+import "../chunk-5K2SMJL6.js";
 import "../chunk-E7TXTI7G.js";
 export {
   log_build_default as default

package/dist/{chunk-GEPV3ACK.js → chunk-5K2SMJL6.js}

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

package/dist/{chunk-J5H7ICLD.js → chunk-7V6DXP63.js}

@@ -1,6 +1,6 @@
 import {
   VERSION
-} from "./chunk-GEPV3ACK.js";
+} from "./chunk-5K2SMJL6.js";
 
 // src/analytics/analytics.js
 import axios from "axios";

package/dist/{chunk-A3QFF66M.js → chunk-D5BKFMHD.js}

@@ -1,6 +1,6 @@
 import {
   raiseEvent
-} from "./chunk-J5H7ICLD.js";
+} from "./chunk-7V6DXP63.js";
 import {
   getEventCatalogConfigFile,
   verifyRequiredFieldsAreInCatalogConfigFile

package/dist/constants.cjs

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

package/dist/constants.js

@@ -1,6 +1,6 @@
 import {
   VERSION
-} from "./chunk-GEPV3ACK.js";
+} from "./chunk-5K2SMJL6.js";
 export {
   VERSION
 };

package/dist/eventcatalog.cjs

@@ -161,7 +161,7 @@ var import_axios = __toESM(require("axios"), 1);
 var import_os = __toESM(require("os"), 1);
 
 // package.json
-var version = "2.16.1";
+var version = "2.16.2";
 
 // src/constants.ts
 var VERSION = version;

package/dist/eventcatalog.js

@@ -1,13 +1,13 @@
 import {
   log_build_default
-} from "./chunk-A3QFF66M.js";
-import "./chunk-J5H7ICLD.js";
+} from "./chunk-D5BKFMHD.js";
+import "./chunk-7V6DXP63.js";
 import {
   catalogToAstro
 } from "./chunk-55YPRY5U.js";
 import {
   VERSION
-} from "./chunk-GEPV3ACK.js";
+} from "./chunk-5K2SMJL6.js";
 import {
   generate
 } from "./chunk-YEQVKHST.js";

package/eventcatalog/src/components/SideBars/CatalogResourcesSideBar/index.tsx

@@ -6,16 +6,7 @@ import { getIconForCollection as getIconForCollectionOriginal } from '@utils/col
 
 const STORAGE_KEY = 'EventCatalog:catalogSidebarCollapsedGroups';
 
-interface CatalogResourcesSideBarProps {
-  resources: any;
-  currentPath: string;
-}
-
-const CatalogResourcesSideBar: React.FC<CatalogResourcesSideBarProps> = ({ resources, currentPath }) => {
-  if (typeof window === 'undefined') {
-    return null;
-  }
-
+const CatalogResourcesSideBar = ({ resources, currentPath }: any) => {
   const [data, setData] = useState(resources);
   const [searchQuery, setSearchQuery] = useState('');
   const [isInitialized, setIsInitialized] = useState(false);

package/eventcatalog/src/components/Tables/Table.tsx

@@ -21,7 +21,7 @@ import type { CollectionTypes } from '@types';
 declare module '@tanstack/react-table' {
   // @ts-ignore
   interface ColumnMeta<TData extends RowData, TValue> {
-    filterVariant?: 'collection' | 'name' | 'badges';
+    filterVariant?: 'collection' | 'name';
     collectionFilterKey?: string;
     showFilter?: boolean;
     className?: string;
@@ -211,16 +211,6 @@ function Filter({ column }: { column: Column<any, unknown> }) {
 
       return uniqueItemsInList.sort().slice(0, 2000);
     }
-    if (filterVariant === 'badges') {
-      const allBadges = column.getFacetedUniqueValues().keys();
-      // join all badges into a single array
-      const allBadgesArray = Array.from(allBadges)
-        .flat()
-        .filter((b) => !!b);
-      const allBadgesString = allBadgesArray.map((badge) => badge.content);
-      const uniqueBadges = Array.from(new Set(allBadgesString));
-      return uniqueBadges.sort().slice(0, 2000);
-    }
     return Array.from(column.getFacetedUniqueValues().keys()).sort().slice(0, 2000);
   }, [column.getFacetedUniqueValues(), filterVariant]);