@eventcatalog/core 2.64.4 → 2.65.0-beta.0

package/dist/migrations/index.d.ts

@@ -0,0 +1,3 @@
+declare const runMigrations: (dir?: string) => Promise<void>;
+
+export { runMigrations };

package/dist/migrations/index.js

@@ -0,0 +1,7 @@
+import {
+  runMigrations
+} from "../chunk-BH3JMNAV.js";
+import "../chunk-622JYJWG.js";
+export {
+  runMigrations
+};

package/dist/migrations/message-channels-to-service-channels.cjs

@@ -0,0 +1,139 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/migrations/message-channels-to-service-channels.ts
+var message_channels_to_service_channels_exports = {};
+__export(message_channels_to_service_channels_exports, {
+  default: () => message_channels_to_service_channels_default
+});
+module.exports = __toCommonJS(message_channels_to_service_channels_exports);
+var import_node_fs = __toESM(require("fs"), 1);
+var import_glob = require("glob");
+var import_node_os = __toESM(require("os"), 1);
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var message_channels_to_service_channels_default = async (dir) => {
+  const PROJECT_DIR = import_node_path.default.join(dir || process.env.PROJECT_DIR);
+  const messages = await (0, import_glob.glob)(
+    [
+      "**/events/*/index.mdx",
+      "**/events/*/index.md",
+      "**/events/*/versioned/*/index.mdx",
+      "**/events/*/versioned/*/index.md",
+      // commands
+      "**/commands/*/index.mdx",
+      "**/commands/*/index.md",
+      "**/commands/*/versioned/*/index.mdx",
+      "**/commands/*/versioned/*/index.md",
+      // queries
+      "**/queries/*/index.mdx",
+      "**/queries/*/index.md",
+      "**/queries/*/versioned/*/index.mdx",
+      "**/queries/*/versioned/*/index.md"
+    ],
+    {
+      // const events = await glob(['**/events/*/index.(md|mdx)', '**/events/*/versioned/*/index.(md|mdx)'], {
+      cwd: PROJECT_DIR,
+      absolute: true,
+      nodir: true,
+      windowsPathsNoEscape: import_node_os.default.platform() == "win32",
+      ignore: ["node_modules/**", "**/dist/**", "**/teams", "**/users", "**/package.json", "**/Dockerfile"]
+    }
+  );
+  const services = await (0, import_glob.glob)(
+    [
+      "**/services/*/index.mdx",
+      "**/services/*/index.md",
+      "**/services/*/versioned/*/index.mdx",
+      "**/services/*/versioned/*/index.md"
+    ],
+    {
+      cwd: PROJECT_DIR,
+      absolute: true
+    }
+  );
+  const messagesWithChannels = messages.reduce((acc, message) => {
+    const file = import_node_fs.default.readFileSync(message, "utf8");
+    const { data } = (0, import_gray_matter.default)(file);
+    if (data.channels?.length > 0) {
+      acc.push({
+        ...data,
+        path: message
+      });
+    }
+    return acc;
+  }, []);
+  if (messagesWithChannels.length === 0) {
+    return { status: "success", message: "No messages with channels found in the catalog" };
+  }
+  const servicesWithChannels = services.reduce((acc, service) => {
+    const file = import_node_fs.default.readFileSync(service, "utf8");
+    const { data } = (0, import_gray_matter.default)(file);
+    const isSending = data.sends?.some((send) => messagesWithChannels.some((message) => message.id === send.id));
+    const isReceiving = data.receives?.some(
+      (receive) => messagesWithChannels.some((message) => message.id === receive.id)
+    );
+    if (isSending || isReceiving) {
+      acc.push({
+        ...data,
+        path: service
+      });
+    }
+    return acc;
+  }, []);
+  for (const service of servicesWithChannels) {
+    const file = import_node_fs.default.readFileSync(service.path, "utf8");
+    const { data } = (0, import_gray_matter.default)(file);
+    const messagesTheServiceSendsThatNeedUpdating = data.sends?.filter((send) => messagesWithChannels.some((message) => message.id === send.id)) ?? [];
+    const messagesTheServiceReceivesThatNeedUpdating = data.receives?.filter((receive) => messagesWithChannels.some((message) => message.id === receive.id)) ?? [];
+    if (messagesTheServiceSendsThatNeedUpdating.length > 0 || messagesTheServiceReceivesThatNeedUpdating.length > 0) {
+      const newSends = messagesTheServiceSendsThatNeedUpdating.map((send) => ({
+        ...send,
+        to: messagesWithChannels.map((message) => message.id === send.id ? message.channels : []).flat().filter((channel) => channel !== null)
+      }));
+      const newReceives = messagesTheServiceReceivesThatNeedUpdating.map((receive) => ({
+        ...receive,
+        from: messagesWithChannels.map((message) => message.id === receive.id ? message.channels : []).flat().filter((channel) => channel !== null)
+      }));
+      const newData = {
+        ...data,
+        ...newSends.length > 0 ? { sends: newSends } : {},
+        ...newReceives.length > 0 ? { receives: newReceives } : {}
+      };
+      import_node_fs.default.writeFileSync(service.path, import_gray_matter.default.stringify(file, newData));
+    }
+  }
+  for (const message of messagesWithChannels) {
+    const file = import_node_fs.default.readFileSync(message.path, "utf8");
+    const parsed = (0, import_gray_matter.default)(file);
+    const { channels, ...newData } = parsed.data;
+    import_node_fs.default.writeFileSync(message.path, import_gray_matter.default.stringify(parsed.content, newData));
+  }
+  console.log("\u2714 Channels migrated to new services API");
+};

