@eventcatalog/core 4.10.9 → 4.10.11

package/eventcatalog/src/components/SchemaExplorer/types.ts

@@ -20,7 +20,7 @@ export interface Owner {
 }
 
 export interface SchemaItem {
-  collection: CollectionMessageTypes | 'services' | 'data-products';
+  collection: CollectionMessageTypes | 'services' | 'domains' | 'data-products';
   data: {
     id: string;
     name: string;
@@ -29,9 +29,12 @@ export interface SchemaItem {
     schemaPath?: string;
     producers?: Producer[];
     consumers?: Consumer[];
+    producerName?: string;
     owners?: Owner[];
   };
   schemaContent?: string;
+  /** Internal URL for loading this version's content without embedding it in the page. */
+  contentUrl?: string;
   schemaExtension?: string;
   specType?: string;
   specName?: string;
@@ -44,6 +47,12 @@ export interface SchemaItem {
   examples?: MessageExample[];
 }
 
+export interface SchemaDetails {
+  schemaContent: string;
+  examples: MessageExample[];
+  data?: Pick<SchemaItem['data'], 'producers' | 'consumers'>;
+}
+
 export interface VersionDiff {
   fromVersion: string;
   toVersion: string;

package/eventcatalog/src/components/SchemaExplorer/useSchemaDetails.ts

@@ -0,0 +1,69 @@
+import { useEffect, useMemo, useState } from 'react';
+import type { SchemaDetails, SchemaItem } from './types';
+
+// Scoped to the explorer component's lifetime by the caller. Also deduplicates
+// requests when the selected version is one of the comparison versions.
+export const createSchemaDetailsLoader = () => {
+  const requests = new Map<string, Promise<SchemaDetails>>();
+  const resolved = new Map<string, SchemaDetails>();
+  const load = (url: string): Promise<SchemaDetails> => {
+    const existing = requests.get(url);
+    if (existing) return existing;
+    const request = fetch(url)
+      .then(async (response) => {
+        if (!response.ok) throw new Error('Unable to load schema content. Please try again.');
+        const details = await response.json();
+        if (typeof details.schemaContent !== 'string' || !Array.isArray(details.examples)) {
+          throw new Error('Unable to load schema content. Please try again.');
+        }
+        resolved.set(url, details);
+        return details as SchemaDetails;
+      })
+      .catch((error) => {
+        requests.delete(url);
+        throw error;
+      });
+    requests.set(url, request);
+    return request;
+  };
+  return Object.assign(load, { peek: (url: string) => resolved.get(url) });
+};
+
+export function useSchemaDetails(
+  item: SchemaItem | undefined,
+  load: ReturnType<typeof createSchemaDetailsLoader>,
+  enabled = true
+) {
+  const url = enabled ? item?.contentUrl : undefined;
+  const [attempt, setAttempt] = useState(0);
+  const [state, setState] = useState<{ url: string; details?: SchemaDetails; error?: string }>();
+
+  useEffect(() => {
+    if (!url || load.peek(url)) return;
+    let current = true;
+    setState(undefined);
+    load(url).then(
+      (details) => current && setState({ url, details }),
+      () => current && setState({ url, error: 'Unable to load schema content. Please try again.' })
+    );
+    return () => {
+      current = false;
+    };
+  }, [url, load, attempt]);
+
+  const matchingState = state?.url === url ? state : undefined;
+  const details = url ? matchingState?.details || load.peek(url) : undefined;
+  const message = useMemo(
+    () => (item && details ? { ...item, ...details, data: { ...item.data, ...details.data } } : item),
+    [item, details]
+  );
+  return {
+    message,
+    loading: !!url && !details && !matchingState?.error,
+    error: details ? undefined : matchingState?.error,
+    retry: () => {
+      setState(undefined);
+      setAttempt((value) => value + 1);
+    },
+  };
+}

package/eventcatalog/src/components/SchemaExplorer/utils.ts

@@ -41,6 +41,18 @@ export function extractServiceName(refId: string): string {
   return match ? match[1] : refId;
 }
 
+/** Resolve both enriched collection entries and compact explorer references. */
+export function getSchemaRelationshipReference(reference: {
+  id: string;
+  version?: string;
+  data?: { id: string; version: string };
+}) {
+  return {
+    id: reference.data?.id ?? reference.id,
+    version: reference.data?.version ?? reference.version,
+  };
+}
+
 export const getLanguageForHighlight = (extension?: string): string => {
   if (!extension) return 'json';
   const ext = extension.toLowerCase();

package/eventcatalog/src/pages/architecture/[type]/[id]/[version]/_index.data.spec.ts

@@ -0,0 +1,88 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { loadArchitectureItems, Page } from './_index.data';
+
+const collectionMocks = vi.hoisted(() => ({
+  getDomains: vi.fn(),
+  getServices: vi.fn(),
+  getSystems: vi.fn(),
+}));
+
+vi.mock('@utils/feature', () => ({
+  isSSR: () => false,
+}));
+
+vi.mock('@utils/collections/domains', () => ({ getDomains: collectionMocks.getDomains }));
+vi.mock('@utils/collections/systems', () => ({ getSystems: collectionMocks.getSystems }));
+vi.mock('@utils/page-loaders/page-data-loader', () => ({
+  pageDataLoader: {
+    services: (...args: unknown[]) => collectionMocks.getServices(...args),
+    domains: (...args: unknown[]) => collectionMocks.getDomains(...args),
+    systems: (...args: unknown[]) => collectionMocks.getSystems(...args),
+  },
+}));
+
+const domain = {
+  collection: 'domains',
+  data: { id: 'ordering', name: 'Ordering', version: '1.0.0' },
+};
+
+const service = {
+  collection: 'services',
+  data: { id: 'order-service', name: 'Order Service', version: '1.0.0' },
+};
+
+const system = {
+  collection: 'systems',
+  data: { id: 'order-management-system', name: 'Order Management', version: '1.0.0' },
+};
+
+describe('architecture page data', () => {
+  beforeEach(() => {
+    collectionMocks.getDomains.mockReset().mockResolvedValue([domain]);
+    collectionMocks.getServices.mockReset().mockResolvedValue([service]);
+    collectionMocks.getSystems.mockReset().mockResolvedValue([system]);
+  });
+
+  it('hydrates domain and system services for static architecture paths', async () => {
+    const paths = await Page.getStaticPaths();
+
+    expect(collectionMocks.getDomains).toHaveBeenCalledWith({ enrichServices: true });
+    expect(collectionMocks.getSystems).toHaveBeenCalledWith({ enrichServices: true });
+    expect(paths).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          params: { type: 'domains', id: 'ordering', version: '1.0.0' },
+        }),
+        expect.objectContaining({
+          params: { type: 'systems', id: 'order-management-system', version: '1.0.0' },
+        }),
+        expect.objectContaining({
+          params: { type: 'services', id: 'order-service', version: '1.0.0' },
+        }),
+      ])
+    );
+  });
+
+  it('hydrates domain services when architecture pages are fetched in SSR', async () => {
+    await Page.getData({
+      props: {},
+      params: { type: 'domains', id: 'ordering', version: '1.0.0' },
+    } as any);
+
+    expect(collectionMocks.getDomains).toHaveBeenCalledWith({ enrichServices: true });
+  });
+
+  it('hydrates system services when architecture pages are fetched in SSR', async () => {
+    await Page.getData({
+      props: {},
+      params: { type: 'systems', id: 'order-management-system', version: '1.0.0' },
+    } as any);
+
+    expect(collectionMocks.getSystems).toHaveBeenCalledWith({ enrichServices: true });
+  });
+
+  it('loads domains with enrichServices so DomainGrid command links keep their collection', async () => {
+    await loadArchitectureItems('domains');
+    expect(collectionMocks.getDomains).toHaveBeenCalledWith({ enrichServices: true });
+  });
+});

