@eventcatalog/core 2.13.3 → 2.14.0

package/bin/dist/eventcatalog.js

@@ -3,24 +3,462 @@
 // bin/eventcatalog.ts
 import { Command } from "commander";
 import { execSync } from "node:child_process";
-import { join } from "node:path";
-import fs from "fs";
+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 { fileURLToPath } from "node:url";
-var currentDir = path.dirname(fileURLToPath(import.meta.url));
-var program = new Command();
-var dir = process.cwd();
-var core = join(dir, ".eventcatalog-core");
-var eventCatalogDir = join(currentDir, "../../");
+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.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} (${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, "../../"));
 program.name("eventcatalog").description("Documentation tool for event-driven architectures");
 var ensureDir = (dir2) => {
-  if (!fs.existsSync(dir2)) {
-    fs.mkdirSync(dir2);
+  if (!fs3.existsSync(dir2)) {
+    fs3.mkdirSync(dir2);
   }
 };
 var copyCore = () => {
   ensureDir(core);
-  fs.cpSync(eventCatalogDir, core, {
+  if (eventCatalogDir === core) {
+    return;
+  }
+  fs3.cpSync(eventCatalogDir, core, {
     recursive: true,
     filter: (src) => {
       return true;
@@ -28,9 +466,9 @@ var copyCore = () => {
   });
 };
 var clearCore = () => {
-  if (fs.existsSync(core)) fs.rmSync(core, { recursive: true });
+  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((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");
@@ -40,15 +478,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");
-  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 } = concurrently([
+      {
+        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);
   execSync(`cross-env PROJECT_DIR='${dir}' CATALOG_DIR='${core}' npm run build`, {
     cwd: core,
     stdio: "inherit"
@@ -69,11 +525,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();
-  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();

package/package.json

@@ -6,7 +6,7 @@
     "url": "https://github.com/event-catalog/eventcatalog.git"
   },
   "type": "module",
-  "version": "2.13.3",
+  "version": "2.14.0",
   "publishConfig": {
     "access": "public"
   },
@@ -14,23 +14,21 @@
     "eventcatalog": "bin/dist/eventcatalog.cjs"
   },
   "scripts": {
-    "dev": "concurrently \"node scripts/watcher.js\" \"npm run scripts:hydrate-content && astro dev\"",
-    "dev:local": "concurrently \"node scripts/watcher.js\" \"astro dev\"",
+    "dev": "astro dev",
     "build:bin": "tsup",
     "prepublishOnly": "npm run build:bin",
     "test": "vitest --config vitest.config.ts",
     "test:ci": "node scripts/ci/test.js",
     "test:e2e": "playwright test",
     "start": "astro dev",
-    "build": "npm run scripts:hydrate-content && node scripts/analytics/log-build.js && astro build",
+    "build": "astro build",
     "build:cd": "node scripts/build-ci.js",
     "preview": "astro preview",
     "astro": "astro",
-    "scripts:hydrate-content": "node scripts/catalog-to-astro-content-directory.js",
     "start:catalog": "node scripts/start-catalog-locally.js",
     "verify-build:catalog": "rimraf dist && npm run build:cd",
     "changeset": "changeset",
-    "generate": "node scripts/generate.js",
+    "generate": "npm run build:bin && npx . generate",
     "release": "changeset publish",
     "format": "prettier --config .prettierrc --write \"**/*.{js,jsx,ts,tsx,json,astro}\"",
     "format:diff": "prettier --config .prettierrc --list-different \"**/*.{js,jsx,ts,tsx,json,astro}\""

package/scripts/analytics/analytics.js

@@ -1,24 +1,10 @@
 import axios from 'axios';
 import os from 'os';
-import fs from 'fs';
-import path from 'path';
-
-async function getVersion() {
-  try {
-    const pkg = await fs.readFileSync(path.join(process.env.CATALOG_DIR, 'package.json'));
-    const parsed = JSON.parse(pkg);
-    return parsed.version;
-  } catch (error) {
-    console.log(error);
-    return 'unknown';
-  }
-}
+import { VERSION } from '../constants';
 
 async function raiseEvent(eventData) {
-  const version = await getVersion();
-
   const url = 'https://queue.simpleanalyticscdn.com/events';
-  const userAgent = `@eventcatalog/eventcatalog@${version} (${os.platform()}; ${os.arch()}; Node/${process.version})`;
+  const userAgent = `@eventcatalog/eventcatalog@${VERSION} (${os.platform()}; ${os.arch()}; Node/${process.version})`;
   const headers = {
     'Content-Type': 'application/json',
   };

package/scripts/analytics/log-build.js

@@ -1,11 +1,15 @@
 import { getEventCatalogConfigFile, verifyRequiredFieldsAreInCatalogConfigFile } from '../eventcatalog-config-file-utils.js';
 import { raiseEvent } from './analytics.js';
 
-const main = async () => {
+/**
+ *
+ * @param {string} projectDir
+ */
+const main = async (projectDir) => {
   if (process.env.NODE_ENV === 'CI') return;
   try {
-    await verifyRequiredFieldsAreInCatalogConfigFile(process.env.PROJECT_DIR);
-    const configFile = await getEventCatalogConfigFile(process.env.PROJECT_DIR);
+    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({
@@ -19,4 +23,4 @@ const main = async () => {
   }
 };
 
-main();
+export default main;

package/scripts/build-ci.js

@@ -11,10 +11,17 @@ const catalog = args[0] || 'default';
 const catalogDir = join(__dirname, '../');
 const projectDIR = join(__dirname, `../examples/${catalog}`);
 
-execSync(
-  `cross-env NODE_ENV=CI PROJECT_DIR=${projectDIR} CATALOG_DIR=${catalogDir} npm run build && astro check --minimumSeverity error`,
-  {
-    cwd: catalogDir,
-    stdio: 'inherit',
-  }
-);
+// Build cli
+execSync('npm run build:bin', { stdio: 'inherit' });
+
+// Build catalog
+execSync(`cross-env NODE_ENV=CI PROJECT_DIR=${projectDIR} CATALOG_DIR=${catalogDir} npx . build`, {
+  cwd: catalogDir,
+  stdio: 'inherit',
+});
+
+// Type check
+execSync('npx astro check --minimumSeverity error', {
+  cwd: catalogDir,
+  stdio: 'inherit',
+});