@eventcatalog/core 4.1.5 → 4.2.1

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

@@ -0,0 +1,201 @@
+---
+import { getCollection, type CollectionEntry } from 'astro:content';
+
+import LineageScenarioSwitcher from '@components/Lineage/LineageScenarioSwitcher';
+import AstroNodeGraph from '@components/MDX/NodeGraph/AstroNodeGraph';
+import ResourceRef from '@components/MDX/ResourceRef/ResourceRef.astro';
+import Footer from '@layouts/Footer.astro';
+import VerticalSideBarLayout from '@layouts/VerticalSideBarLayout.astro';
+import { getTriggeredByOfMessage, getTriggersOfMessage, type MessageReceiver } from '@utils/collections/message-triggers';
+import { buildMessageLineageGraph, groupMessageLineageGraphs } from '@utils/node-graphs/message-lineage';
+import type { CollectionMessageTypes } from '@types';
+
+import { Page } from './_index.data';
+
+export const prerender = Page.prerender;
+export const getStaticPaths = Page.getStaticPaths;
+
+const props = await Page.getData(Astro);
+const { data } = props as CollectionEntry<CollectionMessageTypes>;
+const currentMessage = props as CollectionEntry<CollectionMessageTypes>;
+
+const [events, commands, queries, services, agents, domains] = await Promise.all([
+  getCollection('events'),
+  getCollection('commands'),
+  getCollection('queries'),
+  getCollection('services'),
+  getCollection('agents'),
+  getCollection('domains'),
+]);
+
+const allMessages = [...events, ...commands, ...queries] as CollectionEntry<CollectionMessageTypes>[];
+const receivers = [...services, ...agents, ...domains] as MessageReceiver[];
+
+const triggeredByRows = groupMessageLineageGraphs(
+  getTriggeredByOfMessage(receivers, currentMessage, allMessages).map((relation) =>
+    buildMessageLineageGraph({ currentMessage, relation, direction: 'triggeredBy' })
+  )
+);
+const triggerRows = groupMessageLineageGraphs(
+  getTriggersOfMessage(receivers, currentMessage, allMessages).map((relation) =>
+    buildMessageLineageGraph({ currentMessage, relation, direction: 'triggers' })
+  )
+);
+
+const resourceTypeByCollection = {
+  events: 'event',
+  commands: 'command',
+  queries: 'query',
+  services: 'service',
+  domains: 'domain',
+  agents: 'agent',
+} as const;
+const resourceType = (resource: CollectionEntry<CollectionMessageTypes> | MessageReceiver) =>
+  resourceTypeByCollection[resource.collection];
+const conditionText = (condition: string) => condition.replace(/^when\s+/i, '');
+const scenarioConditions = (row: (typeof triggeredByRows)[number]) =>
+  row.scenarios.map(({ condition }) => (condition ? conditionText(condition) : 'No condition specified'));
+---
+
+<VerticalSideBarLayout title={`Trigger paths | ${data.name}`} description={`Message trigger paths for ${data.name}`}>
+  <main class="w-full min-h-full bg-[rgb(var(--ec-page-bg))] py-8">
+    <header class="border-b border-[rgb(var(--ec-page-border))] py-5">
+      <div class="text-sm font-semibold text-[rgb(var(--ec-accent))]">Trigger paths</div>
+      <h1 class="pt-3 text-2xl md:text-4xl font-bold text-[rgb(var(--ec-page-text))]">{data.name}</h1>
+      <p class="pt-3 text-base text-[rgb(var(--ec-page-text-muted))] font-light">
+        Explore the direct messages that trigger this message and the messages it can trigger.
+      </p>
+    </header>
+
+    <div class="space-y-10 py-8">
+      {
+        triggeredByRows.length > 0 && (
+          <section aria-labelledby="triggered-by-heading">
+            <div class="space-y-5">
+              {triggeredByRows.map((row, index) => (
+                <article class="lineage-row overflow-hidden rounded-xl border border-[rgb(var(--ec-page-border))] bg-[rgb(var(--ec-card-bg))] shadow-sm">
+                  <div class="border-b border-[rgb(var(--ec-page-border))] px-5 py-4">
+                    <h3 class="text-sm md:text-base font-medium text-[rgb(var(--ec-page-text))]">
+                      <ResourceRef type={resourceType(row.target)} version={row.target.data.version}>
+                        {row.target.data.id}
+                      </ResourceRef>{' '}
+                      is triggered by{' '}
+                      <ResourceRef type={resourceType(row.source)} version={row.source.data.version}>
+                        {row.source.data.id}
+                      </ResourceRef>
+                      {row.scenarios.length === 1 && row.scenarios[0].condition && (
+                        <>
+                          {' '}
+                          when <span class="font-semibold">{conditionText(row.scenarios[0].condition)}</span>
+                        </>
+                      )}
+                      {row.scenarios.length > 1 && (
+                        <>
+                          {' '}
+                          when <LineageScenarioSwitcher client:visible conditions={scenarioConditions(row)} />
+                        </>
+                      )}{' '}
+                      via{' '}
+                      <ResourceRef type={resourceType(row.receiver)} version={row.receiver.data.version}>
+                        {row.receiver.data.id}
+                      </ResourceRef>
+                    </h3>
+                  </div>
+                  <div
+                    id={`${data.id}-triggered-by-${index}-portal`}
+                    class="lineage-graph h-[250px] w-full bg-[rgb(var(--ec-page-bg))]"
+                  />
+                  <AstroNodeGraph
+                    client:only="react"
+                    id={`${data.id}-triggered-by-${index}`}
+                    portalId={`${data.id}-triggered-by-${index}-portal`}
+                    nodes={row.nodes}
+                    edges={row.edges}
+                    mode="simple"
+                    linkTo="docs"
+                    includeKey={false}
+                    showSearch={false}
+                    zoomOnScroll={false}
+                    disableMessageAnimation={true}
+                  />
+                </article>
+              ))}
+            </div>
+          </section>
+        )
+      }
+
+      {
+        triggerRows.length > 0 && (
+          <section aria-label="Messages triggered by this message">
+            <div class="space-y-5">
+              {triggerRows.map((row, index) => (
+                <article class="lineage-row overflow-hidden rounded-xl border border-[rgb(var(--ec-page-border))] bg-[rgb(var(--ec-card-bg))] shadow-sm">
+                  <div class="border-b border-[rgb(var(--ec-page-border))] px-5 py-4">
+                    <h3 class="text-sm md:text-base font-medium text-[rgb(var(--ec-page-text))]">
+                      <ResourceRef type={resourceType(row.target)} version={row.target.data.version}>
+                        {row.target.data.id}
+                      </ResourceRef>{' '}
+                      is triggered by{' '}
+                      <ResourceRef type={resourceType(row.source)} version={row.source.data.version}>
+                        {row.source.data.id}
+                      </ResourceRef>
+                      {row.scenarios.length === 1 && row.scenarios[0].condition && (
+                        <>
+                          {' '}
+                          when <span class="font-semibold">{conditionText(row.scenarios[0].condition)}</span>
+                        </>
+                      )}
+                      {row.scenarios.length > 1 && (
+                        <>
+                          {' '}
+                          when <LineageScenarioSwitcher client:visible conditions={scenarioConditions(row)} />
+                        </>
+                      )}{' '}
+                      via{' '}
+                      <ResourceRef type={resourceType(row.receiver)} version={row.receiver.data.version}>
+                        {row.receiver.data.id}
+                      </ResourceRef>
+                    </h3>
+                  </div>
+                  <div
+                    id={`${data.id}-triggers-${index}-portal`}
+                    class="lineage-graph h-[250px] w-full bg-[rgb(var(--ec-page-bg))]"
+                  />
+                  <AstroNodeGraph
+                    client:only="react"
+                    id={`${data.id}-triggers-${index}`}
+                    portalId={`${data.id}-triggers-${index}-portal`}
+                    nodes={row.nodes}
+                    edges={row.edges}
+                    mode="simple"
+                    linkTo="docs"
+                    includeKey={false}
+                    showSearch={false}
+                    zoomOnScroll={false}
+                    disableMessageAnimation={true}
+                  />
+                </article>
+              ))}
+            </div>
+          </section>
+        )
+      }
+    </div>
+
+    <Footer />
+  </main>
+</VerticalSideBarLayout>
+
+<style is:global>
+  .lineage-row {
+    content-visibility: auto;
+    contain-intrinsic-size: 330px;
+  }
+
+  .lineage-graph .react-flow__panel.top,
+  .lineage-graph .react-flow__controls,
+  .lineage-graph .react-flow__attribution {
+    display: none;
+  }
+</style>

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

