@eventcatalog/core 2.42.9 → 2.43.0

package/eventcatalog/src/pages/docs/[type]/[id]/[version]/spec/_[filename].data.ts

@@ -0,0 +1,99 @@
+// pages/docs/[type]/[id]/[version]/spec/[filename]/index.page.ts
+import { isSSR } from '@utils/feature';
+import { HybridPage } from '@utils/page-loaders/hybrid-page';
+import type { CollectionEntry } from 'astro:content';
+import type { CollectionTypes, PageTypes } from '@types';
+
+export class Page extends HybridPage {
+  static get prerender(): boolean {
+    return !isSSR();
+  }
+
+  static async getStaticPaths(): Promise<Array<{ params: any; props: any }>> {
+    if (isSSR()) {
+      return [];
+    }
+
+    const { pageDataLoader } = await import('@utils/page-loaders/page-data-loader');
+    const { getSpecificationsForService } = await import('@utils/collections/services');
+
+    const itemTypes: PageTypes[] = ['events', 'commands', 'queries', 'services', 'domains'];
+    const allItems = await Promise.all(itemTypes.map((type) => pageDataLoader[type]()));
+
+    const hasSpecifications = (item: CollectionEntry<CollectionTypes>) => {
+      const specifications = getSpecificationsForService(item);
+      // Ensure there is at least one 'openapi' specification
+      return specifications && specifications.some((spec) => spec.type === 'openapi');
+    };
+
+    const filteredItems = allItems.map((items) => items.filter(hasSpecifications));
+
+    return filteredItems.flatMap((items, index) =>
+      items.flatMap((item) => {
+        // Filter for openapi specifications only
+        const openApiSpecifications = getSpecificationsForService(item).filter((spec) => spec.type === 'openapi');
+
+        return openApiSpecifications.map((spec) => ({
+          params: {
+            type: itemTypes[index],
+            id: item.data.id,
+            version: item.data.version,
+            filename: spec.filenameWithoutExtension || spec.type,
+          },
+          props: {
+            type: itemTypes[index],
+            filenameWithoutExtension: spec.filenameWithoutExtension || spec.type,
+            filename: spec.filename || spec.type,
+            ...item,
+          },
+        }));
+      })
+    );
+  }
+
+  protected static async fetchData(params: any) {
+    const { type, id, version, filename } = params;
+
+    if (!type || !id || !version || !filename) {
+      return null;
+    }
+
+    const { pageDataLoader } = await import('@utils/page-loaders/page-data-loader');
+    const { getSpecificationsForService } = await import('@utils/collections/services');
+
+    // Get all items of the specified type
+    const items = await pageDataLoader[type as PageTypes]();
+
+    // Find the specific item by id and version
+    const item = items.find((i) => i.data.id === id && i.data.version === version);
+
+    if (!item) {
+      return null;
+    }
+
+    // Check if this item has OpenAPI specifications
+    const specifications = getSpecificationsForService(item);
+    const openApiSpecifications = specifications.filter((spec) => spec.type === 'openapi');
+
+    // Find the specific specification
+    const spec = openApiSpecifications.find((s) => (s.filenameWithoutExtension || s.type) === filename);
+
+    if (!spec) {
+      return null;
+    }
+
+    return {
+      type,
+      filenameWithoutExtension: spec.filenameWithoutExtension || spec.type,
+      filename: spec.filename || spec.type,
+      ...item,
+    };
+  }
+
+  protected static createNotFoundResponse(): Response {
+    return new Response(null, {
+      status: 404,
+      statusText: 'OpenAPI specification not found',
+    });
+  }
+}

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

@@ -44,6 +44,7 @@ export async function getStaticPaths() {
 }
 
 const props = Astro.props;
+
 const pageTitle = `${props.collection} | ${props.data.name}`.replace(/^\w/, (c) => c.toUpperCase());
 
 const { pathname } = Astro.url;

