@eventcatalog/core 4.10.9 → 4.10.11

package/eventcatalog/src/utils/collections/hydrate-services.ts

@@ -0,0 +1,51 @@
+import { findInMap } from '@utils/collections/util';
+
+/**
+ * Resolve service/agent pointers to collection entries and hydrate their
+ * sends/receives/readsFrom/writesTo relationships.
+ */
+export 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) => {
+      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,
+        },
+      };
+    });
+};
+
+export const hydrateAgents = (
+  agentsList: any[],
+  agentMap: Map<string, any[]>,
+  messageMap: Map<string, any[]>,
+  containerMap: Map<string, any[]>
+) => hydrateServices(agentsList, agentMap, messageMap, containerMap);

package/eventcatalog/src/utils/collections/systems.ts

@@ -1,5 +1,6 @@
 import { getCollection } from 'astro:content';
 import type { CollectionEntry } from 'astro:content';
+import { hydrateServices } from '@utils/collections/hydrate-services';
 import { createVersionedMap, findInMap } from './util';
 
 const CACHE_ENABLED = process.env.DISABLE_EVENTCATALOG_CACHE !== 'true';
@@ -7,24 +8,28 @@ export type System = CollectionEntry<'systems'>;
 
 interface Props {
   getAllVersions?: boolean;
+  enrichServices?: boolean;
 }
 
 // cache for build time
 let memoryCache: Record<string, System[]> = {};
 
