@eventcatalog/core 2.58.2 → 2.59.0

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

@@ -0,0 +1,94 @@
+import { getCollection } from 'astro:content';
+import type { CollectionEntry } from 'astro:content';
+import path from 'path';
+import { getVersionForCollectionItem, satisfies } from './util';
+
+const PROJECT_DIR = process.env.PROJECT_DIR || process.cwd();
+
+export type Entity = CollectionEntry<'containers'> & {
+  catalog: {
+    path: string;
+    filePath: string;
+    type: string;
+  };
+};
+
+interface Props {
+  getAllVersions?: boolean;
+}
+
+// cache for build time
+let cachedEntities: Record<string, Entity[]> = {
+  allVersions: [],
+  currentVersions: [],
+};
+
+export const getContainers = async ({ getAllVersions = true }: Props = {}): Promise<Entity[]> => {
+  const cacheKey = getAllVersions ? 'allVersions' : 'currentVersions';
+
+  if (cachedEntities[cacheKey].length > 0) {
+    return cachedEntities[cacheKey];
+  }
+
+  const containers = await getCollection('containers', (container) => {
+    return (getAllVersions || !container.filePath?.includes('versioned')) && container.data.hidden !== true;
+  });
+
+  const services = await getCollection('services');
+
+  cachedEntities[cacheKey] = containers.map((container) => {
+    const { latestVersion, versions } = getVersionForCollectionItem(container, containers);
+
+    const servicesThatReferenceContainer = services.filter((service) => {
+      const references = [...(service.data.writesTo || []), ...(service.data.readsFrom || [])];
+      return references.some((item) => {
+        if (item.id != container.data.id) return false;
+        if (item.version == 'latest' || item.version == undefined) return container.data.version == latestVersion;
+        return satisfies(container.data.version, item.version);
+      });
+    });
+
+    const servicesThatWriteToContainer = services.filter((service) => {
+      return service.data?.writesTo?.some((item) => {
+        if (item.id != container.data.id) return false;
+        if (item.version == 'latest' || item.version == undefined) return container.data.version == latestVersion;
+        return satisfies(container.data.version, item.version);
+      });
+    });
+
+    const servicesThatReadFromContainer = services.filter((service) => {
+      return service.data?.readsFrom?.some((item) => {
+        if (item.id != container.data.id) return false;
+        if (item.version == 'latest' || item.version == undefined) return container.data.version == latestVersion;
+        return satisfies(container.data.version, item.version);
+      });
+    });
+
+    return {
+      ...container,
+      data: {
+        ...container.data,
+        versions,
+        latestVersion,
+        services: servicesThatReferenceContainer,
+        servicesThatWriteToContainer,
+        servicesThatReadFromContainer,
+      },
+      catalog: {
+        path: path.join(container.collection, container.id.replace('/index.mdx', '')),
+        absoluteFilePath: path.join(PROJECT_DIR, container.collection, container.id.replace('/index.mdx', '/index.md')),
+        astroContentFilePath: path.join(process.cwd(), 'src', 'content', container.collection, container.id),
+        filePath: path.join(process.cwd(), 'src', 'catalog-files', container.collection, container.id.replace('/index.mdx', '')),
+        publicPath: path.join('/generated', container.collection, container.id.replace(`-${container.data.version}`, '')),
+        type: 'container',
+      },
+    };
+  });
+
+  // order them by the name of the event
+  cachedEntities[cacheKey].sort((a, b) => {
+    return (a.data.name || a.data.id).localeCompare(b.data.name || b.data.id);
+  });
+
+  return cachedEntities[cacheKey];
+};

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

@@ -11,7 +11,7 @@ import {
   VariableIcon,
   MapIcon,
 } from '@heroicons/react/24/outline';