package/eventcatalog/src/pages/docs/[type]/[id]/language/_index.data.ts

@@ -0,0 +1,40 @@
+import { isSSR } from '@utils/feature';
+import { HybridPage } from '@utils/page-loaders/hybrid-page';
+
+/**
+ * Domain page class with static methods
+ */
+export class Page extends HybridPage {
+  static async getStaticPaths() {
+    if (isSSR()) {
+      return [];
+    }
+
+    const { getDomains } = await import('@utils/collections/domains');
+    const domains = await getDomains({ getAllVersions: false });
+
+    return domains.map((item) => ({
+      params: {
+        type: item.collection,
+        id: item.data.id,
+      },
+      props: {
+        type: item.collection,
+        ...item,
+      },
+    }));
+  }
+
+  protected static async fetchData(params: any) {
+    const { getDomains } = await import('@utils/collections/domains');
+    const domains = await getDomains({ getAllVersions: false });
+    return domains.find((d) => d.data.id === params.id && d.collection === params.type) || null;
+  }
+
+  protected static createNotFoundResponse(): Response {
+    return new Response(null, {
+      status: 404,
+      statusText: 'Domain not found',
+    });
+  }
+}

package/eventcatalog/src/pages/docs/[type]/[id]/{language.astro → language/index.astro}

@@ -1,35 +1,21 @@
 ---
 import Footer from '@layouts/Footer.astro';
 import VerticalSideBarLayout from '@layouts/VerticalSideBarLayout.astro';
-import { getDomains, type Domain, getUbiquitousLanguage } from '@utils/collections/domains';
+import { getUbiquitousLanguage } from '@utils/collections/domains';
 import { buildUrl } from '@utils/url-builder';
-import type { CollectionEntry } from 'astro:content';
 import { ClientRouter } from 'astro:transitions';
 import * as LucideIcons from 'lucide-react';
 
-export async function getStaticPaths() {
-  const domains = await getDomains({ getAllVersions: false });
+import { Page } from './_index.data';
 
-  const buildPages = (collection: CollectionEntry<'domains'>[]) => {
-    return collection.map((item) => ({
-      params: {
-        type: item.collection,
-        id: item.data.id,
-      },
-      props: {
-        type: item.collection,
-        ...item,
-      },
-    }));
-  };
+export const prerender = Page.prerender;
+export const getStaticPaths = Page.getStaticPaths;
 
-  return [...buildPages(domains)];
-}
+// Get data
+const props = await Page.getData(Astro);
 
-const props = Astro.props;
 const pageTitle = `${props.collection} | ${props.data.name}`.replace(/^\w/, (c) => c.toUpperCase());
 const ubiquitousLanguages = await getUbiquitousLanguage(props);
-
 const ubiquitousLanguage = ubiquitousLanguages[0];
 ---
 

package/eventcatalog/src/pages/docs/custom/[...path]/_index.data.ts

@@ -0,0 +1,49 @@
+// pages/docs/custom/[...path]/index.page.ts
+import { isSSR } from '@utils/feature';
+import { HybridPage } from '@utils/page-loaders/hybrid-page';
+
+export class Page extends HybridPage {
+  static get prerender(): boolean {
+    return !isSSR();
+  }
+
+  static async getStaticPaths(): Promise<Array<{ params: any; props: any }>> {
+    if (isSSR()) {
+      return [];
+    }
+
+    const { getCollection } = await import('astro:content');
+    const docs = await getCollection('customPages');
+
+    const paths = docs.map((doc) => ({
+      params: { path: doc.id.replace('docs/', '') },
+      props: doc,
+    }));
+
+    return paths;
+  }
+
+  protected static async fetchData(params: any) {
+    const { path } = params;
+
+    if (!path) {
+      return null;
+    }
+
+    const { getCollection } = await import('astro:content');
+    const docs = await getCollection('customPages');
+
+    // Find the specific doc by reconstructing the id
+    const docId = `docs/${Array.isArray(path) ? path.join('/') : path}`;
+    const doc = docs.find((d) => d.id === docId);
+
+    return doc || null;
+  }
+
+  protected static createNotFoundResponse(): Response {
+    return new Response(null, {
+      status: 404,
+      statusText: 'Custom documentation page not found',
+    });
+  }
+}