package/dist/migrations/message-channels-to-service-channels.d.cts

@@ -0,0 +1,6 @@
+declare const _default: (dir?: string) => Promise<{
+    status: string;
+    message: string;
+} | undefined>;
+
+export { _default as default };

package/dist/migrations/message-channels-to-service-channels.d.ts

@@ -0,0 +1,6 @@
+declare const _default: (dir?: string) => Promise<{
+    status: string;
+    message: string;
+} | undefined>;
+
+export { _default as default };

package/dist/migrations/message-channels-to-service-channels.js

@@ -0,0 +1,6 @@
+import {
+  message_channels_to_service_channels_default
+} from "../chunk-622JYJWG.js";
+export {
+  message_channels_to_service_channels_default as default
+};

package/eventcatalog/src/components/MDX/NodeGraph/Edges/AnimatedMessageEdge.tsx

@@ -12,6 +12,7 @@ const AnimatedMessageEdge = ({
   data,
   label = '',
   markerEnd,
+  markerStart,
 }: any) => {
   const [edgePath, labelX, labelY] = getBezierPath({
     sourceX,
@@ -22,9 +23,6 @@ const AnimatedMessageEdge = ({
     targetPosition,
   });
 
-  const collection = data?.message?.collection;
-  const opacity = data?.opacity ?? 1;
-
   const messageColor = useMemo(
     () => (collection: string) => {
       switch (collection) {
@@ -41,41 +39,57 @@ const AnimatedMessageEdge = ({
     []
   );
 
+  const collection = data?.message?.collection;
+  const opacity = data?.opacity ?? 1;
+  const customColor = data?.customColor || messageColor(collection ?? 'default');
+  const warning = data?.warning;
+
+  // For each customColor (string or array of strings), we need to create the animated nodes
+  const customColors = Array.isArray(customColor) ? customColor : [customColor];
+
   const randomDelay = useMemo(() => Math.random() * 1, []);
 
-  return (
-    // @ts-ignore
-    <>
-      <BaseEdge id={id} path={edgePath} markerEnd={markerEnd} />
-      {/* Circle Icon */}
-      <g className={`z-30 ${opacity === 1 ? 'opacity-100' : 'opacity-10'}`}>
-        <circle cx="0" cy="0" r="7" fill={messageColor(collection)}>
-          <animateMotion dur="2s" repeatCount="indefinite" path={edgePath} rotate="auto" begin={`${randomDelay}s`}>
+  const animatedNodes = customColors.map((color, index) => {
+    // Stagger the animations so multiple colored nodes are visible
+    const delay = randomDelay + index * 0.3;
+    return (
+      <g className={`z-30 ${opacity === 1 ? 'opacity-100' : 'opacity-10'}`} key={`${id}-${color}-${index}`}>
+        <circle key={`${id}-${color}-${index}`} cx="0" cy="0" r="7" fill={color}>
+          <animateMotion dur="2s" repeatCount="indefinite" path={edgePath} rotate="auto" begin={`${delay}s`}>
             <mpath href={`#${id}`} />
           </animateMotion>
         </circle>
       </g>
-      <g>
-        {/* Background rectangle */}
-        <rect
-          x={labelX - label.length * 3} // Adjust based on text length
-          y={labelY - 15} // Position above the text
-          width={label.length * 6} // Width based on text length
-          height={20} // Fixed height
-          fill="white" // Background color
-          opacity={0.8} // Opacity
-          rx="4" // Rounded corners
-        />
+    );
+  });
 
+  // Label can be spit using \n to create multiple lines
+  const lines = String(label ?? '').split('\n');
+
+  return (
+    // @ts-ignore
+    <>
+      <BaseEdge
+        id={id}
+        path={edgePath}
+        markerEnd={markerEnd}
+        markerStart={markerStart}
+        style={warning ? { stroke: 'red', strokeWidth: 1 } : {}}
+      />
+      {/* Circle Icon */}
+      {animatedNodes}
+      {/* <g className={`z-30 ${opacity === 1 ? 'opacity-100' : 'opacity-10'}`}>
+      </g> */}
+      <g>
         {/* Text element */}
-        <text x={labelX} y={labelY} fill="black" fontSize="10" textAnchor="middle" dy="-2">
-          {label}
+        <text x={labelX} y={labelY} textAnchor="middle" dominantBaseline="middle" fontSize="10px" pointerEvents="none">
+          {lines.map((line, i) => (
+            <tspan key={i} x={labelX} dy={i === 0 ? 0 : '1.2em'} style={{ fontStyle: i === 0 ? 'normal' : 'italic' }}>
+              {line}
+            </tspan>
+          ))}
         </text>
       </g>
-      {/* Label */}
-      {/* <text x={labelX} y={labelY} fill="black" fontSize="12" textAnchor="middle" dy="-5">
-        {label}
-      </text> */}
     </>
   );
 };

package/eventcatalog/src/components/SideNav/ListViewSideBar/index.tsx

@@ -82,6 +82,9 @@ const ServiceItem = React.memo(
     const resourceWrites = item.writesTo.filter((writeTo) => !readsAndWritesTo.some((readFrom) => readFrom.id === writeTo.id));
     const hasData = item.writesTo.length > 0 || item.readsFrom.length > 0;
 
+    const sendsMessages = item.sends && item.sends.length > 0;
+    const receivesMessages = item.receives && item.receives.length > 0;
+
     return (
       <CollapsibleGroup
         isCollapsed={collapsedGroups[item.href]}
@@ -167,41 +170,44 @@ const ServiceItem = React.memo(
             </CollapsibleGroup>
           )}
 
-          <CollapsibleGroup
-            isCollapsed={collapsedGroups[`${item.href}-receives`]}
-            onToggle={() => toggleGroupCollapse(`${item.href}-receives`)}
-            title={
-              <button
-                onClick={(e) => {
-                  e.stopPropagation();
-                  toggleGroupCollapse(`${item.href}-receives`);
-                }}
-                className="truncate underline ml-2 text-xs mb-1 py-1"
-              >
-                Receives messages ({item.receives.length})
-              </button>
-            }
-          >
-            <MessageList messages={item.receives} decodedCurrentPath={decodedCurrentPath} searchTerm={searchTerm} />
-          </CollapsibleGroup>
-
-          <CollapsibleGroup
-            isCollapsed={collapsedGroups[`${item.href}-sends`]}
-            onToggle={() => toggleGroupCollapse(`${item.href}-sends`)}
-            title={
-              <button
-                onClick={(e) => {
-                  e.stopPropagation();
-                  toggleGroupCollapse(`${item.href}-sends`);
-                }}
-                className="truncate underline ml-2 text-xs mb-1 py-1"
-              >
-                Sends messages ({item.sends.length})
-              </button>
-            }
-          >
-            <MessageList messages={item.sends} decodedCurrentPath={decodedCurrentPath} searchTerm={searchTerm} />
-          </CollapsibleGroup>
+          {receivesMessages && (
+            <CollapsibleGroup
+              isCollapsed={collapsedGroups[`${item.href}-receives`]}
+              onToggle={() => toggleGroupCollapse(`${item.href}-receives`)}
+              title={
+                <button
+                  onClick={(e) => {
+                    e.stopPropagation();
+                    toggleGroupCollapse(`${item.href}-receives`);
+                  }}
+                  className="truncate underline ml-2 text-xs mb-1 py-1"
+                >
+                  Receives messages ({item.receives.length})
+                </button>
+              }
+            >
+              <MessageList messages={item.receives} decodedCurrentPath={decodedCurrentPath} searchTerm={searchTerm} />
+            </CollapsibleGroup>
+          )}
+          {sendsMessages && (
+            <CollapsibleGroup
+              isCollapsed={collapsedGroups[`${item.href}-sends`]}
+              onToggle={() => toggleGroupCollapse(`${item.href}-sends`)}
+              title={
+                <button
+                  onClick={(e) => {
+                    e.stopPropagation();
+                    toggleGroupCollapse(`${item.href}-sends`);
+                  }}
+                  className="truncate underline ml-2 text-xs mb-1 py-1"
+                >
+                  Sends messages ({item.sends.length})
+                </button>
+              }
+            >
+              <MessageList messages={item.sends} decodedCurrentPath={decodedCurrentPath} searchTerm={searchTerm} />
+            </CollapsibleGroup>
+          )}
           {!isVisualizer && hasData && (
             <CollapsibleGroup
               isCollapsed={collapsedGroups[`${item.href}-data`]}

package/eventcatalog/src/content.config.ts

@@ -44,6 +44,32 @@ const channelPointer = z
   })
   .merge(pointer);
 
+const sendsPointer = z.object({
+  id: z.string(),
+  version: z.string().optional().default('latest'),
+  to: z
+    .array(
+      z.object({
+        ...channelPointer.shape,
+        delivery_mode: z.enum(['push', 'pull', 'push-pull']).optional().default('push'),
+      })
+    )
+    .optional(),
+});
+
+const receivesPointer = z.object({
+  id: z.string(),
+  version: z.string().optional().default('latest'),
+  from: z
+    .array(
+      z.object({
+        ...channelPointer.shape,
+        delivery_mode: z.enum(['push', 'pull', 'push-pull']).optional().default('push'),
+      })
+    )
+    .optional(),
+});
+
 const resourcePointer = z.object({
   id: z.string(),
   version: z.string().optional().default('latest'),
@@ -359,8 +385,8 @@ const services = defineCollection({
   }),
   schema: z
     .object({
-      sends: z.array(pointer).optional(),
-      receives: z.array(pointer).optional(),
+      sends: z.array(sendsPointer).optional(),
+      receives: z.array(receivesPointer).optional(),
       entities: z.array(pointer).optional(),
       writesTo: z.array(pointer).optional(),
       readsFrom: z.array(pointer).optional(),
@@ -492,7 +518,7 @@ const domains = defineCollection({
 
 const channels = defineCollection({
   loader: glob({
-    pattern: ['**/channels/*/index.(md|mdx)', '**/channels/*/versioned/*/index.(md|mdx)'],
+    pattern: ['**/channels/**/index.(md|mdx)', '**/channels/**/versioned/*/index.(md|mdx)'],
     base: projectDirBase,
     generateId: ({ data }) => {
       return `${data.id}-${data.version}`;
@@ -500,8 +526,10 @@ const channels = defineCollection({
   }),
   schema: z
     .object({
+      channels: z.array(channelPointer).optional(),
       address: z.string().optional(),
       protocols: z.array(z.string()).optional(),
+      routes: z.array(channelPointer).optional(),
       parameters: z
         .record(
           z.object({

package/eventcatalog/src/enterprise/eventcatalog-chat/providers/ai-provider.ts

@@ -14,8 +14,6 @@ export const getEventCatalogResources = async () => {
   const url = new URL('/docs/llm/llms.txt', baseUrl);
   const response = await fetch(url.toString());
   const text = await response.text();
-  console.log('URL', url.toString());
-  // console.log('TEXT', text);
   return text;
 };
 
@@ -102,7 +100,6 @@ export class AIProvider {
           ].join('\n'),
           inputSchema: z.object({}),
           execute: async () => {
-            console.log('TOOL HAS BEEN CALLED');
             const text = await getEventCatalogResources();
             return text;
           },
@@ -133,7 +130,6 @@ export class AIProvider {
               .describe('The type of resource to find'),
           }),
           execute: async ({ id, version, type }) => {
-            console.log('TOOL HAS BEEN CALLED TO GET DETAILED INFORMATION ABOUT A RESOURCE');
             const text = await getResourceInformation(type, id, version);
             return text;
           },

package/eventcatalog/src/hooks/eventcatalog-visualizer.ts

@@ -27,8 +27,8 @@ export const useEventCatalogVisualiser = ({
   skipProcessing = false,
 }: EventCatalogVisualizerProps) => {
   const [hideChannels, setHideChannels] = useState(false);
-  const [initialNodes] = useState(nodes);
-  const [initialEdges] = useState(edges);
+  const [initialNodes, setInitialNodes] = useState(nodes);
+  const [initialEdges, setInitialEdges] = useState(edges);
 
   // Initialize hideChannels from localStorage
   useEffect(() => {
@@ -38,6 +38,14 @@ export const useEventCatalogVisualiser = ({
     }
   }, []);
 
+  useEffect(() => {
+    const hasChannels = nodes.some((node) => node.type === 'channels');
+    if (!hideChannels || hasChannels) {
+      setInitialNodes(nodes);
+      setInitialEdges(edges);
+    }
+  }, [nodes, edges, hideChannels]);
+
   const toggleChannelsVisibility = useCallback(() => {
     setHideChannels((prev) => {
       const newValue = !prev;
@@ -50,7 +58,7 @@ export const useEventCatalogVisualiser = ({
   const updatedNodes = useMemo(() => nodes.filter((node) => node.type !== 'channels'), [nodes]);
 
   const updatedEdges = useMemo(() => {
-    return edges.reduce<Edge[]>((acc, edge) => {
+    const newEdges = edges.reduce<Edge[]>((acc, edge) => {
       const { source, target, data } = edge;
       const targetIsChannel = channels.some((channel) => channel.id === target);
       const sourceIsChannel = channels.some((channel) => channel.id === source);
@@ -59,30 +67,42 @@ export const useEventCatalogVisualiser = ({
         return [...acc, edge];
       }
 
-      const dataTarget = data?.target as CollectionEntry<CollectionTypes>;
-      const dataSource = data?.source as CollectionEntry<CollectionTypes>;
+      if (sourceIsChannel || targetIsChannel) {
+        const rootSourceAndTarget = data?.rootSourceAndTarget as {
+          source: { id: string; collection: string };
+          target: { id: string; collection: string };
+        };
+
+        if (!rootSourceAndTarget) {
+          return [...acc, edge];
+        }
 
-      if (sourceIsChannel) {
-        const edgeLabel =
-          dataTarget?.collection === 'services'
-            ? getEdgeLabelForMessageAsSource(dataSource as CollectionEntry<CollectionMessageTypes>)
-            : getEdgeLabelForServiceAsTarget(dataTarget as CollectionEntry<CollectionMessageTypes>);
+        // is target services?
+        const targetIsService = rootSourceAndTarget?.target?.collection === 'services';
+        const edgeLabel = targetIsService
+          ? getEdgeLabelForMessageAsSource(rootSourceAndTarget.source as any)
+          : getEdgeLabelForServiceAsTarget(rootSourceAndTarget.target as any);
+
+        const newEdgeId = `${rootSourceAndTarget.source.id}-${rootSourceAndTarget.target.id}`;
 
         return [
           ...acc,
           createEdge({
-            id: generatedIdForEdge(dataSource, dataTarget),
-            source: generateIdForNode(dataSource),
-            target: generateIdForNode(dataTarget),
+            id: newEdgeId,
+            source: rootSourceAndTarget.source.id,
+            target: rootSourceAndTarget.target.id,
             label: edgeLabel,
           }),
         ];
       }
-
-      return [...acc, edge];
+      return acc;
     }, []);
+
+    return newEdges.filter((edge, index, self) => index === self.findIndex((t) => t.id === edge.id));
   }, [edges, channels]);
 
+  // console.log('UPDATED EDGES', JSON.stringify(updatedEdges, null, 2));
+
   useEffect(() => {
     // Skip processing if there are no channels to manage
     if (skipProcessing) {

package/eventcatalog/src/utils/channels.ts

@@ -1,7 +1,7 @@
 import { getCollection } from 'astro:content';
 import type { CollectionEntry } from 'astro:content';
 import path from 'path';
-import { getVersionForCollectionItem, satisfies } from './collections/util';
+import { getItemsFromCollectionByIdAndSemverOrLatest, getVersionForCollectionItem, satisfies } from './collections/util';
 import { getMessages } from './messages';
 import type { CollectionMessageTypes } from '@types';
 import utils from '@eventcatalog/sdk';
@@ -92,3 +92,75 @@ export const getChannels = async ({ getAllVersions = true }: Props = {}): Promis
 
   return cachedChannels[cacheKey];
 };
+
+// Could be recursive, we need to keep going until we find a loop or until we reach the target channel
+export const isChannelsConnected = (
+  sourceChannel: CollectionEntry<'channels'>,
+  targetChannel: CollectionEntry<'channels'>,
+  channels: CollectionEntry<'channels'>[],
+  visited: Set<string> = new Set()
+) => {
+  // Create a unique key for this channel (id + version to handle multiple versions)
+  const channelKey = `${sourceChannel.data.id}:${sourceChannel.data.version}`;
+
+  // Base case: we've reached the target channel
+  if (sourceChannel.data.id === targetChannel.data.id) {
+    return true;
+  }
+
+  // Prevent infinite loops by tracking visited channels
+  if (visited.has(channelKey)) {
+    return false;
+  }
+
+  // Mark this channel as visited
+  visited.add(channelKey);
+
+  const routes = sourceChannel.data.routes ?? [];
+  for (const route of routes) {
+    const routeChannel = getItemsFromCollectionByIdAndSemverOrLatest(
+      channels,
+      route.id,
+      route.version
+    )[0] as CollectionEntry<'channels'>;
+
+    if (routeChannel) {
+      // Pass the visited set to the recursive call
+      if (isChannelsConnected(routeChannel, targetChannel, channels, visited)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+// Go from the source to the target channel and return the channel chain
+export const getChannelChain = (
+  sourceChannel: CollectionEntry<'channels'>,
+  targetChannel: CollectionEntry<'channels'>,
+  channels: CollectionEntry<'channels'>[]
+): CollectionEntry<'channels'>[] => {
+  // Base case: we've reached the target channel
+  if (sourceChannel.data.id === targetChannel.data.id && sourceChannel.data.version === targetChannel.data.version) {
+    return [sourceChannel];
+  }
+
+  const routes = sourceChannel.data.routes ?? [];
+
+  if (routes.length > 0 && isChannelsConnected(sourceChannel, targetChannel, channels)) {
+    // Need to check every route and see if any of them are connected to the target channel
+    for (const route of routes) {
+      const routeChannel = getItemsFromCollectionByIdAndSemverOrLatest(
+        channels,
+        route.id,
+        route.version
+      )[0] as CollectionEntry<'channels'>;
+      if (routeChannel) {
+        if (isChannelsConnected(routeChannel, targetChannel, channels)) {
+          return [sourceChannel, ...getChannelChain(routeChannel, targetChannel, channels)];
+        }
+      }
+    }
+  }
+  return [];
+};

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

@@ -42,6 +42,13 @@ export function sortVersioned<T>(versioned: T[], versionExtractor: (e: T) => str
   }
 }
 
+// Takes a collection and a id of a resource, and checks if the version is the latest version in the collection
+export const getLatestVersionInCollectionById = (collection: CollectionEntry<CollectionTypes>[], id: string) => {
+  const items = collection.filter((i) => i.data.id === id);
+  const sortedVersions = sortVersioned(items, (v) => v.data.version);
+  return sortedVersions[0]?.data.version ?? id;
+};
+
 export const getVersionForCollectionItem = (
   item: CollectionEntry<CollectionTypes>,
   collection: CollectionEntry<CollectionTypes>[]