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

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

@@ -1,71 +1,11 @@
 ---
-import Footer from '@layouts/Footer.astro';
-import VerticalSideBarLayout from '@layouts/VerticalSideBarLayout.astro';
-import { buildUrl } from '@utils/url-builder';
-import {
-  SystemResourcesTable,
-  type SystemResourceItem,
-  type SystemResourceCollection,
-} from '@components/Tables/SystemResources/SystemResourcesTable';
-import { getResourceGroups, type ResourceOwnerCollection } from './_resources';
-
+import ResourcesPage from './_ResourcesPage.astro';
 import { Page } from './_index.data';
 
 export const prerender = Page.prerender;
 export const getStaticPaths = Page.getStaticPaths;
 
 const resourceOwner = await Page.getData(Astro);
-const { data } = resourceOwner;
-const ownerCollection = resourceOwner.collection as ResourceOwnerCollection;
-
-// Only show resources directly attached to this system/domain. Domain child resources
-// are not flattened, so services inside a child system remain on that system's page.
-const resourceGroups = getResourceGroups(data, ownerCollection);
-
-const hrefForResource = (collection: SystemResourceCollection, id: string, version: string) => {
-  if (collection === 'entities') {
-    return buildUrl(`/docs/entities/${id}/${version}`);
-  }
-  return buildUrl(`/docs/${collection}/${id}/${version}`);
-};
-
-const ownerTypeLabel = ownerCollection === 'domains' ? 'Domain' : 'System';
-
-const resources: SystemResourceItem[] = resourceGroups.flatMap(({ collection, items }) =>
-  items.map((item: any) => ({
-    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: hrefForResource(collection, item.data.id, item.data.version),
-  }))
-);
 ---
 
-<VerticalSideBarLayout title={`${data.name} | Resources`}>
-  <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))]">
-        {/* Header mirrors the resource page (docs/[type]/[id]/[version]/index.astro). */}
-        <div class="border-b border-[rgb(var(--ec-page-border))] md:pb-3 pt-4">
-          <div class="flex flex-col gap-4">
-            <span class="text-xs md:text-sm font-semibold text-[rgb(var(--ec-accent))] capitalize">{ownerTypeLabel}</span>
-            <h2 id="doc-page-header" class="text-2xl md:text-4xl font-bold text-[rgb(var(--ec-page-text))]">
-              {data.name} Resources
-            </h2>
-          </div>
-          <p class="text-base pt-4 pb-1 text-[rgb(var(--ec-page-text-muted))] font-light">
-            {resources.length} {resources.length === 1 ? 'resource' : 'resources'} mapped to the {data.name}{' '}
-            {ownerTypeLabel.toLowerCase()}.
-          </p>
-        </div>
-
-        <div class="pt-8 pb-4 w-full">
-          <SystemResourcesTable resources={resources} client:only="react" />
-        </div>
-      </div>
-    </div>
-  </main>
-</VerticalSideBarLayout>
+<ResourcesPage resourceOwner={resourceOwner} />

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

@@ -0,0 +1,13 @@
+---
+// Services need their own Resources route: /docs/services/[id]/[docType]/[docId] outranks
+// the generic /docs/[type]/[id]/[version]/resources route and would catch these URLs.
+import ResourcesPage from '../../../../[type]/[id]/[version]/resources/_ResourcesPage.astro';
+import { ServicePage } from '../../../../[type]/[id]/[version]/resources/_index.data';
+
+export const prerender = ServicePage.prerender;
+export const getStaticPaths = ServicePage.getStaticPaths;
+
+const resourceOwner = await ServicePage.getData(Astro);
+---
+
+<ResourcesPage resourceOwner={resourceOwner} />

package/eventcatalog/src/stores/sidebar-store/builders/domain.ts

@@ -11,6 +11,7 @@ import {
   buildDiagramNavItems,
   buildResourceDocsSection,
   buildArchitectureDecisionsSection,
+  buildResourcesLink,
 } from './shared';
 import { isVisualiserEnabled, isChangelogEnabled } from '@utils/feature';
 import { pluralizeMessageType } from '@utils/collections/messages';