-export const getSystems = async ({ getAllVersions = true }: Props = {}): Promise<System[]> => {
-  const cacheKey = getAllVersions ? 'allVersions' : 'currentVersions';
+export const getSystems = async ({ getAllVersions = true, enrichServices = false }: Props = {}): Promise<System[]> => {
+  const cacheKey = `${getAllVersions ? 'allVersions' : 'currentVersions'}-${enrichServices ? 'enriched' : 'simple'}`;
 
   if (memoryCache[cacheKey] && memoryCache[cacheKey].length > 0 && CACHE_ENABLED) {
     return memoryCache[cacheKey];
   }
 
-  const [allSystems, allServices, allFlows, allEntities, allContainers] = await Promise.all([
+  const [allSystems, allServices, allFlows, allEntities, allContainers, allEvents, allCommands, allQueries] = await Promise.all([
     getCollection('systems'),
     getCollection('services'),
     getCollection('flows'),
     getCollection('entities'),
     getCollection('containers'),
+    enrichServices ? getCollection('events') : Promise.resolve([]),
+    enrichServices ? getCollection('commands') : Promise.resolve([]),
+    enrichServices ? getCollection('queries') : Promise.resolve([]),
   ]);
 
   // Build optimized map of id -> versions (sorted latest first)
@@ -33,6 +38,7 @@ export const getSystems = async ({ getAllVersions = true }: Props = {}): Promise
   const flowMap = createVersionedMap(allFlows);
   const entityMap = createVersionedMap(allEntities);
   const containerMap = createVersionedMap(allContainers);
+  const messageMap = createVersionedMap([...allEvents, ...allCommands, ...allQueries]);
 
   // Filter systems
   const targetSystems = allSystems.filter((system) => {
@@ -47,10 +53,14 @@ export const getSystems = async ({ getAllVersions = true }: Props = {}): Promise
     const latestVersion = systemVersions[0]?.data.version || system.data.version;
     const versions = systemVersions.map((s) => s.data.version);
 
-    // Resolve service pointers to their full collection entries
-    const services = (system.data.services || [])
-      .map((service: { id: string; version?: string }) => findInMap(serviceMap, service.id, service.version))
-      .filter((s): s is NonNullable<typeof s> => !!s);
+    // Resolve service pointers to their full collection entries.
+    // Architecture grids need sends/receives hydrated so command/query links
+    // keep the correct collection instead of falling back to events.
+    const services = enrichServices
+      ? hydrateServices(system.data.services || [], serviceMap, messageMap, containerMap)
+      : (system.data.services || [])
+          .map((service: { id: string; version?: string }) => findInMap(serviceMap, service.id, service.version))
+          .filter((s): s is NonNullable<typeof s> => !!s);
 
     // Resolve flow pointers to their full collection entries
     const flows = (system.data.flows || [])

package/eventcatalog/src/utils/schema-explorer.ts

@@ -0,0 +1,276 @@
+import { createHash } from 'node:crypto';
+import type { SchemaItem, SchemaDetails, Producer, Consumer } from '@components/SchemaExplorer/types';
+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 buildRegistry() {
+  // Fetch all messages
+  const events = await getEvents({ getAllVersions: true, hydrateServices: false });
+  const commands = await getCommands({ getAllVersions: true, hydrateServices: false });
+  const queries = await getQueries({ getAllVersions: true, hydrateServices: false });
+  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;
+      // The collection types describe raw content references. With
+      // hydrateServices: false, the loaders return compact { id, version } pairs.
+      const producers = (message?.data.producers || []) as unknown as Producer[];
+      const consumers = (message?.data.consumers || []) as unknown as Consumer[];
+
+      return {
+        collection: schema.data.message.collectionName,
+        data: {
+          id: schema.data.message.id,
+          name: schema.data.message.name || message?.data.name || schema.data.name || schema.data.message.id,
+          version: schema.data.message.version,
+          summary: schema.data.message.summary || message?.data.summary,
+          schemaPath,
+          owners: await enrichOwners(schema.data.message.owners || []),
+          // The list shows only the first producer's label; keep this bounded
+          // regardless of how many resources reference the message.
+          producerName: producers[0]?.id,
+        },
+        loadDetails: () => {
+          let examples: SchemaDetails['examples'] = [];
+          if (message) {
+            try {
+              examples = getExamplesForResource(message);
+            } catch (error) {
+              console.error(`Error reading examples for ${message.data.id}:`, error);
+            }
+          }
+          return {
+            schemaContent: schema.data.content || '',
+            examples,
+            data: { producers, consumers },
+          };
+        },
+        schemaExtension,
+      };
+    })
+  );
+
+  // 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 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,
+              },
+              loadDetails: () => ({ schemaContent: readResourceFile(service, spec.path) ?? '', examples: [] }),
+              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 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,
+              },
+              loadDetails: () => ({ schemaContent: readResourceFile(domain, spec.path) ?? '', examples: [] }),
+              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 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,
+              },
+              loadDetails: () => ({ schemaContent: readResourceFile(dataProduct, contract.path) ?? '', examples: [] }),
+              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 new Map(
+    [...messagesWithSchemas, ...flatServicesWithSpecs, ...flatDomainsWithSpecs, ...flatDataProductContracts].map((entry) => {
+      const { loadDetails, ...item } = entry;
+      const key = createHash('sha256')
+        .update(
+          JSON.stringify([
+            item.collection,
+            item.data.id,
+            item.data.version,
+            item.data.schemaPath,
+            'specType' in item ? item.specType : '',
+          ])
+        )
+        .digest('hex');
+      return [
+        key,
+        { item: { ...item, contentUrl: buildUrl(`/schemas/explorer/content/${key}.json`, true) } as SchemaItem, loadDetails },
+      ];
+    })
+  );
+}
+
+// Share metadata during production rendering; dev rebuilds it to reflect content edits.
+let registry: ReturnType<typeof buildRegistry> | undefined;
+export const getSchemaRegistry = () => {
+  if (import.meta.env.DEV || process.env.DISABLE_EVENTCATALOG_CACHE === 'true') return buildRegistry();
+  return (registry ??= buildRegistry().catch((error) => {
+    registry = undefined;
+    throw error;
+  }));
+};
+export const getSchemaMetadata = async (): Promise<SchemaItem[]> =>
+  [...(await getSchemaRegistry()).values()].map(({ item }) => item);
+export const getSchemaDetails = async (key: string): Promise<SchemaDetails | undefined> =>
+  (await getSchemaRegistry()).get(key)?.loadDetails();

package/package.json

@@ -7,7 +7,7 @@
   },
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",
-  "version": "4.10.9",
+  "version": "4.10.11",
   "publishConfig": {
     "access": "public"
   },
@@ -119,8 +119,8 @@
     "uuid": "^11.1.1",
     "zod": "^4.3.6",
     "@eventcatalog/linter": "1.1.18",
-    "@eventcatalog/visualiser": "^4.1.4",
-    "@eventcatalog/sdk": "2.29.0"
+    "@eventcatalog/sdk": "2.29.0",
+    "@eventcatalog/visualiser": "^4.1.4"
   },
   "devDependencies": {
     "@astrojs/check": "^0.9.10",

package/dist/{chunk-A2RZR3U4.js → chunk-6K7XZAYI.js}

@@ -1,9 +1,9 @@
-import {
-  createFileSystemSourceProvider
-} from "./chunk-SDZQJTJW.js";
 import {
   createGitHubSourceProvider
 } from "./chunk-352FGP6W.js";
+import {
+  createFileSystemSourceProvider
+} from "./chunk-SDZQJTJW.js";
 
 // src/federation/source-provider.ts
 var createFederationSourceProvider = (projectDirectory, providers = {}) => {