@eventcatalog/core 2.63.0 → 2.64.0

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/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/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.63.0",
+  "version": "2.64.0",
   "publishConfig": {
     "access": "public"
   },

package/eventcatalog/src/components/MDX/SchemaViewer/SchemaProperty.astro

@@ -1,204 +0,0 @@
----
-import SchemaProp from './SchemaProperty.astro';
-
-interface Props {
-  name: string;
-  details: any;
-  isRequired: boolean;
-  level: number;
-  isListItem?: boolean;
-  expand?: boolean;
-}
-
-const { name, details, isRequired, level, isListItem = false, expand = false } = Astro.props;
-
-const hasNestedProperties = details.type === 'object' && details.properties && Object.keys(details.properties).length > 0;
-const hasArrayItems = details.type === 'array' && details.items;
-const hasArrayItemProperties =
-  hasArrayItems &&
-  ((details.items.type === 'object' && details.items.properties) ||
-    details.items.allOf ||
-    details.items.oneOf ||
-    details.items.$ref);
-const isCollapsible = hasNestedProperties || hasArrayItemProperties;
-
-// Using template literal for class calculation remains safe
-const indentationClass = `pl-${level * 3}`;
-
-const contentId = `prop-${name}-${level}-${Math.random().toString(36).substring(2, 7)}`;
----
-
-{/* Using simpler border class */}
-<div class:list={['property-container mb-1.5 border-l border-gray-100 relative', indentationClass]}>
-  <div class="flex items-start space-x-1.5">
-    {
-      isCollapsible && (
-        <button
-          type="button"
-          aria-expanded={expand ? 'true' : 'false'}
-          aria-controls={contentId}
-          class="property-toggle text-gray-500 hover:text-gray-700 pt-0.5 focus:outline-none w-3 text-center flex-shrink-0"
-        >
-          <span class:list={['icon-collapsed font-mono text-xs', { hidden: expand }]}>&gt;</span>
-          <span class:list={['icon-expanded font-mono text-xs', { hidden: !expand }]}>v</span>
-        </button>
-      )
-    }
-    {!isCollapsible && <div class="w-3 h-4 flex-shrink-0" />}
-
-    <div class="flex-grow">
-      <div class="flex justify-between items-baseline">
-        <div>
-          <span class="font-semibold text-gray-800 text-sm">{name}</span>
-          <span class="ml-1.5 text-purple-600 font-mono text-xs">
-            {/* Expressions using ternary operators are generally safe */}
-            {details.type}
-            {details.type === 'array' && details.items?.type ? `[${details.items.type}]` : ''}
-            {details.format ? `<${details.format}>` : ''}
-            {details._refPath && <span class="text-blue-600 ml-1">→ {details._refName || details._refPath}</span>}
-            {details._refNotFound && <span class="text-red-600 ml-1">❌ ref not found</span>}
-            {
-              details.const !== undefined && (
-                <span>
-                  constant: <code>{details.const}</code>
-                </span>
-              )
-            }
-          </span>
-        </div>
-        {isRequired && <span class="text-red-600 text-xs ml-3 flex-shrink-0">required</span>}
-      </div>
-
-      {details.description && <p class="text-gray-500 text-xs mt-0.5">{details.description}</p>}
-      {
-        details.title && details.title !== details.description && (
-          <p class="text-gray-500 text-xs mt-0.5 italic">Title: {details.title}</p>
-        )
-      }
-
-      {/* Reverted arbitrary text size to standard 'text-xs' */}
-      <div class="text-xs text-gray-500 mt-0.5 space-y-0">
-        {
-          details.pattern && (
-            <div>
-              Match pattern: <code class="bg-gray-100 px-1 rounded text-gray-800 font-thin py-0.5">{details.pattern}</code>
-            </div>
-          )
-        }
-        {
-          details.minimum !== undefined && (
-            <div>
-              Minimum: <code class="bg-gray-100 px-1 rounded text-gray-800 font-thin py-0.5">{details.minimum}</code>
-            </div>
-          )
-        }
-        {
-          details.maximum !== undefined && (
-            <div>
-              Maximum: <code class="bg-gray-100 px-1 rounded text-gray-800 font-thin py-0.5">{details.maximum}</code>
-            </div>
-          )
-        }
-        {
-          details.minLength !== undefined && (
-            <div>
-              Min length: <code class="bg-gray-100 px-1 rounded text-gray-800 font-thin py-0.5">{details.minLength}</code>
-            </div>
-          )
-        }
-        {
-          details.maxLength !== undefined && (
-            <div>
-              Max length: <code class="bg-gray-100 px-1 rounded text-gray-800 font-thin py-0.5">{details.maxLength}</code>
-            </div>
-          )
-        }
-        {
-          details.enum && (
-            <div>
-              <span class="text-xs inline-block">Allowed values:</span>
-
-              {/* Map function rendering standard elements */}
-              {details.enum.map((val: string) => (
-                <span class="text-xs">
-                  <code class="bg-gray-100 px-1 rounded text-gray-800 font-thin py-0.5">{val}</code>
-                </span>
-              ))}
-            </div>
-          )
-        }
-      </div>
-
-      {
-        (hasNestedProperties || hasArrayItems) && (
-          // class:list with conditional object is standard and should be safe
-          <div id={contentId} class:list={['nested-content mt-1', { hidden: isCollapsible && !expand }]}>
-            {/* Recursive component calls */}
-            {hasNestedProperties &&
-              details.properties &&
-              Object.entries(details.properties).map(([nestedName, nestedDetails]) => (
-                <SchemaProp
-                  name={nestedName}
-                  details={nestedDetails}
-                  isRequired={details.required?.includes(nestedName) ?? false}
-                  level={level + 1}
-                  expand={expand}
-                />
-              ))}
-
-            {hasArrayItemProperties && (
-              <div class="mt-1 border-l border-dashed border-gray-400 pl-3 ml-1.5">
-                <span class="text-xs italic text-gray-500 block mb-1">Item Details:</span>
-                {details.items.properties &&
-                  Object.entries(details.items.properties).map(([itemPropName, itemPropDetails]) => (
-                    <SchemaProp
-                      name={itemPropName}
-                      details={itemPropDetails}
-                      isRequired={details.items.required?.includes(itemPropName) ?? false}
-                      level={level + 1}
-                      isListItem={true}
-                      expand={expand}
-                    />
-                  ))}
-                {(details.items.allOf || details.items.oneOf || details.items.$ref) && !details.items.properties && (
-                  <div class="text-xs text-gray-500 mt-1">
-                    Complex array item schema detected. The properties should be processed by the parent SchemaViewer.
-                  </div>
-                )}
-              </div>
-            )}
-          </div>
-        )
-      }
-    </div>
-  </div>
-</div>
-
-{/* Script tag content remains the same */}
-<script is:inline>
-  function setupPropertyToggle() {
-    document.querySelectorAll('.property-toggle').forEach((button) => {
-      if (button.dataset.listenerAttached) return;
-      button.dataset.listenerAttached = 'true';
-
-      button.addEventListener('click', () => {
-        const contentId = button.getAttribute('aria-controls');
-        const content = document.getElementById(contentId);
-        const isExpanded = button.getAttribute('aria-expanded') === 'true';
-        const iconCollapsed = button.querySelector('.icon-collapsed');
-        const iconExpanded = button.querySelector('.icon-expanded');
-
-        if (content) {
-          button.setAttribute('aria-expanded', String(!isExpanded));
-          content.classList.toggle('hidden');
-          iconCollapsed?.classList.toggle('hidden', !isExpanded);
-          iconExpanded?.classList.toggle('hidden', isExpanded);
-        }
-      });
-    });
-  }
-
-  setupPropertyToggle();
-
-  document.addEventListener('astro:page-load', setupPropertyToggle);
-</script>