@eventcatalog/core 3.35.0 → 3.36.1

package/dist/eventcatalog.cjs

@@ -29,10 +29,10 @@ var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 // src/eventcatalog.ts
 var import_commander = require("commander");
 var import_node_child_process = require("child_process");
-var import_node_path8 = require("path");
+var import_node_path9 = require("path");
 var import_node_http = __toESM(require("http"), 1);
 var import_fs2 = __toESM(require("fs"), 1);
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
 var import_node_url = require("url");
 
 // src/generate.js
@@ -114,7 +114,7 @@ var verifyRequiredFieldsAreInCatalogConfigFile = async (projectDirectory) => {
 var import_picocolors = __toESM(require("picocolors"), 1);
 
 // package.json
-var version = "3.35.0";
+var version = "3.36.1";
 
 // src/constants.ts
 var VERSION = version;
@@ -590,10 +590,23 @@ var import_boxen = __toESM(require("boxen"), 1);
 // src/features.ts
 var import_node_path5 = require("path");
 var import_node_fs4 = __toESM(require("fs"), 1);
+var getProjectOutDir = async () => {
+  const config = await getEventCatalogConfigFile(process.env.PROJECT_DIR || "");
+  return config?.outDir || "dist";
+};
 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 = import_node_fs4.default.existsSync((0, import_node_path5.join)(directory, "eventcatalog.auth.js"));
+  return hasAuthConfig;
+};
 
 // src/eventcatalog.ts
 var import_update_notifier = __toESM(require("update-notifier"), 1);
@@ -1086,22 +1099,22 @@ function getAvroTypeName(type) {
 function walkAvroRecord(schema, prefix, fields) {
   if (!schema.fields || !Array.isArray(schema.fields)) return;
   for (const field of schema.fields) {
-    const path9 = prefix ? `${prefix}.${field.name}` : field.name;
+    const path10 = prefix ? `${prefix}.${field.name}` : field.name;
     const isOptional = Array.isArray(field.type) && field.type.includes("null");
     const typeName = getAvroTypeName(field.type);
     fields.push({
-      path: path9,
+      path: path10,
       type: typeName,
       description: field.doc || "",
       required: !isOptional
     });
     const innerType = Array.isArray(field.type) ? field.type.find((t) => typeof t === "object" && t.type === "record") : typeof field.type === "object" && field.type.type === "record" ? field.type : null;
     if (innerType) {
-      walkAvroRecord(innerType, path9, fields);
+      walkAvroRecord(innerType, path10, fields);
     }
     const arrayType = Array.isArray(field.type) ? field.type.find((t) => typeof t === "object" && t.type === "array") : typeof field.type === "object" && field.type.type === "array" ? field.type : null;
     if (arrayType && typeof arrayType.items === "object" && arrayType.items.type === "record") {
-      walkAvroRecord(arrayType.items, `${path9}[]`, fields);
+      walkAvroRecord(arrayType.items, `${path10}[]`, fields);
     }
   }
 }
@@ -1132,32 +1145,32 @@ function walkJsonSchema(node, prefix, requiredList, rootSchema, fields) {
   }
   if (!node.properties) return;
   for (const [name, prop] of Object.entries(node.properties)) {
-    const path9 = prefix ? `${prefix}.${name}` : name;
+    const path10 = prefix ? `${prefix}.${name}` : name;
     const isRequired = requiredList.includes(name);
     if (prop.$ref) {
       const resolved = resolveLocalRef(prop.$ref, rootSchema);
       if (resolved) {
         const rawRefType = resolved.type || "object";
         const type2 = Array.isArray(rawRefType) ? [...rawRefType].sort().join(" | ") : rawRefType;
-        fields.push({ path: path9, type: type2, description: resolved.description || "", required: isRequired });
+        fields.push({ path: path10, type: type2, description: resolved.description || "", required: isRequired });
         if (resolved.properties) {
-          walkJsonSchema(resolved, path9, resolved.required || [], rootSchema, fields);
+          walkJsonSchema(resolved, path10, resolved.required || [], rootSchema, fields);
         }
       } else {
-        fields.push({ path: path9, type: "$ref", description: "", required: isRequired });
+        fields.push({ path: path10, type: "$ref", description: "", required: isRequired });
       }
       continue;
     }
     const rawType = prop.type || (prop.enum ? "enum" : prop.$ref ? "$ref" : "object");
     const typeList = Array.isArray(rawType) ? rawType : [rawType];
     const type = Array.isArray(rawType) ? [...rawType].sort().join(" | ") : rawType;
-    fields.push({ path: path9, type, description: prop.description || "", required: isRequired });
+    fields.push({ path: path10, type, description: prop.description || "", required: isRequired });
     if (typeList.includes("object") && prop.properties) {
-      walkJsonSchema(prop, path9, prop.required || [], rootSchema, fields);
+      walkJsonSchema(prop, path10, prop.required || [], rootSchema, fields);
     }
     if (typeList.includes("array") && prop.items) {
       if (prop.items.type === "object" && prop.items.properties) {
-        walkJsonSchema(prop.items, `${path9}[]`, prop.items.required || [], rootSchema, fields);
+        walkJsonSchema(prop.items, `${path10}[]`, prop.items.required || [], rootSchema, fields);
       }
     }
   }
@@ -1268,16 +1281,331 @@ async function buildFieldsIndex(catalogDir, outputDir) {
   }
 }
 
