@eventcatalog/core 3.44.2 → 3.46.0

package/eventcatalog/src/content.config.ts

@@ -9,6 +9,7 @@ import fs from 'fs';
 import path from 'path';
 import { userTeamDirectoryLoader } from './enterprise/directory/user-team-directory';
 import config from '@config';
+import { schemaLoader } from './utils/collections/schema-loader';
 
 // Enterprise Collections
 import { customPagesSchema, resourceDocsSchema, resourceDocCategoriesSchema } from './enterprise/collections';
@@ -68,6 +69,17 @@ const channelPointer = z
   })
   .extend(pointer.shape);
 
+const schemaPointer = z.object({
+  id: z.string().optional(),
+  ref: z.string().optional(),
+  file: z.string().optional(),
+  path: z.string().optional(),
+  name: z.string().optional(),
+  format: z.string().optional(),
+  environments: z.array(z.string()).optional(),
+  default: z.boolean().optional(),
+});
+
 const sendsPointer = z.object({
   id: z.string(),
   version: z.string().optional().default('latest'),
@@ -375,6 +387,7 @@ const events = defineCollection({
       producers: z.array(reference('services')).optional(),
       consumers: z.array(reference('services')).optional(),
       channels: z.array(channelPointer).optional(),
+      schemas: z.array(schemaPointer).optional(),
       messageChannels: z.array(reference('channels')).optional(),
       detailsPanel: messageDetailsPanelPropertySchema.optional(),
     })
@@ -397,6 +410,7 @@ const commands = defineCollection({
       producers: z.array(reference('services')).optional(),
       consumers: z.array(reference('services')).optional(),
       channels: z.array(channelPointer).optional(),
+      schemas: z.array(schemaPointer).optional(),
       detailsPanel: messageDetailsPanelPropertySchema.optional(),
       messageChannels: z.array(reference('channels')).optional(),
     })
@@ -419,6 +433,7 @@ const queries = defineCollection({
       producers: z.array(reference('services')).optional(),
       consumers: z.array(reference('services')).optional(),
       channels: z.array(channelPointer).optional(),
+      schemas: z.array(schemaPointer).optional(),
       detailsPanel: messageDetailsPanelPropertySchema.optional(),
       messageChannels: z.array(reference('channels')).optional(),
     })
@@ -991,6 +1006,53 @@ const diagrams = defineCollection({
     .extend(baseSchema.shape),
 });
 
+const schemas = defineCollection({
+  loader: schemaLoader({
+    messages: {
+      pattern: withIgnoredBuildArtifacts([
+        '**/events/*/index.{md,mdx}',
+        '**/events/*/versioned/*/index.{md,mdx}',
+        '**/commands/*/index.{md,mdx}',
+        '**/commands/*/versioned/*/index.{md,mdx}',
+        '**/queries/*/index.{md,mdx}',
+        '**/queries/*/versioned/*/index.{md,mdx}',
+      ]) as string[],
+      base: projectDirBase,
+    },
+    sources: config.schemas?.sources ?? [],
+  }),
+  schema: z
+    .object({
+      format: z.string(),
+      schemaId: z.string().optional(),
+      ref: z.string().optional(),
+      content: z.string().optional(),
+      file: z.string().optional(),
+      filePath: z.string().optional(),
+      environments: z.array(z.string()).optional(),
+      default: z.boolean().optional(),
+      latest: z.boolean().optional(),
+      message: z.object({
+        collection: z.enum(['events', 'commands', 'queries']),
+        id: z.string(),
+        name: z.string().optional(),
+        version: z.string(),
+        summary: z.string().optional(),
+        owners: z.array(z.string()).optional(),
+      }),
+      source: z.object({
+        provider: z.string(),
+        id: z.string().optional(),
+        path: z.string().optional(),
+        url: z.string().optional(),
+        ref: z.string().optional(),
+        branch: z.string().optional(),
+      }),
+      readOnly: z.boolean().optional(),
+    })
+    .extend(baseSchema.shape),
+});
+
 export const collections = {
   events,
   commands,
@@ -1024,4 +1086,7 @@ export const collections = {
 
   // Diagrams Collection
   diagrams,
+
+  // Generated from message schema references
+  schemas,
 };

package/eventcatalog/src/enterprise/api/schemas/[collection]/[id]/[version]/index.ts

@@ -5,62 +5,55 @@
 
 import type { APIRoute } from 'astro';
 import { getCollection } from 'astro:content';
-import path from 'node:path';
-import fs from 'node:fs';
-import utils from '@eventcatalog/sdk';
 import { isEventCatalogScaleEnabled } from '@utils/feature';
 import { sortVersioned } from '@utils/collections/util';
 
-export async function getStaticPaths() {
-  const events = await getCollection('events');
-  const commands = await getCollection('commands');
-  const queries = await getCollection('queries');
-  const messages = [...events, ...commands, ...queries];
+const findSchema = async (collection: string | undefined, id: string, version: string | undefined) => {
+  const schemas = await getCollection('schemas');
+  const matchingSchemas = schemas.filter(
+    (schema) => schema.data.message.collection === collection && schema.data.message.id === id
+  );
+
+  if (version === 'latest') {
+    return (
+      matchingSchemas.find((schema) => schema.data.latest) ??
+      sortVersioned(matchingSchemas, (schema) => schema.data.message.version)[0]
+    );
+  }
+
+  return matchingSchemas.find((schema) => schema.data.message.version === version);
+};
 
-  const messagesWithSchemas = messages
-    .filter((message) => message.data.schemaPath)
-    .filter((message) => fs.existsSync(path.join(path.dirname(message.filePath ?? ''), message.data.schemaPath ?? '')));
+export async function getStaticPaths() {
+  const schemas = await getCollection('schemas');
 
   // Generate paths for specific versions
-  const versionedPaths = messagesWithSchemas.map((message) => ({
-    params: { collection: message.collection, id: message.data.id, version: message.data.version },
+  const versionedPaths = schemas.map((schema) => ({
+    params: {
+      collection: schema.data.message.collection,
+      id: schema.data.message.id,
+      version: schema.data.message.version,
+    },
     props: {
-      pathToSchema: path.join(path.dirname(message.filePath ?? ''), message.data.schemaPath ?? ''),
-      schema: fs.readFileSync(path.join(path.dirname(message.filePath ?? ''), message.data.schemaPath ?? ''), 'utf8'),
-      extension: message.data.schemaPath?.split('.').pop(),
+      pathToSchema: schema.data.filePath,
+      schema: schema.data.content,
     },
   }));
 
-  // Group messages by collection and id to find latest versions
-  const groupedMessages = messagesWithSchemas.reduce(
-    (acc, message) => {
-      const key = `${message.collection}:${message.data.id}`;
-      if (!acc[key]) {
-        acc[key] = [];
-      }
-      acc[key].push(message);
-      return acc;
-    },
-    {} as Record<string, typeof messagesWithSchemas>
-  );
-
   // Generate "latest" paths for each unique collection/id combination
-  const latestPaths = Object.values(groupedMessages).map((group) => {
-    // Sort by version (descending) and get the latest
-    const sorted = sortVersioned(group, (m) => m.data.version);
-    const latestMessage = sorted[0];
-    return {
-      params: { collection: latestMessage.collection, id: latestMessage.data.id, version: 'latest' },
+  const latestPaths = schemas
+    .filter((schema) => schema.data.latest)
+    .map((latestSchema) => ({
+      params: {
+        collection: latestSchema.data.message.collection,
+        id: latestSchema.data.message.id,
+        version: 'latest',
+      },
       props: {
-        pathToSchema: path.join(path.dirname(latestMessage.filePath ?? ''), latestMessage.data.schemaPath ?? ''),
-        schema: fs.readFileSync(
-          path.join(path.dirname(latestMessage.filePath ?? ''), latestMessage.data.schemaPath ?? ''),
-          'utf8'
-        ),
-        extension: latestMessage.data.schemaPath?.split('.').pop(),
+        pathToSchema: latestSchema.data.filePath,
+        schema: latestSchema.data.content,
       },
-    };
-  });
+    }));
 
   return [...versionedPaths, ...latestPaths];
 }
@@ -83,14 +76,14 @@ export const GET: APIRoute = async ({ props, params }) => {
   }
 
   // In static mode, props are pre-computed by getStaticPaths
-  if (props.schema) {
+  if (props.schema !== undefined) {
     return new Response(props.schema, {
       headers: { 'Content-Type': 'text/plain' },
     });
   }
 
-  // In SSR mode, dynamically resolve the schema using the SDK
-  const { id, version } = params;
+  // In SSR mode, dynamically resolve the schema using the generated schema collection
+  const { collection, id, version } = params;
 
   if (!id) {
     return new Response(JSON.stringify({ error: 'Missing id parameter' }), {
@@ -99,17 +92,16 @@ export const GET: APIRoute = async ({ props, params }) => {
     });
   }
 
-  const { getSchemaForMessage } = utils(process.env.PROJECT_DIR || '');
-  const result = await getSchemaForMessage(id, version === 'latest' ? undefined : version);
+  const schema = await findSchema(collection, id, version);
 
-  if (!result) {
+  if (schema?.data.content === undefined) {
     return new Response(JSON.stringify({ error: 'Schema not found' }), {
       status: 404,
       headers: { 'Content-Type': 'application/json' },
     });
   }
 
-  return new Response(result.schema, {
+  return new Response(schema.data.content, {
     headers: { 'Content-Type': 'text/plain' },
   });
 };

package/eventcatalog/src/enterprise/tools/catalog-tools.ts

@@ -28,6 +28,8 @@ import { getNodesAndEdges as getNodesAndEdgesForContainer } from '@utils/node-gr
 import { convertToMermaid } from '@utils/node-graphs/export-mermaid';
 import config from '@config';
 
+const MESSAGE_COLLECTIONS = new Set(['events', 'commands', 'queries']);
+
 // ============================================
 // Pagination utilities
 // ============================================
@@ -226,6 +228,27 @@ export async function getSchemaForResource(params: { resourceId: string; resourc
     };
   }
 
+  if (MESSAGE_COLLECTIONS.has(params.resourceCollection)) {
+    const schemaEntries = await getCollection('schemas');
+    const schemas = schemaEntries.filter(
+      (schema) =>
+        schema.data.message.collection === params.resourceCollection &&
+        schema.data.message.id === params.resourceId &&
+        schema.data.message.version === params.resourceVersion
+    );
+
+    if (schemas.length > 0) {
+      return schemas.map((schema) => ({
+        id: schema.id,
+        name: schema.data.name,
+        ref: schema.data.ref,
+        format: schema.data.format,
+        source: schema.data.source,
+        code: schema.data.content || '',
+      }));
+    }
+  }
+
   const schema = await getSchemasFromResource(resource);
 
   if (schema.length > 0) {

package/eventcatalog/src/pages/docs/[type]/[id]/[version]/index.astro

@@ -565,7 +565,7 @@ if (!isAdrPage && !hasCurrentFlowEmbed && !hasCurrentPageNodeGraph) {
         <div data-pagefind-ignore>
           <!-- @ts-ignore -->
           <!-- <SchemaViewer id={props.data.id} catalog={props.catalog} filePath={props.filePath} /> -->
-          <SchemaViewer id={props.data.id} filePath={props.filePath} />
+          <SchemaViewer id={props.data.id} version={props.data.version} collection={props.collection} filePath={props.filePath} />
 
           {
             nodeGraphs.length > 0 &&

package/eventcatalog/src/pages/docs/llm/schemas.txt.ts

@@ -1,14 +1,13 @@
 import { getCollection } from 'astro:content';
 import config from '@config';
 import type { APIRoute } from 'astro';
-import type { CollectionEntry } from 'astro:content';
 import { getSpecificationsForService } from '@utils/collections/services';
 import { isEventCatalogScaleEnabled } from '@utils/feature';
 
-const events = await getCollection('events');
-const commands = await getCollection('commands');
-const queries = await getCollection('queries');
+type MessageCollection = 'events' | 'commands' | 'queries';
+
 const services = await getCollection('services');
+const schemas = await getCollection('schemas');
 
 type ServiceWithSchema = {
   collection: string;
@@ -33,8 +32,19 @@ const servicesWithSchemasFlat = servicesWithSchemas.reduce<ServiceWithSchema[]>(
   ];
 }, []) as ServiceWithSchema[];
 
-const messageHasSchema = (message: CollectionEntry<'events' | 'commands' | 'queries'>) => {
-  return message.data.schemaPath;
+const getMessagesWithSchemas = (collection: MessageCollection) => {
+  const seenMessages = new Set<string>();
+
+  return schemas
+    .filter((schema) => schema.data.message.collection === collection)
+    .map((schema) => {
+      const key = `${schema.data.message.collection}:${schema.data.message.id}:${schema.data.message.version}`;
+      if (seenMessages.has(key)) return null;
+      seenMessages.add(key);
+
+      return schema;
+    })
+    .filter((schema): schema is NonNullable<typeof schema> => schema !== null);
 };
 
 export const GET: APIRoute = async ({ params, request }) => {
@@ -51,8 +61,9 @@ export const GET: APIRoute = async ({ params, request }) => {
   const url = new URL(request.url);
   const baseUrl = process.env.LLMS_TXT_BASE_URL || `${url.origin}`;
 
-  const formatVersionedItem = (item: any, type: string, extraParams?: string | string[]) => {
-    return `- [${item.data.name} - ${item.data.id} - ${item.data.version}](${baseUrl}/api/schemas/${type}/${item.data.id}/${item.data.version})} ${item.data.summary ? `- ${item.data.summary.trim()}` : ''}`;
+  const formatVersionedItem = (item: (typeof schemas)[number]) => {
+    const message = item.data.message;
+    return `- [${message.name || message.id} - ${message.id} - ${message.version}](${baseUrl}/api/schemas/${message.collection}/${message.id}/${message.version})} ${message.summary ? `- ${message.summary.trim()}` : ''}`;
   };
 
   const formatServiceWithSchema = (item: ServiceWithSchema) => {
@@ -63,19 +74,16 @@ export const GET: APIRoute = async ({ params, request }) => {
     `# ${config.organizationName} EventCatalog Schemas`,
     `List of schemas for events, commands, queries, and services in EventCatalog.`,
     '',
-    `## Events\n${events
-      .filter(messageHasSchema)
-      .map((item) => formatVersionedItem(item, 'events'))
+    `## Events\n${getMessagesWithSchemas('events')
+      .map((item) => formatVersionedItem(item))
       .join('\n')}`,
     '',
-    `## Commands\n${commands
-      .filter(messageHasSchema)
-      .map((item) => formatVersionedItem(item, 'commands'))
+    `## Commands\n${getMessagesWithSchemas('commands')
+      .map((item) => formatVersionedItem(item))
       .join('\n')}`,
     '',
-    `## Queries\n${queries
-      .filter(messageHasSchema)
-      .map((item) => formatVersionedItem(item, 'queries'))
+    `## Queries\n${getMessagesWithSchemas('queries')
+      .map((item) => formatVersionedItem(item))
       .join('\n')}`,
     '',
     `## Services\n${servicesWithSchemasFlat.map((item: any) => formatServiceWithSchema(item)).join('\n')}`,

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

@@ -1,3 +1,4 @@
+import { getCollection } from 'astro:content';
 import { isSSR } from '@utils/feature';
 import { HybridPage } from '@utils/page-loaders/hybrid-page';
 import type { PageTypes } from '@types';
@@ -23,25 +24,41 @@ export class Page extends HybridPage {
       // 'entities',
       // 'containers',
     ];
-    const allItems = await Promise.all(itemTypes.map((type) => pageDataLoader[type]()));
+    const [schemas, ...allItems] = await Promise.all([
+      getCollection('schemas'),
+      ...itemTypes.map((type) => pageDataLoader[type]()),
+    ]);
+    const itemsByKey = new Map(allItems.flat().map((item) => [`${item.collection}:${item.data.id}:${item.data.version}`, item]));
 
-    // We only care about any item that has data.schemaPath
-    const itemsWithSchema = allItems.flatMap((items) => items.filter((item) => item.data.schemaPath));
+    const seenMessageSchemas = new Set<string>();
+    const messageSchemas = schemas.filter((schema) => {
+      const key = `${schema.data.message.collection}:${schema.data.message.id}:${schema.data.message.version}`;
+      if (seenMessageSchemas.has(key)) return false;
+      seenMessageSchemas.add(key);
+      return true;
+    });
 
     // Generate paths for messages with schemas
-    const messagePaths = itemsWithSchema.map((item) => ({
-      params: {
-        type: item.collection,
-        id: item.data.id,
-        version: item.data.version,
-      },
-      props: {
-        type: item.collection,
-        ...item,
-        // Not everything needs the body of the page itself.
-        body: undefined,
-      },
-    }));
+    const messagePaths = messageSchemas
+      .map((schema) => {
+        const item = itemsByKey.get(`${schema.data.message.collection}:${schema.data.message.id}:${schema.data.message.version}`);
+        if (!item) return null;
+
+        return {
+          params: {
+            type: schema.data.message.collection,
+            id: schema.data.message.id,
+            version: schema.data.message.version,
+          },
+          props: {
+            type: schema.data.message.collection,
+            ...item,
+            // Not everything needs the body of the page itself.
+            body: undefined,
+          },
+        };
+      })
+      .filter((path): path is NonNullable<typeof path> => path !== null);
 
     // Generate paths for data products with contracts
     const dataProducts = await pageDataLoader['data-products']();

package/eventcatalog/src/pages/schemas/[type]/[id]/[version]/index.astro

@@ -1,5 +1,6 @@
 ---
 import type { PageTypes } from '@types';
+import { getCollection } from 'astro:content';
 import VerticalSideBarLayout from '@layouts/VerticalSideBarLayout.astro';
 import { Page } from './_index.data';
 import SchemaPageViewer from '@components/SchemaExplorer/SchemaPageViewer';
@@ -76,32 +77,41 @@ if (isDataProduct && contractPath) {
   }
 } else {
   // Handle regular messages (events, commands, queries)
-  const allItems = await pageDataLoader[type]();
+  const [allItems, schemaEntries] = await Promise.all([pageDataLoader[type](), getCollection('schemas')]);
   const versions = allItems.filter((item) => item.data.id === data.id);
+  const schemasForMessage = schemaEntries.filter(
+    (schema) => schema.data.message.collection === type && schema.data.message.id === data.id
+  );
+
+  const getSchemaForVersion = (version: string) => {
+    const schemasForVersion = schemasForMessage.filter((schema) => schema.data.message.version === version);
+    return schemasForVersion.find((schema) => schema.data.default) ?? schemasForVersion[0];
+  };
 
   // Transform to SchemaItems
   const availableVersions = versions
-    .filter((message) => message.data.schemaPath && resourceFileExists(message, message.data.schemaPath))
     .map((message) => {
       try {
-        const schemaPath = message.data.schemaPath ?? '';
-        const schemaContent = readResourceFile(message, schemaPath) ?? '';
+        const schema = getSchemaForVersion(message.data.version);
+        if (!schema) return null;
+
+        const schemaPath = schema.data.file || schema.data.source.path || '';
         const schemaExtension = path.extname(schemaPath).slice(1);
 
         return {
           collection: message.collection,
           data: {
             id: message.data.id,
-            name: message.data.name,
+            name: schema.data.message.name || message.data.name,
             version: message.data.version,
-            summary: message.data.summary,
-            schemaPath: message.data.schemaPath,
+            summary: schema.data.message.summary || message.data.summary,
+            schemaPath,
             // @ts-ignore
             producers: message.data.producers || [],
             // @ts-ignore
             consumers: message.data.consumers || [],
           },
-          schemaContent,
+          schemaContent: schema.data.content || '',
           schemaExtension,
           examples: getExamplesForResource(message),
         } as SchemaItem;

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

@@ -10,6 +10,7 @@ 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
@@ -32,61 +33,84 @@ async function fetchAllSchemas() {
   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])
+  );
 
-  // Filter messages with schemas and read schema content - only keep essential data
+  // Read message schemas from the generated schemas collection.
   const messagesWithSchemas = await Promise.all(
-    allMessages
-      .filter((message) => message.data.schemaPath)
-      .filter((message) => resourceFileExists(message, message.data.schemaPath ?? ''))
-      .map(async (message) => {
+    schemaEntries.map(async (schema) => {
+      const message = messagesBySchemaReference.get(
+        `${schema.data.message.collection}:${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 schemaPath = message.data.schemaPath ?? '';
-          const schemaContent = readResourceFile(message, schemaPath) ?? '';
-          const schemaExtension = path.extname(schemaPath).slice(1);
-          const enrichedOwners = await enrichOwners(message.data.owners || []);
+          const enrichedOwners = await enrichOwners(schema.data.message.owners || []);
 
           return {
             collection: message.collection,
             data: {
               id: message.data.id,
-              name: message.data.name,
+              name: schema.data.message.name || message.data.name,
               version: message.data.version,
-              summary: message.data.summary,
-              schemaPath: message.data.schemaPath,
+              summary: schema.data.message.summary || message.data.summary,
+              schemaPath,
               producers: message.data.producers || [],
               consumers: message.data.consumers || [],
               owners: enrichedOwners,
             },
-            schemaContent,
+            schemaContent: schema.data.content || '',
             schemaExtension,
             examples: getExamplesForResource(message),
           };
         } catch (error) {
-          console.error(`Error reading schema for ${message.data.id}:`, error);
-          const enrichedOwners = await enrichOwners(message.data.owners || []);
+          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: message.data.name,
+              name: schema.data.message.name || schema.data.name || message.data.name,
               version: message.data.version,
-              summary: message.data.summary,
-              schemaPath: message.data.schemaPath,
+              summary: schema.data.message.summary || message.data.summary,
+              schemaPath,
               producers: message.data.producers || [],
               consumers: message.data.consumers || [],
               owners: enrichedOwners,
             },
-            schemaContent: '',
-            schemaExtension: 'json',
+            schemaContent: schema.data.content || '',
+            schemaExtension,
           };
         }
-      })
+      }
+
+      return {
+        collection: schema.data.message.collection,
+        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

package/eventcatalog/src/stores/sidebar-store/builders/message.ts

@@ -15,11 +15,33 @@ import { isVisualiserEnabled, isChangelogEnabled } from '@utils/feature';
 import { iconFieldsForResource } from '@utils/icon';
 import { collectionToResourceMap } from '@utils/collections/util';
 
+type MessageSchemaEntry = CollectionEntry<'schemas'>;
+
 const getProducerConsumerPageRef = (resource: any) => {
   const resourceType = collectionToResourceMap[resource.collection as keyof typeof collectionToResourceMap];
   return `${resourceType}:${resource.data.id}:${resource.data.version}`;
 };
 
+const getSchemasForMessage = (
+  message: CollectionEntry<'events' | 'commands' | 'queries'>,
+  schemas: MessageSchemaEntry[] = []
+) => {
+  return schemas.filter(
+    (schema) =>
+      schema.data.message.collection === message.collection &&
+      schema.data.message.id === message.data.id &&
+      schema.data.message.version === message.data.version
+  );
+};
+
+const getSchemaNavTitle = (schemas: MessageSchemaEntry[]) => {
+  if (schemas.length > 1) return 'Schemas';
+
+  const schemaPath = schemas[0]?.data.file || schemas[0]?.data.source.path || schemas[0]?.data.ref || schemas[0]?.id;
+  const format = schemaPath ? getSchemaFormatFromURL(schemaPath) : schemas[0]?.data.format;
+  return format ? `Schema (${format.toUpperCase()})` : 'Schema';
+};
+
 export const buildMessageNode = (
   message: CollectionEntry<'events' | 'commands' | 'queries'>,
   owners: any[],
@@ -51,7 +73,8 @@ export const buildMessageNode = (
   };
   const defaultIcon = iconMap[collection] || 'Mail';
 
-  const hasSchema = message.data.schemaPath !== undefined;
+  const resolvedSchemas = getSchemasForMessage(message, context.schemas);
+  const hasSchema = resolvedSchemas.length > 0;
   const renderVisualiser = isVisualiserEnabled();
   const docsSection = buildResourceDocsSection(
     collection as 'events' | 'commands' | 'queries',
@@ -116,7 +139,7 @@ export const buildMessageNode = (
         pages: [
           {
             type: 'item',
-            title: `Schema (${getSchemaFormatFromURL(message.data.schemaPath!).toUpperCase()})`,
+            title: getSchemaNavTitle(resolvedSchemas),
             href: buildUrl(`/schemas/${collection}/${message.data.id}/${message.data.version}`),
           },
           hasFieldUsage && {