@eventcatalog/core 3.25.6 → 3.26.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_path7 = require("path");
+var import_node_path8 = require("path");
 var import_node_http = __toESM(require("http"), 1);
 var import_fs2 = __toESM(require("fs"), 1);
-var import_node_path8 = __toESM(require("path"), 1);
+var import_node_path9 = __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.25.6";
+var version = "3.26.1";
 
 // src/constants.ts
 var VERSION = version;
@@ -699,16 +699,533 @@ var runMigrations = async (dir2) => {
   await message_channels_to_service_channels_default(dir2);
 };
 
+// eventcatalog/src/enterprise/fields/field-indexer.ts
+var import_node_path7 = __toESM(require("path"), 1);
+var import_node_fs7 = __toESM(require("fs"), 1);
+
+// eventcatalog/src/enterprise/fields/fields-db.ts
+var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
+var import_node_fs6 = __toESM(require("fs"), 1);
+var SCHEMA_SQL = `
+  CREATE TABLE IF NOT EXISTS fields (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    path TEXT NOT NULL,
+    type TEXT NOT NULL,
+    description TEXT NOT NULL DEFAULT '',
+    required INTEGER NOT NULL DEFAULT 0,
+    schema_format TEXT NOT NULL,
+    message_id TEXT NOT NULL,
+    message_version TEXT NOT NULL,
+    message_type TEXT NOT NULL,
+    message_name TEXT NOT NULL DEFAULT '',
+    message_summary TEXT NOT NULL DEFAULT '',
+    message_owners TEXT NOT NULL DEFAULT '[]'
+  );
+
+  CREATE TABLE IF NOT EXISTS message_producers (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    message_id TEXT NOT NULL,
+    message_version TEXT NOT NULL,
+    service_id TEXT NOT NULL,
+    service_version TEXT NOT NULL,
+    service_name TEXT NOT NULL DEFAULT '',
+    service_summary TEXT NOT NULL DEFAULT '',
+    service_owners TEXT NOT NULL DEFAULT '[]'
+  );
+
+  CREATE TABLE IF NOT EXISTS message_consumers (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    message_id TEXT NOT NULL,
+    message_version TEXT NOT NULL,
+    service_id TEXT NOT NULL,
+    service_version TEXT NOT NULL,
+    service_name TEXT NOT NULL DEFAULT '',
+    service_summary TEXT NOT NULL DEFAULT '',
+    service_owners TEXT NOT NULL DEFAULT '[]'
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_fields_path ON fields(path);
+  CREATE INDEX IF NOT EXISTS idx_fields_message ON fields(message_id, message_version);
+  CREATE INDEX IF NOT EXISTS idx_producers_message ON message_producers(message_id, message_version);
+  CREATE INDEX IF NOT EXISTS idx_consumers_message ON message_consumers(message_id, message_version);
+`;
+var FTS_SQL = `
+  DROP TABLE IF EXISTS fields_fts;
+  CREATE VIRTUAL TABLE fields_fts USING fts5(
+    path,
+    description,
+    type,
+    content=fields,
+    content_rowid=id
+  );
+  INSERT INTO fields_fts(rowid, path, description, type) SELECT id, path, description, type FROM fields;
+`;
+var FieldsDatabase = class {
+  db;
+  constructor(dbPath, options) {
+    if (options?.recreate && import_node_fs6.default.existsSync(dbPath)) {
+      import_node_fs6.default.unlinkSync(dbPath);
+    }
+    this.db = new import_better_sqlite3.default(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.exec(SCHEMA_SQL);
+  }
+  insertField(field) {
+    this.db.prepare(
+      `INSERT INTO fields (path, type, description, required, schema_format, message_id, message_version, message_type, message_name, message_summary, message_owners)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      field.path,
+      field.type,
+      field.description,
+      field.required ? 1 : 0,
+      field.schemaFormat,
+      field.messageId,
+      field.messageVersion,
+      field.messageType,
+      field.messageName || "",
+      field.messageSummary || "",
+      JSON.stringify(field.messageOwners || [])
+    );
+  }
+  insertProducer(messageId, messageVersion, serviceId, serviceVersion, serviceName, serviceSummary, serviceOwners) {
+    this.db.prepare(
+      `INSERT INTO message_producers (message_id, message_version, service_id, service_version, service_name, service_summary, service_owners)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      messageId,
+      messageVersion,
+      serviceId,
+      serviceVersion,
+      serviceName || "",
+      serviceSummary || "",
+      JSON.stringify(serviceOwners || [])
+    );
+  }
+  insertConsumer(messageId, messageVersion, serviceId, serviceVersion, serviceName, serviceSummary, serviceOwners) {
+    this.db.prepare(
+      `INSERT INTO message_consumers (message_id, message_version, service_id, service_version, service_name, service_summary, service_owners)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      messageId,
+      messageVersion,
+      serviceId,
+      serviceVersion,
+      serviceName || "",
+      serviceSummary || "",
+      JSON.stringify(serviceOwners || [])
+    );
+  }
+  rebuildFts() {
+    this.db.exec(FTS_SQL);
+  }
+  queryFields(params) {
+    const {
+      q,
+      shared,
+      conflicting,
+      format,
+      type,
+      messageType,
+      message,
+      producer,
+      consumer,
+      required,
+      path: fieldPath,
+      pageSize = 50,
+      cursor
+    } = params;
+    const conditions = [];
+    const bindings = [];
+    if (fieldPath) {
+      conditions.push(`f.path = ?`);
+      bindings.push(fieldPath);
+    }
+    if (q) {
+      conditions.push(`f.id IN (SELECT rowid FROM fields_fts WHERE fields_fts MATCH ?)`);
+      const escaped = q.replace(/"/g, '""');
+      bindings.push(`"${escaped}" *`);
+    }
+    if (format) {
+      const formats2 = format.split(",").map((f) => f.trim()).filter(Boolean);
+      conditions.push(`f.schema_format IN (${formats2.map(() => "?").join(", ")})`);
+      bindings.push(...formats2);
+    }
+    if (type) {
+      conditions.push(`f.type = ?`);
+      bindings.push(type);
+    }
+    if (messageType) {
+      const types2 = messageType.split(",").map((t) => t.trim()).filter(Boolean);
+      conditions.push(`f.message_type IN (${types2.map(() => "?").join(", ")})`);
+      bindings.push(...types2);
+    }
+    if (message) {
+      conditions.push(`f.message_id = ?`);
+      bindings.push(message);
+    }
+    if (required) {
+      conditions.push(`f.required = 1`);
+    }
+    if (producer) {
+      conditions.push(
+        `EXISTS (SELECT 1 FROM message_producers p WHERE p.message_id = f.message_id AND p.message_version = f.message_version AND p.service_id = ?)`
+      );
+      bindings.push(producer);
+    }
+    if (consumer) {
+      conditions.push(
+        `EXISTS (SELECT 1 FROM message_consumers c WHERE c.message_id = f.message_id AND c.message_version = f.message_version AND c.service_id = ?)`
+      );
+      bindings.push(consumer);
+    }
+    if (shared) {
+      const sharedSubquery = `SELECT path FROM fields GROUP BY path HAVING COUNT(DISTINCT message_id || '/' || message_version) > 1`;
+      conditions.push(`f.path IN (${sharedSubquery})`);
+    }
+    if (conflicting) {
+      const conflictSubquery = `SELECT path FROM fields GROUP BY path HAVING COUNT(DISTINCT type) > 1`;
+      conditions.push(`f.path IN (${conflictSubquery})`);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const cursorConditions = [];
+    const cursorBindings = [];
+    if (cursor) {
+      const lastId = decodeCursor(cursor);
+      cursorConditions.push(`f.id > ?`);
+      cursorBindings.push(lastId);
+    }
+    const paginationWhere = cursorConditions.length > 0 ? whereClause ? `${whereClause} AND ${cursorConditions.join(" AND ")}` : `WHERE ${cursorConditions.join(" AND ")}` : whereClause;
+    const countSql = `SELECT COUNT(*) as cnt FROM fields f ${whereClause}`;
+    const total = this.db.prepare(countSql).get(...bindings).cnt;
+    const mainSql = `SELECT f.* FROM fields f ${paginationWhere} ORDER BY f.id ASC LIMIT ?`;
+    const allBindings = [...bindings, ...cursorBindings, pageSize];
+    const rows = this.db.prepare(mainSql).all(...allBindings);
+    const usedInStmt = this.db.prepare(
+      `SELECT COUNT(DISTINCT message_id || '/' || message_version) as cnt FROM fields WHERE path = ?`
+    );
+    const conflictsStmt = this.db.prepare(
+      `SELECT type, COUNT(DISTINCT message_id || '/' || message_version) as count FROM fields WHERE path = ? GROUP BY type`
+    );
+    const fields = rows.map((row) => {
+      const producers = this.db.prepare(
+        `SELECT service_id, service_version, service_name, service_summary, service_owners FROM message_producers WHERE message_id = ? AND message_version = ?`
+      ).all(row.message_id, row.message_version);
+      const consumers = this.db.prepare(
+        `SELECT service_id, service_version, service_name, service_summary, service_owners FROM message_consumers WHERE message_id = ? AND message_version = ?`
+      ).all(row.message_id, row.message_version);
+      const parseOwners = (raw) => {
+        try {
+          return JSON.parse(raw || "[]");
+        } catch {
+          return [];
+        }
+      };
+      const usedInCount = usedInStmt.get(row.path).cnt;
+      const typeRows = conflictsStmt.all(row.path);
+      const conflicts = typeRows.length > 1 ? typeRows.map((r) => ({ type: r.type, count: r.count })) : void 0;
+      return {
+        id: row.id,
+        path: row.path,
+        type: row.type,
+        description: row.description,
+        required: row.required === 1,
+        schemaFormat: row.schema_format,
+        messageId: row.message_id,
+        messageVersion: row.message_version,
+        messageType: row.message_type,
+        messageName: row.message_name || row.message_id,
+        messageSummary: row.message_summary || "",
+        messageOwners: parseOwners(row.message_owners),
+        usedInCount,
+        conflicts,
+        producers: producers.map((p) => ({
+          id: p.service_id,
+          version: p.service_version,
+          name: p.service_name || p.service_id,
+          summary: p.service_summary || "",
+          owners: parseOwners(p.service_owners)
+        })),
+        consumers: consumers.map((c) => ({
+          id: c.service_id,
+          version: c.service_version,
+          name: c.service_name || c.service_id,
+          summary: c.service_summary || "",
+          owners: parseOwners(c.service_owners)
+        }))
+      };
+    });
+    const formatsFacetSql = `SELECT f.schema_format as value, COUNT(*) as count FROM fields f ${whereClause} GROUP BY f.schema_format`;
+    const formats = this.db.prepare(formatsFacetSql).all(...bindings);
+    const typesFacetSql = `SELECT f.type as value, COUNT(*) as count FROM fields f ${whereClause} GROUP BY f.type`;
+    const types = this.db.prepare(typesFacetSql).all(...bindings);
+    const messageTypesFacetSql = `SELECT f.message_type as value, COUNT(*) as count FROM fields f ${whereClause} GROUP BY f.message_type`;
+    const messageTypes = this.db.prepare(messageTypesFacetSql).all(...bindings);
+    const lastRow = rows[rows.length - 1];
+    const nextCursor = lastRow && rows.length === pageSize ? encodeCursor(lastRow.id) : void 0;
+    return {
+      fields,
+      total,
+      cursor: nextCursor,
+      facets: { formats, types, messageTypes }
+    };
+  }
+  close() {
+    this.db.close();
+  }
+};
+function encodeCursor(id) {
+  return Buffer.from(String(id)).toString("base64url");
+}
+function decodeCursor(cursor) {
+  return parseInt(Buffer.from(cursor, "base64url").toString(), 10);
+}
+
+// eventcatalog/src/enterprise/fields/field-extractor.ts
+function extractSchemaFieldsDeep(content, format) {
+  if (!content) return [];
+  if (format === "json-schema") {
+    return extractJsonSchemaFields(content);
+  }
+  if (format === "avro") {
+    return extractAvroFields(content);
+  }
+  if (format === "proto") {
+    return extractProtoFields(content);
+  }
+  return [];
+}
+function extractProtoFields(content) {
+  if (!content) return [];
+  const fields = [];
+  const fieldRegex = /^\s*(repeated\s+|optional\s+|required\s+)?(\w+)\s+(\w+)\s*=\s*\d+\s*;(?:\s*\/\/\s*(.*))?/gm;
+  let match;
+  while ((match = fieldRegex.exec(content)) !== null) {
+    const modifier = (match[1] || "").trim();
+    const type = modifier ? `${modifier} ${match[2]}` : match[2];
+    fields.push({
+      path: match[3],
+      type,
+      description: match[4]?.trim() || "",
+      required: modifier === "required"
+    });
+  }
+  return fields;
+}
+function extractAvroFields(content) {
+  try {
+    const schema = JSON.parse(content);
+    const fields = [];
+    walkAvroRecord(schema, "", fields);
+    return fields;
+  } catch {
+    return [];
+  }
+}
+function getAvroTypeName(type) {
+  if (typeof type === "string") return type;
+  if (Array.isArray(type)) {
+    return type.map((t) => typeof t === "string" ? t : t.type || "complex").join(" | ");
+  }
+  if (typeof type === "object" && type !== null) {
+    if (type.type === "array" && type.items) return `array<${getAvroTypeName(type.items)}>`;
+    if (type.type === "record") return type.name || "record";
+    return type.type || "complex";
+  }
+  return "unknown";
+}
+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 isOptional = Array.isArray(field.type) && field.type.includes("null");
+    const typeName = getAvroTypeName(field.type);
+    fields.push({
+      path: path9,
+      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);
+    }
+    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);
+    }
+  }
+}
+function extractJsonSchemaFields(content) {
+  try {
+    const schema = JSON.parse(content);
+    const fields = [];
+    walkJsonSchema(schema, "", schema.required || [], schema, fields);
+    return fields;
+  } catch {
+    return [];
+  }
+}
+function walkJsonSchema(node, prefix, requiredList, rootSchema, fields) {
+  if (node.allOf && Array.isArray(node.allOf)) {
+    const merged = { type: "object", properties: {}, required: [] };
+    for (let sub of node.allOf) {
+      if (sub.$ref) {
+        const resolved = resolveLocalRef(sub.$ref, rootSchema);
+        if (resolved) sub = resolved;
+        else continue;
+      }
+      Object.assign(merged.properties, sub.properties || {});
+      merged.required.push(...sub.required || []);
+    }
+    walkJsonSchema(merged, prefix, merged.required, rootSchema, fields);
+    return;
+  }
+  if (!node.properties) return;
+  for (const [name, prop] of Object.entries(node.properties)) {
+    const path9 = prefix ? `${prefix}.${name}` : name;
+    const isRequired = requiredList.includes(name);
+    if (prop.$ref) {
+      const resolved = resolveLocalRef(prop.$ref, rootSchema);
+      if (resolved) {
+        const type2 = resolved.type || "object";
+        fields.push({ path: path9, type: type2, description: resolved.description || "", required: isRequired });
+        if (resolved.properties) {
+          walkJsonSchema(resolved, path9, resolved.required || [], rootSchema, fields);
+        }
+      } else {
+        fields.push({ path: path9, type: "$ref", description: "", required: isRequired });
+      }
+      continue;
+    }
+    const type = prop.type || (prop.enum ? "enum" : prop.$ref ? "$ref" : "object");
+    fields.push({ path: path9, type, description: prop.description || "", required: isRequired });
+    if (prop.type === "object" && prop.properties) {
+      walkJsonSchema(prop, path9, prop.required || [], rootSchema, fields);
+    }
+    if (prop.type === "array" && prop.items) {
+      if (prop.items.type === "object" && prop.items.properties) {
+        walkJsonSchema(prop.items, `${path9}[]`, prop.items.required || [], rootSchema, fields);
+      }
+    }
+  }
+}
+function resolveLocalRef(ref, rootSchema) {
+  if (!ref.startsWith("#/")) return null;
+  const parts = ref.replace("#/", "").split("/");
+  let current = rootSchema;
+  for (const part of parts) {
+    current = current?.[part];
+    if (!current) return null;
+  }
+  return current;
+}
+
+// eventcatalog/src/enterprise/fields/field-indexer.ts
+function detectFormat(fileName) {
+  const ext = import_node_path7.default.extname(fileName).toLowerCase();
+  if (ext === ".proto") return "proto";
+  if (ext === ".avro" || ext === ".avsc") return "avro";
+  return "json-schema";
+}
+async function buildFieldsIndex(catalogDir, outputDir) {
+  const sdkModule = await import("@eventcatalog/sdk");
+  const sdk = sdkModule.default(catalogDir);
+  const dbDir = import_node_path7.default.join(outputDir || catalogDir, ".eventcatalog");
+  const dbPath = import_node_path7.default.join(dbDir, "fields.db");
+  if (!import_node_fs7.default.existsSync(dbDir)) {
+    import_node_fs7.default.mkdirSync(dbDir, { recursive: true });
+  }
+  const db = new FieldsDatabase(dbPath, { recreate: true });
+  const warnings = [];
+  try {
+    const [events, commands, queries] = await Promise.all([
+      sdk.getEvents({ latestOnly: true }),
+      sdk.getCommands({ latestOnly: true }),
+      sdk.getQueries({ latestOnly: true })
+    ]);
+    const collections = [
+      { entries: events, type: "event" },
+      { entries: commands, type: "command" },
+      { entries: queries, type: "query" }
+    ];
+    for (const { entries, type } of collections) {
+      for (const entry of entries) {
+        const msgId = entry.id;
+        const msgVersion = entry.version;
+        let schemaData;
+        try {
+          schemaData = await sdk.getSchemaForMessage(msgId, msgVersion);
+        } catch {
+          continue;
+        }
+        if (!schemaData) continue;
+        const { schema: content, fileName } = schemaData;
+        const format = detectFormat(fileName);
+        try {
+          const fields = extractSchemaFieldsDeep(content, format);
+          for (const field of fields) {
+            db.insertField({
+              path: field.path,
+              type: field.type,
+              description: field.description,
+              required: field.required,
+              schemaFormat: format,
+              messageId: msgId,
+              messageVersion: msgVersion,
+              messageType: type,
+              messageName: entry.name || msgId,
+              messageSummary: entry.summary || "",
+              messageOwners: entry.owners || []
+            });
+          }
+          const { producers, consumers } = await sdk.getProducersAndConsumersForMessage(msgId, msgVersion);
+          for (const producer of producers) {
+            db.insertProducer(
+              msgId,
+              msgVersion,
+              producer.id,
+              producer.version,
+              producer.name || producer.id,
+              producer.summary || "",
+              producer.owners || []
+            );
+          }
+          for (const consumer of consumers) {
+            db.insertConsumer(
+              msgId,
+              msgVersion,
+              consumer.id,
+              consumer.version,
+              consumer.name || consumer.id,
+              consumer.summary || "",
+              consumer.owners || []
+            );
+          }
+        } catch (err) {
+          warnings.push({ messageId: msgId, version: msgVersion, error: err.message });
+        }
+      }
+    }
+    db.rebuildFts();
+    db.close();
+    return { dbPath, warnings };
+  } catch (err) {
+    db.close();
+    throw err;
+  }
+}
+
 // src/eventcatalog.ts
 var import_license = require("@eventcatalog/license");
-var currentDir = import_node_path8.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
+var currentDir = import_node_path9.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
 var program = new import_commander.Command().version(VERSION);
-var dir = import_node_path8.default.resolve(process.env.PROJECT_DIR || process.cwd());
-var core = import_node_path8.default.resolve(process.env.CATALOG_DIR || (0, import_node_path7.join)(dir, ".eventcatalog-core"));
-var eventCatalogDir = import_node_path8.default.resolve((0, import_node_path7.join)(currentDir, "../eventcatalog/"));
+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 getInstalledEventCatalogVersion = () => {
   try {
-    const pkg = import_fs2.default.readFileSync((0, import_node_path7.join)(dir, "package.json"), "utf8");
+    const pkg = import_fs2.default.readFileSync((0, import_node_path8.join)(dir, "package.json"), "utf8");
     const json = JSON.parse(pkg);
     return json.dependencies["@eventcatalog/core"];
   } catch (error) {
@@ -913,8 +1430,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_path8.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path8.default.join(dir, ".env") });
+  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 (options.debug) {
     logger.info("Debug mode enabled", "debug");
@@ -933,6 +1450,19 @@ program.command("dev").description("Run development server of EventCatalog").opt
   );
   const isEventCatalogStarter = await (0, import_license.isEventCatalogStarterEnabled)();
   const isEventCatalogScale = await (0, import_license.isEventCatalogScaleEnabled)();
+  if (isServer) {
+    try {
+      logger.info("Building fields index...", "fields");
+      const { warnings } = await buildFieldsIndex(dir, core);
+      if (warnings.length > 0) {
+        logger.info(`Fields index built with ${warnings.length} warning(s)`, "fields");
+      } else {
+        logger.info("Fields index built successfully", "fields");
+      }
+    } catch (err) {
+      logger.info(`Failed to build fields index: ${err.message}`, "fields");
+    }
+  }
   checkForUpdate();
   let watchUnsub;
   try {
@@ -973,8 +1503,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_path8.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path8.default.join(dir, ".env") });
+  if (import_fs2.default.existsSync(import_node_path9.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path9.default.join(dir, ".env") });
   }
   await verifyRequiredFieldsAreInCatalogConfigFile(dir);
   copyCore();
@@ -993,6 +1523,19 @@ program.command("build").description("Run build of EventCatalog").action(async (
   await resolve_catalog_dependencies_default(dir, core);
   await runMigrations(dir);
   await catalogToAstro(dir, core);
+  if (isServer) {
+    try {
+      logger.info("Building fields index...", "fields");
+      const { warnings } = await buildFieldsIndex(dir, core);
+      if (warnings.length > 0) {
+        logger.info(`Fields index built with ${warnings.length} warning(s)`, "fields");
+      } else {
+        logger.info("Fields index built successfully", "fields");
+      }
+    } catch (err) {
+      logger.info(`Failed to build fields index: ${err.message}`, "fields");
+    }
+  }
   checkForUpdate();
   const args = command.args.join(" ").trim();
   await runCommandWithFilteredOutput({
@@ -1028,7 +1571,7 @@ var startServerCatalog = ({
   isEventCatalogStarter = false,
   isEventCatalogScale = false
 }) => {
-  const serverEntryPath = import_node_path8.default.join(dir, "dist", "server", "entry.mjs");
+  const serverEntryPath = import_node_path9.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}"`,
     {
@@ -1040,8 +1583,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_path8.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path8.default.join(dir, ".env") });
+  if (import_fs2.default.existsSync(import_node_path9.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path9.default.join(dir, ".env") });
   }
   const canEmbedPages = await (0, import_license.isFeatureEnabled)(
     "@eventcatalog/backstage-plugin-eventcatalog",
@@ -1054,8 +1597,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_path8.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path8.default.join(dir, ".env") });
+  if (import_fs2.default.existsSync(import_node_path9.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path9.default.join(dir, ".env") });
   }
   const canEmbedPages = await (0, import_license.isFeatureEnabled)(
     "@eventcatalog/backstage-plugin-eventcatalog",
@@ -1081,8 +1624,8 @@ program.command("start").description("Serves the contents of your eventcatalog b
   }
 });
 program.command("generate [siteDir]").description("Start the generator scripts.").action(async () => {
-  if (import_fs2.default.existsSync(import_node_path8.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path8.default.join(dir, ".env") });
+  if (import_fs2.default.existsSync(import_node_path9.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path9.default.join(dir, ".env") });
   }
   await generate(dir);
 });