@eventcatalog/core 5.0.0-beta.2 → 5.0.0-beta.21

package/eventcatalog/src/features/studio/tool-sync.ts

@@ -0,0 +1,75 @@
+import * as Y from 'yjs';
+import { applyAwarenessUpdate, encodeAwarenessUpdate, type Awareness } from 'y-protocols/awareness';
+import type { Status } from './hooks/use-studio-flow';
+
+/**
+ * Syncing a canvas through MCP tool calls, for when a view can't open the collaboration WebSocket
+ * (e.g. an MCP App inside a chat whose sandbox blocks it). Each call sends the server what it doesn't have
+ * yet (by its state vector) and our presence, and gets back what we don't have and everyone's presence.
+ * Slower than the WebSocket (it polls), but works wherever the chat can call the MCP server's tools.
+ */
+
+export type SyncRequest = {
+  canvasId: string;
+  clientId: number;
+  /** What we have, so the server sends only what we're missing */
+  stateVector: string;
+  /** What we have that the server doesn't (as of its last state vector) */
+  update: string;
+  /** Our presence (name, pointer, selection...) */
+  awareness: string;
+};
+export type SyncResponse = { update: string; stateVector: string; awareness?: string };
+export type ToolSync = (request: SyncRequest) => Promise<SyncResponse>;
+
+// Binary Yjs updates travel as base64 in tool arguments and results (atob/btoa exist in browsers and Node)
+export const toBase64 = (bytes: Uint8Array) => {
+  let text = '';
+  for (let i = 0; i < bytes.length; i += 0x8000) text += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
+  return btoa(text);
+};
+export const fromBase64 = (text: string) => Uint8Array.from(atob(text), (char) => char.charCodeAt(0));
+
+/** Applied with this origin, so undo (which tracks local changes) leaves other people's changes alone */
+const REMOTE = Symbol('tool-sync');
+
+export function startToolSync(
+  doc: Y.Doc,
+  awareness: Awareness,
+  {
+    canvasId,
+    sync,
+    onStatus,
+    intervalMs = 1000,
+  }: { canvasId: string; sync: ToolSync; onStatus: (status: Status) => void; intervalMs?: number }
+) {
+  let serverVector: Uint8Array | undefined;
+  let stopped = false;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+
+  const tick = async () => {
+    try {
+      const response = await sync({
+        canvasId,
+        clientId: doc.clientID,
+        stateVector: toBase64(Y.encodeStateVector(doc)),
+        update: toBase64(Y.encodeStateAsUpdate(doc, serverVector)),
+        awareness: toBase64(encodeAwarenessUpdate(awareness, [doc.clientID])),
+      });
+      if (stopped) return;
+      Y.applyUpdate(doc, fromBase64(response.update), REMOTE);
+      serverVector = fromBase64(response.stateVector);
+      if (response.awareness) applyAwarenessUpdate(awareness, fromBase64(response.awareness), REMOTE);
+      onStatus('connected');
+    } catch {
+      if (!stopped) onStatus('disconnected');
+    }
+    if (!stopped) timer = setTimeout(tick, intervalMs);
+  };
+  void tick();
+
+  return () => {
+    stopped = true;
+    clearTimeout(timer);
+  };
+}

package/eventcatalog/src/layouts/BaseLayout.astro

@@ -6,12 +6,12 @@ import NavigationProgress from '../components/NavigationProgress.astro';
 import config from '@config';
 
 interface Props {
-  title: string;
+  /** The page's own title; the catalog's title follows it (the homepage has none) */
+  title?: string;
   description?: string;
-  ogTitle?: string;
 }
 
-const { title, description, ogTitle } = Astro.props;
+const { title, description } = Astro.props;
 const catalogTheme = config.theme || 'default';
 ---
 
@@ -50,7 +50,7 @@ const catalogTheme = config.theme || 'default';
         document.addEventListener('astro:page-load', applyTheme);
       })();
     </script>
