@eventcatalog/core 3.44.1 → 3.45.0

package/dist/analytics/analytics.cjs

@@ -36,7 +36,7 @@ module.exports = __toCommonJS(analytics_exports);
 var import_os = __toESM(require("os"), 1);
 
 // package.json
-var version = "3.44.1";
+var version = "3.45.0";
 
 // src/constants.ts
 var VERSION = version;

package/dist/analytics/analytics.js

@@ -1,7 +1,7 @@
 import {
   raiseEvent
-} from "../chunk-MFLSPCEA.js";
-import "../chunk-EPDZMVQ3.js";
+} from "../chunk-6XNMBNIU.js";
+import "../chunk-E4K4KTSR.js";
 export {
   raiseEvent
 };

package/dist/analytics/log-build.cjs

@@ -140,7 +140,7 @@ var verifyRequiredFieldsAreInCatalogConfigFile = async (projectDirectory) => {
 var import_os = __toESM(require("os"), 1);
 
 // package.json
-var version = "3.44.1";
+var version = "3.45.0";
 
 // src/constants.ts
 var VERSION = version;

package/dist/analytics/log-build.js

@@ -1,9 +1,9 @@
 import {
   log_build_default
-} from "../chunk-DKKPJ3QM.js";
-import "../chunk-MFLSPCEA.js";
+} from "../chunk-2QK37BNF.js";
+import "../chunk-6XNMBNIU.js";
 import "../chunk-DAOXTQVS.js";
-import "../chunk-EPDZMVQ3.js";
+import "../chunk-E4K4KTSR.js";
 import "../chunk-6QENHZZP.js";
 export {
   log_build_default as default

package/dist/{chunk-DKKPJ3QM.js → chunk-2QK37BNF.js}

@@ -1,6 +1,6 @@
 import {
   raiseEvent
-} from "./chunk-MFLSPCEA.js";
+} from "./chunk-6XNMBNIU.js";
 import {
   countResources,
   serializeCounts

package/dist/{chunk-MFLSPCEA.js → chunk-6XNMBNIU.js}

@@ -1,6 +1,6 @@
 import {
   VERSION
-} from "./chunk-EPDZMVQ3.js";
+} from "./chunk-E4K4KTSR.js";
 
 // src/analytics/analytics.js
 import os from "os";

package/dist/{chunk-EPDZMVQ3.js → chunk-E4K4KTSR.js}

@@ -1,5 +1,5 @@
 // package.json
-var version = "3.44.1";
+var version = "3.45.0";
 
 // src/constants.ts
 var VERSION = version;

package/dist/{chunk-L26L4Y5J.js → chunk-G6KYCMUM.js}

@@ -1,6 +1,6 @@
 import {
   VERSION
-} from "./chunk-EPDZMVQ3.js";
+} from "./chunk-E4K4KTSR.js";
 
 // src/utils/cli-logger.ts
 import pc from "picocolors";

package/dist/{chunk-3UVY6YHH.js → chunk-KHL25572.js}

