@eventcatalog/core 3.35.0 → 3.36.1

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 = "3.35.0";
+var version = "3.36.1";
 
 // src/constants.ts
 var VERSION = version;

package/dist/analytics/analytics.js

@@ -1,7 +1,7 @@
 import {
   raiseEvent
-} from "../chunk-B2LDVIVY.js";
-import "../chunk-NEWQKEP7.js";
+} from "../chunk-V22QY5Q3.js";
+import "../chunk-C7JCOHTI.js";
 export {
   raiseEvent
 };

package/dist/analytics/log-build.cjs

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

package/dist/analytics/log-build.js

@@ -1,9 +1,9 @@
 import {
   log_build_default
-} from "../chunk-DFLUDECO.js";
-import "../chunk-B2LDVIVY.js";
+} from "../chunk-UJ7DX4SA.js";
 import "../chunk-4UVFXLPI.js";
-import "../chunk-NEWQKEP7.js";
+import "../chunk-V22QY5Q3.js";
+import "../chunk-C7JCOHTI.js";
 import "../chunk-5T63CXKU.js";
 export {
   log_build_default as default

package/dist/{chunk-LUWCWNOR.js → chunk-6D65JSOA.js}

@@ -1,6 +1,6 @@
 import {
   VERSION
-} from "./chunk-NEWQKEP7.js";
+} from "./chunk-C7JCOHTI.js";
 
 // src/utils/cli-logger.ts
 import pc from "picocolors";

package/dist/{chunk-NEWQKEP7.js → chunk-C7JCOHTI.js}

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

package/dist/chunk-D6IBLY3O.js

