@eventcatalog/core 2.42.10 → 2.43.1

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

@@ -0,0 +1,98 @@
+// pages/docs/[type]/[id]/[version]/asyncapi/[filename]/index.page.ts
+import { isSSR, isAuthEnabled } 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 'asyncapi' specification
+      return specifications && specifications.some((spec) => spec.type === 'asyncapi');
+    };
+
+    const filteredItems = allItems.map((items) => items.filter(hasSpecifications));
+
+    return filteredItems.flatMap((items, index) =>
+      items.flatMap((item) => {
+        const asyncApiSpecifications = getSpecificationsForService(item).filter((spec) => spec.type === 'asyncapi');
+
+        return asyncApiSpecifications.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 AsyncAPI specifications
+    const specifications = getSpecificationsForService(item);
+    const asyncApiSpecifications = specifications.filter((spec) => spec.type === 'asyncapi');
+
+    // Find the specific specification
+    const spec = asyncApiSpecifications.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: 'AsyncAPI specification not found',
+    });
+  }
+}

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

@@ -0,0 +1,68 @@
+import { isSSR } from '@utils/feature';
+import { HybridPage } from '@utils/page-loaders/hybrid-page';
+import type { 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 itemTypes: PageTypes[] = ['events', 'commands', 'queries', 'services', 'domains', 'flows'];
+    const allItems = await Promise.all(itemTypes.map((type) => pageDataLoader[type]()));
+
+    return allItems.flatMap((items, index) =>
+      items.map((item) => ({
+        params: {
+          type: itemTypes[index],
+          id: item.data.id,
+          version: item.data.version,
+        },
+        props: {
+          type: itemTypes[index],
+          allCollectionItems: items,
+          ...item,
+        },
+      }))
+    );
+  }
+
+  protected static async fetchData(params: any) {
+    const { type, id, version } = params;
+
+    if (!type || !id || !version) {
+      return null;
+    }
+
+    const { pageDataLoader } = await import('@utils/page-loaders/page-data-loader');
+
+    // 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;
+    }
+
+    return {
+      type,
+      allCollectionItems: items,
+      ...item,
+    };
+  }
+
+  protected static createNotFoundResponse(): Response {
+    return new Response(null, {
+      status: 404,
+      statusText: 'Changelog not found',
+    });
+  }
+}

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

@@ -1,6 +1,5 @@
 ---
 import Footer from '@layouts/Footer.astro';
