@eventcatalog/core 4.10.8 → 4.10.10

package/eventcatalog/src/pages/schemas/explorer/_index.data.ts

@@ -1,272 +1,6 @@
 import { isSSR } from '@utils/feature';
 import { HybridPage } from '@utils/page-loaders/hybrid-page';
-import { getEvents } from '@utils/collections/events';
-import { getCommands } from '@utils/collections/commands';
-import { getQueries } from '@utils/collections/queries';
-import { getServices, getSpecificationsForService } from '@utils/collections/services';
-import { getDomains, getSpecificationsForDomain } from '@utils/collections/domains';
-import { getDataProducts } from '@utils/collections/data-products';
-import { getOwner } from '@utils/collections/owners';
-import { buildUrl } from '@utils/url-builder';
-import { resourceFileExists, readResourceFile } from '@utils/resource-files';
-import { getExamplesForResource } from '@utils/collections/examples';
-import { getCollection } from 'astro:content';
-import path from 'path';
-
-// Helper function to enrich owners with full details
-async function enrichOwners(ownersRaw: any[]) {
-  if (!ownersRaw || ownersRaw.length === 0) return [];
-
-  const owners = await Promise.all(ownersRaw.map(getOwner));
-  const filteredOwners = owners.filter((o) => o !== undefined);
-
-  return filteredOwners.map((o) => ({
-    id: o.data.id,
-    name: o.data.name,
-    type: o.collection,
-    href: buildUrl(`/docs/${o.collection}/${o.data.id}`),
-  }));
-}
-
-async function fetchAllSchemas() {
-  // Fetch all messages
-  const events = await getEvents({ getAllVersions: true });
-  const commands = await getCommands({ getAllVersions: true });
-  const queries = await getQueries({ getAllVersions: true });
-  const schemaEntries = await getCollection('schemas');
-
-  // Fetch all services
-  const services = await getServices({ getAllVersions: true });
-
-  // Combine all messages
-  const allMessages = [...events, ...commands, ...queries];
-  const messagesBySchemaReference = new Map(
-    allMessages.map((message) => [`${message.collection}:${message.data.id}:${message.data.version}`, message])
-  );
-
-  // Read message schemas from the generated schemas collection.
-  const messagesWithSchemas = await Promise.all(
-    schemaEntries.map(async (schema) => {
-      const message = messagesBySchemaReference.get(
-        `${schema.data.message.collectionName}:${schema.data.message.id}:${schema.data.message.version}`
-      );
-      const schemaPath = schema.data.file || schema.data.source.path || '';
-      const schemaExtension = path.extname(schemaPath).slice(1) || schema.data.format;
-
-      if (message) {
-        try {
-          const enrichedOwners = await enrichOwners(schema.data.message.owners || []);
-
-          return {
-            collection: message.collection,
-            data: {
-              id: message.data.id,
-              name: schema.data.message.name || message.data.name,
-              version: message.data.version,
-              summary: schema.data.message.summary || message.data.summary,
-              schemaPath,
-              producers: message.data.producers || [],
-              consumers: message.data.consumers || [],
-              owners: enrichedOwners,
-            },
-            schemaContent: schema.data.content || '',
-            schemaExtension,
-            examples: getExamplesForResource(message),
-          };
-        } catch (error) {
-          console.error(`Error reading schema metadata for ${message.data.id}:`, error);
-          const enrichedOwners = await enrichOwners(schema.data.message.owners || []);
-          return {
-            collection: message.collection,
-            data: {
-              id: message.data.id,
-              name: schema.data.message.name || schema.data.name || message.data.name,
-              version: message.data.version,
-              summary: schema.data.message.summary || message.data.summary,
-              schemaPath,
-              producers: message.data.producers || [],
-              consumers: message.data.consumers || [],
-              owners: enrichedOwners,
-            },
-            schemaContent: schema.data.content || '',
-            schemaExtension,
-          };
-        }
-      }
-
-      return {
-        collection: schema.data.message.collectionName,
-        data: {
-          id: schema.data.message.id,
-          name: schema.data.message.name || schema.data.name || schema.data.message.id,
-          version: schema.data.message.version,
-          summary: schema.data.message.summary,
-          schemaPath,
-          owners: await enrichOwners(schema.data.message.owners || []),
-          producers: [],
-          consumers: [],
-        },
-        schemaContent: schema.data.content || '',
-        schemaExtension,
-        examples: [],
-      };
-    })
-  );
-
-  // Filter services with specifications and read spec content - only keep essential data
-  const servicesWithSpecs = await Promise.all(
-    services.map(async (service) => {
-      try {
-        const specifications = getSpecificationsForService(service);
-
-        if (specifications.length === 0) {
-          return null;
-        }
-
-        return await Promise.all(
-          specifications.map(async (spec) => {
-            if (!resourceFileExists(service, spec.path)) {
-              return null;
-            }
-
-            const schemaContent = readResourceFile(service, spec.path) ?? '';
-            const schemaExtension = spec.type;
-            const enrichedOwners = await enrichOwners(service.data.owners || []);
-
-            return {
-              collection: 'services',
-              data: {
-                id: `${service.data.id}`,
-                name: `${service.data.name} - ${spec.name}`,
-                version: service.data.version,
-                summary: service.data.summary,
-                schemaPath: spec.path,
-                owners: enrichedOwners,
-              },
-              schemaContent,
-              schemaExtension,
-              specType: spec.type,
-              specName: spec.name,
-              specFilenameWithoutExtension: spec.filenameWithoutExtension,
-            };
-          })
-        );
-      } catch (error) {
-        console.error(`Error reading specifications for service ${service.data.id}:`, error);
-        return null;
-      }
-    })
-  );
-
-  // Flatten and filter out null values
-  const flatServicesWithSpecs = servicesWithSpecs.flat().filter((service) => service !== null);
-
-  // Fetch all domains
-  const domains = await getDomains({ getAllVersions: true });
-
-  // Filter domains with specifications and read spec content - only keep essential data
-  const domainsWithSpecs = await Promise.all(
-    domains.map(async (domain) => {
-      try {
-        const specifications = getSpecificationsForDomain(domain);
-
-        if (specifications.length === 0) {
-          return null;
-        }
-
-        return await Promise.all(
-          specifications.map(async (spec) => {
-            if (!resourceFileExists(domain, spec.path)) {
-              return null;
-            }
-
-            const schemaContent = readResourceFile(domain, spec.path) ?? '';
-            const schemaExtension = spec.type;
-            const enrichedOwners = await enrichOwners(domain.data.owners || []);
-
-            return {
-              collection: 'domains',
-              data: {
-                id: `${domain.data.id}`,
-                name: `${domain.data.name} - ${spec.name}`,
-                version: domain.data.version,
-                summary: domain.data.summary,
-                schemaPath: spec.path,
-                owners: enrichedOwners,
-              },
-              schemaContent,
-              schemaExtension,
-              specType: spec.type,
-              specName: spec.name,
-              specFilenameWithoutExtension: spec.filenameWithoutExtension,
-            };
-          })
-        );
-      } catch (error) {
-        console.error(`Error reading specifications for domain ${domain.data.id}:`, error);
-        return null;
-      }
-    })
-  );
-
-  // Flatten and filter out null values for domains
-  const flatDomainsWithSpecs = domainsWithSpecs.flat().filter((domain) => domain !== null);
-
-  // Fetch all data products and extract contracts from outputs
-  const dataProducts = await getDataProducts({ getAllVersions: true });
-
-  // Filter data products with contracts in outputs and read contract content
-  const dataProductsWithContracts = await Promise.all(
-    dataProducts.map(async (dataProduct) => {
-      try {
-        const outputs = dataProduct.data.outputs || [];
-        const outputsWithContracts = outputs.filter((output) => output.contract);
-
-        if (outputsWithContracts.length === 0) {
-          return null;
-        }
-
-        return await Promise.all(
-          outputsWithContracts.map(async (output) => {
-            const contract = output.contract!;
-            if (!resourceFileExists(dataProduct, contract.path)) {
-              return null;
-            }
-
-            const schemaContent = readResourceFile(dataProduct, contract.path) ?? '';
-            const schemaExtension = path.extname(contract.path).slice(1) || 'json';
-            const enrichedOwners = await enrichOwners(dataProduct.data.owners || []);
-
-            return {
-              collection: 'data-products',
-              data: {
-                id: `${dataProduct.data.id}__${contract.path}`,
-                name: contract.name,
-                version: dataProduct.data.version,
-                summary: `Data contract for ${dataProduct.data.name}`,
-                schemaPath: contract.path,
-                owners: enrichedOwners,
-              },
-              schemaContent,
-              schemaExtension,
-              contractType: contract.type,
-              dataProductId: dataProduct.data.id,
-              dataProductVersion: dataProduct.data.version,
-            };
-          })
-        );
-      } catch (error) {
-        console.error(`Error reading contracts for data product ${dataProduct.data.id}:`, error);
-        return null;
-      }
-    })
-  );
-
-  // Flatten and filter out null values for data product contracts
-  const flatDataProductContracts = dataProductsWithContracts.flat().filter((contract) => contract !== null);
-
-  return [...messagesWithSchemas, ...flatServicesWithSpecs, ...flatDomainsWithSpecs, ...flatDataProductContracts];
-}
+import { getSchemaMetadata } from '@utils/schema-explorer';
 
 export class Page extends HybridPage {
   static get prerender(): boolean {
@@ -278,7 +12,7 @@ export class Page extends HybridPage {
       return [];
     }
 
-    const allSchemas = await fetchAllSchemas();
+    const allSchemas = await getSchemaMetadata();
 
     return [
       {
@@ -291,7 +25,7 @@ export class Page extends HybridPage {
   }
 
   protected static async fetchData(_params: any) {
-    const allSchemas = await fetchAllSchemas();
+    const allSchemas = await getSchemaMetadata();
     return {
       schemas: allSchemas,
     };

package/eventcatalog/src/pages/schemas/explorer/content/[key].json.ts

@@ -0,0 +1,17 @@
+import type { APIRoute } from 'astro';
+import { isSSR } from '@utils/feature';
+import { getSchemaRegistry, getSchemaDetails } from '@utils/schema-explorer';
+
+export const prerender = !isSSR();
+
+export async function getStaticPaths() {
+  return [...(await getSchemaRegistry()).keys()].map((key) => ({ params: { key } }));
+}
+
+export const GET: APIRoute = async ({ params }) => {
+  const details = params.key ? await getSchemaDetails(params.key) : undefined;
+  if (!details) return new Response('Schema not found', { status: 404 });
+  return new Response(JSON.stringify(details), {
+    headers: { 'Content-Type': 'application/json' },
+  });
+};

package/eventcatalog/src/stores/sidebar-store/state.ts

@@ -42,6 +42,7 @@ import {
   withArchitectureDecisionsSection,
 } from './builders/shared';
 import { isArchitectureGraphEnabled, isChangelogEnabled, isResourceDocsEnabled } from '@utils/feature';
+import { collectMessageIdsWithFieldUsage } from '@utils/collections/field-usage';
 
 export type { NavigationData, NavNode, ChildRef };
 
@@ -580,34 +581,8 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
     {} as Record<string, NavNode | string>
   );
 
-  // Build a set of message IDs that have field usage declared by any resource that can receive messages.
-  // We use raw collections because the hydrated resources replace
-  // sends/receives pointers with resolved message entries, which strips the fields property.
-  const messagesWithFieldUsage = new Set<string>();
-  for (const agent of rawAgents) {
-    for (const pointer of agent.data.sends || []) {
-      if (pointer.fields?.length) messagesWithFieldUsage.add(pointer.id);
-    }
-    for (const pointer of agent.data.receives || []) {
-      if (pointer.fields?.length) messagesWithFieldUsage.add(pointer.id);
-    }
-  }
-  for (const service of rawServices) {
-    for (const pointer of service.data.sends || []) {
-      if (pointer.fields?.length) messagesWithFieldUsage.add(pointer.id);
-    }
-    for (const pointer of service.data.receives || []) {
-      if (pointer.fields?.length) messagesWithFieldUsage.add(pointer.id);
-    }
-  }
-  for (const domain of rawDomains) {
-    for (const pointer of domain.data.sends || []) {
-      if (pointer.fields?.length) messagesWithFieldUsage.add(pointer.id);
-    }
-    for (const pointer of domain.data.receives || []) {
-      if (pointer.fields?.length) messagesWithFieldUsage.add(pointer.id);
-    }
-  }
+  // Raw collections keep send/receive pointers (and their `fields`) which hydration strips.
+  const messagesWithFieldUsage = collectMessageIdsWithFieldUsage(rawAgents, rawServices, rawDomains);
 
   const flowRefsByMessage = buildFlowReferencesByMessage({
     flows,

package/eventcatalog/src/utils/collections/field-usage.ts

@@ -0,0 +1,48 @@
+import { getCollection } from 'astro:content';
+
+type PointerWithFields = { id?: string; fields?: string[] };
+
+type ResourceWithMessagePointers = {
+  data: {
+    sends?: PointerWithFields[];
+    receives?: PointerWithFields[];
+  };
+};
+
+const addFieldUsageFromPointers = (messageIds: Set<string>, pointers: PointerWithFields[] | undefined) => {
+  for (const pointer of pointers || []) {
+    if (pointer.id && pointer.fields?.length) {
+      messageIds.add(pointer.id);
+    }
+  }
+};
+
+/**
+ * Message ids that have field-level lineage declared on a send/receive pointer.
+ * Uses raw (unhydrated) resources because hydration replaces those pointers and drops `fields`.
+ * Matches the sidebar "Field Usage" link gate.
+ */
+export const collectMessageIdsWithFieldUsage = (
+  agents: ResourceWithMessagePointers[],
+  services: ResourceWithMessagePointers[],
+  domains: ResourceWithMessagePointers[]
+): Set<string> => {
+  const messageIds = new Set<string>();
+
+  for (const resource of [...agents, ...services, ...domains]) {
+    addFieldUsageFromPointers(messageIds, resource.data.sends);
+    addFieldUsageFromPointers(messageIds, resource.data.receives);
+  }
+
+  return messageIds;
+};
+
+export const getMessageIdsWithFieldUsage = async (): Promise<Set<string>> => {
+  const [agents, services, domains] = await Promise.all([
+    getCollection('agents'),
+    getCollection('services'),
+    getCollection('domains'),
+  ]);
+
+  return collectMessageIdsWithFieldUsage(agents, services, domains);
+};

package/eventcatalog/src/utils/node-graphs/channel-node-graph.ts

@@ -1,5 +1,4 @@
 import { getCollection, type CollectionEntry } from 'astro:content';
-import dagre from 'dagre';
 import {
   buildContextMenuForAgent,
   buildContextMenuForMessage,
@@ -17,6 +16,7 @@ import {
   getOperationFields,
   DEFAULT_NODE_WIDTH,
   DEFAULT_NODE_HEIGHT,
+  layoutDagreGraph,
 } from './utils/utils';
 import { createVersionedMap, findInMap } from '@utils/collections/util';
 import { getChannelChain, getChannels } from '@utils/collections/channels';
@@ -457,7 +457,7 @@ export const getNodesAndEdges = async ({ id, version, defaultFlow, mode = 'simpl
   });
 
   if (layout) {
-    dagre.layout(flow);
+    layoutDagreGraph(flow);
   }
 
   return {

package/eventcatalog/src/utils/node-graphs/compact-visualiser-graph.ts

@@ -0,0 +1,246 @@
+import type { Edge, Node } from '@xyflow/react';
+
+/**
+ * Fields the visualiser nodes actually read from a resource. Everything else
+ * (markdown bodies, file paths, hydrated producers/consumers, full send/receive
+ * collections) is dropped before Astro serialises the graph into the page.
+ */
+const RESOURCE_DATA_KEYS = [
+  'id',
+  'name',
+  'version',
+  'summary',
+  'owners',
+  'deprecated',
+  'draft',
+  'notes',
+  'styles',
+  'badges',
+  'latestVersion',
+  'method',
+  'path',
+  'statusCodes',
+  'specifications',
+  'externalSystem',
+  'repository',
+  'model',
+  'tools',
+  'parameters',
+  'protocols',
+  'address',
+  'deliveryGuarantee',
+  'type',
+  'container_type',
+  'schemas',
+  'properties',
+  'aggregateRoot',
+  'sidebar',
+] as const;
+
+const RESOURCE_OBJECT_KEYS = new Set([
+  'message',
+  'service',
+  'agent',
+  'domain',
+  'channel',
+  'dataProduct',
+  'container',
+  'entity',
+  'flow',
+  'data',
+]);
+
+const DROP_EDGE_RESOURCE_KEYS = new Set(['publisherService', 'consumerService']);
+
+const isPlainObject = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+const isCollectionEntry = (value: Record<string, unknown>): boolean =>
+  isPlainObject(value.data) &&
+  ('collection' in value || 'filePath' in value || 'digest' in value || 'body' in value || 'rendered' in value);
+
+const compactDomainService = (service: unknown) => {
+  if (!isPlainObject(service)) return service;
+
+  const data = isPlainObject(service.data) ? service.data : service;
+  const id = data.id ?? service.id;
+  const name = data.name ?? service.name;
+  const version = data.version ?? service.version;
+
+  return {
+    data: {
+      ...(id !== undefined ? { id } : {}),
+      ...(name !== undefined ? { name } : {}),
+      ...(version !== undefined ? { version } : {}),
+    },
+  };
+};
+
+const compactOwners = (owners: unknown): unknown => {
+  if (!Array.isArray(owners)) return owners;
+  return owners.map((owner) => {
+    if (typeof owner === 'string') return owner;
+    if (!isPlainObject(owner)) return owner;
+    const data = isPlainObject(owner.data) ? owner.data : owner;
+    const id = data.id ?? owner.id;
+    const name = data.name ?? owner.name;
+    if (id === undefined && name === undefined) return owner;
+    return {
+      ...(id !== undefined ? { id } : {}),
+      ...(name !== undefined ? { name } : {}),
+    };
+  });
+};
+
+export const compactVisualiserResource = (value: unknown): unknown => {
+  if (value == null || typeof value !== 'object') return value;
+  if (Array.isArray(value)) return value.map(compactVisualiserResource);
+
+  const obj = value as Record<string, unknown>;
+
+  if (isCollectionEntry(obj)) {
+    const data = compactVisualiserResourceData(obj.data);
+    const resourceId = isPlainObject(data) && data.id !== undefined ? data.id : obj.id;
+    return {
+      ...(resourceId !== undefined ? { id: resourceId } : {}),
+      ...(obj.collection !== undefined ? { collection: obj.collection } : {}),
+      data,
+      // EventNode / ServiceNode / ChannelNode read name/version/summary from the
+      // top level. Collection-entry shaped payloads only have those on `.data`.
+      ...(isPlainObject(data) ? data : {}),
+    };
+  }
+
+  return compactVisualiserResourceData(obj);
+};
+
+const compactVisualiserResourceData = (value: unknown): unknown => {
+  if (!isPlainObject(value)) return value;
+
+  const out: Record<string, unknown> = {};
+  for (const key of RESOURCE_DATA_KEYS) {
+    if (value[key] === undefined) continue;
+    if (key === 'owners') {
+      out[key] = compactOwners(value[key]);
+      continue;
+    }
+    if (key === 'tools' && Array.isArray(value[key])) {
+      out[key] = value[key];
+      continue;
+    }
+    out[key] = value[key];
+  }
+
+  // Domain nodes render `domain.data.services[].data.{id,name,version}`.
+  if (Array.isArray(value.services)) {
+    out.services = value.services.map(compactDomainService);
+  }
+
+  return out;
+};
+
+const compactEndpoint = (endpoint: unknown): unknown => {
+  if (!isPlainObject(endpoint)) return endpoint;
+
+  const data = isPlainObject(endpoint.data) ? endpoint.data : undefined;
+  const collection = endpoint.collection ?? data?.collection;
+  const id = endpoint.id ?? (data?.id !== undefined && data?.version !== undefined ? `${data.id}-${data.version}` : data?.id);
+
+  return {
+    ...(id !== undefined ? { id } : {}),
+    ...(collection !== undefined ? { collection } : {}),
+    ...(data
+      ? {
+          data: {
+            ...(data.id !== undefined ? { id: data.id } : {}),
+            ...(data.version !== undefined ? { version: data.version } : {}),
+            ...(collection !== undefined ? { collection } : {}),
+          },
+        }
+      : {}),
+  };
+};
+
+const compactNodeData = (data: unknown): unknown => {
+  if (!isPlainObject(data)) return data;
+
+  const out: Record<string, unknown> = {};
+
+  for (const [key, value] of Object.entries(data)) {
+    if (value === undefined) continue;
+
+    if (RESOURCE_OBJECT_KEYS.has(key)) {
+      out[key] = compactVisualiserResource(value);
+      continue;
+    }
+
+    if (key === 'messages' && Array.isArray(value)) {
+      out[key] = value.map((entry) => {
+        if (!isPlainObject(entry)) return entry;
+        return {
+          ...entry,
+          ...(entry.message !== undefined ? { message: compactVisualiserResource(entry.message) } : {}),
+          ...(Array.isArray(entry.channels) ? { channels: entry.channels.map(compactVisualiserResource) } : {}),
+        };
+      });
+      continue;
+    }
+
+    out[key] = value;
+  }
+
+  return out;
+};
+
+const compactEdgeData = (data: unknown): unknown => {
+  if (!isPlainObject(data)) return data;
+
+  const out: Record<string, unknown> = {};
+
+  for (const [key, value] of Object.entries(data)) {
+    if (value === undefined || DROP_EDGE_RESOURCE_KEYS.has(key)) continue;
+
+    if (key === 'rootSourceAndTarget' && isPlainObject(value)) {
+      out[key] = {
+        source: compactEndpoint(value.source),
+        target: compactEndpoint(value.target),
+      };
+      continue;
+    }
+
+    if (RESOURCE_OBJECT_KEYS.has(key) || key === 'message') {
+      out[key] = compactVisualiserResource(value);
+      continue;
+    }
+
+    out[key] = value;
+  }
+
+  return out;
+};
+
+const compactNode = <T extends Node>(node: T): T => {
+  const { data, ...rest } = node;
+  return {
+    ...rest,
+    ...(data !== undefined ? { data: compactNodeData(data) } : {}),
+  } as T;
+};
+
+const compactEdge = <T extends Edge>(edge: T): T => {
+  const { data, ...rest } = edge;
+  return {
+    ...rest,
+    ...(data !== undefined ? { data: compactEdgeData(data) } : {}),
+  } as T;
+};
+
+/**
+ * Strip collection-entry weight from a React Flow graph before it is serialised
+ * into an Astro island. Node/edge structure and the fields visualiser components
+ * read are preserved.
+ */
+export const compactVisualiserGraph = <N extends Node, E extends Edge>(nodes: N[], edges: E[]): { nodes: N[]; edges: E[] } => ({
+  nodes: nodes.map(compactNode),
+  edges: edges.map(compactEdge),
+});

package/eventcatalog/src/utils/node-graphs/container-node-graph.ts

@@ -1,5 +1,4 @@
 import type { CollectionEntry } from 'astro:content';
-import dagre from 'dagre';
 import {
   calculatedNodes,
   createDagreGraph,
@@ -10,6 +9,7 @@ import {
   buildContextMenuForResource,
   DEFAULT_NODE_WIDTH,
   DEFAULT_NODE_HEIGHT,
+  layoutDagreGraph,
 } from './utils/utils';
 import { MarkerType } from '@xyflow/react';
 import { findMatchingNodes } from '@utils/collections/util';
@@ -299,7 +299,7 @@ export const getNodesAndEdges = async ({
 
   // Render the diagram in memory getting hte X and Y
   if (layout) {
-    dagre.layout(flow);
+    layoutDagreGraph(flow);
   }
 
   return {