package/eventcatalog/src/pages/architecture/[type]/[id]/[version]/_index.data.ts

@@ -3,11 +3,27 @@ import { HybridPage } from '@utils/page-loaders/hybrid-page';
 import type { PageTypes } from '@types';
 import { pageDataLoader } from '@utils/page-loaders/page-data-loader';
 import { getDomains } from '@utils/collections/domains';
-import { getServices } from '@utils/collections/services';
 import { getSystems } from '@utils/collections/systems';
 
 const architecturePageTypes: PageTypes[] = ['services', 'domains', 'systems'];
 
+/**
+ * Architecture grids render service sends/receives as docs links, so domains and
+ * systems must hydrate those messages (collection + name). `pageDataLoader`
+ * uses the cheaper unenriched path used by docs/sidebar.
+ */
+export const loadArchitectureItems = (type: PageTypes) => {
+  if (type === 'domains') {
+    return getDomains({ enrichServices: true });
+  }
+
+  if (type === 'systems') {
+    return getSystems({ enrichServices: true });
+  }
+
+  return pageDataLoader[type as PageTypes]();
+};
+
 /**
  * Documentation page class for all collection types with versioning
  */
@@ -17,11 +33,7 @@ export class Page extends HybridPage {
       return [];
     }
 
-    const domains = await getDomains({ enrichServices: true });
-    const services = await getServices();
-    const systems = await getSystems();
-
-    const pageData = [services, domains, systems];
+    const pageData = await Promise.all(architecturePageTypes.map((type) => loadArchitectureItems(type)));
 
     return pageData.flatMap((items, index) =>
       items.map((item) => ({
@@ -47,8 +59,7 @@ export class Page extends HybridPage {
       return null;
     }
 
-    // Get all items of the specified type
-    const items = await pageDataLoader[type as PageTypes]();
+    const items = await loadArchitectureItems(type as PageTypes);
 
     // Find the specific item by id and version
     const item = items.find((i) => i.data.id === id && i.data.version === version);

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/utils/collections/domains.ts

@@ -4,6 +4,7 @@ import path from 'path';
 import type { CollectionMessageTypes } from '@types';
 import type { Agent, Service } from './types';
 import { createVersionedMap, findInMap, processSpecifications } from '@utils/collections/util';
+import { hydrateAgents, hydrateServices } from '@utils/collections/hydrate-services';
 
 const CACHE_ENABLED = process.env.DISABLE_EVENTCATALOG_CACHE !== 'true';
 
@@ -19,86 +20,6 @@ interface Props {
 // Simple in-memory cache variable
 let memoryCache: Record<string, Domain[]> = {};
 
-// Helper to hydrate services
-const hydrateServices = (
-  servicesList: any[],
-  serviceMap: Map<string, any[]>,
-  messageMap: Map<string, any[]>,
-  containerMap: Map<string, any[]>
-) => {
-  return servicesList
-    .map((service: { id: string; version: string | undefined }) => findInMap(serviceMap, service.id, service.version))
-    .filter((s) => !!s)
-    .map((service) => {
-      // Hydrate service messages and containers
-      const sends = (service.data.sends || [])
-        .map((msg: any) => findInMap(messageMap, msg.id, msg.version))
-        .filter((m: any) => !!m);
-
-      const receives = (service.data.receives || [])
-        .map((msg: any) => findInMap(messageMap, msg.id, msg.version))
-        .filter((m: any) => !!m);
-
-      const readsFrom = (service.data.readsFrom || [])
-        .map((c: any) => findInMap(containerMap, c.id, c.version))
-        .filter((c: any) => !!c);
-
-      const writesTo = (service.data.writesTo || [])
-        .map((c: any) => findInMap(containerMap, c.id, c.version))
-        .filter((c: any) => !!c);
-
-      return {
-        ...service,
-        data: {
-          ...service.data,
-          sends: sends as any,
-          receives: receives as any,
-          readsFrom: readsFrom as any,
-          writesTo: writesTo as any,
-        },
-      };
-    });
-};
-
-const hydrateAgents = (
-  agentsList: any[],
-  agentMap: Map<string, any[]>,
-  messageMap: Map<string, any[]>,
-  containerMap: Map<string, any[]>
-) => {
-  return agentsList
-    .map((agent: { id: string; version: string | undefined }) => findInMap(agentMap, agent.id, agent.version))
-    .filter((a) => !!a)
-    .map((agent) => {
-      const sends = (agent.data.sends || [])
-        .map((msg: any) => findInMap(messageMap, msg.id, msg.version))
-        .filter((m: any) => !!m);
-
-      const receives = (agent.data.receives || [])
-        .map((msg: any) => findInMap(messageMap, msg.id, msg.version))
-        .filter((m: any) => !!m);
-
-      const readsFrom = (agent.data.readsFrom || [])
-        .map((c: any) => findInMap(containerMap, c.id, c.version))
-        .filter((c: any) => !!c);
-
-      const writesTo = (agent.data.writesTo || [])
-        .map((c: any) => findInMap(containerMap, c.id, c.version))
-        .filter((c: any) => !!c);
-
-      return {
-        ...agent,
-        data: {
-          ...agent.data,
-          sends: sends as any,
-          receives: receives as any,
-          readsFrom: readsFrom as any,
-          writesTo: writesTo as any,
-        },
-      };
-    });
-};
-
 // --- MAIN FUNCTION ---
 
 export const getDomains = async ({