@eventcatalog/core 2.42.10 → 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/page-loaders/hybrid-page.ts

@@ -0,0 +1,68 @@
+import type { AstroGlobal } from 'astro';
+import { isSSR } from '@utils/feature';
+
+/**
+ * Base class for all hybrid pages with static methods
+ */
+export class HybridPage<T = any> {
+  /**
+   * Static method for prerender setting
+   */
+  static get prerender(): boolean {
+    return !isSSR();
+  }
+
+  /**
+   * Static method for generating static paths
+   */
+  static async getStaticPaths(): Promise<Array<{ params: any; props: any }>> {
+    if (isSSR()) {
+      return [];
+    }
+    // Don't call this.generateStaticPaths() here - let each subclass implement this method directly
+    throw new Error('getStaticPaths must be implemented by subclass');
+  }
+
+  /**
+   * Static method for getting data
+   */
+  static async getData(astro: AstroGlobal): Promise<any> {
+    // Try props first (static mode)
+    if (astro.props && this.hasValidProps(astro.props)) {
+      return this.transformProps(astro.props);
+    }
+
+    const data = await this.fetchData(astro.params);
+
+    if (!data) {
+      throw this.createNotFoundResponse();
+    }
+
+    return data;
+  }
+
+  /**
+   * Methods to be overridden by subclasses
+   */
+  protected static async fetchData(params: any): Promise<any> {
+    throw new Error('fetchData must be implemented by subclass');
+  }
+
+  /**
+   * Override these static methods if needed
+   */
+  protected static hasValidProps(props: any): boolean {
+    return props && Object.keys(props).length > 0 && props.data;
+  }
+
+  protected static transformProps(props: any): any {
+    return props;
+  }
+
+  protected static createNotFoundResponse(): Response {
+    return new Response(null, {
+      status: 404,
+      statusText: 'Not found',
+    });
+  }
+}

package/eventcatalog/tsconfig.json

@@ -13,7 +13,8 @@
       "@utils/*": ["src/utils/*"],
       "@layouts/*": ["src/layouts/*"],
       "@enterprise/*": ["src/enterprise/*"],
-      "@ai/*": ["src/generated-ai/*"]
+      "@ai/*": ["src/generated-ai/*"],
+      "auth:config": ["./auth.config.ts"]
     },
     "jsx": "react-jsx",
     "jsxImportSource": "react",