@eventcatalog/core 2.12.3 → 2.13.0

package/src/utils/channels.ts

@@ -0,0 +1,64 @@
+import { getCollection } from 'astro:content';
+import type { CollectionEntry } from 'astro:content';
+import path from 'path';
+import { getVersionForCollectionItem, satisfies } from './collections/util';
+import { getMessages } from './messages';
+import type { CollectionMessageTypes } from '@types';
+
+const PROJECT_DIR = process.env.PROJECT_DIR || process.cwd();
+
+type Channel = CollectionEntry<'channels'> & {
+  catalog: {
+    path: string;
+    filePath: string;
+    type: string;
+  };
+};
+
+interface Props {
+  getAllVersions?: boolean;
+}
+
+export const getChannels = async ({ getAllVersions = true }: Props = {}): Promise<Channel[]> => {
+  const channels = await getCollection('channels', (query) => {
+    return (getAllVersions || !query.slug.includes('versioned')) && query.data.hidden !== true;
+  });
+
+  const { commands, events, queries } = await getMessages();
+  const allMessages = [...commands, ...events, ...queries];
+
+  return channels.map((channel) => {
+    const { latestVersion, versions } = getVersionForCollectionItem(channel, channels);
+
+    const messagesForChannel = allMessages.filter((message) => {
+      return message.data.channels?.some((messageChannel) => {
+        if (messageChannel.id != channel.data.id) return false;
+        if (messageChannel.version == 'latest' || messageChannel.version == undefined)
+          return channel.data.version == latestVersion;
+        return satisfies(channel.data.version, messageChannel.version);
+      });
+    });
+
+    const messages = messagesForChannel.map((message: CollectionEntry<CollectionMessageTypes>) => {
+      return { id: message.data.id, name: message.data.name, version: message.data.version, collection: message.collection };
+    });
+
+    return {
+      ...channel,
+      data: {
+        ...channel.data,
+        versions,
+        latestVersion,
+        messages,
+      },
+      catalog: {
+        path: path.join(channel.collection, channel.id.replace('/index.mdx', '')),
+        absoluteFilePath: path.join(PROJECT_DIR, channel.collection, channel.id.replace('/index.mdx', '/index.md')),
+        astroContentFilePath: path.join(process.cwd(), 'src', 'content', channel.collection, channel.id),
+        filePath: path.join(process.cwd(), 'src', 'catalog-files', channel.collection, channel.id.replace('/index.mdx', '')),
+        publicPath: path.join('/generated', channel.collection, channel.id.replace('/index.mdx', '')),
+        type: 'event',
+      },
+    };
+  });
+};

package/src/utils/collections/icons.ts

@@ -7,6 +7,8 @@ import {
   QueueListIcon,
   UserGroupIcon,
   UserIcon,
+  ArrowsRightLeftIcon,
+  VariableIcon,
 } from '@heroicons/react/24/outline';
 
 export const getIconForCollection = (collection: string) => {
@@ -27,6 +29,10 @@ export const getIconForCollection = (collection: string) => {
       return UserGroupIcon;
     case 'users':
       return UserIcon;
+    case 'channels':
+      return ArrowsRightLeftIcon;
+    case 'channels-parameter':
+      return VariableIcon;
     default:
       return ServerIcon;
   }

package/src/utils/commands.ts

@@ -21,7 +21,9 @@ export const getCommands = async ({ getAllVersions = true }: Props = {}): Promis
   const commands = await getCollection('commands', (command) => {
     return (getAllVersions || !command.slug.includes('versioned')) && command.data.hidden !== true;
   });
+
   const services = await getCollection('services');
+  const allChannels = await getCollection('channels');
 
   return commands.map((command) => {
     const { latestVersion, versions } = getVersionForCollectionItem(command, commands);
@@ -42,10 +44,14 @@ export const getCommands = async ({ getAllVersions = true }: Props = {}): Promis
       });
     });
 