-import type { PageTypes } from '@types';
 import { getChangeLogs } from '@utils/collections/changelogs';
 import {
   RectangleGroupIcon,
@@ -10,7 +9,6 @@ import {
   MagnifyingGlassIcon,
   QueueListIcon,
 } from '@heroicons/react/24/outline';
-import { pageDataLoader } from '@utils/page-loaders/page-data-loader';
 import { render, getEntry } from 'astro:content';
 import mdxComponents from '@components/MDX/components';
 import 'diff2html/bundles/css/diff2html.min.css';
@@ -20,38 +18,20 @@ import { getPreviousVersion } from '@utils/collections/util';
 import { getDiffsForCurrentAndPreviousVersion } from '@utils/collections/file-diffs';
 import VerticalSideBarLayout from '@layouts/VerticalSideBarLayout.astro';
 import { ClientRouter } from 'astro:transitions';
-
 import { isChangelogEnabled } from '@utils/feature';
 
-export async function getStaticPaths() {
-  if (!isChangelogEnabled()) {
-    return [];
-  }
+import { Page } from './_index.data';
 
-  const itemTypes: PageTypes[] = ['events', 'commands', 'queries', 'services', 'domains', 'flows'];
-  const allItems = await Promise.all(itemTypes.map((type) => pageDataLoader[type]()));
+export const prerender = Page.prerender;
+export const getStaticPaths = Page.getStaticPaths;
 
-  return allItems.flatMap((items, index) =>
-    items.map((item) => ({
-      params: {
-        type: itemTypes[index],
-        id: item.data.id,
-        version: item.data.version,
-      },
-      props: {
-        type: itemTypes[index],
-        allCollectionItems: items,
-        ...item,
-      },
-    }))
-  );
-}
+// Get data
+const props = await Page.getData(Astro);
 
 if (!isChangelogEnabled()) {
   return Astro.redirect('/docs');
 }
 
-const props = Astro.props;
 let collectionItem = props;
 const logs = await getChangeLogs(props);
 

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

@@ -31,7 +31,6 @@ import {
 } from '@heroicons/react/24/outline';
 import { ArrowsRightLeftIcon } from '@heroicons/react/20/solid';
 import { Box, Boxes } from 'lucide-react';
-import type { PageTypes } from '@types';
 import type { CollectionTypes } from '@types';
 
 import { ClientRouter } from 'astro:transitions';
@@ -40,7 +39,6 @@ import type { CollectionEntry } from 'astro:content';
 
 import { getIcon } from '@utils/badges';
 import { getDeprecatedDetails } from '@utils/collections/util';
-import { pageDataLoader } from '@utils/page-loaders/page-data-loader';
 import { buildUrl } from '@utils/url-builder';
 import { getSchemasFromResource } from '@utils/collections/schemas';
 import { isEventCatalogChatEnabled, isMarkdownDownloadEnabled } from '@utils/feature';
@@ -48,38 +46,21 @@ import { isEventCatalogChatEnabled, isMarkdownDownloadEnabled } from '@utils/fea
 import { getMDXComponentsByName } from '@utils/markdown';
 
 import config from '@config';
+import { Page } from './_index.data';
 
-export async function getStaticPaths() {
-  const itemTypes: PageTypes[] = ['events', 'commands', 'queries', 'services', 'domains', 'flows', 'channels', 'entities'];
-  const allItems = await Promise.all(itemTypes.map((type) => pageDataLoader[type]()));
+export const prerender = Page.prerender;
+export const getStaticPaths = Page.getStaticPaths;
 
-  return allItems.flatMap((items, index) =>
-    items.map((item) => ({
-      params: {
-        type: itemTypes[index],
-        id: item.data.id,
-        version: item.data.version,
-      },
-      props: {
-        type: itemTypes[index],
-        ...item,
-      },
-    }))
-  );
-}
-
-const props = Astro.props;
+// Get data
+const props = await Page.getData(Astro);
 
 const { Content } = await render(props);
 
-// const { Content } = await props.render();
-
-// Capitalize the first letter of a string
 const pageTitle = `${props.collection} | ${props.data.name}`.replace(/^\w/, (c) => c.toUpperCase());
 const contentBadges = props.data.badges || [];
 
 const getContentBadges = () =>
-  contentBadges.map((badge) => ({
+  contentBadges.map((badge: any) => ({
     ...badge,
     icon: badge.icon ? getIcon(badge.icon) : null,
   }));

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

@@ -11,45 +11,16 @@ import { pageDataLoader } from '@utils/page-loaders/page-data-loader';
 import VerticalSideBarLayout from '@layouts/VerticalSideBarLayout.astro';
 import { getSpecificationsForService } from '@utils/collections/services';
 import './_styles.css';
+import { Page } from './_[filename].data.ts';
 
-export async function getStaticPaths() {
-  const itemTypes: PageTypes[] = ['events', 'commands', 'queries', 'services', 'domains'];
+export const prerender = Page.prerender;
+export const getStaticPaths = Page.getStaticPaths;
 
-  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,
-        },
-      }));
-    })
-  );
-}
+// Get data
+const props = await Page.getData(Astro);
 
 // @ts-ignore
-const { collection, data, catalog, filePath, filename } = Astro.props;
+const { collection, data, catalog, filePath, filename } = props;
 const fileName = filename || 'openapi.yml';
 
 const directory = path.dirname(filePath || '');

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',
+    });
+  }
+}