@@ -1,6 +1,6 @@
 import {
   logger
-} from "./chunk-L26L4Y5J.js";
+} from "./chunk-G6KYCMUM.js";
 import {
   cleanup,
   getEventCatalogConfigFile

package/dist/constants.cjs

@@ -25,7 +25,7 @@ __export(constants_exports, {
 module.exports = __toCommonJS(constants_exports);
 
 // package.json
-var version = "3.44.1";
+var version = "3.45.0";
 
 // src/constants.ts
 var VERSION = version;

package/dist/constants.js

@@ -1,6 +1,6 @@
 import {
   VERSION
-} from "./chunk-EPDZMVQ3.js";
+} from "./chunk-E4K4KTSR.js";
 export {
   VERSION
 };

package/dist/eventcatalog.cjs

@@ -144,7 +144,7 @@ var verifyRequiredFieldsAreInCatalogConfigFile = async (projectDirectory) => {
 var import_picocolors = __toESM(require("picocolors"), 1);
 
 // package.json
-var version = "3.44.1";
+var version = "3.45.0";
 
 // src/constants.ts
 var VERSION = version;

package/dist/eventcatalog.js

@@ -13,8 +13,8 @@ import {
 } from "./chunk-3H2RT3CM.js";
 import {
   log_build_default
-} from "./chunk-DKKPJ3QM.js";
-import "./chunk-MFLSPCEA.js";
+} from "./chunk-2QK37BNF.js";
+import "./chunk-6XNMBNIU.js";
 import "./chunk-DAOXTQVS.js";
 import {
   catalogToAstro
@@ -28,13 +28,13 @@ import {
 } from "./chunk-B7HCX5HM.js";
 import {
   generate
-} from "./chunk-3UVY6YHH.js";
+} from "./chunk-KHL25572.js";
 import {
   logger
-} from "./chunk-L26L4Y5J.js";
+} from "./chunk-G6KYCMUM.js";
 import {
   VERSION
-} from "./chunk-EPDZMVQ3.js";
+} from "./chunk-E4K4KTSR.js";
 import {
   getEventCatalogConfigFile,
   verifyRequiredFieldsAreInCatalogConfigFile

package/dist/generate.cjs

@@ -108,7 +108,7 @@ var getEventCatalogConfigFile = async (projectDirectory) => {
 var import_picocolors = __toESM(require("picocolors"), 1);
 
 // package.json
-var version = "3.44.1";
+var version = "3.45.0";
 
 // src/constants.ts
 var VERSION = version;

package/dist/generate.js

@@ -1,8 +1,8 @@
 import {
   generate
-} from "./chunk-3UVY6YHH.js";
-import "./chunk-L26L4Y5J.js";
-import "./chunk-EPDZMVQ3.js";
+} from "./chunk-KHL25572.js";
+import "./chunk-G6KYCMUM.js";
+import "./chunk-E4K4KTSR.js";
 import "./chunk-6QENHZZP.js";
 export {
   generate

package/dist/utils/cli-logger.cjs

@@ -36,7 +36,7 @@ module.exports = __toCommonJS(cli_logger_exports);
 var import_picocolors = __toESM(require("picocolors"), 1);
 
 // package.json
-var version = "3.44.1";
+var version = "3.45.0";
 
 // src/constants.ts
 var VERSION = version;

package/dist/utils/cli-logger.js

@@ -1,7 +1,7 @@
 import {
   logger
-} from "../chunk-L26L4Y5J.js";
-import "../chunk-EPDZMVQ3.js";
+} from "../chunk-G6KYCMUM.js";
+import "../chunk-E4K4KTSR.js";
 export {
   logger
 };

package/eventcatalog/src/components/EnvironmentDropdown.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest';
+import { buildEnvironmentUrl, findCurrentEnvironment } from './EnvironmentDropdown';
+
+const environments = [
+  {
+    name: 'Development',
+    url: 'https://example.com/event-catalog/dev',
+    shortName: 'Dev',
+  },
+  {
+    name: 'UAT',
+    url: 'https://example.com/event-catalog/uat',
+    shortName: 'UAT',
+  },
+  {
+    name: 'Production',
+    url: 'https://example.com/event-catalog/prod',
+    shortName: 'Prod',
+  },
+];
+
+describe('EnvironmentDropdown', () => {
+  it('finds the current environment when environments share an origin but use different base paths', () => {
+    expect(findCurrentEnvironment(environments, 'https://example.com/event-catalog/uat/services/foo')?.name).toBe('UAT');
+  });
+
+  it('builds environment urls by replacing the current environment base path', () => {
+    expect(
+      buildEnvironmentUrl(
+        'https://example.com/event-catalog/prod',
+        'https://example.com/event-catalog/uat/services/foo',
+        'https://example.com/event-catalog/uat'
+      )
+    ).toBe('https://example.com/event-catalog/prod/services/foo');
+  });
+
+  it('preserves search params and hashes when switching environments', () => {
+    expect(
+      buildEnvironmentUrl(
+        'https://example.com/event-catalog/prod',
+        'https://example.com/event-catalog/uat/services/foo?tab=messages#latest',
+        'https://example.com/event-catalog/uat'
+      )
+    ).toBe('https://example.com/event-catalog/prod/services/foo?tab=messages#latest');
+  });
+
+  it('keeps existing origin based environment switching for root catalogs', () => {
+    expect(
+      buildEnvironmentUrl('https://prod.example.com', 'https://uat.example.com/services/foo', 'https://uat.example.com')
+    ).toBe('https://prod.example.com/services/foo');
+  });
+
+  it('switches from a root catalog to a subpath catalog', () => {
+    expect(buildEnvironmentUrl('https://example.com/prod', 'https://example.com/services/foo', 'https://example.com')).toBe(
+      'https://example.com/prod/services/foo'
+    );
+  });
+
+  it('preserves the current path when the current environment is unknown', () => {
+    expect(buildEnvironmentUrl('https://example.com/prod', 'http://localhost:3000/services/foo')).toBe(
+      'https://example.com/prod/services/foo'
+    );
+  });
+});

package/eventcatalog/src/components/EnvironmentDropdown.tsx

@@ -11,20 +11,56 @@ interface EnvironmentDropdownProps {
   environments: Environment[];
 }
 
+const stripTrailingSlash = (pathname: string) => pathname.replace(/\/$/, '') || '/';
+
+const startsWithPath = (pathname: string, basePathname: string) =>
+  basePathname === '/' || pathname === basePathname || pathname.startsWith(`${basePathname}/`);
+
+export const findCurrentEnvironment = (environments: Environment[], currentHref: string) => {
+  const currentUrl = new URL(currentHref);
+
+  return (
+    environments
+      .filter((env) => {
+        const envUrl = new URL(env.url, currentUrl.href);
+        const envPathname = stripTrailingSlash(envUrl.pathname);
+
+        return envUrl.origin === currentUrl.origin && startsWithPath(currentUrl.pathname, envPathname);
+      })
+      .sort(
+        (a, b) =>
+          stripTrailingSlash(new URL(b.url, currentUrl.href).pathname).length -
+          stripTrailingSlash(new URL(a.url, currentUrl.href).pathname).length
+      )[0] || null
+  );
+};
+
+export const buildEnvironmentUrl = (environmentUrl: string, currentHref: string, currentEnvironmentUrl?: string) => {
+  const currentUrl = new URL(currentHref);
+  const targetUrl = new URL(environmentUrl, currentUrl.href);
+  const targetBasePathname = stripTrailingSlash(targetUrl.pathname);
+  const currentBasePathname = currentEnvironmentUrl
+    ? stripTrailingSlash(new URL(currentEnvironmentUrl, currentUrl.href).pathname)
+    : undefined;
+  const pathWithinEnvironment =
+    currentBasePathname && currentBasePathname !== '/' && startsWithPath(currentUrl.pathname, currentBasePathname)
+      ? currentUrl.pathname.slice(currentBasePathname.length)
+      : currentUrl.pathname;
+
+  targetUrl.pathname = `${targetBasePathname}${pathWithinEnvironment}`.replace(/\/+/g, '/');
+  targetUrl.search = currentUrl.search;
+  targetUrl.hash = currentUrl.hash;
+
+  return targetUrl.toString();
+};
+
 export const EnvironmentDropdown: React.FC<EnvironmentDropdownProps> = ({ environments }) => {
   const [isOpen, setIsOpen] = useState(false);
   const [currentEnvironment, setCurrentEnvironment] = useState<Environment | null>(null);
   const dropdownRef = useRef<HTMLDivElement>(null);
 
   useEffect(() => {
-    // Check if current URL matches any environment
-    const currentUrl = window.location.origin;
-    const matchedEnv = environments.find((env) => {
-      // Normalize URLs for comparison
-      const envUrl = new URL(env.url).origin;
-      return envUrl === currentUrl;
-    });
-    setCurrentEnvironment(matchedEnv || null);
+    setCurrentEnvironment(findCurrentEnvironment(environments, window.location.href));
   }, [environments]);
 
   useEffect(() => {
@@ -99,11 +135,7 @@ export const EnvironmentDropdown: React.FC<EnvironmentDropdownProps> = ({ enviro
               href={env.url}
               onClick={(e) => {
                 e.preventDefault();
-                // Construct the full URL with the current path when clicked
-                const currentPath = window.location.pathname + window.location.search + window.location.hash;
-                const targetUrl = new URL(env.url);
-                targetUrl.pathname = currentPath;
-                window.location.href = targetUrl.toString();
+                window.location.href = buildEnvironmentUrl(env.url, window.location.href, currentEnvironment?.url);
               }}
               className={`block rounded-xl px-3 py-3 transition-colors ${
                 isCurrentEnv

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,16 @@ const channelPointer = z
   })
   .extend(pointer.shape);
 
+const schemaPointer = z.object({
+  id: 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 +386,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 +409,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 +432,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 +1005,47 @@ 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,
+    },
+  }),
+  schema: z
+    .object({
+      format: z.string(),
+      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(),
+        path: z.string().optional(),
+        url: z.string().optional(),
+      }),
+      readOnly: z.boolean().optional(),
+    })
+    .extend(baseSchema.shape),
+});
+
 export const collections = {
   events,
   commands,
@@ -1024,4 +1079,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/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/utils/collections/schema-loader.ts

@@ -0,0 +1,237 @@
+import type { Loader } from 'astro/loaders';
+import { glob } from 'glob';
+import matter from 'gray-matter';
+import fs from 'node:fs/promises';
+import fsSync from 'node:fs';
+import path from 'node:path';
+import { sortVersioned } from './util';
+
+type MessageCollection = 'events' | 'commands' | 'queries';
+
+type SchemaReference = {
+  id?: string;
+  file?: string;
+  path?: string;
+  name?: string;
+  format?: string;
+  environments?: string[];
+  default?: boolean;
+};
+
+type MessageFrontmatter = {
+  id?: string;
+  name?: string;
+  version?: string;
+  summary?: string;
+  owners?: string[];
+  schemaPath?: string;
+  schemas?: SchemaReference[];
+};
+
+export type MessageSchemaResource = {
+  id: string;
+  name?: string;
+  version?: string;
+  format: string;
+  content?: string;
+  file?: string;
+  filePath?: string;
+  environments?: string[];
+  default?: boolean;
+  latest?: boolean;
+  message: {
+    collection: MessageCollection;
+    id: string;
+    name?: string;
+    version: string;
+    summary?: string;
+    owners?: string[];
+  };
+  source: {
+    provider: 'file';
+    path: string;
+  };
+};
+
+type SchemaLoaderOptions = {
+  messages: {
+    pattern: string[];
+    base?: string;
+  };
+};
+
+type LoaderContext = Parameters<Loader['load']>[0];
+
+const MESSAGE_COLLECTIONS: MessageCollection[] = ['events', 'commands', 'queries'];
+
+const normalizePath = (value: string) => value.replace(/\\/g, '/');
+
+const getMessageCollectionFromPath = (filePath: string): MessageCollection | undefined => {
+  const parts = normalizePath(filePath).split('/');
+  return MESSAGE_COLLECTIONS.find((collection) => parts.includes(collection));
+};
+
+const getSchemaFormat = (schemaPath: string) => {
+  const extension = path.extname(schemaPath).replace('.', '').toLowerCase();
+
+  if (extension === 'avsc' || extension === 'avro') return 'avro';
+  if (extension === 'proto') return 'protobuf';
+  if (extension === 'json') return 'jsonschema';
+  if (extension === 'yaml' || extension === 'yml') return 'yaml';
+
+  return extension || 'unknown';
+};
+
+const buildGeneratedSchemaId = (message: { collection: MessageCollection; id: string; version: string }, schemaPath: string) =>
+  `schema:${message.collection}:${message.id}:${message.version}:${schemaPath}`;
+
+const getSchemaFile = (reference: SchemaReference) => reference.file ?? reference.path;
+
+const schemaFileExists = (schema: MessageSchemaResource): schema is MessageSchemaResource & { filePath: string } =>
+  Boolean(schema.filePath && fsSync.existsSync(schema.filePath));
+
+const addLatestMetadata = (schemas: MessageSchemaResource[]) => {
+  const schemasByMessage = schemas.reduce(
+    (acc, schema) => {
+      const key = `${schema.message.collection}:${schema.message.id}`;
+      acc[key] = [...(acc[key] ?? []), schema];
+      return acc;
+    },
+    {} as Record<string, MessageSchemaResource[]>
+  );
+
+  const latestVersionsByMessage = Object.entries(schemasByMessage).reduce(
+    (acc, [key, messageSchemas]) => {
+      acc[key] = sortVersioned(messageSchemas, (schema) => schema.message.version)[0]?.message.version;
+      return acc;
+    },
+    {} as Record<string, string | undefined>
+  );
+
+  return schemas.map((schema) => {
+    const key = `${schema.message.collection}:${schema.message.id}`;
+    return {
+      ...schema,
+      latest: schema.message.version === latestVersionsByMessage[key],
+    };
+  });
+};
+
+export const getMessageSchemasFromFrontmatter = ({
+  data,
+  collection,
+  messageFilePath,
+}: {
+  data: MessageFrontmatter;
+  collection: MessageCollection;
+  messageFilePath: string;
+}): MessageSchemaResource[] => {
+  if (!data.id || !data.version) return [];
+
+  const message = {
+    collection,
+    id: data.id,
+    name: data.name,
+    version: data.version,
+    summary: data.summary,
+    owners: data.owners,
+  };
+
+  const schemaReferences =
+    data.schemas?.filter((schema) => getSchemaFile(schema)) ??
+    (data.schemaPath
+      ? [
+          {
+            id: buildGeneratedSchemaId(message, data.schemaPath),
+            file: data.schemaPath,
+            name: 'Schema',
+            default: true,
+          },
+        ]
+      : []);
+
+  return schemaReferences.map((reference) => {
+    const schemaFile = getSchemaFile(reference) as string;
+    const schemaFilePath = path.resolve(path.dirname(messageFilePath), schemaFile);
+    const schemaId = reference.id ?? buildGeneratedSchemaId(message, schemaFile);
+
+    return {
+      id: schemaId,
+      name: reference.name ?? schemaId,
+      version: data.version,
+      format: reference.format ?? getSchemaFormat(schemaFile),
+      file: schemaFile,
+      filePath: schemaFilePath,
+      environments: reference.environments,
+      default: reference.default,
+      message,
+      source: {
+        provider: 'file',
+        path: schemaFile,
+      },
+    };
+  });
+};
+
+export const loadMessageSchemas = async ({ pattern, base }: SchemaLoaderOptions['messages']) => {
+  if (!base) return [];
+
+  const files = await glob(pattern, {
+    cwd: base,
+    absolute: true,
+    nodir: true,
+    ignore: ['dist/**', '**/dist/**'],
+  });
+
+  const schemas = await Promise.all(
+    files.map(async (file) => {
+      const collection = getMessageCollectionFromPath(file);
+      if (!collection) return [];
+
+      const { data } = matter.read(file) as { data: MessageFrontmatter };
+      return getMessageSchemasFromFrontmatter({ data, collection, messageFilePath: file });
+    })
+  );
+
+  return addLatestMetadata(schemas.flat().filter(schemaFileExists));
+};
+
+const getSchemaBody = async (schema: MessageSchemaResource) => {
+  if (!schemaFileExists(schema)) return undefined;
+  return fs.readFile(schema.filePath, 'utf8');
+};
+
+const setSchema = async (context: LoaderContext, schema: MessageSchemaResource) => {
+  const body = await getSchemaBody(schema);
+  if (body === undefined) return;
+
+  const schemaWithContent = {
+    ...schema,
+    content: body,
+  };
+  const parsedData = await context.parseData({
+    id: schema.id,
+    data: schemaWithContent,
+  });
+
+  context.store.set({
+    id: schema.id,
+    data: parsedData,
+    body,
+    digest: context.generateDigest(schemaWithContent),
+  });
+};
+
+export const schemaLoader = ({ messages }: SchemaLoaderOptions): Loader => {
+  return {
+    name: 'eventcatalog-schema-loader',
+    load: async (context) => {
+      context.store.clear();
+      const schemas = await loadMessageSchemas(messages);
+
+      for (const schema of schemas) {
+        await setSchema(context, schema);
+      }
+    },
+  };
+};

package/package.json

@@ -7,7 +7,7 @@
   },
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",
-  "version": "3.44.1",
+  "version": "3.45.0",
   "publishConfig": {
     "access": "public"
   },
@@ -113,8 +113,8 @@
     "uuid": "^10.0.0",
     "zod": "^4.3.6",
     "@eventcatalog/sdk": "2.24.1",
-    "@eventcatalog/visualiser": "^3.22.1",
-    "@eventcatalog/linter": "1.0.29"
+    "@eventcatalog/linter": "1.0.29",
+    "@eventcatalog/visualiser": "^3.22.1"
   },
   "devDependencies": {
     "@astrojs/check": "^0.9.9",