+    const messageChannels = command.data.channels || [];
+    const channelsForCommand = allChannels.filter((c) => messageChannels.some((channel) => c.data.id === channel.id));
+
     return {
       ...command,
       data: {
         ...command.data,
+        messageChannels: channelsForCommand,
         producers,
         consumers,
         versions,

package/src/utils/{config → eventcatalog-config}/catalog.ts

@@ -24,7 +24,7 @@ const getConfigValue = (obj: any, key: string, defaultValue: any) => {
 
 export const isCollectionVisibleInCatalog = (collection: string) => {
   const sidebarConfig = config?.default?.docs?.sidebar || {};
-  const collections = ['events', 'commands', 'queries', 'domains', 'flows', 'services', 'teams', 'users'];
+  const collections = ['events', 'commands', 'queries', 'domains', 'channels', 'flows', 'services', 'teams', 'users'];
 
   if (!collections.includes(collection)) return false;
 

package/src/utils/events.ts

@@ -23,6 +23,7 @@ export const getEvents = async ({ getAllVersions = true }: Props = {}): Promise<
   });
 
   const services = await getCollection('services');
+  const allChannels = await getCollection('channels');
 
   return events.map((event) => {
     const { latestVersion, versions } = getVersionForCollectionItem(event, events);
@@ -43,10 +44,14 @@ export const getEvents = async ({ getAllVersions = true }: Props = {}): Promise<
       })
     );
 
+    const messageChannels = event.data.channels || [];
+    const channelsForEvent = allChannels.filter((c) => messageChannels.some((channel) => c.data.id === channel.id));
+
     return {
       ...event,
       data: {
         ...event.data,
+        messageChannels: channelsForEvent,
         producers,
         consumers,
         versions,

package/src/utils/{domains/node-graph.ts → node-graphs/domains-node-graph.ts}

@@ -1,6 +1,6 @@
 import { getCollection } from 'astro:content';
-import { createDagreGraph, calculatedNodes } from '@utils/node-graph-utils/utils';
-import { getNodesAndEdges as getServicesNodeAndEdges } from '../services/node-graph';
+import { createDagreGraph, calculatedNodes } from '@utils/node-graphs/utils/utils';
+import { getNodesAndEdges as getServicesNodeAndEdges } from './services-node-graph';
 import merge from 'lodash.merge';
 import { getItemsFromCollectionByIdAndSemverOrLatest } from '@utils/collections/util';
 

package/src/utils/{flows/node-graph.ts → node-graphs/flows-node-graph.ts}

@@ -1,6 +1,6 @@
 import { getCollection, type CollectionEntry } from 'astro:content';
 import dagre from 'dagre';
-import { createDagreGraph, calculatedNodes } from '@utils/node-graph-utils/utils';
+import { createDagreGraph, calculatedNodes } from '@utils/node-graphs/utils/utils';
 import { MarkerType } from 'reactflow';
 import type { Node as NodeType } from 'reactflow';
 import { getItemsFromCollectionByIdAndSemverOrLatest } from '@utils/collections/util';
@@ -118,7 +118,7 @@ export const getNodesAndEdges = async ({ id, defaultFlow, version, mode = 'simpl
         id: `step-${step.id}-step-${path.id}`,
         source: `step-${step.id}`,
         target: `step-${path.id}`,
-        type: 'smoothstep',
+        type: 'bezier',
         label: path.label,
         animated: true,
         markerEnd: {

package/src/utils/node-graphs/message-node-graph.ts

@@ -0,0 +1,216 @@
+// import { getColor } from '@utils/colors';
+import { getEvents } from '@utils/events';
+import type { CollectionEntry } from 'astro:content';
+import dagre from 'dagre';
+import {
+  calculatedNodes,
+  createDagreGraph,
+  createEdge,
+  generatedIdForEdge,
+  generateIdForNode,
+  getChannelNodesAndEdges,
+} from './utils/utils';
+import { MarkerType } from 'reactflow';
+import { findMatchingNodes } from '@utils/collections/util';
+import type { CollectionMessageTypes } from '@types';
+import { getCommands } from '@utils/commands';
+import { getQueries } from '@utils/queries';
+
+type DagreGraph = any;
+
+interface Props {
+  id: string;
+  version: string;
+  defaultFlow?: DagreGraph;
+  mode?: 'simple' | 'full';
+  collection?: CollectionEntry<CollectionMessageTypes>[];
+}
+
+const getEdgeLabelForServiceAsTarget = (data: CollectionEntry<CollectionMessageTypes>) => {
+  const type = data.collection;
+  switch (type) {
+    case 'commands':
+      return 'invokes';
+    case 'events':
+      return 'publishes event';
+    case 'queries':
+      return 'requests';
+    default:
+      return 'sends to';
+  }
+};
+const getEdgeLabelForMessageAsSource = (data: CollectionEntry<CollectionMessageTypes>) => {
+  const type = data.collection;
+  switch (type) {
+    case 'commands':
+      return 'accepts';
+    case 'events':
+      return 'subscribed by';
+    case 'queries':
+      return 'accepts';
+    default:
+      return 'sends to';
+  }
+};
+
+const getNodesAndEdges = async ({ id, version, defaultFlow, mode = 'simple', collection = [] }: Props) => {
+  const flow = defaultFlow || createDagreGraph({ ranksep: 300, nodesep: 50 });
+  const nodes = [] as any,
+    edges = [] as any;
+
+  const message = collection.find((message) => {
+    return message.data.id === id && message.data.version === version;
+  });
+
+  // Nothing found...
+  if (!message) {
+    return {
+      nodes: [],
+      edges: [],
+    };
+  }
+
+  const producers = (message.data.producers as CollectionEntry<'services'>[]) || [];
+  const consumers = (message.data.consumers as CollectionEntry<'services'>[]) || [];
+  const channels = (message.data.messageChannels as CollectionEntry<'channels'>[]) || [];
+
+  // Track nodes that are both sent and received
+  const bothSentAndReceived = findMatchingNodes(producers, consumers);
+
+  producers.forEach((producer) => {
+    nodes.push({
+      id: generateIdForNode(producer),
+      type: producer?.collection,
+      sourcePosition: 'right',
+      targetPosition: 'left',
+      data: { mode, service: producer },
+      position: { x: 250, y: 0 },
+    });
+
+    // If the event has channels, we need to render them, otherwise connect the producer to the event
+    if (message.data.channels) {
+      const { nodes: channelNodes, edges: channelEdges } = getChannelNodesAndEdges({
+        channels,
+        channelsToRender: message.data.channels,
+        source: producer,
+        target: message,
+        sourceToChannelLabel: getEdgeLabelForServiceAsTarget(message),
+        channelToTargetLabel: getEdgeLabelForServiceAsTarget(message),
+        mode,
+        currentNodes: nodes,
+      });
+      nodes.push(...channelNodes);
+      edges.push(...channelEdges);
+    } else {
+      edges.push({
+        id: generatedIdForEdge(producer, message),
+        source: generateIdForNode(producer),
+        target: generateIdForNode(message),
+        label: getEdgeLabelForServiceAsTarget(message),
+        data: { message },
+        animated: false,
+        markerEnd: {
+          type: MarkerType.ArrowClosed,
+          width: 40,
+          height: 40,
+        },
+        style: {
+          strokeWidth: 1,
+        },
+      });
+    }
+  });
+
+  // The message itself
+  nodes.push({
+    id: generateIdForNode(message),
+    sourcePosition: 'right',
+    targetPosition: 'left',
+    data: { mode, message: message },
+    position: { x: 0, y: 0 },
+    type: message.collection,
+  });
+
+  // The messages the service sends
+  consumers.forEach((consumer) => {
+    nodes.push({
+      id: generateIdForNode(consumer),
+      sourcePosition: 'right',
+      targetPosition: 'left',
+      data: { title: consumer?.data.id, mode, service: consumer },
+      position: { x: 0, y: 0 },
+      type: consumer?.collection,
+    });
+
+    if (message.data.channels) {
+      const { nodes: channelNodes, edges: channelEdges } = getChannelNodesAndEdges({
+        channels,
+        channelsToRender: channels.map((channel) => ({ id: channel.data.id, version: channel.data.version })),
+        source: message,
+        target: consumer,
+        channelToTargetLabel: getEdgeLabelForMessageAsSource(message),
+        mode,
+        currentNodes: nodes,
+      });
+
+      nodes.push(...channelNodes);
+      edges.push(...channelEdges);
+    } else {
+      edges.push(
+        createEdge({
+          id: generatedIdForEdge(message, consumer),
+          source: generateIdForNode(message),
+          target: generateIdForNode(consumer),
+          label: getEdgeLabelForMessageAsSource(message),
+          data: { message },
+        })
+      );
+    }
+  });
+
+  // Handle messages that are both sent and received
+  bothSentAndReceived.forEach((_message) => {
+    if (message) {
+      edges.push(
+        createEdge({
+          id: generatedIdForEdge(message, _message) + '-both',
+          source: generateIdForNode(message),
+          target: generateIdForNode(_message),
+          label: 'publishes and subscribes',
+          data: { message },
+        })
+      );
+    }
+  });
+
+  nodes.forEach((node: any) => {
+    flow.setNode(node.id, { width: 150, height: 100 });
+  });
+
+  edges.forEach((edge: any) => {
+    flow.setEdge(edge.source, edge.target);
+  });
+
+  // Render the diagram in memory getting hte X and Y
+  dagre.layout(flow);
+
+  return {
+    nodes: calculatedNodes(flow, nodes),
+    edges,
+  };
+};
+
+export const getNodesAndEdgesForQueries = async ({ id, version, defaultFlow, mode = 'simple' }: Props) => {
+  const queries = await getQueries();
+  return getNodesAndEdges({ id, version, defaultFlow, mode, collection: queries });
+};
+
+export const getNodesAndEdgesForCommands = async ({ id, version, defaultFlow, mode = 'simple' }: Props) => {
+  const commands = await getCommands();
+  return getNodesAndEdges({ id, version, defaultFlow, mode, collection: commands });
+};
+
+export const getNodesAndEdgesForEvents = async ({ id, version, defaultFlow, mode = 'simple' }: Props) => {
+  const events = await getEvents();
+  return getNodesAndEdges({ id, version, defaultFlow, mode, collection: events });
+};

package/src/utils/{services/node-graph.ts → node-graphs/services-node-graph.ts}

@@ -1,8 +1,16 @@
 import { getCollection, type CollectionEntry } from 'astro:content';
 import dagre from 'dagre';
-import { createDagreGraph, generateIdForNode, generatedIdForEdge, calculatedNodes } from '@utils/node-graph-utils/utils';
+import {
+  createDagreGraph,
+  generateIdForNode,
+  generatedIdForEdge,
+  calculatedNodes,
+  createEdge,
+  getChannelNodesAndEdges,
+} from '@utils/node-graphs/utils/utils';
 import { findMatchingNodes, getItemsFromCollectionByIdAndSemverOrLatest } from '@utils/collections/util';
 import { MarkerType } from 'reactflow';
+import type { CollectionMessageTypes } from '@types';
 
 type DagreGraph = any;
 
@@ -62,6 +70,7 @@ export const getNodesAndEdges = async ({ id, defaultFlow, version, mode = 'simpl
   const events = await getCollection('events');
   const commands = await getCollection('commands');
   const queries = await getCollection('queries');
+  const channels = await getCollection('channels');
 
   const messages = [...events, ...commands, ...queries];
 
@@ -75,50 +84,57 @@ export const getNodesAndEdges = async ({ id, defaultFlow, version, mode = 'simpl
     .flat()
     .filter((e) => e !== undefined);
 
-  const receives = (receivesHydrated as CollectionEntry<'events' | 'commands' | 'queries'>[]) || [];
-  const sends = (sendsHydrated as CollectionEntry<'events' | 'commands' | 'queries'>[]) || [];
+  const receives = (receivesHydrated as CollectionEntry<CollectionMessageTypes>[]) || [];
+  const sends = (sendsHydrated as CollectionEntry<CollectionMessageTypes>[]) || [];
 
   // Track messages that are both sent and received
   const bothSentAndReceived = findMatchingNodes(receives, sends);
 
-  // Get all the data from them
-  if (receives && receives.length > 0) {
-    // All the messages the service receives
-    receives.forEach((receive, index) => {
-      nodes.push({
-        id: generateIdForNode(receive),
-        type: receive?.collection,
-        sourcePosition: 'right',
-        targetPosition: 'left',
-        data: { mode, message: receive, showTarget: renderAllEdges },
-        position: { x: 250, y: index * 100 },
-      });
-      edges.push({
-        id: generatedIdForEdge(receive, service),
-        source: generateIdForNode(receive),
-        target: generateIdForNode(service),
-        type: 'smoothstep',
-        label: getReceivesMessageByMessageType(receive?.collection),
-        animated: false,
-        markerEnd: {
-          type: MarkerType.ArrowClosed,
-          width: 40,
-          height: 40,
-        },
-        style: {
-          strokeWidth: 1,
-        },
-      });
+  // All the messages the service receives
+  receives.forEach((receive) => {
+    // Create the node for the message
+    nodes.push({
+      id: generateIdForNode(receive),
+      type: receive?.collection,
+      sourcePosition: 'right',
+      targetPosition: 'left',
+      data: { mode, message: receive },
     });
-  }
+
+    // does the message have channels defined?
+    if (receive.data.channels) {
+      const { nodes: channelNodes, edges: channelEdges } = getChannelNodesAndEdges({
+        channels,
+        channelsToRender: receive.data.channels,
+        source: receive,
+        channelToTargetLabel: getReceivesMessageByMessageType(receive?.collection),
+        target: service,
+        mode,
+        currentNodes: nodes,
+      });
+
+      nodes.push(...channelNodes);
+      edges.push(...channelEdges);
+    } else {
+      // No channels, just link the message to the service
+      edges.push(
+        createEdge({
+          id: generatedIdForEdge(receive, service),
+          source: generateIdForNode(receive),
+          target: generateIdForNode(service),
+          label: getReceivesMessageByMessageType(receive?.collection),
+          data: { message: receive },
+        })
+      );
+    }
+  });
 
   // The service itself
   nodes.push({
     id: generateIdForNode(service),
     sourcePosition: 'right',
     targetPosition: 'left',
-    data: { mode, service: service, showSource: sends.length > 0, showTarget: receives.length > 0 },
-    position: { x: 0, y: 0 },
+    data: { mode, service: service },
     type: service.collection,
   });
 
@@ -128,26 +144,35 @@ export const getNodesAndEdges = async ({ id, defaultFlow, version, mode = 'simpl
       id: generateIdForNode(send),
       sourcePosition: 'right',
       targetPosition: 'left',
-      data: { mode, message: send, showSource: renderAllEdges },
-      position: { x: 500, y: index * 100 },
+      data: { mode, message: send },
       type: send?.collection,
     });
-    edges.push({
-      id: generatedIdForEdge(service, send),
-      source: generateIdForNode(service),
-      target: generateIdForNode(send),
-      type: 'smoothstep',
-      label: getSendsMessageByMessageType(send?.collection),
-      animated: false,
-      markerEnd: {
-        type: MarkerType.ArrowClosed,
-        width: 40,
-        height: 40,
-      },
-      style: {
-        strokeWidth: 1,
-      },
-    });
+
+    if (send.data.channels) {
+      const { nodes: channelNodes, edges: channelEdges } = getChannelNodesAndEdges({
+        channels,
+        channelsToRender: send.data.channels,
+        source: service,
+        target: send,
+        mode,
+        sourceToChannelLabel: `${getSendsMessageByMessageType(send?.collection)}`,
+        channelToTargetLabel: getSendsMessageByMessageType(send?.collection),
+        currentNodes: nodes,
+      });
+      nodes.push(...channelNodes);
+      edges.push(...channelEdges);
+    } else {
+      // No channels, just link the message to the service
+      edges.push(
+        createEdge({
+          id: generatedIdForEdge(service, send),
+          source: generateIdForNode(service),
+          target: generateIdForNode(send),
+          label: getSendsMessageByMessageType(send?.collection),
+          data: { message: send },
+        })
+      );
+    }
   });
 
   // Handle messages that are both sent and received
@@ -157,9 +182,9 @@ export const getNodesAndEdges = async ({ id, defaultFlow, version, mode = 'simpl
         id: generatedIdForEdge(service, message) + '-both',
         source: generateIdForNode(service),
         target: generateIdForNode(message),
-        type: 'smoothstep',
         label: `${getSendsMessageByMessageType(message?.collection)} & ${getReceivesMessageByMessageType(message?.collection)}`,
         animated: false,
+        data: { message },
         markerEnd: {
           type: MarkerType.ArrowClosed,
           width: 40,
@@ -185,6 +210,6 @@ export const getNodesAndEdges = async ({ id, defaultFlow, version, mode = 'simpl
 
   return {
     nodes: calculatedNodes(flow, nodes),
-    edges: edges,
+    edges,
   };
 };