@@ -14,6 +14,7 @@ import {
 import { isVisualiserEnabled, isChangelogEnabled } from '@utils/feature';
 import { iconFieldsForResource } from '@utils/icon';
 import { collectionToResourceMap } from '@utils/collections/util';
+import type { MessageTrigger } from '@utils/collections/message-triggers';
 
 type MessageSchemaEntry = CollectionEntry<'schemas'>;
 
@@ -47,16 +48,22 @@ export const buildMessageNode = (
   owners: any[],
   context: ResourceGroupContext,
   hasFieldUsage: boolean = false,
-  flowRefs: string[] = []
+  flowRefs: string[] = [],
+  messageTriggers: { triggers: MessageTrigger[]; triggeredBy: MessageTrigger[] } = { triggers: [], triggeredBy: [] }
 ): NavNode => {
   const producers = message.data.producers || [];
   const consumers = message.data.consumers || [];
   const collection = message.collection;
+  const triggerRefs = [...new Set(messageTriggers.triggers.map(({ message }) => getProducerConsumerPageRef(message)))];
+  const triggeredByRefs = [...new Set(messageTriggers.triggeredBy.map(({ message }) => getProducerConsumerPageRef(message)))];
 
   const renderProducers = producers.length > 0 && shouldRenderSideBarSection(message, 'producers');
   const renderConsumers = consumers.length > 0 && shouldRenderSideBarSection(message, 'consumers');
+  const renderTriggers = triggerRefs.length > 0 && shouldRenderSideBarSection(message, 'triggers');
+  const renderTriggeredBy = triggeredByRefs.length > 0 && shouldRenderSideBarSection(message, 'triggeredBy');
   const renderFlows = flowRefs.length > 0 && shouldRenderSideBarSection(message, 'flows');
   const renderRepository = message.data.repository && shouldRenderSideBarSection(message, 'repository');
+  const hasTriggerPaths = messageTriggers.triggers.length > 0 || messageTriggers.triggeredBy.length > 0;
 
   // Determine badge based on collection type
   const badgeMap: Record<string, string> = {
@@ -124,6 +131,15 @@ export const buildMessageNode = (
             title: 'Map',
             href: buildUrl(`/visualiser/${collection}/${message.data.id}/${message.data.version}`),
           },
+          ...(hasTriggerPaths
+            ? [
+                {
+                  type: 'item' as const,
+                  title: 'Trigger paths',
+                  href: buildUrl(`/triggers/${collection}/${message.data.id}/${message.data.version}`),
+                },
+              ]
+            : []),
         ],
       },
       hasDiagrams && {
@@ -163,6 +179,20 @@ export const buildMessageNode = (
         pages: consumers.map(getProducerConsumerPageRef),
         visible: consumers.length > 0,
       },
+      renderTriggeredBy && {
+        type: 'group',
+        title: 'Triggered by',
+        icon: 'Mail',
+        pages: triggeredByRefs,
+        visible: triggeredByRefs.length > 0,
+      },
+      renderTriggers && {
+        type: 'group',
+        title: 'Triggers',
+        icon: 'Mail',
+        pages: triggerRefs,
+        visible: triggerRefs.length > 0,
+      },
       renderFlows && {
         type: 'group',
         title: 'Appears in flows',

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

@@ -8,6 +8,7 @@ import { getDomains } from '@utils/collections/domains';
 import { getSystems } from '@utils/collections/systems';
 import { getServices } from '@utils/collections/services';
 import { getMessages, pluralizeMessageType } from '@utils/collections/messages';
+import { getTriggeredByOfMessage, getTriggersOfMessage } from '@utils/collections/message-triggers';
 import { getOwner } from '@utils/collections/owners';
 import { getFlows } from '@utils/collections/flows';
 import { getUsers } from '@utils/collections/users';
@@ -451,10 +452,14 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
     {} as Record<string, NavNode | string>
   );
 
-  const rawAgents = await getCollection('agents');
+  const [rawAgents, rawServices, rawDomains] = await Promise.all([
+    getCollection('agents'),
+    getCollection('services'),
+    getCollection('domains'),
+  ]);
+  const messageReceivers = [...rawServices, ...rawAgents, ...rawDomains];
 
   // Compute channels for each service from raw sends[].to / receives[].from pointers
-  const rawServices = await getCollection('services');
   const channelMap = createVersionedMap(channels);
   const serviceChannelsMap = new Map<string, CollectionEntry<'channels'>[]>();
 
@@ -560,7 +565,7 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
     {} as Record<string, NavNode | string>
   );
 
-  // Build a set of message IDs that have field usage declared by any service or agent.
+  // Build a set of message IDs that have field usage declared by any resource that can receive messages.
   // We use raw collections because the hydrated resources replace
   // sends/receives pointers with resolved message entries, which strips the fields property.
   const messagesWithFieldUsage = new Set<string>();
@@ -580,6 +585,14 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
       if (pointer.fields?.length) messagesWithFieldUsage.add(pointer.id);
     }
   }