@@ -0,0 +1,320 @@
+// src/search-indexer.ts
+import fs from "fs/promises";
+import path from "path";
+import { glob } from "glob";
+import matter from "gray-matter";
+var RESOURCE_COLLECTIONS = {
+  channels: { docsPath: "channels", type: "Channel" },
+  commands: { docsPath: "commands", type: "Command" },
+  containers: { docsPath: "containers", type: "Container" },
+  "data-products": { docsPath: "data-products", type: "Data Product" },
+  domains: { docsPath: "domains", type: "Domain" },
+  entities: { docsPath: "entities", type: "Entity" },
+  events: { docsPath: "events", type: "Event" },
+  flows: { docsPath: "flows", type: "Flow" },
+  queries: { docsPath: "queries", type: "Query" },
+  services: { docsPath: "services", type: "Service" },
+  subdomains: { docsPath: "domains", type: "Domain" }
+};
+var IGNORED_GLOBS = [
+  "**/.git/**",
+  "**/.eventcatalog-core/**",
+  "**/dist/**",
+  "**/node_modules/**",
+  "**/public/**",
+  "**/snippets/**",
+  "**/chat-prompts/**"
+];
+var trimSlashes = (value) => value.replace(/^\/+|\/+$/g, "");
+var normalizePath = (value) => value.replace(/\\/g, "/");
+var removeExtension = (value) => value.replace(/\.(md|mdx)$/i, "");
+var stripNumericPrefix = (value) => value.replace(/^\d+(?:[-_.\s]+)?/, "") || value;
+var normalizeUrlPath = (value) => {
+  const withoutIndex = value.replace(/\/index$/i, "");
+  return withoutIndex || "";
+};
+var buildUrl = (pathname, config) => {
+  const base = config.base ? `/${trimSlashes(config.base)}` : "";
+  const cleanPath = `/${trimSlashes(pathname)}`;
+  const url = `${base}${cleanPath}`.replace(/\/{2,}/g, "/");
+  if (config.trailingSlash === true && !url.endsWith("/")) {
+    return `${url}/`;
+  }
+  return url || "/";
+};
+var valueToSearchText = (value) => {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) return value.map(valueToSearchText).filter(Boolean).join(" ");
+  if (typeof value === "object") return Object.values(value).map(valueToSearchText).filter(Boolean).join(" ");
+  return "";
+};
+var markdownToSearchText = (content) => {
+  return content.replace(/<!--[\s\S]*?-->/g, " ").replace(/^\s*import\s+.*$/gm, " ").replace(/^\s*export\s+.*$/gm, " ").replace(/```[\s\S]*?```/g, (match) => match.replace(/```[a-zA-Z0-9-]*\n?/g, " ").replace(/```/g, " ")).replace(/<([A-Z][A-Za-z0-9.]*)\b([^>]*)\/?>/g, (_match, _component, attributes) => {
+    const quotedValues = [...String(attributes).matchAll(/(?:title|label|description|alt|summary)=["'`]([^"'`]+)["'`]/g)];
+    return quotedValues.map((entry) => entry[1]).join(" ");
+  }).replace(/<\/?[A-Za-z][^>]*>/g, " ").replace(/\[\[([^|\]]+)\|([^\]]+)\]\]/g, "$2").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/[`*_~>#|{}[\]():]/g, " ").replace(/\s+/g, " ").trim();
+};
+var inferDocIdFromFile = (relativePath, frontmatterId) => {
+  if (frontmatterId) return frontmatterId;
+  const fileName = path.posix.basename(removeExtension(relativePath));
+  if (fileName.toLowerCase() === "index") {
+    return path.posix.basename(path.posix.dirname(relativePath));
+  }
+  return stripNumericPrefix(fileName);
+};
+var findResourceSegment = (segments) => {
+  let match = null;
+  for (let index = 0; index < segments.length - 1; index++) {
+    const segment = segments[index];
+    if (RESOURCE_COLLECTIONS[segment] && segments[index + 1]) {
+      match = { index, segment };
+    }
+  }
+  return match;
+};
+var readResourceFrontmatter = async (projectDir, resourcePath) => {
+  const candidates = [path.join(projectDir, resourcePath, "index.mdx"), path.join(projectDir, resourcePath, "index.md")];
+  for (const candidate of candidates) {
+    try {
+      const file = await fs.readFile(candidate, "utf8");
+      return matter(file).data;
+    } catch {
+    }
+  }
+  return {};
+};
+var deriveRecordFromPath = async ({
+  projectDir,
+  relativePath,
+  data,
+  config
+}) => {
+  const normalizedRelativePath = normalizePath(relativePath);
+  const segments = normalizedRelativePath.split("/").filter(Boolean);
+  const fileName = segments[segments.length - 1] || "";
+  const fileNameWithoutExtension = removeExtension(fileName);
+  if (data.hidden === true || data.draft) {
+    return null;
+  }
+  if (segments[0] === "docs") {
+    const customPath = normalizeUrlPath(removeExtension(segments.slice(1).join("/")));
+    const title = data.title || data.label || path.posix.basename(customPath) || "Custom docs";
+    return {
+      url: buildUrl(`/docs/custom/${customPath}`, config),
+      title,
+      summary: data.summary,
+      type: "Custom Doc",
+      collection: "custom-docs",
+      id: customPath
+    };
+  }
+  if (segments[0] === "users" || segments[0] === "teams") {
+    const id = data.id || (fileNameWithoutExtension === "index" ? segments[1] : fileNameWithoutExtension);
+    const type = segments[0] === "users" ? "User" : "Team";
+    return {
+      url: buildUrl(`/docs/${segments[0]}/${id}`, config),
+      title: data.name || data.title || id,
+      summary: data.summary,
+      type,
+      collection: segments[0],
+      id
+    };
+  }
+  const resourceMatch = findResourceSegment(segments);
+  if (!resourceMatch) {
+    return null;
+  }
+  const resourceConfig = RESOURCE_COLLECTIONS[resourceMatch.segment];
+  const resourceFolderId = segments[resourceMatch.index + 1];
+  const resourcePathSegments = segments.slice(0, resourceMatch.index + 2);
+  const versionFromPath = segments[resourceMatch.index + 2] === "versioned" && segments[resourceMatch.index + 3] ? segments[resourceMatch.index + 3] : void 0;
+  if (versionFromPath) {
+    resourcePathSegments.push("versioned", versionFromPath);
+  }
+  const resourcePath = resourcePathSegments.join("/");
+  const resourceData = fileNameWithoutExtension === "index" ? data : await readResourceFrontmatter(projectDir, resourcePath);
+  const resourceId = resourceData.id || data.resourceId || resourceFolderId;
+  const resourceVersion = versionFromPath || resourceData.version || data.resourceVersion || data.version;
+  if (!resourceVersion) {
+    return null;
+  }
+  if (fileNameWithoutExtension === "index") {
+    return {
+      url: buildUrl(`/docs/${resourceConfig.docsPath}/${resourceId}/${resourceVersion}`, config),
+      title: data.name || data.title || resourceId,
+      summary: data.summary,
+      type: resourceConfig.type,
+      collection: resourceConfig.docsPath,
+      id: resourceId,
+      version: resourceVersion
+    };
+  }
+  if (fileNameWithoutExtension === "ubiquitous-language") {
+    return {
+      url: buildUrl(`/docs/${resourceConfig.docsPath}/${resourceId}/language`, config),
+      title: data.title || `${resourceData.name || resourceId} ubiquitous language`,
+      summary: data.summary,
+      type: "Language",
+      collection: "language",
+      id: resourceId,
+      version: resourceVersion
+    };
+  }
+  if (fileNameWithoutExtension === "changelog") {
+    return {
+      url: buildUrl(`/docs/${resourceConfig.docsPath}/${resourceId}/${resourceVersion}/changelog`, config),
+      title: data.title || `${resourceData.name || resourceId} changelog`,
+      summary: data.summary,
+      type: "Changelog",
+      collection: "changelog",
+      id: resourceId,
+      version: resourceVersion
+    };
+  }
+  const docsIndex = segments.indexOf("docs");
+  if (docsIndex > resourceMatch.index) {
+    const docType = data.type || segments[docsIndex + 1] || "pages";
+    const docId = inferDocIdFromFile(normalizedRelativePath, data.id);
+    const title = data.title || stripNumericPrefix(removeExtension(fileName));
+    return {
+      url: buildUrl(`/docs/${resourceConfig.docsPath}/${resourceId}/${resourceVersion}/${docType}/${docId}`, config),
+      title,
+      summary: data.summary,
+      type: "Resource Doc",
+      collection: docType,
+      id: docId,
+      version: data.version || resourceVersion
+    };
+  }
+  if (segments[0] === "diagrams") {
+    const id = data.id || resourceFolderId;
+    const version = data.version || resourceVersion;
+    return {
+      url: buildUrl(`/diagrams/${id}/${version}`, config),
+      title: data.name || data.title || id,
+      summary: data.summary,
+      type: "Design",
+      collection: "diagrams",
+      id,
+      version
+    };
+  }
+  return null;
+};
+var collectSearchRecords = async ({
+  projectDir,
+  config
+}) => {
+  const files = await glob("**/*.{md,mdx}", {
+    cwd: projectDir,
+    absolute: true,
+    nodir: true,
+    ignore: IGNORED_GLOBS,
+    windowsPathsNoEscape: process.platform === "win32"
+  });
+  const records = await Promise.all(
+    files.map(async (file) => {
+      const raw = await fs.readFile(file, "utf8");
+      const parsed = matter(raw);
+      const relativePath = normalizePath(path.relative(projectDir, file));
+      const baseRecord = await deriveRecordFromPath({
+        projectDir,
+        relativePath,
+        data: parsed.data,
+        config
+      });
+      if (!baseRecord) {
+        return null;
+      }
+      const frontmatterText = valueToSearchText({
+        id: baseRecord.id,
+        title: baseRecord.title,
+        summary: baseRecord.summary,
+        version: baseRecord.version,
+        owners: parsed.data.owners,
+        badges: parsed.data.badges
+      });
+      const content = [frontmatterText, markdownToSearchText(parsed.content)].filter(Boolean).join("\n\n");
+      if (!content.trim()) {
+        return null;
+      }
+      return {
+        ...baseRecord,
+        content
+      };
+    })
+  );
+  const uniqueRecords = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (!record) continue;
+    uniqueRecords.set(record.url, record);
+  }
+  return [...uniqueRecords.values()].sort((a, b) => a.url.localeCompare(b.url));
+};
+var getSearchOutputPath = ({
+  outDir,
+  isServer,
+  searchOutputPath
+}) => {
+  if (searchOutputPath) {
+    return searchOutputPath;
+  }
+  return path.join(outDir, isServer ? "client" : "", "pagefind");
+};
+var buildSearchIndex = async ({ projectDir, outDir, config, isServer, searchOutputPath }) => {
+  const records = await collectSearchRecords({ projectDir, config });
+  if (records.length === 0) {
+    throw new Error("No searchable Markdown or MDX content was found.");
+  }
+  const pagefind = await import("pagefind");
+  const { index } = await pagefind.createIndex({
+    keepIndexUrl: false,
+    writePlayground: false
+  });
+  const errors = [];
+  for (const record of records) {
+    const result = await index.addCustomRecord({
+      url: record.url,
+      content: record.content,
+      language: "en",
+      meta: {
+        title: record.title,
+        summary: record.summary || "",
+        type: record.type,
+        collection: record.collection,
+        id: record.id || "",
+        version: record.version || ""
+      },
+      filters: {
+        type: [record.type],
+        collection: [record.collection]
+      }
+    });
+    if (result.errors?.length) {
+      errors.push(...result.errors.map((error) => `${record.url}: ${error.message || error}`));
+    }
+  }
+  const outputPath = getSearchOutputPath({ outDir, isServer, searchOutputPath });
+  await fs.rm(outputPath, { recursive: true, force: true });
+  const writeResult = await index.writeFiles({ outputPath });
+  if (writeResult.errors?.length) {
+    errors.push(...writeResult.errors.map((error) => error.message || String(error)));
+  }
+  await index.deleteIndex?.();
+  await pagefind.close?.();
+  if (errors.length > 0) {
+    throw new Error(`Failed to build indexed search:
+${errors.join("\n")}`);
+  }
+  return {
+    records: records.length,
+    outputPath
+  };
+};
+
+export {
+  markdownToSearchText,
+  collectSearchRecords,
+  buildSearchIndex
+};

package/dist/{chunk-Y5O6SCX3.js → chunk-HDENGAZL.js}

@@ -1,6 +1,6 @@
 import {
   logger
-} from "./chunk-LUWCWNOR.js";
+} from "./chunk-6D65JSOA.js";
 import {
   cleanup,
   getEventCatalogConfigFile

package/dist/{chunk-DFLUDECO.js → chunk-UJ7DX4SA.js}

@@ -1,10 +1,10 @@
-import {
-  raiseEvent
-} from "./chunk-B2LDVIVY.js";
 import {
   countResources,
   serializeCounts
 } from "./chunk-4UVFXLPI.js";
+import {
+  raiseEvent
+} from "./chunk-V22QY5Q3.js";
 import {
   getEventCatalogConfigFile,
   verifyRequiredFieldsAreInCatalogConfigFile

package/dist/{chunk-3KXCGYET.js → chunk-ULZYHF3V.js}

@@ -13,6 +13,10 @@ var isOutputServer = async () => {
   const config = await getEventCatalogConfigFile(process.env.PROJECT_DIR || "");
   return config?.output === "server";
 };
+var isIndexedSearchEnabled = async () => {
+  const config = await getEventCatalogConfigFile(process.env.PROJECT_DIR || "");
+  return config?.search?.type === "indexed";
+};
 var isAuthEnabled = async () => {
   const directory = process.env.PROJECT_DIR || process.cwd();
   const hasAuthConfig = fs.existsSync(join(directory, "eventcatalog.auth.js"));
@@ -22,5 +26,6 @@ var isAuthEnabled = async () => {
 export {
   getProjectOutDir,
   isOutputServer,
+  isIndexedSearchEnabled,
   isAuthEnabled
 };

package/dist/{chunk-B2LDVIVY.js → chunk-V22QY5Q3.js}

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

package/dist/constants.cjs

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

package/dist/constants.js

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

package/dist/docs/api/01-overview.md

@@ -0,0 +1,74 @@
+---
+sidebar_position: 1
+keywords:
+- EventCatalog CLI
+sidebar_label: EventCatalog CLI
+title: EventCatalog CLI
+description: Understand the CLI of EventCatalog
+---
+
+EventCatalog provides a set of scripts to help you generate, serve, and deploy your catalog.
+
+Once your catalog is bootstrapped, the source will contain the EventCatalog scripts that you can invoke with your package manager:
+
+```json title="package.json"
+{
+  // ...
+  "scripts": {
+    // Runs the dev server locally
+    "dev": "eventcatalog dev",
+    // Builds the catalog
+    "build": "eventcatalog build",
+
+    // start/preview both run the built catalog locally.
+    "start": "eventcatalog start",
+    "preview": "eventcatalog preview",
+
+    // Export your catalog as JSON
+    "export": "eventcatalog export",
+  }
+}
+```
+
+import TOCInline from "@theme/TOCInline"
+
+<TOCInline toc={toc} minHeadingLevel={3}/>
+
+## EventCatalog CLI commands {#eventcatalog-cli-commands}
+
+Below is a list of EventCatalog CLI commands and their usages:
+
+### `eventcatalog dev` {#eventcatalog-dev-sitedir}
+
+Runs your catalog in development mode.
+
+This will start the dev server and watch for changes to your catalog. You will use this as you develop your catalog.
+
+
+### `eventcatalog start/preview` {#eventcatalog-start-sitedir}
+
+Runs EventCatalog in production mode, requires a `build` first. This will serve the built catalog from the `dist` folder.
+
+Can be used to preview your catalog before deploying.
+
+### `eventcatalog build` {#eventcatalog-build-sitedir}
+
+Builds your catalog for production, and outputs the catalog to the `dist` folder.
+
+### `eventcatalog export` {#eventcatalog-export}
+
+Exports your entire catalog as a JSON file using the SDK's `dumpCatalog` function. The export is saved to the `exports/` directory in your project with a date stamp (e.g. `exports/catalog-2026-03-30.json`).
+
+**Options:**
+
+| Option | Description |
+|--------|-------------|
+| `--include-markdown` | Include markdown content in the export (default: `false`) |
+
+```bash
+# Export catalog as JSON
+eventcatalog export
+
+# Export with markdown content included
+eventcatalog export --include-markdown
+```