-import { BookText, Box } from 'lucide-react';
+import { BookText, Box, DatabaseIcon } from 'lucide-react';
 
 export const getIconForCollection = (collection: string) => {
   switch (collection) {
@@ -41,6 +41,8 @@ export const getIconForCollection = (collection: string) => {
       return MapIcon;
     case 'entities':
       return Box;
+    case 'containers':
+      return DatabaseIcon;
     default:
       return ServerIcon;
   }

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

@@ -35,6 +35,7 @@ export const getServices = async ({ getAllVersions = true }: Props = {}): Promis
   const commands = await getCollection('commands');
   const queries = await getCollection('queries');
   const entities = await getCollection('entities');
+  const containers = await getCollection('containers');
   const allMessages = [...events, ...commands, ...queries];
 
   // @ts-ignore // TODO: Fix this type
@@ -44,6 +45,8 @@ export const getServices = async ({ getAllVersions = true }: Props = {}): Promis
     const sendsMessages = service.data.sends || [];
     const receivesMessages = service.data.receives || [];
     const serviceEntities = service.data.entities || [];
+    const serviceWritesTo = service.data.writesTo || [];
+    const serviceReadsFrom = service.data.readsFrom || [];
 
     const sends = sendsMessages
       .map((message: any) => getItemsFromCollectionByIdAndSemverOrLatest(allMessages, message.id, message.version))
@@ -60,10 +63,22 @@ export const getServices = async ({ getAllVersions = true }: Props = {}): Promis
       .flat()
       .filter((e: any) => e !== undefined);
 
+    const mappedWritesTo = serviceWritesTo
+      .map((container: any) => getItemsFromCollectionByIdAndSemverOrLatest(containers, container.id, container.version))
+      .flat()
+      .filter((e: any) => e !== undefined);
+
+    const mappedReadsFrom = serviceReadsFrom
+      .map((container: any) => getItemsFromCollectionByIdAndSemverOrLatest(containers, container.id, container.version))
+      .flat()
+      .filter((e: any) => e !== undefined);
+
     return {
       ...service,
       data: {
         ...service.data,
+        writesTo: mappedWritesTo,
+        readsFrom: mappedReadsFrom,
         receives,
         sends,
         versions,
@@ -157,7 +172,6 @@ export const getSpecificationsForService = (service: CollectionEntry<CollectionT
     filenameWithoutExtension: path.basename(spec.path, path.extname(spec.path)),
   }));
 };
-
 // Get services for channel
 export const getProducersAndConsumersForChannel = async (channel: CollectionEntry<'channels'>) => {
   const messages = channel.data.messages ?? [];

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

@@ -87,8 +87,8 @@ export const getItemsFromCollectionByIdAndSemverOrLatest = <T extends { data: {
 };
 
 export const findMatchingNodes = (
-  nodesA: CollectionEntry<'events' | 'commands' | 'queries' | 'services'>[],
-  nodesB: CollectionEntry<'events' | 'commands' | 'queries' | 'services'>[]
+  nodesA: CollectionEntry<'events' | 'commands' | 'queries' | 'services' | 'containers'>[],
+  nodesB: CollectionEntry<'events' | 'commands' | 'queries' | 'services' | 'containers'>[]
 ) => {
   // Track messages that are both sent and received
   return nodesA.filter((nodeA) => {
@@ -108,6 +108,7 @@ export const resourceToCollectionMap = {
   channel: 'channels',
   user: 'users',
   team: 'teams',
+  container: 'containers',
 } as const;
 
 export const collectionToResourceMap = {
@@ -120,6 +121,7 @@ export const collectionToResourceMap = {
   channels: 'channel',
   users: 'user',
   teams: 'team',
+  containers: 'container',
 } as const;
 
 export const getDeprecatedDetails = (item: CollectionEntry<CollectionTypes>) => {

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

@@ -0,0 +1,155 @@
+import type { CollectionEntry } from 'astro:content';
+import dagre from 'dagre';
+import { calculatedNodes, createDagreGraph, createEdge, generatedIdForEdge, generateIdForNode } from './utils/utils';
+import { MarkerType } from '@xyflow/react';
+import { findMatchingNodes } from '@utils/collections/util';
+import { getContainers } from '@utils/collections/containers';
+
+type DagreGraph = any;
+
+interface Props {
+  id: string;
+  version: string;
+  defaultFlow?: DagreGraph;
+  mode?: 'simple' | 'full';
+  channelRenderMode?: 'flat' | 'single';
+  collection?: CollectionEntry<'containers'>[];
+}
+
+export const getNodesAndEdges = async ({ id, version, defaultFlow, mode = 'simple', channelRenderMode = 'flat' }: Props) => {
+  const containers = await getContainers();
+
+  const flow = defaultFlow || createDagreGraph({ ranksep: 300, nodesep: 50 });
+  const nodes = [] as any,
+    edges = [] as any;
+
+  const container = containers.find((container) => container.data.id === id && container.data.version === version);
+
+  // Nothing found...
+  if (!container) {
+    return {
+      nodes: [],
+      edges: [],
+    };
+  }
+
+  const servicesThatWriteToContainer = (container.data.servicesThatWriteToContainer as CollectionEntry<'services'>[]) || [];
+  const servicesThatReadFromContainer = (container.data.servicesThatReadFromContainer as CollectionEntry<'services'>[]) || [];
+
+  // Track nodes that are bth sent and received
+  const bothSentAndReceived = findMatchingNodes(servicesThatWriteToContainer, servicesThatReadFromContainer);
+
+  servicesThatWriteToContainer.forEach((service) => {
+    nodes.push({
+      id: generateIdForNode(service),
+      type: service?.collection,
+      sourcePosition: 'right',
+      targetPosition: 'left',
+      data: { mode, service: { ...service.data } },
+      position: { x: 250, y: 0 },
+    });
+
+    if (!bothSentAndReceived.includes(service)) {
+      edges.push({
+        id: generatedIdForEdge(service, container),
+        source: generateIdForNode(service),
+        target: generateIdForNode(container),
+        label: 'writes to',
+        data: { service },
+        animated: false,
+        type: 'default',
+        style: {
+          strokeWidth: 1,
+        },
+      });
+    }
+  });
+
+  // The message itself
+  nodes.push({
+    id: generateIdForNode(container),
+    sourcePosition: 'right',
+    targetPosition: 'left',
+    data: {
+      mode,
+      data: {
+        ...container.data,
+      },
+    },
+    position: { x: 0, y: 0 },
+    type: 'data',
+  });
+
+  //   // The messages the service sends
+  servicesThatReadFromContainer.forEach((service) => {
+    nodes.push({
+      id: generateIdForNode(service),
+      sourcePosition: 'left',
+      targetPosition: 'right',
+      data: { title: service?.data.id, mode, service: { ...service.data } },
+      position: { x: 0, y: 0 },
+      type: service?.collection,
+    });
+
+    if (!bothSentAndReceived.includes(service)) {
+      edges.push(
+        createEdge({
+          id: generatedIdForEdge(service, container),
+          source: generateIdForNode(container),
+          target: generateIdForNode(service),
+          label: `reads from \n (${container.data.technology})`,
+          data: { service },
+          type: 'multiline',
+          // type: 'animatedData',
+          markerStart: {
+            type: MarkerType.ArrowClosed,
+            width: 40,
+            height: 40,
+          },
+          markerEnd: undefined,
+        })
+      );
+    }
+  });
+
+  // Handle messages that are both sent and received
+  bothSentAndReceived.forEach((_service) => {
+    if (container) {
+      edges.push(
+        createEdge({
+          id: generatedIdForEdge(container, _service) + '-both',
+          source: generateIdForNode(_service),
+          target: generateIdForNode(container),
+          label: `read and writes to \n (${container.data.technology})`,
+          type: 'multiline',
+          markerStart: {
+            type: MarkerType.ArrowClosed,
+            width: 40,
+            height: 40,
+          },
+          markerEnd: {
+            type: MarkerType.ArrowClosed,
+            width: 40,
+            height: 40,
+          },
+        })
+      );
+    }
+  });
+
+  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,
+  };
+};

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

@@ -21,6 +21,7 @@ interface Props {
   mode?: 'simple' | 'full';
   renderAllEdges?: boolean;
   channelRenderMode?: 'single' | 'flat';
+  renderMessages?: boolean;
 }
 
 const getSendsMessageByMessageType = (messageType: string) => {
@@ -55,9 +56,10 @@ export const getNodesAndEdges = async ({
   mode = 'simple',
   renderAllEdges = false,
   channelRenderMode = 'flat',
+  renderMessages = true,
 }: Props) => {
   const flow = defaultFlow || createDagreGraph({ ranksep: 300, nodesep: 50 });
-  const nodes = [] as any,
+  let nodes = [] as any,
     edges = [] as any;
 
   const services = await getCollection('services');
@@ -74,11 +76,14 @@ export const getNodesAndEdges = async ({
 
   const receivesRaw = service?.data.receives || [];
   const sendsRaw = service?.data.sends || [];
+  const writesToRaw = service?.data.writesTo || [];
+  const readsFromRaw = service?.data.readsFrom || [];
 
   const events = await getCollection('events');
   const commands = await getCollection('commands');
   const queries = await getCollection('queries');
   const channels = await getCollection('channels');
+  const containers = await getCollection('containers');
 
   const messages = [...events, ...commands, ...queries];
 
@@ -92,51 +97,66 @@ export const getNodesAndEdges = async ({
     .flat()
     .filter((e) => e !== undefined);
 
+  const writesToHydrated = writesToRaw
+    .map((container) => getItemsFromCollectionByIdAndSemverOrLatest(containers, container.id, container.version))
+    .flat()
+    .filter((e) => e !== undefined);
+
+  const readsFromHydrated = readsFromRaw
+    .map((container) => getItemsFromCollectionByIdAndSemverOrLatest(containers, container.id, container.version))
+    .flat()
+    .filter((e) => e !== undefined);
+
   const receives = (receivesHydrated as CollectionEntry<CollectionMessageTypes>[]) || [];
   const sends = (sendsHydrated as CollectionEntry<CollectionMessageTypes>[]) || [];
+  const writesTo = (writesToHydrated as CollectionEntry<'containers'>[]) || [];
+  const readsFrom = (readsFromHydrated as CollectionEntry<'containers'>[]) || [];
 
   // Track messages that are both sent and received
   const bothSentAndReceived = findMatchingNodes(receives, sends);
+  const bothReadsAndWrites = findMatchingNodes(readsFrom, writesTo);
 
-  // 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.data } },
-    });
-
-    // 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,
-        channelRenderMode,
+  if (renderMessages) {
+    // 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.data } },
       });
 
-      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.data } },
-        })
-      );
-    }
-  });
+      // 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,
+          channelRenderMode,
+        });
+
+        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.data } },
+          })
+        );
+      }
+    });
+  }
 
   // The service itself
   nodes.push({
@@ -148,66 +168,152 @@ export const getNodesAndEdges = async ({
     type: service.collection,
   });
 
-  // The messages the service sends
-  sends.forEach((send, index) => {
+  // Any containers the service writes to
+  writesTo.forEach((writeTo) => {
     nodes.push({
-      id: generateIdForNode(send),
+      id: generateIdForNode(writeTo),
       sourcePosition: 'right',
       targetPosition: 'left',
-      data: { mode, message: { ...send.data } },
-      type: send?.collection,
+      data: { mode, data: { ...writeTo.data } },
+      type: 'data',
     });
 
-    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,
-        channelRenderMode,
-      });
-      nodes.push(...channelNodes);
-      edges.push(...channelEdges);
-    } else {
-      // No channels, just link the message to the service
+    // If its not in the reads/and writes to, we need to add the edge
+    if (!bothReadsAndWrites.includes(writeTo)) {
       edges.push(
         createEdge({
-          id: generatedIdForEdge(service, send),
+          id: generatedIdForEdge(service, writeTo),
           source: generateIdForNode(service),
-          target: generateIdForNode(send),
-          label: getSendsMessageByMessageType(send?.collection),
-          data: { message: { ...send.data } },
+          target: generateIdForNode(writeTo),
+          label: `writes to \n (${writeTo.data?.technology})`,
+          type: 'multiline',
+          markerEnd: {
+            type: MarkerType.ArrowClosed,
+            color: '#666',
+            width: 40,
+            height: 40,
+          },
         })
       );
     }
   });
 
-  // Handle messages that are both sent and received
-  bothSentAndReceived.forEach((message) => {
-    if (message) {
-      edges.push({
-        id: generatedIdForEdge(service, message) + '-both',
-        source: generateIdForNode(service),
-        target: generateIdForNode(message),
-        label: `${getSendsMessageByMessageType(message?.collection)} & ${getReceivesMessageByMessageType(message?.collection)}`,
-        animated: false,
-        data: { message: { ...message.data } },
-        markerEnd: {
-          type: MarkerType.ArrowClosed,
-          width: 40,
-          height: 40,
-        },
-        style: {
-          strokeWidth: 1,
-        },
-      });
+  // Any containers the service reads from
+  readsFrom.forEach((readFrom) => {
+    nodes.push({
+      id: generateIdForNode(readFrom),
+      sourcePosition: 'right',
+      targetPosition: 'left',
+      data: { mode, data: { ...readFrom.data } },
+      type: 'data',
+    });
+
+    // If its not in the reads/and writes to, we need to add the edge
+    if (!bothReadsAndWrites.includes(readFrom)) {
+      edges.push(
+        createEdge({
+          id: generatedIdForEdge(service, readFrom),
+          source: generateIdForNode(readFrom),
+          target: generateIdForNode(service),
+          label: `reads from \n (${readFrom.data?.technology})`,
+          type: 'multiline',
+          markerStart: {
+            type: MarkerType.ArrowClosed,
+            color: '#666',
+            width: 40,
+            height: 40,
+          },
+          markerEnd: undefined,
+        })
+      );
     }
   });
 
+  if (renderMessages) {
+    // The messages the service sends
+    sends.forEach((send, index) => {
+      nodes.push({
+        id: generateIdForNode(send),
+        sourcePosition: 'right',
+        targetPosition: 'left',
+        data: { mode, message: { ...send.data } },
+        type: send?.collection,
+      });
+
+      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,
+          channelRenderMode,
+        });
+        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.data } },
+          })
+        );
+      }
+    });
+
+    // Handle messages that are both sent and received
+    bothSentAndReceived.forEach((message) => {
+      if (message) {
+        edges.push({
+          id: generatedIdForEdge(service, message) + '-both',
+          source: generateIdForNode(service),
+          target: generateIdForNode(message),
+          label: `${getSendsMessageByMessageType(message?.collection)} & ${getReceivesMessageByMessageType(message?.collection)}`,
+          animated: false,
+          data: { message: { ...message.data } },
+          markerEnd: {
+            type: MarkerType.ArrowClosed,
+            width: 40,
+            height: 40,
+          },
+          style: {
+            strokeWidth: 1,
+          },
+        });
+      }
+    });
+  }
+
+  bothReadsAndWrites.forEach((container) => {
+    edges.push({
+      id: generatedIdForEdge(service, container) + '-both',
+      source: generateIdForNode(service),
+      target: generateIdForNode(container),
+      type: 'multiline',
+      // @ts-ignore
+      label: `reads from \n and writes to \n (${container.data.technology})`,
+      markerStart: {
+        type: MarkerType.ArrowClosed,
+        color: '#666',
+        width: 40,
+        height: 40,
+      },
+      markerEnd: {
+        type: MarkerType.ArrowClosed,
+        color: '#666',
+        width: 40,
+        height: 40,
+      },
+    });
+  });
+
   nodes.forEach((node: any) => {
     flow.setNode(node.id, { width: 150, height: 100 });
   });