@eventcatalog/core 3.7.1 → 3.8.0

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

@@ -1,7 +1,8 @@
 import { getCollection } from 'astro:content';
 import type { CollectionEntry } from 'astro:content';
 import path from 'path';
-import { createVersionedMap, findInMap, satisfies } from './util';
+import { createVersionedMap } from './util';
+import { hydrateProducersAndConsumers } from './messages';
 import utils from '@eventcatalog/sdk';
 
 const PROJECT_DIR = process.env.PROJECT_DIR || process.cwd();
@@ -35,10 +36,11 @@ export const getEvents = async ({ getAllVersions = true, hydrateServices = true
   }
 
   // 1. Fetch collections in parallel
-  const [allEvents, allServices, allChannels] = await Promise.all([
+  const [allEvents, allServices, allChannels, allDataProducts] = await Promise.all([
     getCollection('events'),
     getCollection('services'),
     getCollection('channels'),
+    getCollection('data-products'),
   ]);
 
   // 2. Build optimized maps
@@ -64,33 +66,13 @@ export const getEvents = async ({ getAllVersions = true, hydrateServices = true
       const latestVersion = eventVersions[0]?.data.version || event.data.version;
       const versions = eventVersions.map((e) => e.data.version);
 
-      // Find Producers (Services that send this event)
-      const producers = allServices
-        .filter((service) =>
-          service.data.sends?.some((item) => {
-            if (item.id !== event.data.id) return false;
-            if (item.version === 'latest' || item.version === undefined) return event.data.version === latestVersion;
-            return satisfies(event.data.version, item.version);
-          })
-        )
-        .map((service) => {
-          if (!hydrateServices) return { id: service.data.id, version: service.data.version };
-          return service;
-        });
-
-      // Find Consumers (Services that receive this event)
-      const consumers = allServices
-        .filter((service) =>
-          service.data.receives?.some((item) => {
-            if (item.id !== event.data.id) return false;
-            if (item.version === 'latest' || item.version === undefined) return event.data.version === latestVersion;
-            return satisfies(event.data.version, item.version);
-          })
-        )
-        .map((service) => {
-          if (!hydrateServices) return { id: service.data.id, version: service.data.version };
-          return service;
-        });
+      // Find producers and consumers (services + data products)
+      const { producers, consumers } = hydrateProducersAndConsumers({
+        message: { data: { ...event.data, latestVersion } },
+        services: allServices,
+        dataProducts: allDataProducts,
+        hydrate: hydrateServices,
+      });
 
       // Find Channels
       const messageChannels = event.data.channels || [];

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

@@ -10,6 +10,7 @@ import {
   ArrowsRightLeftIcon,
   VariableIcon,
   MapIcon,
+  CubeIcon,
 } from '@heroicons/react/24/outline';
 import { BookText, Box, DatabaseIcon } from 'lucide-react';
 
@@ -43,6 +44,8 @@ export const getIconForCollection = (collection: string) => {
       return Box;
     case 'containers':
       return DatabaseIcon;
+    case 'data-products':
+      return CubeIcon;
     default:
       return ServerIcon;
   }
@@ -74,6 +77,8 @@ export const getColorAndIconForCollection = (collection: string) => {
       return { color: 'yellow', Icon: icon };
     case 'services':
       return { color: 'pink', Icon: icon };
+    case 'data-products':
+      return { color: 'cyan', Icon: icon };
     default:
       return { color: 'gray', Icon: icon };
   }

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

@@ -3,6 +3,7 @@ import { getCommands } from '@utils/collections/commands';
 import { getEvents } from '@utils/collections/events';
 import { getQueries } from './queries';
 import type { CollectionEntry } from 'astro:content';
+import { satisfies } from './util';
 export { getCommands } from '@utils/collections/commands';
 export { getEvents } from '@utils/collections/events';
 
@@ -11,6 +12,69 @@ interface Props {
   hydrateServices?: boolean;
 }
 
+interface HydrateProducersAndConsumersProps {
+  message: {
+    data: {
+      id: string;
+      version: string;
+      latestVersion?: string;
+    };
+  };
+  services: CollectionEntry<'services'>[];
+  dataProducts: CollectionEntry<'data-products'>[];
+  hydrate?: boolean;
+}
+
+/**
+ * Hydrates producers and consumers for a message (event, command, or query).
+ * Finds services and data products that produce or consume the given message.
+ */
+export const hydrateProducersAndConsumers = ({
+  message,
+  services = [],
+  dataProducts = [],
+  hydrate = true,
+}: HydrateProducersAndConsumersProps) => {
+  const { id: messageId, version: messageVersion, latestVersion = messageVersion } = message.data;
+
+  const matchesVersion = (pointerVersion: string | undefined) => {
+    if (pointerVersion === 'latest' || pointerVersion === undefined) {
+      return messageVersion === latestVersion;
+    }
+    return satisfies(messageVersion, pointerVersion);
+  };
+
+  const toResult = <T extends CollectionEntry<'services'> | CollectionEntry<'data-products'>>(resource: T) => {
+    if (!hydrate) return { id: resource.data.id, version: resource.data.version };
+    return resource;
+  };
+
+  // Services that send this message (producers)
+  const serviceProducers = services
+    .filter((s) => s.data.sends?.some((p) => p.id === messageId && matchesVersion(p.version)))
+    .map(toResult);
+
+  // Services that receive this message (consumers)
+  const serviceConsumers = services
+    .filter((s) => s.data.receives?.some((p) => p.id === messageId && matchesVersion(p.version)))
+    .map(toResult);
+
+  // Data products that output this message (producers)
+  const dataProductProducers = dataProducts
+    .filter((dp) => dp.data.outputs?.some((p) => p.id === messageId && matchesVersion(p.version)))
+    .map(toResult);
+
+  // Data products that input this message (consumers)
+  const dataProductConsumers = dataProducts
+    .filter((dp) => dp.data.inputs?.some((p) => p.id === messageId && matchesVersion(p.version)))
+    .map(toResult);
+
+  return {
+    producers: [...serviceProducers, ...dataProductProducers],
+    consumers: [...serviceConsumers, ...dataProductConsumers],
+  };
+};
+
 type Messages = {
   commands: CollectionEntry<'commands'>[];
   events: CollectionEntry<'events'>[];
@@ -40,3 +104,7 @@ export const getMessages = async ({ getAllVersions = true, hydrateServices = tru
     queries,
   };
 };
+
+export const isCollectionAMessage = (collection: string): boolean => {
+  return ['events', 'commands', 'queries'].includes(collection);
+};

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

@@ -2,7 +2,8 @@ import { getCollection } from 'astro:content';
 import type { CollectionEntry } from 'astro:content';
 import path from 'path';
 import utils from '@eventcatalog/sdk';
-import { createVersionedMap, satisfies } from './util';
+import { createVersionedMap } from './util';
+import { hydrateProducersAndConsumers } from './messages';
 
 const PROJECT_DIR = process.env.PROJECT_DIR || process.cwd();
 const CACHE_ENABLED = process.env.DISABLE_EVENTCATALOG_CACHE !== 'true';
@@ -34,10 +35,11 @@ export const getQueries = async ({ getAllVersions = true, hydrateServices = true
   }
 
   // 1. Fetch collections in parallel
-  const [allQueries, allServices, allChannels] = await Promise.all([
+  const [allQueries, allServices, allChannels, allDataProducts] = await Promise.all([
     getCollection('queries'),
     getCollection('services'),
     getCollection('channels'),
+    getCollection('data-products'),
   ]);
 
   // 2. Build optimized maps
@@ -60,33 +62,13 @@ export const getQueries = async ({ getAllVersions = true, hydrateServices = true
       const latestVersion = queryVersions[0]?.data.version || query.data.version;
       const versions = queryVersions.map((e) => e.data.version);
 
-      // Find Producers (Services that send this query)
-      const producers = allServices
-        .filter((service) =>
-          service.data.sends?.some((item) => {
-            if (item.id !== query.data.id) return false;
-            if (item.version === 'latest' || item.version === undefined) return query.data.version === latestVersion;
-            return satisfies(query.data.version, item.version);
-          })
-        )
-        .map((service) => {
-          if (!hydrateServices) return { id: service.data.id, version: service.data.version };
-          return service;
-        });
-
-      // Find Consumers (Services that receive this query)
-      const consumers = allServices
-        .filter((service) =>
-          service.data.receives?.some((item) => {
-            if (item.id !== query.data.id) return false;
-            if (item.version === 'latest' || item.version === undefined) return query.data.version === latestVersion;
-            return satisfies(query.data.version, item.version);
-          })
-        )
-        .map((service) => {
-          if (!hydrateServices) return { id: service.data.id, version: service.data.version };
-          return service;
-        });
+      // Find producers and consumers (services + data products)
+      const { producers, consumers } = hydrateProducersAndConsumers({
+        message: { data: { ...query.data, latestVersion } },
+        services: allServices,
+        dataProducts: allDataProducts,
+        hydrate: hydrateServices,
+      });
 
       // Find Channels
       const messageChannels = query.data.channels || [];

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

@@ -6,7 +6,7 @@ import type { CollectionMessageTypes, CollectionTypes } from '@types';
 const PROJECT_DIR = process.env.PROJECT_DIR || process.cwd();
 import utils, { type Domain } from '@eventcatalog/sdk';
 import { getDomains, getDomainsForService } from './domains';
-import { createVersionedMap, findInMap } from '@utils/collections/util';
+import { createVersionedMap, findInMap, processSpecifications } from '@utils/collections/util';
 
 export type Service = CollectionEntry<'services'>;
 
@@ -174,31 +174,7 @@ export const getConsumersOfMessage = (services: Service[], message: CollectionEn
 };
 
 export const getSpecificationsForService = (service: CollectionEntry<CollectionTypes>) => {
-  const specifications = Array.isArray(service.data.specifications) ? service.data.specifications : [];
-
-  if (service.data.specifications && !Array.isArray(service.data.specifications)) {
-    if (service.data.specifications.asyncapiPath) {
-      specifications.push({
-        type: 'asyncapi',
-        path: service.data.specifications.asyncapiPath,
-        name: 'AsyncAPI',
-      });
-    }
-    if (service.data.specifications.openapiPath) {
-      specifications.push({
-        type: 'openapi',
-        path: service.data.specifications.openapiPath,
-        name: 'OpenAPI',
-      });
-    }
-  }
-
-  return specifications.map((spec) => ({
-    ...spec,
-    name: spec.name || (spec.type === 'asyncapi' ? 'AsyncAPI' : 'OpenAPI'),
-    filename: path.basename(spec.path),
-    filenameWithoutExtension: path.basename(spec.path, path.extname(spec.path)),
-  }));
+  return processSpecifications(service.data.specifications as any);
 };
 // Get services for channel
 export const getProducersAndConsumersForChannel = async (channel: CollectionEntry<'channels'>) => {

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

@@ -1,6 +1,70 @@
 import type { CollectionTypes } from '@types';
 import type { CollectionEntry } from 'astro:content';
 import semver, { coerce, compare, eq, satisfies as satisfiesRange } from 'semver';
+import path from 'node:path';
+
+// --- SPECIFICATION HELPERS ---
+
+export type SpecificationType = 'asyncapi' | 'openapi' | 'graphql';
+
+export interface SpecificationInput {
+  type: SpecificationType;
+  path: string;
+  name?: string;
+}
+
+export interface ProcessedSpecification {
+  type: SpecificationType;
+  path: string;
+  name: string;
+  filename: string;
+  filenameWithoutExtension: string;
+}
+
+export const getDefaultSpecificationName = (type: string): string => {
+  switch (type) {
+    case 'asyncapi':
+      return 'AsyncAPI';
+    case 'openapi':
+      return 'OpenAPI';
+    case 'graphql':
+      return 'GraphQL';
+    default:
+      return 'Specification';
+  }
+};
+
+interface LegacySpecificationFormat {
+  asyncapiPath?: string;
+  openapiPath?: string;
+  graphqlPath?: string;
+}
+
+export const processSpecifications = (
+  specifications: SpecificationInput[] | LegacySpecificationFormat | undefined
+): ProcessedSpecification[] => {
+  const specs: SpecificationInput[] = Array.isArray(specifications) ? [...specifications] : [];
+
+  // Handle legacy object format
+  if (specifications && !Array.isArray(specifications)) {
+    if (specifications.asyncapiPath) {
+      specs.push({ type: 'asyncapi', path: specifications.asyncapiPath, name: 'AsyncAPI' });
+    }
+    if (specifications.openapiPath) {
+      specs.push({ type: 'openapi', path: specifications.openapiPath, name: 'OpenAPI' });
+    }
+    if (specifications.graphqlPath) {
+      specs.push({ type: 'graphql', path: specifications.graphqlPath, name: 'GraphQL' });
+    }
+  }
+
+  return specs.map((spec) => ({
+    ...spec,
+    name: spec.name || getDefaultSpecificationName(spec.type),
+    filename: path.basename(spec.path),
+    filenameWithoutExtension: path.basename(spec.path, path.extname(spec.path)),
+  }));
+};
 
 export const getPreviousVersion = (version: string, versions: string[]) => {
   const index = versions.indexOf(version);
@@ -94,8 +158,8 @@ export const getItemsFromCollectionByIdAndSemverOrLatest = <T extends { data: {
 };
 
 export const findMatchingNodes = (
-  nodesA: CollectionEntry<'events' | 'commands' | 'queries' | 'services' | 'containers'>[],
-  nodesB: CollectionEntry<'events' | 'commands' | 'queries' | 'services' | 'containers'>[]
+  nodesA: CollectionEntry<'events' | 'commands' | 'queries' | 'services' | 'containers' | 'data-products'>[],
+  nodesB: CollectionEntry<'events' | 'commands' | 'queries' | 'services' | 'containers' | 'data-products'>[]
 ) => {
   // Track messages that are both sent and received
   return nodesA.filter((nodeA) => {
@@ -118,6 +182,7 @@ export const resourceToCollectionMap = {
   container: 'containers',
   entity: 'entities',
   diagram: 'diagrams',
+  'data-product': 'data-products',
 } as const;
 
 export const collectionToResourceMap = {
@@ -133,6 +198,7 @@ export const collectionToResourceMap = {
   containers: 'container',
   entities: 'entity',
   diagrams: 'diagram',
+  'data-products': 'data-product',
 } as const;
 
 export const getDeprecatedDetails = (item: CollectionEntry<CollectionTypes>) => {
@@ -197,6 +263,13 @@ export const createVersionedMap = <T extends { data: { id: string; version?: str
   return map;
 };
 
+// Merge as many given maps as you want
+export const mergeMaps = <T>(...maps: Map<string, T[]>[]): Map<string, T[]> => {
+  return maps.reduce((acc, map) => {
+    return new Map([...acc, ...map]);
+  }, new Map<string, T[]>());
+};
+
 /**
  * Fast lookup helper.
  * If version is provided, find it. If not, return the first (latest) item.

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

@@ -37,9 +37,14 @@ export const getNodesAndEdges = async ({ id, version, defaultFlow, mode = 'simpl
 
   const servicesThatWriteToContainer = (container.data.servicesThatWriteToContainer as CollectionEntry<'services'>[]) || [];
   const servicesThatReadFromContainer = (container.data.servicesThatReadFromContainer as CollectionEntry<'services'>[]) || [];
+  const dataProductsThatWriteToContainer =
+    (container.data.dataProductsThatWriteToContainer as CollectionEntry<'data-products'>[]) || [];
+  const dataProductsThatReadFromContainer =
+    (container.data.dataProductsThatReadFromContainer as CollectionEntry<'data-products'>[]) || [];
 
-  // Track nodes that are bth sent and received
+  // Track nodes that are both sent and received
   const bothSentAndReceived = findMatchingNodes(servicesThatWriteToContainer, servicesThatReadFromContainer);
+  const dataProductsBothSentAndReceived = findMatchingNodes(dataProductsThatWriteToContainer, dataProductsThatReadFromContainer);
 
   servicesThatWriteToContainer.forEach((service) => {
     nodes.push({
@@ -67,7 +72,34 @@ export const getNodesAndEdges = async ({ id, version, defaultFlow, mode = 'simpl
     }
   });
 
-  // The message itself
+  // Data products that write to the container
+  dataProductsThatWriteToContainer.forEach((dataProduct) => {
+    nodes.push({
+      id: generateIdForNode(dataProduct),
+      type: 'data-products',
+      sourcePosition: 'right',
+      targetPosition: 'left',
+      data: { mode, dataProduct: { ...dataProduct.data } },
+      position: { x: 250, y: 0 },
+    });
+
+    if (!dataProductsBothSentAndReceived.includes(dataProduct)) {
+      edges.push({
+        id: generatedIdForEdge(dataProduct, container),
+        source: generateIdForNode(dataProduct),
+        target: generateIdForNode(container),
+        label: 'writes to',
+        data: { dataProduct },
+        animated: false,
+        type: 'default',
+        style: {
+          strokeWidth: 1,
+        },
+      });
+    }
+  });
+
+  // The container itself
   nodes.push({
     id: generateIdForNode(container),
     sourcePosition: 'right',
@@ -114,7 +146,38 @@ export const getNodesAndEdges = async ({ id, version, defaultFlow, mode = 'simpl
     }
   });
 
-  // Handle messages that are both sent and received
+  // Data products that read from the container
+  dataProductsThatReadFromContainer.forEach((dataProduct) => {
+    nodes.push({
+      id: generateIdForNode(dataProduct),
+      sourcePosition: 'left',
+      targetPosition: 'right',
+      data: { title: dataProduct?.data.id, mode, dataProduct: { ...dataProduct.data } },
+      position: { x: 0, y: 0 },
+      type: 'data-products',
+    });
+
+    if (!dataProductsBothSentAndReceived.includes(dataProduct)) {
+      edges.push(
+        createEdge({
+          id: generatedIdForEdge(dataProduct, container),
+          source: generateIdForNode(container),
+          target: generateIdForNode(dataProduct),
+          label: `reads from \n (${container.data.technology})`,
+          data: { dataProduct },
+          type: 'multiline',
+          markerStart: {
+            type: MarkerType.ArrowClosed,
+            width: 40,
+            height: 40,
+          },
+          markerEnd: undefined,
+        })
+      );
+    }
+  });
+
+  // Handle services that are both sent and received
   bothSentAndReceived.forEach((_service) => {
     if (container) {
       edges.push(
@@ -139,6 +202,31 @@ export const getNodesAndEdges = async ({ id, version, defaultFlow, mode = 'simpl
     }
   });
 
+  // Handle data products that both read and write
+  dataProductsBothSentAndReceived.forEach((_dataProduct) => {
+    if (container) {
+      edges.push(
+        createEdge({
+          id: generatedIdForEdge(container, _dataProduct) + '-both',
+          source: generateIdForNode(_dataProduct),
+          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 });
   });