+  for (const domain of rawDomains) {
+    for (const pointer of domain.data.sends || []) {
+      if (pointer.fields?.length) messagesWithFieldUsage.add(pointer.id);
+    }
+    for (const pointer of domain.data.receives || []) {
+      if (pointer.fields?.length) messagesWithFieldUsage.add(pointer.id);
+    }
+  }
 
   const flowRefsByMessage = buildFlowReferencesByMessage({ flows, events, commands, queries });
 
@@ -588,8 +601,13 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
       const type = pluralizeMessageType(message as any);
       const versionedKey = `${type}:${message.data.id}:${message.data.version}`;
       const hasFieldUsage = messagesWithFieldUsage.has(message.data.id);
+      const triggers = getTriggersOfMessage(messageReceivers, message, messages);
+      const triggeredBy = getTriggeredByOfMessage(messageReceivers, message, messages);
       acc[versionedKey] = withArchitectureDecisionsSection(
-        buildMessageNode(message, owners, context, hasFieldUsage, flowRefsByMessage.get(versionedKey) || []),
+        buildMessageNode(message, owners, context, hasFieldUsage, flowRefsByMessage.get(versionedKey) || [], {
+          triggers,
+          triggeredBy,
+        }),
         message,
         adrs
       );

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

@@ -20,7 +20,7 @@ export const getCommands = async ({ getAllVersions = true, hydrateServices = tru
   const cacheKey = `${getAllVersions ? 'allVersions' : 'currentVersions'}-${hydrateServices ? 'hydrated' : 'minimal'}`;
 
   // Check cache
-  if (memoryCache[cacheKey] && memoryCache[cacheKey].length > 0) {
+  if (memoryCache[cacheKey] && memoryCache[cacheKey].length > 0 && CACHE_ENABLED) {
     // console.timeEnd('✅ New getCommands');
     return memoryCache[cacheKey];
   }

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

@@ -0,0 +1,118 @@
+import type { CollectionEntry } from 'astro:content';
+import type { CollectionMessageTypes } from '@types';
+import { getItemsFromCollectionByIdAndSemverOrLatest, versionMatches } from './util';
+
+type Message = CollectionEntry<CollectionMessageTypes>;
+export type MessageReceiver = CollectionEntry<'services'> | CollectionEntry<'domains'> | CollectionEntry<'agents'>;
+
+interface TriggerPointer {
+  id: string;
+  version?: string;
+  condition?: string;
+}
+
+interface ReceivePointer {
+  id: string;
+  version?: string;
+  triggers?: TriggerPointer[];
+}
+
+export interface MessageTrigger {
+  receiver: MessageReceiver;
+  message: Message;
+  condition?: string;
+}
+
+const messageMatchesPointer = (message: Message, pointer: { id: string; version?: string }) => {
+  if (pointer.id !== message.data.id) return false;
+
+  if (!pointer.version || pointer.version === 'latest') {
+    return !message.data.latestVersion || message.data.version === message.data.latestVersion;
+  }
+
+  return versionMatches(message.data.version, pointer.version);
+};
+
+/**
+ * Returns the messages triggered when a resource receives the given message.
+ *
+ * Receivers must be raw collection entries because hydration replaces receive
+ * pointers with messages and therefore removes trigger metadata.
+ */
+export const getTriggersOfMessage = (
+  receivers: MessageReceiver[],
+  message: Message,
+  allMessages: Message[]
+): MessageTrigger[] => {
+  const triggers: MessageTrigger[] = [];
+
+  for (const receiver of receivers) {
+    const receives = (receiver.data.receives as ReceivePointer[]) ?? [];
+
+    for (const receive of receives) {
+      if (!receive.triggers?.length || !messageMatchesPointer(message, receive)) continue;
+
+      for (const trigger of receive.triggers) {
+        const target = getItemsFromCollectionByIdAndSemverOrLatest(allMessages, trigger.id, trigger.version)[0];
+        if (!target) continue;
+
+        triggers.push({ receiver, message: target, condition: trigger.condition });
+      }
+    }
+  }
+
+  return triggers;
+};
+
+/**
+ * Returns the messages whose handling can trigger the given message.
+ *
+ * Receivers must be raw collection entries because hydration replaces receive
+ * pointers with messages and therefore removes trigger metadata.
+ */
+export const getTriggeredByOfMessage = (
+  receivers: MessageReceiver[],
+  message: Message,
+  allMessages: Message[]
+): MessageTrigger[] => {
+  const triggeredBy: MessageTrigger[] = [];
+
+  for (const receiver of receivers) {
+    const receives = (receiver.data.receives as ReceivePointer[]) ?? [];
+
+    for (const receive of receives) {
+      for (const trigger of receive.triggers ?? []) {
+        if (!messageMatchesPointer(message, trigger)) continue;
+
+        const source = getItemsFromCollectionByIdAndSemverOrLatest(allMessages, receive.id, receive.version)[0];
+        if (!source) continue;
+
+        triggeredBy.push({ receiver, message: source, condition: trigger.condition });
+      }
+    }
+  }
+
+  return triggeredBy;
+};
+
+const getMessageKey = (message: Message) => `${message.collection}:${message.data.id}:${message.data.version}`;
+
+/**
+ * Returns only messages that participate in at least one resolved trigger path.
+ * Both the source and target are included so empty trigger pages are never generated.
+ */
+export const getMessagesWithTriggerPaths = (receivers: MessageReceiver[], allMessages: Message[]): Message[] => {
+  const messageKeysWithPaths = new Set<string>();
+
+  for (const source of allMessages) {
+    const triggers = getTriggersOfMessage(receivers, source, allMessages);
+    if (triggers.length === 0) continue;
+
+    messageKeysWithPaths.add(getMessageKey(source));
+    for (const trigger of triggers) {
+      messageKeysWithPaths.add(getMessageKey(trigger.message));
+    }
+  }
+
+  return allMessages.filter((message) => messageKeysWithPaths.has(getMessageKey(message)));
+};

package/eventcatalog/src/utils/file-diffs.ts

@@ -1,8 +1,9 @@
 import { readdir, readFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
+import { dirname, isAbsolute, join } from 'node:path';
 import { formatPatch, structuredPatch } from 'diff';
 import { html, parse } from 'diff2html';
 import { getItemsFromCollectionByIdAndSemverOrLatest } from './collections/util';
+import { getAbsoluteFilePathForAstroFile } from './files';
 import type { CollectionEntry } from 'astro:content';
 import type { CollectionTypes } from '@types';
 
@@ -32,7 +33,8 @@ export async function getFilesForDiffInCollection(
   const pathToFolder = collection.filePath;
   if (!pathToFolder) return [];
 
-  const dir = dirname(pathToFolder);
+  const absolutePathToFolder = isAbsolute(pathToFolder) ? pathToFolder : getAbsoluteFilePathForAstroFile(pathToFolder);
+  const dir = dirname(absolutePathToFolder);
   const allFilesInDirectory = await readdir(dir);
 
   return allFilesInDirectory

package/eventcatalog/src/utils/node-graphs/container-node-graph.ts

@@ -143,11 +143,12 @@ export const getNodesAndEdges = async ({
     targetPosition: 'left',
     data: {
       mode,
+      isFocused: true,
       data: {
         ...container.data,
       },
       contextMenu: buildContextMenuForResource({
-        collection: 'entities',
+        collection: 'containers',
         id: container.data.id,
         version: container.data.version,
       }),

package/eventcatalog/src/utils/node-graphs/message-lineage.ts

@@ -0,0 +1,131 @@
+import type { CollectionEntry } from 'astro:content';
+import type { Edge, Node } from '@xyflow/react';
+import type { CollectionMessageTypes } from '@types';
+import type { MessageTrigger } from '@utils/collections/message-triggers';
+import {
+  createEdge,
+  createNode,
+  generateIdForNode,
+  generatedIdForEdge,
+  getColorFromString,
+  getEdgeLabelForMessageAsSource,
+  getEdgeLabelForServiceAsTarget,
+} from './utils/utils';
+import { createTriggerMessageNode, getTriggerReceiverNodeData } from './message-node-graph';
+
+type Message = CollectionEntry<CollectionMessageTypes>;
+
+export type MessageLineageDirection = 'triggeredBy' | 'triggers';
+
+export interface MessageLineageGraph {
+  direction: MessageLineageDirection;
+  condition?: string;
+  source: Message;
+  receiver: MessageTrigger['receiver'];
+  target: Message;
+  relatedMessage: Message;
+  nodes: Node[];
+  edges: Edge[];
+}
+
+export interface MessageLineageScenario {
+  condition?: string;
+}
+
+export interface MessageLineageGroup extends Omit<MessageLineageGraph, 'condition'> {
+  scenarios: MessageLineageScenario[];
+}
+
+const createLineageEdge = (source: any, target: any, label: string, colorMessage: Message): Edge =>
+  createEdge({
+    id: generatedIdForEdge(source, target),
+    source: generateIdForNode(source),
+    target: generateIdForNode(target),
+    label,
+    animated: false,
+    data: {
+      animated: false,
+      customColor: getColorFromString(colorMessage.data.id),
+      rootSourceAndTarget: {
+        source: { id: generateIdForNode(source), collection: source.collection },
+        target: { id: generateIdForNode(target), collection: target.collection },
+      },
+    },
+  });
+
+export const buildMessageLineageGraph = ({
+  currentMessage,
+  relation,
+  direction,
+}: {
+  currentMessage: Message;
+  relation: MessageTrigger;
+  direction: MessageLineageDirection;
+}): MessageLineageGraph => {
+  const source = direction === 'triggeredBy' ? relation.message : currentMessage;
+  const target = direction === 'triggeredBy' ? currentMessage : relation.message;
+  const mode = 'simple';
+
+  const nodes: Node[] = [
+    {
+      ...createTriggerMessageNode(source, mode, source === currentMessage),
+      position: { x: 0, y: 0 },
+    },
+    createNode({
+      id: generateIdForNode(relation.receiver),
+      type: relation.receiver.collection,
+      data: getTriggerReceiverNodeData(relation.receiver, mode),
+      position: { x: 320, y: 0 },
+    }),
+    {
+      ...createTriggerMessageNode(target, mode, target === currentMessage),
+      position: { x: 640, y: 0 },
+    },
+  ];
+
+  return {
+    direction,
+    condition: relation.condition,
+    source,
+    receiver: relation.receiver,
+    target,
+    relatedMessage: relation.message,
+    nodes,
+    edges: [
+      createLineageEdge(source, relation.receiver, getEdgeLabelForMessageAsSource(source), source),
+      createLineageEdge(relation.receiver, target, getEdgeLabelForServiceAsTarget(target), target),
+    ],
+  };
+};
+
+const getResourceKey = (resource: Message | MessageTrigger['receiver']) =>
+  `${resource.collection}:${resource.data.id}:${resource.data.version}`;
+
+export const groupMessageLineageGraphs = (graphs: MessageLineageGraph[]): MessageLineageGroup[] => {
+  const groups = new Map<string, MessageLineageGroup>();
+
+  for (const graph of graphs) {
+    const key = [
+      graph.direction,
+      getResourceKey(graph.source),
+      getResourceKey(graph.receiver),
+      getResourceKey(graph.target),
+    ].join('>');
+    const existingGroup = groups.get(key);
+
+    if (existingGroup) {
+      if (!existingGroup.scenarios.some((scenario) => scenario.condition === graph.condition)) {
+        existingGroup.scenarios.push({ condition: graph.condition });
+      }
+      continue;
+    }
+
+    const { condition, ...lineage } = graph;
+    groups.set(key, {
+      ...lineage,
+      scenarios: [{ condition }],
+    });
+  }
+
+  return [...groups.values()];
+};