+// src/search-indexer.ts
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
+var import_glob4 = require("glob");
+var import_gray_matter4 = __toESM(require("gray-matter"), 1);
+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 = import_node_path8.default.posix.basename(removeExtension(relativePath));
+  if (fileName.toLowerCase() === "index") {
+    return import_node_path8.default.posix.basename(import_node_path8.default.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 = [import_node_path8.default.join(projectDir, resourcePath, "index.mdx"), import_node_path8.default.join(projectDir, resourcePath, "index.md")];
+  for (const candidate of candidates) {
+    try {
+      const file = await import_promises2.default.readFile(candidate, "utf8");
+      return (0, import_gray_matter4.default)(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 || import_node_path8.default.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 version2 = data.version || resourceVersion;
+    return {
+      url: buildUrl(`/diagrams/${id}/${version2}`, config),
+      title: data.name || data.title || id,
+      summary: data.summary,
+      type: "Design",
+      collection: "diagrams",
+      id,
+      version: version2
+    };
+  }
+  return null;
+};
+var collectSearchRecords = async ({
+  projectDir,
+  config
+}) => {
+  const files = await (0, import_glob4.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 import_promises2.default.readFile(file, "utf8");
+      const parsed = (0, import_gray_matter4.default)(raw);
+      const relativePath = normalizePath(import_node_path8.default.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 import_node_path8.default.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 import_promises2.default.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
+  };
+};
+
 // src/eventcatalog.ts
 var import_license = require("@eventcatalog/license");
-var currentDir = import_node_path9.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
+var currentDir = import_node_path10.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
 var program = new import_commander.Command().version(VERSION);
-var dir = import_node_path9.default.resolve(process.env.PROJECT_DIR || process.cwd());
-var core = import_node_path9.default.resolve(process.env.CATALOG_DIR || (0, import_node_path8.join)(dir, ".eventcatalog-core"));
-var eventCatalogDir = import_node_path9.default.resolve((0, import_node_path8.join)(currentDir, "../eventcatalog/"));
+var dir = import_node_path10.default.resolve(process.env.PROJECT_DIR || process.cwd());
+var core = import_node_path10.default.resolve(process.env.CATALOG_DIR || (0, import_node_path9.join)(dir, ".eventcatalog-core"));
+var eventCatalogDir = import_node_path10.default.resolve((0, import_node_path9.join)(currentDir, "../eventcatalog/"));
 var getInstalledEventCatalogVersion = () => {
   try {
-    const pkg = import_fs2.default.readFileSync((0, import_node_path8.join)(dir, "package.json"), "utf8");
+    const pkg = import_fs2.default.readFileSync((0, import_node_path9.join)(dir, "package.json"), "utf8");
     const json = JSON.parse(pkg);
     return json.dependencies["@eventcatalog/core"];
   } catch (error) {
@@ -1351,6 +1679,57 @@ var createAstroDevLineFilter = () => {
     return shouldFilterAstroLine(line) || line.includes("[router]");
   };
 };
+var buildDevSearchIndex = async ({ config }) => {
+  const result = await buildSearchIndex({
+    projectDir: dir,
+    outDir: import_node_path10.default.join(core, "public"),
+    searchOutputPath: import_node_path10.default.join(core, "public", "pagefind"),
+    config,
+    isServer: false
+  });
+  logger.info(`Indexed ${result.records} page(s) into ${import_node_path10.default.relative(core, result.outputPath)}`, "search");
+};
+var warnIfIndexedSearchUsesAuth = async () => {
+  if (!await isAuthEnabled()) {
+    return;
+  }
+  logger.info(
+    "Indexed search creates client-readable search files. Make sure your deployment protects /pagefind assets if your catalog is private.",
+    "search"
+  );
+};
+var createDevSearchIndexWatcher = ({ config }) => {
+  let timeout;
+  let isBuilding = false;
+  let queued = false;
+  const run = async () => {
+    if (isBuilding) {
+      queued = true;
+      return;
+    }
+    isBuilding = true;
+    try {
+      await buildDevSearchIndex({ config });
+    } catch (err) {
+      logger.info(`Failed to rebuild indexed search: ${err.message}`, "search");
+    } finally {
+      isBuilding = false;
+      if (queued) {
+        queued = false;
+        run();
+      }
+    }
+  };
+  return (_err, events) => {
+    if (!events.some((event) => event.path.endsWith(".md") || event.path.endsWith(".mdx"))) {
+      return;
+    }
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(run, 500);
+  };
+};
 var replaceAstroReadyVersionLine = (line) => {
   const matches = line.match(/^(\s*)astro(\s+)v\S+(\s+ready.*)$/i);
   if (!matches) {
@@ -1482,8 +1861,8 @@ program.command("dev").description("Run development server of EventCatalog").opt
   logger.info("Setting up EventCatalog...", "eventcatalog");
   const isServer = await isOutputServer();
   logger.info(isServer ? "EventCatalog is running in Server Mode" : "EventCatalog is running in Static Mode", "config");
-  if (import_fs2.default.existsSync(import_node_path9.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path9.default.join(dir, ".env") });
+  if (import_fs2.default.existsSync(import_node_path10.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path10.default.join(dir, ".env") });
   }
   if (options.debug) {
     logger.info("Debug mode enabled", "debug");
@@ -1496,6 +1875,7 @@ program.command("dev").description("Run development server of EventCatalog").opt
   await resolve_catalog_dependencies_default(dir, core);
   await runMigrations(dir);
   await catalogToAstro(dir, core);
+  const config = await getEventCatalogConfigFile(dir);
   const canEmbedPages = await (0, import_license.isFeatureEnabled)(
     "@eventcatalog/backstage-plugin-eventcatalog",
     process.env.EVENTCATALOG_LICENSE_KEY_BACKSTAGE
@@ -1515,10 +1895,16 @@ program.command("dev").description("Run development server of EventCatalog").opt
       logger.info(`Failed to build fields index: ${err.message}`, "fields");
     }
   }
+  const shouldBuildIndexedSearch = await isIndexedSearchEnabled();
+  if (shouldBuildIndexedSearch) {
+    await warnIfIndexedSearchUsesAuth();
+    logger.info("Building indexed search for local development...", "search");
+    await buildDevSearchIndex({ config });
+  }
   checkForUpdate();
   let watchUnsub;
   try {
-    watchUnsub = await watch(dir, core);
+    watchUnsub = await watch(dir, core, shouldBuildIndexedSearch ? createDevSearchIndexWatcher({ config }) : void 0);
     const args = command.args.join(" ").trim();
     if (options.prewarm) {
       const prewarmPort = await resolveDevPort({
@@ -1555,8 +1941,8 @@ program.command("build").description("Run build of EventCatalog").action(async (
   logger.info("Building EventCatalog...", "build");
   const isServer = await isOutputServer();
   logger.info(isServer ? "EventCatalog is running in Server Mode" : "EventCatalog is running in Static Mode", "config");
-  if (import_fs2.default.existsSync(import_node_path9.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path9.default.join(dir, ".env") });
+  if (import_fs2.default.existsSync(import_node_path10.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path10.default.join(dir, ".env") });
   }
   await verifyRequiredFieldsAreInCatalogConfigFile(dir);
   copyCore();
@@ -1602,6 +1988,19 @@ program.command("build").description("Run build of EventCatalog").action(async (
     },
     shouldFilterLine: createAstroLineFilter()
   });
+  if (await isIndexedSearchEnabled()) {
+    await warnIfIndexedSearchUsesAuth();
+    const config = await getEventCatalogConfigFile(dir);
+    const outDir = import_node_path10.default.resolve(dir, await getProjectOutDir());
+    logger.info("Building indexed search...", "search");
+    const result = await buildSearchIndex({
+      projectDir: dir,
+      outDir,
+      config,
+      isServer
+    });
+    logger.info(`Indexed ${result.records} page(s) into ${import_node_path10.default.relative(dir, result.outputPath)}`, "search");
+  }
 });
 var previewCatalog = ({
   command,
@@ -1623,7 +2022,7 @@ var startServerCatalog = ({
   isEventCatalogStarter = false,
   isEventCatalogScale = false
 }) => {
-  const serverEntryPath = import_node_path9.default.join(dir, "dist", "server", "entry.mjs");
+  const serverEntryPath = import_node_path10.default.join(dir, "dist", "server", "entry.mjs");
   (0, import_node_child_process.execSync)(
     `cross-env PROJECT_DIR='${dir}' CATALOG_DIR='${core}' ENABLE_EMBED=${canEmbedPages} EVENTCATALOG_STARTER=${isEventCatalogStarter} EVENTCATALOG_SCALE=${isEventCatalogScale} node "${serverEntryPath}"`,
     {
@@ -1635,8 +2034,8 @@ var startServerCatalog = ({
 program.command("preview").description("Serves the contents of your eventcatalog build directory").action(async (options, command) => {
   logger.welcome();
   logger.info("Starting preview of your build...", "preview");
-  if (import_fs2.default.existsSync(import_node_path9.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path9.default.join(dir, ".env") });
+  if (import_fs2.default.existsSync(import_node_path10.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path10.default.join(dir, ".env") });
   }
   const canEmbedPages = await (0, import_license.isFeatureEnabled)(
     "@eventcatalog/backstage-plugin-eventcatalog",
@@ -1649,8 +2048,8 @@ program.command("preview").description("Serves the contents of your eventcatalog
 program.command("start").description("Serves the contents of your eventcatalog build directory").action(async (options, command) => {
   logger.welcome();
   logger.info("Starting preview of your build...", "preview");
-  if (import_fs2.default.existsSync(import_node_path9.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path9.default.join(dir, ".env") });
+  if (import_fs2.default.existsSync(import_node_path10.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path10.default.join(dir, ".env") });
   }
   const canEmbedPages = await (0, import_license.isFeatureEnabled)(
     "@eventcatalog/backstage-plugin-eventcatalog",
@@ -1678,22 +2077,22 @@ program.command("start").description("Serves the contents of your eventcatalog b
 program.command("export").description("Export your EventCatalog using the SDK dumpCatalog function").option("--include-markdown", "Include markdown content in the export", false).action(async (options) => {
   logger.welcome();
   logger.info("Exporting EventCatalog...", "export");
-  if (import_fs2.default.existsSync(import_node_path9.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path9.default.join(dir, ".env") });
+  if (import_fs2.default.existsSync(import_node_path10.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path10.default.join(dir, ".env") });
   }
   const { default: initSDK } = await import("@eventcatalog/sdk");
   const sdk = initSDK(dir);
   const catalog = await sdk.dumpCatalog({ includeMarkdown: options.includeMarkdown });
-  const exportsDir = import_node_path9.default.join(dir, "exports");
+  const exportsDir = import_node_path10.default.join(dir, "exports");
   ensureDir(exportsDir);
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  const exportFile = import_node_path9.default.join(exportsDir, `catalog-${date}.json`);
+  const exportFile = import_node_path10.default.join(exportsDir, `catalog-${date}.json`);
   import_fs2.default.writeFileSync(exportFile, JSON.stringify(catalog, null, 2), "utf-8");
   logger.info(`Catalog exported to ${exportFile}`, "export");
 });
 program.command("generate [siteDir]").description("Start the generator scripts.").action(async () => {
-  if (import_fs2.default.existsSync(import_node_path9.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path9.default.join(dir, ".env") });
+  if (import_fs2.default.existsSync(import_node_path10.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path10.default.join(dir, ".env") });
   }
   await generate(dir);
 });

package/dist/eventcatalog.config.d.cts

@@ -90,6 +90,14 @@ interface Config {
         enabled: boolean;
         limit: number;
     };
+    search?: {
+        /**
+         * - 'resource': Fast default search across catalog resources.
+         * - 'indexed': Opt-in full-content search index generated at build time.
+         * @default 'resource'
+         */
+        type?: 'resource' | 'indexed';
+    };
     llmsTxt?: {
         enabled: boolean;
     };

package/dist/eventcatalog.config.d.ts

@@ -90,6 +90,14 @@ interface Config {
         enabled: boolean;
         limit: number;
     };
+    search?: {
+        /**
+         * - 'resource': Fast default search across catalog resources.
+         * - 'indexed': Opt-in full-content search index generated at build time.
+         * @default 'resource'
+         */
+        type?: 'resource' | 'indexed';
+    };
     llmsTxt?: {
         enabled: boolean;
     };