package/eventcatalog/src/pages/docs/custom/[...path]/index.astro

@@ -1,20 +1,14 @@
 ---
 import CustomDocumentationPage from '@enterprise/custom-documentation/pages/docs/custom/index.astro';
-import { getCollection } from 'astro:content';
 import { buildUrl } from '@utils/url-builder';
-import type { GetStaticPaths } from 'astro';
 import { isCustomDocsEnabled } from '@utils/feature';
+import { Page } from './_index.data';
 
-export const getStaticPaths = (async () => {
-  const docs = await getCollection('customPages');
-  const paths = docs.map((doc) => ({
-    params: { path: doc.id.replace('docs/', '') },
-    props: doc,
-  }));
-  return paths;
-}) satisfies GetStaticPaths;
+export const prerender = Page.prerender;
+export const getStaticPaths = Page.getStaticPaths;
 
-const props = Astro.props;
+// Get data
+const props = await Page.getData(Astro);
 
 if (!isCustomDocsEnabled()) {
   return Astro.redirect(buildUrl('/docs/custom/feature'));

package/eventcatalog/src/pages/docs/teams/[id]/_index.data.ts

@@ -0,0 +1,46 @@
+// pages/teams/[id]/index.page.ts
+import { isSSR } from '@utils/feature';
+import { HybridPage } from '@utils/page-loaders/hybrid-page';
+
+export class Page extends HybridPage {
+  static get prerender(): boolean {
+    return !isSSR();
+  }
+
+  static async getStaticPaths(): Promise<Array<{ params: any; props: any }>> {
+    if (isSSR()) {
+      return [];
+    }
+
+    const { getTeams } = await import('@utils/teams');
+    const teams = await getTeams();
+
+    return teams.map((team) => ({
+      params: { id: team.data.id },
+      props: team,
+    }));
+  }
+
+  protected static async fetchData(params: any) {
+    const { id } = params;
+
+    if (!id) {
+      return null;
+    }
+
+    const { getTeams } = await import('@utils/teams');
+    const teams = await getTeams();
+
+    // Find the specific team by id
+    const team = teams.find((t) => t.data.id === id);
+
+    return team || null;
+  }
+
+  protected static createNotFoundResponse(): Response {
+    return new Response(null, {
+      status: 404,
+      statusText: 'Team not found',
+    });
+  }
+}

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

@@ -2,7 +2,6 @@
 import components from '@components/MDX/components';
 
 // SideBars
-import { getTeams } from '@utils/teams';
 import { getEntry, render } from 'astro:content';
 import type { CollectionEntry } from 'astro:content';
 import OwnersList from '@components/Lists/OwnersList';
@@ -10,21 +9,18 @@ import PillListFlat from '@components/Lists/PillListFlat';
 import EnvelopeIcon from '@heroicons/react/16/solid/EnvelopeIcon';
 import { buildUrl } from '@utils/url-builder';
 import VerticalSideBarLayout from '@layouts/VerticalSideBarLayout.astro';
+import { Page } from './_index.data';
 
-export async function getStaticPaths() {
-  const teams = await getTeams();
+export const prerender = Page.prerender;
+export const getStaticPaths = Page.getStaticPaths;
 
-  return teams.map((team) => ({
-    params: { id: team.data.id },
-    props: team,
-  }));
-}
+// Get data
+const props = await Page.getData(Astro);
 
-const props = Astro.props;
 const { Content } = await render(props);
 
 const membersRaw = props.data.members || [];
-const members = (await Promise.all(membersRaw.map((m) => getEntry(m)))).filter(Boolean);
+const members = (await Promise.all(membersRaw.map((m: CollectionEntry<'teams'>) => getEntry(m)))).filter(Boolean);
 
 const domains = props.data.ownedDomains as CollectionEntry<'domains'>[];
 const services = props.data.ownedServices as CollectionEntry<'services'>[];

package/eventcatalog/src/pages/docs/users/[id]/_index.data.ts

@@ -0,0 +1,46 @@
+// pages/teams/[id]/index.page.ts
+import { isSSR } from '@utils/feature';
+import { HybridPage } from '@utils/page-loaders/hybrid-page';
+
+export class Page extends HybridPage {
+  static get prerender(): boolean {
+    return !isSSR();
+  }
+
+  static async getStaticPaths(): Promise<Array<{ params: any; props: any }>> {
+    if (isSSR()) {
+      return [];
+    }
+
+    const { getUsers } = await import('@utils/users');
+    const users = await getUsers();
+
+    return users.map((user) => ({
+      params: { id: user.data.id },
+      props: user,
+    }));
+  }
+
+  protected static async fetchData(params: any) {
+    const { id } = params;
+
+    if (!id) {
+      return null;
+    }
+
+    const { getUsers } = await import('@utils/users');
+    const users = await getUsers();
+
+    // Find the specific team by id
+    const user = users.find((u) => u.data.id === id);
+
+    return user || null;
+  }
+
+  protected static createNotFoundResponse(): Response {
+    return new Response(null, {
+      status: 404,
+      statusText: 'User not found',
+    });
+  }
+}

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

@@ -6,21 +6,17 @@ import { render } from 'astro:content';
 import type { CollectionEntry } from 'astro:content';
 import OwnersList from '@components/Lists/OwnersList';
 import PillListFlat from '@components/Lists/PillListFlat';
-import { getUsers } from '@utils/users';
 import EnvelopeIcon from '@heroicons/react/16/solid/EnvelopeIcon';
 import { buildUrl } from '@utils/url-builder';
 import VerticalSideBarLayout from '@layouts/VerticalSideBarLayout.astro';
+import { Page } from './_index.data';
 
-export async function getStaticPaths() {
-  const users = await getUsers();
+export const prerender = Page.prerender;
+export const getStaticPaths = Page.getStaticPaths;
 
-  return users.map((user) => ({
-    params: { id: user.data.id },
-    props: user,
-  }));
-}
+// Get data
+const props = await Page.getData(Astro);
 
-const props = Astro.props;
 const { Content } = await render(props);
 
 const domains = props.data.ownedDomains as CollectionEntry<'domains'>[];

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

@@ -0,0 +1,99 @@
+// pages/visualiser/[type]/[id]/[version]/index.page.ts
+import { HybridPage } from '@utils/page-loaders/hybrid-page';
+import { isAuthEnabled } from '@utils/feature';
+import type { PageTypes } from '@types';
+import { pageDataLoader } from '@utils/page-loaders/page-data-loader';
+
+type PageTypesWithFlows = PageTypes | 'flows';
+
+export class Page extends HybridPage {
+  static async getStaticPaths(): Promise<Array<{ params: any; props: any }>> {
+    if (isAuthEnabled()) {
+      return [];
+    }
+
+    const { getFlows } = await import('@utils/collections/flows');
+
+    const loaders = {
+      ...pageDataLoader,
+      flows: getFlows,
+    };
+
+    const itemTypes: PageTypesWithFlows[] = ['events', 'commands', 'queries', 'services', 'domains', 'flows'];
+    const allItems = await Promise.all(itemTypes.map((type) => loaders[type]()));
+
+    return allItems.flatMap((items, index) =>
+      items
+        .filter((item) => item.data.visualiser !== false)
+        .map((item) => ({
+          params: {
+            type: itemTypes[index],
+            id: item.data.id,
+            version: item.data.version,
+          },
+          props: {
+            type: itemTypes[index],
+            ...item,
+          },
+        }))
+    );
+  }
+
+  protected static async fetchData(params: any) {
+    const { type, id, version } = params;
+
+    if (!type || !id || !version) {
+      return null;
+    }
+
+    const { getFlows } = await import('@utils/collections/flows');
+
+    const loaders = {
+      ...pageDataLoader,
+      flows: getFlows,
+    };
+
+    // Get all items of the specified type
+    const items = await loaders[type as PageTypesWithFlows]();
+
+    // Find the specific item by id and version
+    const item = items.find((i) => i.data.id === id && i.data.version === version && i.data.visualiser !== false);
+
+    if (!item) {
+      return null;
+    }
+
+    return {
+      type,
+      ...item,
+    };
+  }
+
+  protected static createNotFoundResponse(): Response {
+    return new Response(null, {
+      status: 404,
+      statusText: 'Visualiser page not found',
+    });
+  }
+
+  static get clientAuthScript(): string {
+    if (!isAuthEnabled()) {
+      return '';
+    }
+
+    return `
+      if (typeof window !== 'undefined' && !import.meta.env.SSR) {
+        fetch('/api/auth/session')
+          .then(res => res.json())
+          .then(session => {
+            if (!session?.user) {
+              window.location.href = '/auth/login?callbackUrl=' + encodeURIComponent(window.location.pathname);
+            }
+          })
+          .catch(() => {
+            window.location.href = '/auth/login?callbackUrl=' + encodeURIComponent(window.location.pathname);
+          });
+      }
+    `;
+  }
+}

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

@@ -2,40 +2,16 @@
 import NodeGraph from '@components/MDX/NodeGraph/NodeGraph.astro';
 import VisualiserLayout from '@layouts/VisualiserLayout.astro';
 import type { PageTypes } from '@types';
-import { getFlows } from '@utils/collections/flows';
 import { buildUrl } from '@utils/url-builder';
-
-import { pageDataLoader } from '@utils/page-loaders/page-data-loader';
 import { ClientRouter } from 'astro:transitions';
-type PageTypesWithFlows = PageTypes | 'flows';
-
-export async function getStaticPaths() {
-  const loaders = {
-    ...pageDataLoader,
-    flows: getFlows,
-  };
 
-  const itemTypes: PageTypesWithFlows[] = ['events', 'commands', 'queries', 'services', 'domains', 'flows'];
-  const allItems = await Promise.all(itemTypes.map((type) => loaders[type]()));
+import { Page } from './_index.data';
 
-  return allItems.flatMap((items, index) =>
-    items
-      .filter((item) => item.data.visualiser !== false)
-      .map((item) => ({
-        params: {
-          type: itemTypes[index],
-          id: item.data.id,
-          version: item.data.version,
-        },
-        props: {
-          type: itemTypes[index],
-          ...item,
-        },
-      }))
-  );
-}
+export const prerender = Page.prerender;
+export const getStaticPaths = Page.getStaticPaths;
 
-const props = Astro.props;
+// Get data
+const props = await Page.getData(Astro);
 
 const {
   data: { id },

package/eventcatalog/src/utils/feature.ts

@@ -12,6 +12,8 @@
  */
 
 import config from '@config';
+import fs from 'fs';
+import { join } from 'path';
 
 // These functions check for valid, legally obtained access to premium features
 export const isEventCatalogStarterEnabled = () => process.env.EVENTCATALOG_STARTER === 'true';
@@ -42,3 +44,11 @@ export const isEventCatalogUpgradeEnabled = () => !isEventCatalogStarterEnabled(
 export const isCustomLandingPageEnabled = () => isEventCatalogStarterEnabled() || isEventCatalogScaleEnabled();
 
 export const isMarkdownDownloadEnabled = () => config?.llmsTxt?.enabled ?? false;
+
+export const isAuthEnabled = () => {
+  const directory = process.env.PROJECT_DIR || process.cwd();
+  const hasAuthConfig = fs.existsSync(join(directory, 'eventcatalog.auth.js'));
+  return (hasAuthConfig && isSSR() && isEventCatalogScaleEnabled()) || false;
+};
+
+export const isSSR = () => config?.output === 'server';

package/eventcatalog/src/utils/node-graphs/domains-node-graph.ts

@@ -17,6 +17,7 @@ type DagreGraph = any;
 
 interface Props {
   defaultFlow?: DagreGraph;
+  channelRenderMode?: 'single' | 'flat';
 }
 
 export const getNodesAndEdgesForDomainContextMap = async ({ defaultFlow = null }: Props) => {
@@ -214,9 +215,17 @@ interface NodesAndEdgesProps {
   defaultFlow?: DagreGraph;
   mode: 'simple' | 'full';
   group?: boolean;
+  channelRenderMode?: 'single' | 'flat';
 }
 
-export const getNodesAndEdges = async ({ id, version, defaultFlow, mode = 'simple', group = false }: NodesAndEdgesProps) => {
+export const getNodesAndEdges = async ({
+  id,
+  version,
+  defaultFlow,
+  mode = 'simple',
+  group = false,
+  channelRenderMode = 'flat',
+}: NodesAndEdgesProps) => {
   const flow = defaultFlow || createDagreGraph({ ranksep: 360, nodesep: 50, edgesep: 50 });
   let nodes = new Map(),
     edges = new Map();
@@ -257,6 +266,7 @@ export const getNodesAndEdges = async ({ id, version, defaultFlow, mode = 'simpl
       defaultFlow: flow,
       mode,
       renderAllEdges: true,
+      channelRenderMode,
     });
     serviceNodes.forEach((n) => {
       /**
@@ -280,6 +290,7 @@ export const getNodesAndEdges = async ({ id, version, defaultFlow, mode = 'simpl
       defaultFlow: flow,
       mode,
       group: true,
+      channelRenderMode,
     });
     subDomainNodes.forEach((n) => {
       nodes.set(n.id, nodes.has(n.id) ? merge(nodes.get(n.id), n) : n);

package/eventcatalog/src/utils/node-graphs/services-node-graph.ts

@@ -20,6 +20,7 @@ interface Props {
   defaultFlow?: DagreGraph;
   mode?: 'simple' | 'full';
   renderAllEdges?: boolean;
+  channelRenderMode?: 'single' | 'flat';
 }
 
 const getSendsMessageByMessageType = (messageType: string) => {
@@ -47,7 +48,14 @@ const getReceivesMessageByMessageType = (messageType: string) => {
   }
 };
 
-export const getNodesAndEdges = async ({ id, defaultFlow, version, mode = 'simple', renderAllEdges = false }: Props) => {
+export const getNodesAndEdges = async ({
+  id,
+  defaultFlow,
+  version,
+  mode = 'simple',
+  renderAllEdges = false,
+  channelRenderMode = 'flat',
+}: Props) => {
   const flow = defaultFlow || createDagreGraph({ ranksep: 300, nodesep: 50 });
   const nodes = [] as any,
     edges = [] as any;
@@ -111,6 +119,7 @@ export const getNodesAndEdges = async ({ id, defaultFlow, version, mode = 'simpl
         target: service,
         mode,
         currentNodes: nodes,
+        channelRenderMode,
       });
 
       nodes.push(...channelNodes);
@@ -158,6 +167,7 @@ export const getNodesAndEdges = async ({ id, defaultFlow, version, mode = 'simpl
         sourceToChannelLabel: `${getSendsMessageByMessageType(send?.collection)}`,
         channelToTargetLabel: getSendsMessageByMessageType(send?.collection),
         currentNodes: nodes,
+        channelRenderMode,
       });
       nodes.push(...channelNodes);
       edges.push(...channelEdges);