-    <SEO title={title} description={description} ogTitle={ogTitle} />
+    <SEO title={title} description={description} />
     <AnalyticsHead />
     <slot name="head" />
   </head>

package/eventcatalog/src/layouts/VerticalSideBarLayout.astro

@@ -1,6 +1,7 @@
 ---
 interface Props {
-  title: string;
+  /** The page's own title; the catalog's title follows it (the homepage has none) */
+  title?: string;
   sidebar?: boolean;
   description?: string;
   showNestedSideBar?: boolean;
@@ -52,7 +53,7 @@ import { buildUrl } from '@utils/url-builder';
 import { getQueries } from '@utils/collections/queries';
 import { getFirstNavigationPage } from '@features/custom-documentation/utils/custom-docs';
 
-import { isSSR } from '@utils/feature';
+import { isCanvasEnabled, isSSR } from '@utils/feature';
 
 const customDocs = await getCollection('customPages');
 const firstCustomDocsPage = customDocs.length > 0 ? await getFirstNavigationPage() : null;
@@ -241,7 +242,7 @@ const builtinNavigationItems: Record<string, Omit<VerticalNavigationItem, 'curre
   '/studio': {
     id: '/studio',
     matchId: '/studio',
-    label: 'EventCatalog Studio',
+    label: 'Studio',
     icon: 'SquareDashedMousePointer',
     href: buildUrl('/studio'),
   },
@@ -292,7 +293,12 @@ const builtinNavigationItems: Record<string, Omit<VerticalNavigationItem, 'curre
 const defaultNavigationGroups: NavigationGroupConfig[] = [
   {
     id: 'main',
-    items: [{ id: '/' }, { id: '/docs/custom', visible: customDocs.length > 0 }],
+    items: [
+      { id: '/' },
+      { id: '/docs/custom', visible: customDocs.length > 0 },
+      // Collaborative canvases, where they're on
+      { id: '/studio', visible: isCanvasEnabled() },
+    ],
   },
   {
     id: 'browse',
@@ -323,7 +329,6 @@ const isNavigationItemCurrent = (item: Pick<VerticalNavigationItem, 'href' | 'ma
     return (
       pathname === itemPath ||
       (pathname.includes('/docs') && !pathname.includes('/docs/custom')) ||
-      pathname.includes('/architecture/') ||
       pathname.includes('/visualiser') ||
       (pathname.includes('/schemas') && !pathname.includes('/schemas/explorer') && !pathname.includes('/schemas/fields'))
     );
@@ -372,6 +377,8 @@ const resolveNavigationItem = (item: NavigationItemConfig): VerticalNavigationIt
   if (item.visible === false) return null;
 
   const builtinId = navigationBuiltinAliases[item.id] || item.id;
+  // Studio is only there where canvases are on
+  if (builtinId === '/studio' && !item.href && !isCanvasEnabled()) return null;
   const builtin = builtinNavigationItems[builtinId];
   const href = item.href ? normalizeNavigationHref(item.href) : builtin?.href;
 
@@ -424,7 +431,7 @@ const { title, description, showNestedSideBar = true, showHeader = true, reduced
 const verticalNavAutoCollapsePaths = [buildUrl('/discover', true), buildUrl('/docs', true)];
 ---
 
-<BaseLayout title={`EventCatalog | ${title}`} description={description} ogTitle={title}>
+<BaseLayout title={title} description={description}>
   <Fragment slot="head">
     <script is:inline define:vars={{ verticalNavAutoCollapsePaths }}>
       (() => {
@@ -889,7 +896,6 @@ const verticalNavAutoCollapsePaths = [buildUrl('/discover', true), buildUrl('/do
       return (
         pathname === targetPath ||
         (pathname.includes('/docs') && !pathname.includes('/docs/custom')) ||
-        pathname.includes('/architecture/') ||
         pathname.includes('/visualiser') ||
         (pathname.includes('/schemas') && !pathname.includes('/schemas/explorer') && !pathname.includes('/schemas/fields'))
       );

package/eventcatalog/src/pages/_index.astro

@@ -134,7 +134,7 @@ const exploreCards: ExploreCard[] = [
 ];
 ---
 
-<VerticalSideBarLayout title="EventCatalog" showNestedSideBar={showNestedSideBar}>
+<VerticalSideBarLayout showNestedSideBar={showNestedSideBar}>
   <div class="ec-home min-h-screen">
     <!-- Hero -->
     <header class="ec-hero">

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

@@ -1,88 +1,77 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { loadArchitectureItems, Page } from './_index.data';
+import { Page } from './_index.data';
 
-const collectionMocks = vi.hoisted(() => ({
+const mocks = vi.hoisted(() => ({
+  isSSR: vi.fn(() => false),
   getDomains: vi.fn(),
   getServices: vi.fn(),
   getSystems: vi.fn(),
+  getOwnersWithResources: vi.fn(),
 }));
 
-vi.mock('@utils/feature', () => ({
-  isSSR: () => false,
-}));
+const loaders: Record<string, () => Promise<unknown>> = {
+  domains: () => mocks.getDomains(),
+  services: () => mocks.getServices(),
+  systems: () => mocks.getSystems(),
+};
 
-vi.mock('@utils/collections/domains', () => ({ getDomains: collectionMocks.getDomains }));
-vi.mock('@utils/collections/systems', () => ({ getSystems: collectionMocks.getSystems }));
-vi.mock('@utils/page-loaders/page-data-loader', () => ({
-  pageDataLoader: {
-    services: (...args: unknown[]) => collectionMocks.getServices(...args),
-    domains: (...args: unknown[]) => collectionMocks.getDomains(...args),
-    systems: (...args: unknown[]) => collectionMocks.getSystems(...args),
-  },
+vi.mock('@utils/feature', () => ({ isSSR: mocks.isSSR }));
+vi.mock('@utils/url-builder', () => ({ buildUrl: (path: string) => path }));
+vi.mock('@utils/collections/resource-owners', () => ({
+  createResourcesCatalog: () => ({}),
+  loadResourceOwners: (type: string) => loaders[type](),
+  getOwnersWithResources: mocks.getOwnersWithResources,
 }));
 
-const domain = {
-  collection: 'domains',
-  data: { id: 'ordering', name: 'Ordering', version: '1.0.0' },
-};
-
-const service = {
-  collection: 'services',
-  data: { id: 'order-service', name: 'Order Service', version: '1.0.0' },
-};
+const entry = (collection: string, id: string, version = '1.0.0') => ({ collection, data: { id, name: id, version } });
 
-const system = {
-  collection: 'systems',
-  data: { id: 'order-management-system', name: 'Order Management', version: '1.0.0' },
-};
+const ordering = entry('domains', 'ordering');
+const orderService = entry('services', 'order-service');
+const orderServiceV0 = entry('services', 'order-service', '0.1.0');
+const cartSystem = entry('systems', 'cart-system');
 
-describe('architecture page data', () => {
+describe('architecture page redirects', () => {
   beforeEach(() => {
-    collectionMocks.getDomains.mockReset().mockResolvedValue([domain]);
-    collectionMocks.getServices.mockReset().mockResolvedValue([service]);
-    collectionMocks.getSystems.mockReset().mockResolvedValue([system]);
+    mocks.isSSR.mockReturnValue(false);
+    mocks.getDomains.mockReset().mockResolvedValue([ordering]);
+    mocks.getServices.mockReset().mockResolvedValue([orderService, orderServiceV0]);
+    mocks.getSystems.mockReset().mockResolvedValue([cartSystem]);
+    // Only the latest order service and the cart system have a Resources page.
+    mocks.getOwnersWithResources.mockReset().mockImplementation(async (type: string) => {
+      if (type === 'services') return [orderService];
+      if (type === 'systems') return [cartSystem];
+      return [];
+    });
   });
 
-  it('hydrates domain and system services for static architecture paths', async () => {
+  it('redirects every architecture page to its Resources page, or the docs page when it has no Resources page', async () => {
     const paths = await Page.getStaticPaths();
 
-    expect(collectionMocks.getDomains).toHaveBeenCalledWith({ enrichServices: true });
-    expect(collectionMocks.getSystems).toHaveBeenCalledWith({ enrichServices: true });
-    expect(paths).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          params: { type: 'domains', id: 'ordering', version: '1.0.0' },
-        }),
-        expect.objectContaining({
-          params: { type: 'systems', id: 'order-management-system', version: '1.0.0' },
-        }),
-        expect.objectContaining({
-          params: { type: 'services', id: 'order-service', version: '1.0.0' },
-        }),
-      ])
-    );
+    expect(
+      paths.map(({ params, props }) => [`/architecture/${params.type}/${params.id}/${params.version}`, props.redirectPath])
+    ).toEqual([
+      ['/architecture/services/order-service/1.0.0', '/docs/services/order-service/1.0.0/resources'],
+      ['/architecture/services/order-service/0.1.0', '/docs/services/order-service/0.1.0'],
+      ['/architecture/domains/ordering/1.0.0', '/docs/domains/ordering/1.0.0'],
+      ['/architecture/systems/cart-system/1.0.0', '/docs/systems/cart-system/1.0.0/resources'],
+    ]);
   });
 
-  it('hydrates domain services when architecture pages are fetched in SSR', async () => {
-    await Page.getData({
-      props: {},
-      params: { type: 'domains', id: 'ordering', version: '1.0.0' },
-    } as any);
+  it('works out the redirect when the page is requested on a server', async () => {
+    mocks.isSSR.mockReturnValue(true);
 
-    expect(collectionMocks.getDomains).toHaveBeenCalledWith({ enrichServices: true });
+    await expect(
+      Page.getData({ params: { type: 'systems', id: 'cart-system', version: '1.0.0' }, props: {} } as any)
+    ).resolves.toMatchObject({ redirectPath: '/docs/systems/cart-system/1.0.0/resources' });
   });
 
-  it('hydrates system services when architecture pages are fetched in SSR', async () => {
-    await Page.getData({
-      props: {},
-      params: { type: 'systems', id: 'order-management-system', version: '1.0.0' },
-    } as any);
-
-    expect(collectionMocks.getSystems).toHaveBeenCalledWith({ enrichServices: true });
-  });
+  it('returns not found for resources without an architecture page', async () => {
+    mocks.isSSR.mockReturnValue(true);
 
-  it('loads domains with enrichServices so DomainGrid command links keep their collection', async () => {
-    await loadArchitectureItems('domains');
-    expect(collectionMocks.getDomains).toHaveBeenCalledWith({ enrichServices: true });
+    await expect(
+      Page.getData({ params: { type: 'events', id: 'order-created', version: '1.0.0' }, props: {} } as any)
+    ).rejects.toMatchObject({
+      status: 404,
+    });
   });
 });

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

@@ -1,53 +1,48 @@
 import { isSSR } from '@utils/feature';
 import { HybridPage } from '@utils/page-loaders/hybrid-page';
-import type { PageTypes } from '@types';
-import { pageDataLoader } from '@utils/page-loaders/page-data-loader';
-import { getDomains } from '@utils/collections/domains';
-import { getSystems } from '@utils/collections/systems';
+import {
+  createResourcesCatalog,
+  getOwnersWithResources,
+  loadResourceOwners,
+  type ResourcesCatalog,
+} from '@utils/collections/resource-owners';
+import type { ResourceOwner } from '@utils/collections/resources';
 
-const architecturePageTypes: PageTypes[] = ['services', 'domains', 'systems'];
+// The architecture overview pages were replaced by the Resources pages. These routes stay so
+// old links keep working: each one redirects to the resource's Resources page, or to its docs
+// page when it has nothing to list.
+const architecturePageTypes = ['services', 'domains', 'systems'] as const;
+type ArchitecturePageType = (typeof architecturePageTypes)[number];
 
-/**
- * Architecture grids render service sends/receives as docs links, so domains and
- * systems must hydrate those messages (collection + name). `pageDataLoader`
- * uses the cheaper unenriched path used by docs/sidebar.
- */
-export const loadArchitectureItems = (type: PageTypes) => {
-  if (type === 'domains') {
-    return getDomains({ enrichServices: true });
-  }
+const isArchitecturePageType = (type: string): type is ArchitecturePageType =>
+  architecturePageTypes.includes(type as ArchitecturePageType);
 
-  if (type === 'systems') {
-    return getSystems({ enrichServices: true });
-  }
+const key = (item: ResourceOwner) => `${item.data.id}:${item.data.version}`;
+
+const getRedirectPaths = async (type: ArchitecturePageType, catalog: ResourcesCatalog = createResourcesCatalog()) => {
+  const [items, ownersWithResources] = await Promise.all([loadResourceOwners(type), getOwnersWithResources(type, catalog)]);
+  const hasResourcesPage = new Set(ownersWithResources.map(key));
 
-  return pageDataLoader[type as PageTypes]();
+  return items.map((item) => {
+    const docsPath = `/docs/${type}/${item.data.id}/${item.data.version}`;
+    return { item, redirectPath: hasResourcesPage.has(key(item)) ? `${docsPath}/resources` : docsPath };
+  });
 };
 
-/**
- * Documentation page class for all collection types with versioning
- */
 export class Page extends HybridPage {
   static async getStaticPaths() {
     if (isSSR()) {
       return [];
     }
 
-    const pageData = await Promise.all(architecturePageTypes.map((type) => loadArchitectureItems(type)));
+    const catalog = createResourcesCatalog();
+    const redirects: Awaited<ReturnType<typeof getRedirectPaths>>[] = [];
+    for (const type of architecturePageTypes) redirects.push(await getRedirectPaths(type, catalog));
 
-    return pageData.flatMap((items, index) =>
-      items.map((item) => ({
-        params: {
-          type: architecturePageTypes[index],
-          id: item.data.id,
-          version: item.data.version,
-        },
-        props: {
-          type: architecturePageTypes[index],
-          ...item,
-          // Not everything needs the body of the page itself.
-          body: undefined,
-        },
+    return architecturePageTypes.flatMap((type, index) =>
+      redirects[index].map(({ item, redirectPath }) => ({
+        params: { type, id: item.data.id, version: item.data.version },
+        props: { type, data: { id: item.data.id, name: item.data.name, version: item.data.version }, redirectPath },
       }))
     );
   }
@@ -55,23 +50,16 @@ export class Page extends HybridPage {
   protected static async fetchData(params: any) {
     const { type, id, version } = params;
 
-    if (!type || !id || !version || !architecturePageTypes.includes(type)) {
+    if (!type || !id || !version || !isArchitecturePageType(type)) {
       return null;
     }
 
-    const items = await loadArchitectureItems(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) {
+    const match = (await getRedirectPaths(type)).find(({ item }) => item.data.id === id && item.data.version === version);
+    if (!match) {
       return null;
     }
 
-    return {
-      type,
-      ...item,
-    };
+    return { type, data: { id, name: match.item.data.name, version }, redirectPath: match.redirectPath };
   }
 
   protected static createNotFoundResponse(): Response {

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

@@ -1,38 +1,20 @@
 ---
-import DomainGrid from '@components/Grids/DomainGrid';
-import SystemGrid from '@components/Grids/SystemGrid';
-import MessageGrid from '@components/Grids/MessageGrid';
-import { getSpecificationsForService } from '@utils/collections/services';
-
-import VerticalSideBarLayout from '@layouts/VerticalSideBarLayout.astro';
+// The architecture overview pages were replaced by the Resources pages; this route only
+// redirects so old links keep working.
+import LatestVersionRedirect from '@components/LatestVersionRedirect.astro';
+import { isSSR } from '@utils/feature';
+import { buildUrl } from '@utils/url-builder';
 import { Page } from './_index.data';
 
 export const prerender = Page.prerender;
 export const getStaticPaths = Page.getStaticPaths;
 
-// Get data
-const props = await Page.getData(Astro);
-let domain = props;
-
-const pageTitle = `${props.type} | ${props.data.name}`.replace(/^\w/, (c) => c.toUpperCase());
-
-const type = props.type;
+const { data, redirectPath } = await Page.getData(Astro);
+const redirectUrl = buildUrl(redirectPath);
 
-const specifications = type === 'services' ? getSpecificationsForService(props) : [];
+if (isSSR()) {
+  return Astro.redirect(`${redirectUrl}${Astro.url.search}${Astro.url.hash}`, 301);
+}
 ---
 
-<VerticalSideBarLayout title={pageTitle}>
-  <main class="flex docs-layout min-h-full bg-[rgb(var(--ec-page-bg))]">
-    <div class="flex docs-layout w-full">
-      <div class="w-full min-w-0 lg:mr-2 xl:pr-12 py-8 bg-[rgb(var(--ec-page-bg))]">
-        {type === 'domains' && <DomainGrid domain={domain} client:load />}
-        {type === 'systems' && <SystemGrid system={props} client:load />}
-        {
-          (type === 'agents' || type === 'services') && (
-            <MessageGrid service={props} specifications={specifications} client:load />
-          )
-        }
-      </div>
-    </div>
-  </main>
-</VerticalSideBarLayout>
+<LatestVersionRedirect title={`${data.name} | Resources`} redirectUrl={redirectUrl} />

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

@@ -0,0 +1,79 @@
+---
+import VerticalSideBarLayout from '@layouts/VerticalSideBarLayout.astro';
+import { buildUrl } from '@utils/url-builder';
+import { isVisualiserEnabled } from '@utils/feature';
+import {
+  ResourcesTable,
+  type ResourceItem,
+} from '@components/Tables/Resources/ResourcesTable';
+import { getCollection } from 'astro:content';
+import {
+  getDocsPath,
+  getFavorite,
+  getResourceGroups,
+  getResourceRelationship,
+  getSchemaPath,
+  getVisualiserPath,
+  type ResourceOwner,
+  type ResourceOwnerCollection,
+} from '@utils/collections/resources';
+
+// Shared by the generic Resources route and the services route.
+interface Props {
+  resourceOwner: ResourceOwner;
+}
+
+const { resourceOwner } = Astro.props;
+const { data } = resourceOwner;
+const ownerCollection = resourceOwner.collection as ResourceOwnerCollection;
+
+// Only show resources directly attached to the owner. Domain child resources are not
+// flattened, so services inside a child system remain on that system's page.
+const resourceGroups = getResourceGroups(data, ownerCollection, resourceOwner);
+
+const withBaseUrl = (path: string | undefined) => (path ? buildUrl(path) : undefined);
+
+// Messages with an entry in the schemas collection have a schema page.
+const schemaKeys = new Set(
+  (await getCollection('schemas')).map(
+    ({ data: schema }) => `${schema.message.collectionName}:${schema.message.id}:${schema.message.version}`
+  )
+);
+
+const resources: ResourceItem[] = resourceGroups.flatMap(({ collection, items }) =>
+  items.map((item) => ({
+    collection,
+    id: item.data.id,
+    name: item.data.name || item.data.id,
+    version: item.data.version,
+    summary: item.data.summary,
+    icon: item.data?.styles?.icon,
+    href: buildUrl(getDocsPath(collection, item)),
+    visualiserHref: withBaseUrl(getVisualiserPath(collection, item, isVisualiserEnabled())),
+    schemaHref: withBaseUrl(getSchemaPath(collection, item, schemaKeys)),
+    favorite: getFavorite(collection, item),
+    relationship: getResourceRelationship(data, ownerCollection, collection, item, resourceOwner),
+  }))
+);
+---
+
+<VerticalSideBarLayout title={`${data.name} | Resources`}>
+  <style is:global>
+    :root[data-embedded='true'] #resources-page {
+      height: 100dvh !important;
+    }
+  </style>
+  {/* Like the discover pages: pull the table out of the content gutter and fill the viewport so it can paginate. */}
+  <main
+    id="resources-page"
+    class="flex h-full min-h-0 flex-col overflow-hidden bg-[rgb(var(--ec-page-bg))]"
+    style="margin-left: calc(var(--ec-app-content-padding-left, 5rem) * -1); margin-right: calc(var(--ec-app-content-padding-right, 5rem) * -1); height: calc(100dvh - 60px);"
+  >
+    <ResourcesTable
+      resources={resources}
+      title={`${data.name} Resources`}
+      description={`${resources.length} ${resources.length === 1 ? 'resource' : 'resources'} mapped to ${data.name}.`}
+      client:only="react"
+    />
+  </main>
+</VerticalSideBarLayout>

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

@@ -1,28 +1,46 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { loadResourceOwner } from './_index.data';
+import { Page, ServicePage } from './_index.data';
 
-const collectionMocks = vi.hoisted(() => ({
-  getDomains: vi.fn(() => Promise.resolve([])),
-  getSystems: vi.fn(() => Promise.resolve([])),
+const mocks = vi.hoisted(() => ({
+  getOwnersWithResources: vi.fn(),
+  findOwnerWithResources: vi.fn(),
 }));
 
-vi.mock('@utils/collections/domains', () => ({ getDomains: collectionMocks.getDomains }));
-vi.mock('@utils/collections/systems', () => ({ getSystems: collectionMocks.getSystems }));
+vi.mock('@utils/feature', () => ({ isSSR: () => false }));
+vi.mock('@utils/collections/resource-owners', () => ({
+  RESOURCE_OWNER_COLLECTIONS: ['domains', 'systems', 'services', 'flows', 'channels', 'events', 'commands', 'queries'],
+  createResourcesCatalog: () => ({}),
+  getOwnersWithResources: mocks.getOwnersWithResources,
+  findOwnerWithResources: mocks.findOwnerWithResources,
+}));
+
+const owner = (collection: string, id: string) => ({ collection, data: { id, version: '1.0.0' } });
 
-describe('Resources page owner loader', () => {
+describe('Resources routes', () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    mocks.getOwnersWithResources.mockReset().mockImplementation(async (type: string) => [owner(type, `${type}-owner`)]);
+    mocks.findOwnerWithResources.mockReset();
   });
 
-  it('loads domains without flattening child-subdomain services and agents', async () => {
-    await loadResourceOwner('domains');
+  // /docs/services/[id]/[docType]/[docId] would otherwise catch /docs/services/{id}/{version}/resources,
+  // so services get their own route and the generic route leaves them out.
+  it('gives every owner type but services a path on the generic route', async () => {
+    const paths = await Page.getStaticPaths();
 
-    expect(collectionMocks.getDomains).toHaveBeenCalledWith({ includeServicesInSubdomains: false });
+    expect(paths.map(({ params }) => params.type)).toEqual(['domains', 'systems', 'flows', 'channels', 'events', 'commands', 'queries']);
+    expect(paths[0]).toEqual({ params: { type: 'domains', id: 'domains-owner', version: '1.0.0' }, props: owner('domains', 'domains-owner') });
   });
 
-  it('keeps the system loader unchanged', async () => {
-    await loadResourceOwner('systems');
+  it('gives services their own route without a type param', async () => {
+    const paths = await ServicePage.getStaticPaths();
+
+    expect(paths).toEqual([{ params: { id: 'services-owner', version: '1.0.0' }, props: owner('services', 'services-owner') }]);
+  });
 
-    expect(collectionMocks.getSystems).toHaveBeenCalledWith();
+  it('returns not found for types without a Resources page on a server request', async () => {
+    await expect(Page.getData({ params: { type: 'entities', id: 'Order', version: '1.0.0' }, props: {} } as any)).rejects.toMatchObject({
+      status: 404,
+    });
+    expect(mocks.findOwnerWithResources).not.toHaveBeenCalled();
   });
 });