@eventcatalog/core 2.42.10 → 2.43.1

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",

package/package.json

@@ -6,7 +6,7 @@
     "url": "https://github.com/event-catalog/eventcatalog.git"
   },
   "type": "module",
-  "version": "2.42.10",
+  "version": "2.43.1",
   "publishConfig": {
     "access": "public"
   },
@@ -33,6 +33,7 @@
     "@asyncapi/avro-schema-parser": "^3.0.24",
     "@asyncapi/parser": "^3.4.0",
     "@asyncapi/react-component": "^2.4.3",
+    "@auth/core": "^0.37.4",
     "@eventcatalog/generator-ai": "^1.1.0",
     "@eventcatalog/sdk": "^2.2.7",
     "@fontsource/inter": "^5.2.5",
@@ -58,6 +59,7 @@
     "astro-expressive-code": "^0.40.1",
     "astro-pagefind": "^1.6.0",
     "astro-seo": "^0.8.4",
+    "auth-astro": "^4.2.0",
     "axios": "^1.7.7",
     "boxen": "^8.0.1",
     "commander": "^12.1.0",

package/dist/{chunk-SLEMYHTU.js → chunk-SFA7F3CQ.js}

@@ -1,9 +1,9 @@
-import {
-  verifyRequiredFieldsAreInCatalogConfigFile
-} from "./chunk-E7TXTI7G.js";
 import {
   mapCatalogToAstro
 } from "./chunk-EXAALOQA.js";
+import {
+  verifyRequiredFieldsAreInCatalogConfigFile
+} from "./chunk-E7TXTI7G.js";
 
 // src/catalog-to-astro-content-directory.js
 import { glob } from "glob";