@eventcatalog/core 2.62.1 → 2.64.0

package/eventcatalog/src/layouts/DiscoverLayout.astro

@@ -14,6 +14,7 @@ import { DatabaseIcon } from 'lucide-react';
 import { MagnifyingGlassIcon } from '@heroicons/react/20/solid';
 import VerticalSideBarLayout from './VerticalSideBarLayout.astro';
 import Checkbox from '@components/Checkbox.astro';
+import config from '@config';
 
 const events = await getEvents();
 const queries = await getQueries();
@@ -35,6 +36,9 @@ const currentPath = Astro.url.pathname;
 const checkboxLatestId = 'latest-only';
 const checkboxDraftsId = 'show-drafts';
 
+// @ts-ignore
+const tableConfiguration = config[type as keyof typeof config]?.tableConfiguration ?? { columns: {} };
+
 const tabs = [
   {
     label: `Events (${events.length})`,
@@ -43,6 +47,7 @@ const tabs = [
     icon: BoltIcon,
     activeColor: 'orange',
     enabled: events.length > 0,
+    visible: events.length > 0,
   },
   {
     label: `Commands (${commands.length})`,
@@ -51,6 +56,7 @@ const tabs = [
     icon: ChatBubbleLeftIcon,
     activeColor: 'blue',
     enabled: commands.length > 0,
+    visible: commands.length > 0,
   },
   {
     label: `Queries (${queries.length})`,
@@ -59,6 +65,7 @@ const tabs = [
     icon: MagnifyingGlassIcon,
     activeColor: 'green',
     enabled: queries.length > 0,
+    visible: queries.length > 0,
   },
   {
     label: `Services (${services.length})`,
@@ -67,6 +74,7 @@ const tabs = [
     icon: ServerIcon,
     activeColor: 'pink',
     enabled: services.length > 0,
+    visible: services.length > 0,
   },
   {
     label: `Domains (${domains.length})`,
@@ -75,6 +83,7 @@ const tabs = [
     icon: RectangleGroupIcon,
     activeColor: 'yellow',
     enabled: domains.length > 0,
+    visible: domains.length > 0,
   },
   {
     label: `Data (${containers.length})`,
@@ -83,6 +92,7 @@ const tabs = [
     icon: DatabaseIcon,
     activeColor: 'blue',
     enabled: containers.length > 0,
+    visible: containers.length > 0,
   },
   {
     label: `Flows (${flows.length})`,
@@ -91,6 +101,7 @@ const tabs = [
     icon: QueueListIcon,
     activeColor: 'teal',
     enabled: flows.length > 0,
+    visible: flows.length > 0,
   },
 ];
 ---
@@ -102,18 +113,20 @@ const tabs = [
         <div class="border-b border-gray-200">
           <nav class="flex space-x-8 -mb-0.5 pl-6" aria-label="Tabs">
             {
-              tabs.map((tab) => (
-                <a
-                  href={tab.href}
-                  class={` text-black  group inline-flex items-center py-4 px-1 text-sm font-light ${tab.isActive ? `border-${tab.activeColor}-500 border-b-[2px] text-${tab.activeColor}-500` : 'opacity-80'} ${!tab.enabled ? 'disabled' : ''}`}
-                  aria-current="page"
-                >
-                  <tab.icon
-                    className={`w-6 h-6 -ml-0.5 mr-2  ${tab.isActive ? `text-${tab.activeColor}-500` : 'text-gray-500'}`}
-                  />
-                  <span>{tab.label}</span>
-                </a>
-              ))
+              tabs
+                .filter((tab) => tab.visible)
+                .map((tab) => (
+                  <a
+                    href={tab.href}
+                    class={` text-black  group inline-flex items-center py-4 px-1 text-sm font-light ${tab.isActive ? `border-${tab.activeColor}-500 border-b-[2px] text-${tab.activeColor}-500` : 'opacity-80'} ${!tab.enabled ? 'disabled' : ''}`}
+                    aria-current="page"
+                  >
+                    <tab.icon
+                      className={`w-6 h-6 -ml-0.5 mr-2  ${tab.isActive ? `text-${tab.activeColor}-500` : 'text-gray-500'}`}
+                    />
+                    <span>{tab.label}</span>
+                  </a>
+                ))
             }
           </nav>
         </div>
@@ -145,6 +158,7 @@ const tabs = [
                 checkboxDraftsId={checkboxDraftsId}
                 data={data}
                 collection={type}
+                tableConfiguration={tableConfiguration}
                 client:load
               />
             </div>

package/eventcatalog/src/layouts/VerticalSideBarLayout.astro

@@ -17,6 +17,8 @@ import {
   Rocket,
   FileText,
   SquareDashedMousePointerIcon,
+  PackageSearch,
+  FileJson,
 } from 'lucide-react';
 import Header from '../components/Header.astro';
 import SEO from '../components/Seo.astro';
@@ -121,6 +123,14 @@ const navigationItems = [
     current: currentPath.includes('/discover/'),
     sidebar: false,
   },
+  {
+    id: '/schemas',
+    label: 'Schema Explorer',
+    icon: FileJson,
+    href: buildUrl('/schemas'),
+    current: currentPath.includes('/schemas'),
+    sidebar: false,
+  },
   {
     id: '/directory',
     label: 'Users & Teams',

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

@@ -0,0 +1,45 @@
+import type { APIRoute } from 'astro';
+import { getCollection } from 'astro:content';
+import path from 'node:path';
+import fs from 'node:fs';
+import { isEventCatalogScaleEnabled } from '@utils/feature';
+
+export async function getStaticPaths() {
+  const events = await getCollection('events');
+  const commands = await getCollection('commands');
+  const queries = await getCollection('queries');
+  const messages = [...events, ...commands, ...queries];
+  return messages
+    .filter((message) => message.data.schemaPath)
+    .filter((message) => fs.existsSync(path.join(path.dirname(message.filePath ?? ''), message.data.schemaPath ?? '')))
+    .map((message) => ({
+      params: { collection: message.collection, id: message.data.id, version: message.data.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(),
+      },
+    }));
+}
+
+export const GET: APIRoute = async ({ props }) => {
+  if (!isEventCatalogScaleEnabled()) {
+    return new Response(
+      JSON.stringify({
+        error: 'feature_not_available_on_server',
+        message: 'Schema API is not enabled for this deployment and supported in EventCatalog Scale.',
+      }),
+      {
+        status: 501,
+        headers: {
+          'Content-Type': 'application/json',
+          'Cache-Control': 'no-store',
+        },
+      }
+    );
+  }
+
+  return new Response(props.schema, {
+    headers: { 'Content-Type': 'text/plain' },
+  });
+};

package/eventcatalog/src/pages/api/schemas/services/[id]/[version]/[specification]/index.ts

@@ -0,0 +1,51 @@
+import type { APIRoute } from 'astro';
+import { getCollection } from 'astro:content';
+import path from 'node:path';
+import fs from 'node:fs';
+import { getSpecificationsForService } from '@utils/collections/services';
+import { isEventCatalogScaleEnabled } from '@utils/feature';
+
+export async function getStaticPaths() {
+  const services = await getCollection('services');
+  const servicesWithSpecifications = services.filter((service) => getSpecificationsForService(service).length > 0);
+  return servicesWithSpecifications.reduce<
+    { params: { collection: string; id: string; version: string; specification: string }; props: { schema: string } }[]
+  >(
+    (acc, service) => {
+      const specifications = getSpecificationsForService(service);
+      return [
+        ...acc,
+        ...specifications.map((specification) => ({
+          params: {
+            collection: service.collection,
+            id: service.data.id,
+            version: service.data.version,
+            specification: specification.type,
+          },
+          props: {
+            schema: fs.readFileSync(path.join(path.dirname(service.filePath ?? ''), specification.path ?? ''), 'utf8'),
+          },
+        })),
+      ];
+    },
+    [] as { params: { collection: string; id: string; version: string; specification: string }; props: { schema: string } }[]
+  );
+}
+
+export const GET: APIRoute = async ({ props }) => {
+  if (!isEventCatalogScaleEnabled()) {
+    return new Response(
+      JSON.stringify({
+        error: 'feature_not_available_on_server',
+        message: 'Schema API is not enabled for this deployment and supported in EventCatalog Scale.',
+      }),
+      {
+        status: 501,
+        headers: { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' },
+      }
+    );
+  }
+  return new Response(props.schema, {
+    headers: { 'Content-Type': 'text/plain' },
+  });
+};

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

@@ -548,6 +548,7 @@ nodeGraphs.push({
         }
 
         if (enableSupportForElkLayout) {
+          // @ts-ignore
           const { default: elkLayouts } = await import('@mermaid-js/layout-elk/dist/mermaid-layout-elk.core.mjs');
           mermaid.registerLayoutLoaders(elkLayouts);
         }

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

@@ -0,0 +1,86 @@
+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');
+const services = await getCollection('services');
+
+type ServiceWithSchema = {
+  collection: string;
+  id: string;
+  version: string;
+  specification: string;
+  summary: string;
+};
+
+const servicesWithSchemas = services.filter((service) => getSpecificationsForService(service).length > 0);
+
+const servicesWithSchemasFlat = servicesWithSchemas.reduce<ServiceWithSchema[]>((acc, service) => {
+  return [
+    ...acc,
+    ...getSpecificationsForService(service).map((specification) => ({
+      collection: 'services',
+      id: service.data.id,
+      version: service.data.version,
+      specification: specification.type,
+      summary: service.data.summary?.trim() || '',
+    })),
+  ];
+}, []) as ServiceWithSchema[];
+
+const messageHasSchema = (message: CollectionEntry<'events' | 'commands' | 'queries'>) => {
+  return message.data.schemaPath;
+};
+
+export const GET: APIRoute = async ({ params, request }) => {
+  if (!isEventCatalogScaleEnabled()) {
+    return new Response(
+      JSON.stringify({
+        error: 'feature_not_available_on_server',
+        message: 'Schema API is not enabled for this deployment and supported in EventCatalog Scale.',
+      }),
+      { status: 501, headers: { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' } }
+    );
+  }
+
+  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 formatServiceWithSchema = (item: ServiceWithSchema) => {
+    return `- [${item.id} - ${item.version} - ${item.specification} specification](${baseUrl}/api/schemas/${item.collection}/${item.id}/${item.version}/${item.specification}) ${item.summary ? `- Specification for ${item.summary}` : ''}`;
+  };
+
+  const content = [
+    `# ${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'))
+      .join('\n')}`,
+    '',
+    `## Commands\n${commands
+      .filter(messageHasSchema)
+      .map((item) => formatVersionedItem(item, 'commands'))
+      .join('\n')}`,
+    '',
+    `## Queries\n${queries
+      .filter(messageHasSchema)
+      .map((item) => formatVersionedItem(item, 'queries'))
+      .join('\n')}`,
+    '',
+    `## Services\n${servicesWithSchemasFlat.map((item: any) => formatServiceWithSchema(item)).join('\n')}`,
+  ].join('\n');
+  return new Response(content, {
+    headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+  });
+};

package/eventcatalog/src/pages/schemas/index.astro

@@ -0,0 +1,175 @@
+---
+import VerticalSideBarLayout from '@layouts/VerticalSideBarLayout.astro';
+import { getEvents } from '@utils/events';
+import { getCommands } from '@utils/commands';
+import { getQueries } from '@utils/queries';
+import { getServices, getSpecificationsForService } from '@utils/collections/services';
+import SchemaExplorer from '@components/SchemaExplorer/SchemaExplorer';
+import { isEventCatalogScaleEnabled } from '@utils/feature';
+import { getOwner } from '@utils/collections/owners';
+import { buildUrl } from '@utils/url-builder';
+import fs from 'fs';
+import path from 'path';
+
+// Fetch all messages
+const events = await getEvents({ getAllVersions: true });
+const commands = await getCommands({ getAllVersions: true });
+const queries = await getQueries({ getAllVersions: true });
+
+// Fetch all services
+const services = await getServices({ getAllVersions: true });
+
+// Combine all messages
+const allMessages = [...events, ...commands, ...queries];
+
+// 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}`),
+  }));
+}
+
+// Filter messages with schemas and read schema content - only keep essential data
+const messagesWithSchemas = await Promise.all(
+  allMessages
+    .filter((message) => message.data.schemaPath)
+    // Make sure the file exists
+    .filter((message) => fs.existsSync(path.join(path.dirname(message.filePath ?? ''), message.data.schemaPath ?? '')))
+    .map(async (message) => {
+      try {
+        // Get the schema file path
+        const schemaPath = message.data.schemaPath;
+        const fullSchemaPath = path.join(path.dirname(message.filePath ?? ''), schemaPath ?? '');
+
+        // Read the schema content
+        let schemaContent = '';
+        if (fs.existsSync(fullSchemaPath)) {
+          schemaContent = fs.readFileSync(fullSchemaPath, 'utf-8');
+        }
+
+        // Get schema file extension
+        const schemaExtension = path.extname(schemaPath ?? '').slice(1);
+
+        // Enrich owners with full details
+        const enrichedOwners = await enrichOwners(message.data.owners || []);
+
+        // Only return essential data - strip out markdown, full data objects, etc.
+        return {
+          collection: message.collection,
+          data: {
+            id: message.data.id,
+            name: message.data.name,
+            version: message.data.version,
+            summary: message.data.summary,
+            schemaPath: message.data.schemaPath,
+            producers: message.data.producers || [],
+            consumers: message.data.consumers || [],
+            owners: enrichedOwners,
+          },
+          schemaContent,
+          schemaExtension,
+        };
+      } catch (error) {
+        console.error(`Error reading schema for ${message.data.id}:`, error);
+        const enrichedOwners = await enrichOwners(message.data.owners || []);
+        return {
+          collection: message.collection,
+          data: {
+            id: message.data.id,
+            name: message.data.name,
+            version: message.data.version,
+            summary: message.data.summary,
+            schemaPath: message.data.schemaPath,
+            producers: message.data.producers || [],
+            consumers: message.data.consumers || [],
+            owners: enrichedOwners,
+          },
+          schemaContent: '',
+          schemaExtension: 'json',
+        };
+      }
+    })
+);
+
+// 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);
+
+      // Only include services that have specifications
+      if (specifications.length === 0) {
+        return null;
+      }
+
+      // Process each specification file for this service
+      return await Promise.all(
+        specifications.map(async (spec) => {
+          const specPath = path.join(path.dirname(service.filePath ?? ''), spec.path);
+
+          // Only include if the spec file exists
+          if (!fs.existsSync(specPath)) {
+            return null;
+          }
+
+          const schemaContent = fs.readFileSync(specPath, 'utf-8');
+          // Use spec type (openapi, asyncapi) as the extension for proper labeling
+          const schemaExtension = spec.type;
+
+          // Enrich owners with full details
+          const enrichedOwners = await enrichOwners(service.data.owners || []);
+
+          // Only return essential data - strip out markdown, sends/receives, entities, etc.
+          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);
+
+// Combine messages and services
+const allSchemas = [...messagesWithSchemas, ...flatServicesWithSpecs];
+
+const apiAccessEnabled = isEventCatalogScaleEnabled();
+---
+
+<VerticalSideBarLayout title="Schema Explorer - EventCatalog">
+  <main class="flex sm:px-8 docs-layout h-[calc(100vh-var(--header-height,0px)-64px)]">
+    <div class="flex docs-layout w-full h-full">
+      <div class="w-full lg:mr-2 pr-8 py-6 flex flex-col h-full">
+        <div class="w-full !max-w-none h-full flex flex-col overflow-hidden">
+          <SchemaExplorer client:load schemas={allSchemas as any} apiAccessEnabled={apiAccessEnabled} />
+        </div>
+      </div>
+    </div>
+  </main>
+</VerticalSideBarLayout>

package/eventcatalog/src/types/index.ts

@@ -20,3 +20,12 @@ export type PageTypes =
   | 'flows'
   | 'entities'
   | 'containers';
+
+export type TableConfiguration = {
+  columns: {
+    [key: string]: {
+      label?: string;
+      visible?: boolean;
+    };
+  };
+};

package/eventcatalog/src/utils/files.ts

@@ -50,3 +50,12 @@ export const getAbsoluteFilePathForAstroFile = (filePath: string, fileName?: str
 
   return resolveProjectPath(filePath, PROJECT_DIR);
 };
+
+/**
+ * Checks if a file path is an Avro schema based on its extension
+ * @param filePath - The file path to check
+ * @returns True if the file is an Avro schema (.avro or .avsc)
+ */
+export const isAvroSchema = (filePath: string): boolean => {
+  return filePath.endsWith('.avro') || filePath.endsWith('.avsc');
+};

package/package.json

@@ -6,7 +6,7 @@
     "url": "https://github.com/event-catalog/eventcatalog.git"
   },
   "type": "module",
-  "version": "2.62.1",
+  "version": "2.64.0",
   "publishConfig": {
     "access": "public"
   },