@@ -131,19 +132,6 @@ export const buildDomainSections = (
   const sortedReceivesMessages = [...receivesMessages].sort(byResourceName);
   const renderMessages = shouldRenderSideBarSection(domain, 'messages');
 
-  // The Resources page/link only makes sense when the domain has direct resources.
-  // Keep this aligned with the resource groups rendered by the page.
-  const hasResources =
-    subDomains.length > 0 ||
-    systemsInDomain.length > 0 ||
-    agentsInDomain.length > 0 ||
-    dataProductsInDomain.length > 0 ||
-    allServicesInDomain.length > 0 ||
-    domainFlows.length > 0 ||
-    entitiesInDomain.length > 0 ||
-    sendsMessages.length > 0 ||
-    receivesMessages.length > 0;
-
   // Diagrams
   const domainDiagrams = domain.data.diagrams || [];
   const diagramNavItems = buildDiagramNavItems(domainDiagrams, context.diagrams);
@@ -223,10 +211,7 @@ export const buildDomainSections = (
     'quick-reference': buildQuickReferenceSection(
       [
         { title: 'Overview', href: buildUrl(`/docs/domains/${domain.data.id}/${domain.data.version}`) },
-        hasResources && {
-          title: 'Domain Resources',
-          href: buildUrl(`/docs/domains/${domain.data.id}/${domain.data.version}/resources`),
-        },
+        buildResourcesLink(context, 'domains', domain.data.id, domain.data.version),
         renderUbiquitousLanguage && {
           title: 'Ubiquitous Language',
           href: buildUrl(`/docs/domains/${domain.data.id}/language`),
@@ -239,31 +224,28 @@ export const buildDomainSections = (
       ].filter(Boolean) as { title: string; href: string }[]
     ),
     documentation: docsSection,
-    architecture: {
-      type: 'group',
-      title: 'Architecture',
-      icon: 'Workflow',
-      pages: [
-        {
-          type: 'item',
-          title: 'Overview',
-          href: buildUrl(`/architecture/domains/${domain.data.id}/${domain.data.version}`),
-        },
-        // The domain's diagram, with levels from the domains it talks to down to
-        // its messages
-        renderVisualiser && {
-          type: 'item',
-          title: 'Diagram',
-          href: buildUrl(`/visualiser/domains/${domain.data.id}/${domain.data.version}`),
-        },
-        renderEntities &&
-          renderVisualiser && {
-            type: 'item',
-            title: 'Entity Diagram',
-            href: buildUrl(`/visualiser/domains/${domain.data.id}/${domain.data.version}/entity-map`),
-          },
-      ].filter(Boolean) as ChildRef[],
-    },
+    // Every Architecture link is a visualiser view, so the group is left out when the visualiser is off.
+    architecture: renderVisualiser
+      ? {
+          type: 'group',
+          title: 'Architecture',
+          icon: 'Workflow',
+          pages: [
+            // The domain's diagram, with levels from the domains it talks to down to
+            // its messages
+            {
+              type: 'item',
+              title: 'Diagram',
+              href: buildUrl(`/visualiser/domains/${domain.data.id}/${domain.data.version}`),
+            },
+            renderEntities && {
+              type: 'item',
+              title: 'Entity Diagram',
+              href: buildUrl(`/visualiser/domains/${domain.data.id}/${domain.data.version}/entity-map`),
+            },
+          ].filter(Boolean) as ChildRef[],
+        }
+      : null,
     diagrams: hasDiagrams
       ? {
           type: 'group',

package/eventcatalog/src/stores/sidebar-store/builders/flow.ts

@@ -6,6 +6,7 @@ import {
   buildResourceDocsSection,
   shouldRenderSideBarSection,
   buildArchitectureDecisionsSection,
+  buildResourcesLink,
 } from './shared';
 import { isChangelogEnabled } from '@utils/feature';
 import { createVersionedMap, findInMap } from '@utils/collections/util';
@@ -157,6 +158,7 @@ export const buildFlowSections = (flow: CollectionEntry<'flows'>, context: Resou
     'quick-reference': buildQuickReferenceSection(
       [
         { title: 'Overview', href: buildUrl(`/docs/flows/${flow.data.id}/${flow.data.version}`) },
+        buildResourcesLink(context, 'flows', flow.data.id, flow.data.version),
         isChangelogEnabled() &&
           shouldRenderSideBarSection(flow, 'changelog') && {
             title: 'Changelog',

package/eventcatalog/src/stores/sidebar-store/builders/message.ts

@@ -11,6 +11,7 @@ import {
   buildDiagramNavItems,
   buildResourceDocsSection,
   buildArchitectureDecisionsSection,
+  buildResourcesLink,
 } from './shared';
 import { isVisualiserEnabled, isChangelogEnabled } from '@utils/feature';
 import { iconFieldsForResource } from '@utils/icon';
@@ -137,6 +138,7 @@ export const buildMessageSections = (
           title: 'Overview',
           href: buildUrl(`/docs/${collection}/${message.data.id}/${message.data.version}`),
         },
+        buildResourcesLink(context, collection, message.data.id, message.data.version),
         isChangelogEnabled() &&
           shouldRenderSideBarSection(message, 'changelog') && {
             title: 'Changelog',

package/eventcatalog/src/stores/sidebar-store/builders/service.ts

@@ -13,6 +13,7 @@ import {
   buildDiagramNavItems,
   buildResourceDocsSection,
   buildArchitectureDecisionsSection,
+  buildResourcesLink,
 } from './shared';
 import { isVisualiserEnabled, isChangelogEnabled } from '@utils/feature';
 import { pluralizeMessageType } from '@utils/collections/messages';
@@ -98,6 +99,7 @@ export const buildServiceSections = (
   const hasAttachments = service.data.attachments && service.data.attachments.length > 0;
 
   const hasDataStores = dataStoresInService.length > 0;
+
   const resourceGroups = service.data.resourceGroups || [];
   const hasResourceGroups = resourceGroups.length > 0;
 
@@ -126,6 +128,7 @@ export const buildServiceSections = (
     'quick-reference': buildQuickReferenceSection(
       [
         { title: 'Overview', href: buildUrl(docsBasePath) },
+        buildResourcesLink(context, 'services', service.data.id, service.data.version),
         isChangelogEnabled() &&
           shouldRenderSideBarSection(service, 'changelog') && {
             title: 'Changelog',
@@ -134,29 +137,26 @@ export const buildServiceSections = (
       ].filter(Boolean) as { title: string; href: string }[]
     ),
     documentation: docsSection,
-    architecture: {
-      type: 'group',
-      title: 'Architecture',
-      icon: 'Workflow',
-      pages: [
-        {
-          type: 'item',
-          title: 'Overview',
-          href: buildUrl(`/architecture/services/${service.data.id}/${service.data.version}`),
-        },
-        renderVisualiser && {
-          type: 'item',
-          title: 'Diagram',
-          href: buildUrl(`/visualiser/services/${service.data.id}/${service.data.version}`),
-        },
-        renderVisualiser &&
-          renderEntities && {
-            type: 'item',
-            title: 'Entity Diagram',
-            href: buildUrl(`/visualiser/services/${service.data.id}/${service.data.version}/entity-map`),
-          },
-      ].filter(Boolean) as ChildRef[],
-    },
+    // Every Architecture link is a visualiser view, so the group is left out when the visualiser is off.
+    architecture: renderVisualiser
+      ? {
+          type: 'group',
+          title: 'Architecture',
+          icon: 'Workflow',
+          pages: [
+            {
+              type: 'item',
+              title: 'Diagram',
+              href: buildUrl(`/visualiser/services/${service.data.id}/${service.data.version}`),
+            },
+            renderEntities && {
+              type: 'item',
+              title: 'Entity Diagram',
+              href: buildUrl(`/visualiser/services/${service.data.id}/${service.data.version}/entity-map`),
+            },
+          ].filter(Boolean) as ChildRef[],
+        }
+      : null,
     diagrams: hasDiagrams
       ? {
           type: 'group',

package/eventcatalog/src/stores/sidebar-store/builders/shared.ts

@@ -79,8 +79,21 @@ export type ResourceGroupContext = {
   teams?: CollectionEntry<'teams'>[];
   resourceDocs: ResourceDocEntry[];
   resourceDocCategories: ResourceDocCategoryEntry[];
+  /** `collection:id:version` of every resource with a Resources page (see getResourcesPageKeys). */
+  resourcesPages?: Set<string>;
 };
 
+/** The Quick Reference link to a resource's Resources page, when it has one. */
+export const buildResourcesLink = (
+  context: Pick<ResourceGroupContext, 'resourcesPages'>,
+  collection: string,
+  id: string,
+  version: string
+) =>
+  context.resourcesPages?.has(`${collection}:${id}:${version}`)
+    ? { title: 'Resources', href: buildUrl(`/docs/${collection}/${id}/${version}/resources`) }
+    : false;
+
 export const buildQuickReferenceSection = (items: { title: string; href: string }[]): NavNode => ({
   type: 'group',
   title: 'Quick Reference',

package/eventcatalog/src/stores/sidebar-store/builders/system.ts

@@ -10,6 +10,7 @@ import {
   buildDiagramNavItems,
   buildResourceDocsSection,
   buildArchitectureDecisionsSection,
+  buildResourcesLink,
 } from './shared';
 import { isChangelogEnabled, isVisualiserEnabled } from '@utils/feature';
 import { customIconFieldsForResource } from '@utils/icon';
@@ -74,11 +75,6 @@ export const buildSystemSections = (
   const containersInSystem = [...(system.data.containers || [])].sort(byResourceName);
   const renderContainers = containersInSystem.length > 0 && shouldRenderSideBarSection(system, 'containers');
 
-  // The Resources page/link only makes sense when the system actually has resources
-  // attached (services, flows, entities or data stores). Mirrors what the page renders.
-  const hasResources =
-    servicesInSystem.length > 0 || flowsInSystem.length > 0 || entitiesInSystem.length > 0 || containersInSystem.length > 0;
-
   const systemDiagrams = system.data.diagrams || [];
   const diagramNavItems = buildDiagramNavItems(systemDiagrams, context.diagrams);
   const hasDiagrams = diagramNavItems.length > 0 && shouldRenderSideBarSection(system, 'diagrams');
@@ -138,10 +134,7 @@ export const buildSystemSections = (
           title: 'Overview',
           href: buildUrl(`/docs/systems/${system.data.id}/${system.data.version}`),
         },
-        hasResources && {
-          title: 'System Resources',
-          href: buildUrl(`/docs/systems/${system.data.id}/${system.data.version}/resources`),
-        },
+        buildResourcesLink(context, 'systems', system.data.id, system.data.version),
         isChangelogEnabled() &&
           shouldRenderSideBarSection(system, 'changelog') && {
             title: 'Changelog',
@@ -150,24 +143,22 @@ export const buildSystemSections = (
       ].filter(Boolean) as { title: string; href: string }[]
     ),
     documentation: docsSection,
-    architecture: {
-      type: 'group',
-      title: 'Architecture',
-      icon: 'Workflow',
-      pages: [
-        {
-          type: 'item',
-          title: 'Overview',
-          href: buildUrl(`/architecture/systems/${system.data.id}/${system.data.version}`),
-        },
-        // The system's diagram, with levels from its context down to its messages
-        renderVisualiser && {
-          type: 'item',
-          title: 'Diagram',
-          href: buildUrl(`/visualiser/systems/${system.data.id}/${system.data.version}`),
-        },
-      ].filter(Boolean) as ChildRef[],
-    },
+    // Every Architecture link is a visualiser view, so the group is left out when the visualiser is off.
+    architecture: renderVisualiser
+      ? {
+          type: 'group',
+          title: 'Architecture',
+          icon: 'Workflow',
+          pages: [
+            // The system's diagram, with levels from its context down to its messages
+            {
+              type: 'item',
+              title: 'Diagram',
+              href: buildUrl(`/visualiser/systems/${system.data.id}/${system.data.version}`),
+            },
+          ],
+        }
+      : null,
     diagrams: hasDiagrams
       ? {
           type: 'group',

package/eventcatalog/src/stores/sidebar-store/state.ts

@@ -38,9 +38,11 @@ import { iconFieldsForResource } from '@utils/icon';
 import {
   buildQuickReferenceSection,
   buildResourceDocsSection,
+  buildResourcesLink,
   shouldRenderSideBarSection,
   withArchitectureDecisionsSection,
 } from './builders/shared';
+import { getResourcesPageKeys } from '@utils/collections/resource-owners';
 import { isArchitectureGraphEnabled, isChangelogEnabled } from '@utils/feature';
 import { collectMessageIdsWithFieldUsage } from '@utils/collections/field-usage';
 
@@ -355,6 +357,8 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
     teams,
     resourceDocs,
     resourceDocCategories,
+    // Same rule the Resources pages are built from, so a link never points at a missing page.
+    resourcesPages: await getResourcesPageKeys(),
   };
 
   // Process all domains with their owners first (async)
@@ -801,6 +805,7 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
                   title: 'Overview',
                   href: buildUrl(`/docs/${channel.collection}/${channel.data.id}/${channel.data.version}`),
                 },
+                buildResourcesLink(context, 'channels', channel.data.id, channel.data.version),
                 isChangelogEnabled() &&
                   shouldRenderSideBarSection(channel, 'changelog') && {
                     title: 'Changelog',

package/eventcatalog/src/styles/tailwind.css

@@ -171,7 +171,7 @@
  * scanning, so we explicitly declare them here.
  *
  * Colors used: orange, blue, green, emerald, amber, violet, pink, purple, gray, yellow, teal, cyan, indigo
- * Used in: SchemaListItem, Grids/components, SchemaExplorer, MessageGrid
+ * Used in: SchemaListItem, SchemaExplorer
  */
 @source inline("bg-{orange,blue,green,emerald,amber,violet,pink,purple,gray,yellow,teal,cyan,indigo}-{50,100}");
 @source inline("bg-{orange,blue,green,emerald,amber,violet,pink,purple,gray,yellow,teal,cyan,indigo}-500/{10,20}");
@@ -180,7 +180,7 @@
 @source inline("ring-2");
 @source inline("ring-{orange,blue,green,emerald,amber,violet,pink,purple,gray,yellow,teal,cyan,indigo}-500");
 
-/* Border color variants for MessageGrid cards */
+/* Border color variants built at runtime (e.g. hover borders in MessageTableColumns) */
 @source inline("border-{orange,blue,green,emerald,amber,violet,pink,purple,gray,yellow,teal,cyan,indigo}-{200,300}");
 @source inline("{dark:,}border-{orange,blue,green,emerald,amber,violet,pink,purple,gray,yellow,teal,cyan,indigo}-500/{30,50}");
 @source inline("{hover:,dark:hover:,}border-{orange,blue,green,emerald,amber,violet,pink,purple,gray,yellow,teal,cyan,indigo}-{300,400,500,500/50}");

package/eventcatalog/src/utils/collections/channels.ts

@@ -1,6 +1,13 @@
 import { getCollection } from 'astro:content';
 import type { CollectionEntry } from 'astro:content';
-import { getItemsFromCollectionByIdAndSemverOrLatest, createVersionedMap, satisfies } from './util';
+import {
+  getItemsFromCollectionByIdAndSemverOrLatest,
+  createVersionedMap,
+  findInMap,
+  getVersionedMap,
+  satisfies,
+  uniqueResources,
+} from './util';
 import type { CollectionMessageTypes } from '@types';
 
 const CACHE_ENABLED = process.env.DISABLE_EVENTCATALOG_CACHE !== 'true';
@@ -195,3 +202,51 @@ export const getChannelChain = (
   }
   return [];
 };
+
+/**
+ * What a channel connects: the services and agents that send to it (`sends[].to`) or receive
+ * from it (`receives[].from`), and the messages that travel through it, from those pointers or
+ * from messages that list the channel (`data.messages` from getChannels). Pass raw entries:
+ * hydration resolves sends/receives to messages and drops the channel pointers. Pointers
+ * without a version mean the latest channel or message.
+ */
+export const getChannelConnections = (
+  channel: Channel,
+  catalog: {
+    endpoints: Array<CollectionEntry<'services'> | CollectionEntry<'agents'>>;
+    channels: Channel[];
+    messages: CollectionEntry<CollectionMessageTypes>[];
+  }
+) => {
+  const channelMap = getVersionedMap(catalog.channels);
+  const messageMap = getVersionedMap(catalog.messages);
+  const isThisChannel = (pointer: { id: string; version?: string }) => {
+    const match = findInMap(channelMap, pointer.id, pointer.version);
+    return match?.data.id === channel.data.id && match?.data.version === channel.data.version;
+  };
+
+  const producers: Array<CollectionEntry<'services'> | CollectionEntry<'agents'>> = [];
+  const consumers: Array<CollectionEntry<'services'> | CollectionEntry<'agents'>> = [];
+  const messages: CollectionEntry<CollectionMessageTypes>[] = [];
+  const addMessage = (pointer: { id: string; version?: string }) => {
+    const message = findInMap(messageMap, pointer.id, pointer.version);
+    if (message) messages.push(message);
+  };
+
+  for (const endpoint of catalog.endpoints) {
+    for (const send of (endpoint.data.sends || []) as any[]) {
+      if (!(send.to || []).some(isThisChannel)) continue;
+      producers.push(endpoint);
+      addMessage(send);
+    }
+    for (const receive of (endpoint.data.receives || []) as any[]) {
+      if (!(receive.from || []).some(isThisChannel)) continue;
+      consumers.push(endpoint);
+      addMessage(receive);
+    }
+  }
+
+  for (const message of (channel.data as any).messages || []) addMessage(message);
+
+  return { producers: uniqueResources(producers), consumers: uniqueResources(consumers), messages: uniqueResources(messages) };
+};

package/eventcatalog/src/utils/collections/flows.ts

@@ -1,6 +1,6 @@
 import { getCollection } from 'astro:content';
 import type { CollectionEntry } from 'astro:content';
-import { createVersionedMap, findInMap } from '@utils/collections/util';
+import { createVersionedMap, findInMap, getVersionedMap, uniqueResources } from '@utils/collections/util';
 import { getDomains } from './domains';
 import { getServices } from './services';
 import { getAgents } from './agents';
@@ -147,6 +147,55 @@ export const getFlowsNotInAnyResource = async (): Promise<Flow[]> => {
   return flowsNotInAnyResource;
 };
 
+/**
+ * Finds the flows with a step that points at the service. A step without a version points
+ * at the latest service version, so `services` must include every version.
+ */
+export const getFlowsWithServiceStep = (
+  service: CollectionEntry<'services'>,
+  flows: Flow[],
+  services: CollectionEntry<'services'>[]
+): Flow[] => {
+  const serviceMap = getVersionedMap(services);
+  return flows.filter((flow) =>
+    (flow.data.steps || []).some((step: any) => {
+      if (!step.service) return false;
+      const match = findInMap(serviceMap, step.service.id, step.service.version);
+      return match?.data.id === service.data.id && match?.data.version === service.data.version;
+    })
+  );
+};
+
+/** A catalog entry a flow step points at (a service, message, agent, data store, data product or flow). */
+type FlowStepResource = { collection: string; data: { id: string; version: string; [key: string]: any } };
+
+/**
+ * The catalog resources a flow's steps point at, each listed once in step order: messages,
+ * services, agents, data stores, data products and sub-flows (the same steps the flow's
+ * sidebar lists). Expects steps as getFlows returns them, where messages, agents, data stores
+ * and data products are already resolved; services and sub-flows are resolved here, with a
+ * pointer without a version meaning the latest.
+ */
+export const getFlowStepResources = (
+  flow: Flow,
+  catalog: { services: CollectionEntry<'services'>[]; flows: Flow[] }
+): FlowStepResource[] => {
+  const serviceMap = getVersionedMap(catalog.services);
+  const flowMap = getVersionedMap(catalog.flows);
+  const resources: FlowStepResource[] = [];
+
+  for (const step of (flow.data.steps || []) as any[]) {
+    const resource = step.service
+      ? findInMap(serviceMap, step.service.id, step.service.version)
+      : step.flow
+        ? findInMap(flowMap, step.flow.id, step.flow.version)
+        : [step.message, step.agent, step.container, step.dataProduct].find(Array.isArray)?.[0];
+    if (resource?.data) resources.push(resource);
+  }
+
+  return uniqueResources(resources);
+};
+
 /** A flow that includes a message in one of its steps, reduced to what the schema pages display. */
 export interface FlowReference {
   id: string;

package/eventcatalog/src/utils/collections/message-connections.ts

@@ -0,0 +1,60 @@
+import type { CollectionEntry } from 'astro:content';
+import type { CollectionMessageTypes } from '@types';
+import { findInMap, getVersionedMap, uniqueResources } from './util';
+import { getTriggeredByOfMessage, getTriggersOfMessage, messageMatchesPointer, type MessageReceiver } from './message-triggers';
+
+type Message = CollectionEntry<CollectionMessageTypes>;
+type Pointer = { id: string; version?: string };
+
+/**
+ * What a message connects to, beyond the producers and consumers getEvents/getCommands/getQueries
+ * already attach: the channels it travels on (its own `channels`, and the `to`/`from` channels of
+ * services, agents and domains that send or receive it), the flows with a step for it, and the
+ * messages it triggers or is triggered by. Receivers must be raw collection entries, because
+ * hydration drops the channel and trigger pointers on sends/receives.
+ */
+export const getMessageConnections = (
+  message: Message,
+  catalog: {
+    receivers: MessageReceiver[];
+    messages: Message[];
+    channels: CollectionEntry<'channels'>[];
+    flows: CollectionEntry<'flows'>[];
+  }
+) => {
+  const channelMap = getVersionedMap(catalog.channels);
+  const resolveChannels = (pointers: Pointer[] = []) =>
+    pointers.map((pointer) => findInMap(channelMap, pointer.id, pointer.version)).filter((channel) => !!channel);
+
+  const channels = [...resolveChannels((message.data as any).channels)];
+  for (const receiver of catalog.receivers) {
+    for (const send of ((receiver.data as any).sends || []) as Array<Pointer & { to?: Pointer[] }>) {
+      if (messageMatchesPointer(message, send)) channels.push(...resolveChannels(send.to));
+    }
+    for (const receive of ((receiver.data as any).receives || []) as Array<Pointer & { from?: Pointer[] }>) {
+      if (messageMatchesPointer(message, receive)) channels.push(...resolveChannels(receive.from));
+    }
+  }
+
+  const flows = catalog.flows.filter((flow) =>
+    ((flow.data.steps || []) as any[]).some((step) => {
+      const stepMessage = Array.isArray(step.message) ? step.message[0] : undefined;
+      return (
+        stepMessage?.collection === message.collection &&
+        stepMessage?.data.id === message.data.id &&
+        stepMessage?.data.version === message.data.version
+      );
+    })
+  );
+
+  return {
+    channels: uniqueResources(channels as CollectionEntry<'channels'>[]),
+    flows: uniqueResources(flows),
+    triggers: uniqueResources(
+      getTriggersOfMessage(catalog.receivers, message, catalog.messages).map((trigger) => trigger.message)
+    ),
+    triggeredBy: uniqueResources(
+      getTriggeredByOfMessage(catalog.receivers, message, catalog.messages).map((trigger) => trigger.message)
+    ),
+  };
+};

package/eventcatalog/src/utils/collections/message-triggers.ts

@@ -23,7 +23,8 @@ export interface MessageTrigger {
   condition?: string;
 }
 
-const messageMatchesPointer = (message: Message, pointer: { id: string; version?: string }) => {
+/** Whether a pointer points at the message; a pointer without a version (or `latest`) means the latest version. */
+export const messageMatchesPointer = (message: Message, pointer: { id: string; version?: string }) => {
   if (pointer.id !== message.data.id) return false;
 
   if (!pointer.version || pointer.version === 'latest') {