@eventcatalog/core 2.65.0 → 3.0.0-beta.0

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

@@ -0,0 +1,122 @@
+import type { CollectionTypes } from '@types';
+import { getCollection } from 'astro:content';
+import type { CollectionEntry } from 'astro:content';
+import path from 'path';
+
+export type User = CollectionEntry<'users'>;
+
+// Simple in-memory cache
+let memoryCache: User[] = [];
+
+export const getUsers = async (): Promise<User[]> => {
+  // console.time('✅ New getUsers');
+
+  if (memoryCache.length > 0) {
+    // console.timeEnd('✅ New getUsers');
+    return memoryCache;
+  }
+
+  // 1. Fetch all collections in parallel
+  const [allUsers, allDomains, allServices, allEvents, allCommands, allQueries, allTeams] = await Promise.all([
+    getCollection('users'),
+    getCollection('domains'),
+    getCollection('services'),
+    getCollection('events'),
+    getCollection('commands'),
+    getCollection('queries'),
+    getCollection('teams'),
+  ]);
+
+  // 2. Filter users
+  const targetUsers = allUsers.filter((user) => user.data.hidden !== true);
+  const visibleTeams = allTeams.filter((team) => team.data.hidden !== true);
+
+  // 3. Process users (Optimization: Iterate once over relationships if possible,
+  // but since we need to check ownership for EACH user against ALL items,
+  // we can't easily invert the map without building an "owner" index first.
+  // Given users/teams count is usually lower than events/services, iterating users and filtering items is acceptable,
+  // OR we can index items by ownerID for O(1) lookup. Let's try indexing items by ownerID.)
+
+  // Build Owner Index: Map<OwnerID, Item[]>
+  const ownershipMap = new Map<string, CollectionEntry<CollectionTypes>[]>();
+
+  const addToIndex = (items: CollectionEntry<CollectionTypes>[]) => {
+    for (const item of items) {
+      if (item.data.owners) {
+        for (const owner of item.data.owners) {
+          if (!ownershipMap.has(owner.id)) {
+            ownershipMap.set(owner.id, []);
+          }
+          ownershipMap.get(owner.id)!.push(item);
+        }
+      }
+    }
+  };
+
+  addToIndex(allDomains);
+  addToIndex(allServices);
+  addToIndex(allEvents);
+  addToIndex(allCommands);
+  addToIndex(allQueries);
+
+  // Team Membership Index: Map<UserID, Team[]>
+  const teamMembershipMap = new Map<string, typeof visibleTeams>();
+  for (const team of visibleTeams) {
+    if (team.data.members) {
+      for (const member of team.data.members) {
+        if (!teamMembershipMap.has(member.id)) {
+          teamMembershipMap.set(member.id, []);
+        }
+        teamMembershipMap.get(member.id)!.push(team);
+      }
+    }
+  }
+
+  const mappedUsers = targetUsers.map((user) => {
+    const userId = user.data.id;
+    const associatedTeams = teamMembershipMap.get(userId) || [];
+    const associatedTeamIds = associatedTeams.map((t) => t.data.id);
+
+    // Collect all owned items directly owned by user OR by their teams
+    const directOwnedItems = ownershipMap.get(userId) || [];
+    const teamOwnedItems = associatedTeamIds.flatMap((teamId) => ownershipMap.get(teamId) || []);
+
+    // Combine and deduplicate items (by ID+Version or just reference equality since they come from same source arrays)
+    const allOwnedItems = Array.from(new Set([...directOwnedItems, ...teamOwnedItems]));
+
+    // Categorize items
+    const ownedDomains = allOwnedItems.filter((i) => i.collection === 'domains') as CollectionEntry<'domains'>[];
+    const ownedServices = allOwnedItems.filter((i) => i.collection === 'services') as CollectionEntry<'services'>[];
+    const ownedEvents = allOwnedItems.filter((i) => i.collection === 'events') as CollectionEntry<'events'>[];
+    const ownedCommands = allOwnedItems.filter((i) => i.collection === 'commands') as CollectionEntry<'commands'>[];
+    const ownedQueries = allOwnedItems.filter((i) => i.collection === 'queries') as CollectionEntry<'queries'>[];
+
+    return {
+      ...user,
+      data: {
+        ...user.data,
+        ownedDomains,
+        ownedServices,
+        ownedEvents,
+        ownedCommands,
+        ownedQueries,
+        associatedTeams,
+      },
+      catalog: {
+        path: path.join(user.collection, user.id.replace('/index.mdx', '')),
+        filePath: path.join(process.cwd(), 'src', 'catalog-files', user.collection, user.id.replace('/index.mdx', '')),
+        type: 'user',
+      },
+    };
+  });
+
+  // order them by the name of the user
+  mappedUsers.sort((a, b) => {
+    return (a.data.name || a.data.id).localeCompare(b.data.name || b.data.id);
+  });
+
+  memoryCache = mappedUsers;
+  // console.timeEnd('✅ New getUsers');
+
+  return mappedUsers;
+};

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

@@ -1,6 +1,6 @@
 import type { CollectionTypes } from '@types';
 import type { CollectionEntry } from 'astro:content';
-import { coerce, compare, eq, satisfies as satisfiesRange } from 'semver';
+import semver, { coerce, compare, eq, satisfies as satisfiesRange } from 'semver';
 
 export const getPreviousVersion = (version: string, versions: string[]) => {
   const index = versions.indexOf(version);
@@ -116,6 +116,7 @@ export const resourceToCollectionMap = {
   user: 'users',
   team: 'teams',
   container: 'containers',
+  entity: 'entities',
 } as const;
 
 export const collectionToResourceMap = {
@@ -129,6 +130,7 @@ export const collectionToResourceMap = {
   users: 'user',
   teams: 'team',
   containers: 'container',
+  entities: 'entity',
 } as const;
 
 export const getDeprecatedDetails = (item: CollectionEntry<CollectionTypes>) => {
@@ -165,3 +167,57 @@ export const removeContentFromCollection = (collection: CollectionEntry<Collecti
     catalog: undefined,
   }));
 };
+
+// --- OPTIMIZATION HELPERS ---
+
+/**
+ * Groups items by ID and sorts them by version (Newest first).
+ * This allows O(1) lookup for "latest" (index 0) and specific versions.
+ */
+export const createVersionedMap = <T extends { data: { id: string; version?: string } }>(items: T[]) => {
+  const map = new Map<string, T[]>();
+
+  for (const item of items) {
+    const id = item.data.id;
+    if (!map.has(id)) map.set(id, []);
+    map.get(id)!.push(item);
+  }
+
+  // Sort every entry so index [0] is always the latest version
+  for (const [key, list] of map.entries()) {
+    list.sort((a, b) => {
+      // specific version sorting logic (fallback to string compare if not valid semver)
+      const vA = a.data.version || '0.0.0';
+      const vB = b.data.version || '0.0.0';
+      return semver.valid(vB) && semver.valid(vA) ? semver.rcompare(vA, vB) : vB.localeCompare(vA);
+    });
+  }
+  return map;
+};
+
+/**
+ * Fast lookup helper.
+ * If version is provided, find it. If not, return the first (latest) item.
+ */
+export const findInMap = <T extends { data: { version?: string } }>(
+  map: Map<string, T[]>,
+  id: string,
+  version?: string
+): T | undefined => {
+  const items = map.get(id);
+  if (!items || items.length === 0) return undefined;
+
+  // If no version specified or 'latest', return the first item (which is sorted to be latest)
+  if (!version || version === 'latest') return items[0];
+
+  // Try exact match
+  const exactMatch = items.find((i) => i.data.version === version);
+  if (exactMatch) return exactMatch;
+
+  // Try semver match if not exact
+  if (semver.validRange(version)) {
+    return items.find((i) => semver.satisfies(i.data.version || '0.0.0', version));
+  }
+
+  return undefined;
+};

package/eventcatalog/src/utils/feature.ts

@@ -34,7 +34,7 @@ export const showCustomBranding = () => {
   return isEventCatalogStarterEnabled() || isEventCatalogScaleEnabled();
 };
 
-export const isChangelogEnabled = () => config?.changelog?.enabled ?? true;
+export const isChangelogEnabled = () => config?.changelog?.enabled ?? false;
 
 export const isCustomDocsEnabled = () => isEventCatalogStarterEnabled() || isEventCatalogScaleEnabled();
 export const isEventCatalogChatEnabled = () => {
@@ -55,3 +55,5 @@ export const isAuthEnabled = () => {
 };
 
 export const isSSR = () => config?.output === 'server';
+export const isRSSEnabled = () => config?.rss?.enabled ?? false;
+export const isVisualiserEnabled = () => config?.visualiser?.enabled ?? true;

package/eventcatalog/src/utils/{collections/file-diffs.ts → file-diffs.ts}

@@ -2,7 +2,7 @@ import { readdir, readFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { formatPatch, structuredPatch } from 'diff';
 import { html, parse } from 'diff2html';
-import { getItemsFromCollectionByIdAndSemverOrLatest } from './util';
+import { getItemsFromCollectionByIdAndSemverOrLatest } from './collections/util';
 import type { CollectionEntry } from 'astro:content';
 import type { CollectionTypes } from '@types';
 

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

@@ -17,12 +17,14 @@ interface Props {
 }
 
 export const getNodesAndEdges = async ({ id, version, defaultFlow, mode = 'simple', channelRenderMode = 'flat' }: Props) => {
+  // 1. Fetch data
   const containers = await getContainers();
 
   const flow = defaultFlow || createDagreGraph({ ranksep: 300, nodesep: 50 });
   const nodes = [] as any,
     edges = [] as any;
 
+  // Optimized: Use find since we're looking for a specific item
   const container = containers.find((container) => container.data.id === id && container.data.version === version);
 
   // Nothing found...

package/eventcatalog/src/utils/node-graphs/domain-entity-map.ts

@@ -2,9 +2,9 @@ import { getCollection, getEntry } from 'astro:content';
 import { generateIdForNode } from './utils/utils';
 import ELK from 'elkjs/lib/elk.bundled.js';
 import { MarkerType } from '@xyflow/react';
-import { getItemsFromCollectionByIdAndSemverOrLatest } from '@utils/collections/util';
+import { createVersionedMap, findInMap } from '@utils/collections/util';
 import { getVersionFromCollection } from '@utils/collections/versions';
-import { getEntities, type Entity } from '@utils/entities';
+import { getEntities, type Entity } from '@utils/collections/entities';
 import { getDomains, type Domain } from '@utils/collections/domains';
 import { getServices, type Service } from '@utils/collections/services';
 
@@ -21,9 +21,8 @@ export const getNodesAndEdges = async ({ id, version, entities, type = 'domains'
   let nodes = [] as any,
     edges = [] as any;
 
-  const allDomains = await getDomains();
-  const allEntities = await getEntities();
-  const allServices = await getServices();
+  // 1. Fetch all collections in parallel
+  const [allDomains, allEntities, allServices] = await Promise.all([getDomains(), getEntities(), getServices()]);
 
   let resource = null;
 
@@ -65,14 +64,25 @@ export const getNodesAndEdges = async ({ id, version, entities, type = 'domains'
   const externalToDomain = Array.from(new Set<string>(listOfReferencedEntities as string[])) // Remove duplicates
     .filter((entityId: any) => !resourceEntities.some((domainEntity: any) => domainEntity.id === entityId));
 
+  // 2. Build optimized maps
+  // Only build domain map if we have domains to search
+  // Only build entity map if we have entities to search
+  const entityMap = createVersionedMap(allEntities);
+
   // Helper function to find which domain an entity belongs to
+  // Optimized to use direct iteration over domains (domains usually contain entity arrays)
+  // We can't easily map entity->domain without scanning domains first unless we build a reverse index.
+  // Given domains count is usually manageable, scanning is acceptable, OR we could build an index if needed.
+  // For now, let's keep the scan but make it efficient.
   const findEntityDomain = (entityId: string) => {
     return allDomains.find((domain) => domain.data.entities?.some((domainEntity: any) => domainEntity.data.id === entityId));
   };
 
   const addedExternalEntities = [];
+
   for (const entityId of externalToDomain) {
-    const externalEntity = getItemsFromCollectionByIdAndSemverOrLatest(allEntities, entityId as string, 'latest')[0] as Entity;
+    // 3. Use map lookup
+    const externalEntity = findInMap(entityMap, entityId as string, 'latest') as Entity;
 
     if (externalEntity) {
       const nodeId = generateIdForNode(externalEntity);

package/eventcatalog/src/utils/node-graphs/domains-canvas.ts

@@ -1,9 +1,10 @@
 import { getCollection, type CollectionEntry } from 'astro:content';
 import dagre from 'dagre';
 import { generateIdForNode, createDagreGraph, calculatedNodes, createEdge } from '@utils/node-graphs/utils/utils';
-import { getItemsFromCollectionByIdAndSemverOrLatest } from '@utils/collections/util';
+import { findInMap, createVersionedMap } from '@utils/collections/util';
 import type { Node, Edge } from '@xyflow/react';
 import { getDomains } from '@utils/collections/domains';
+import type { CollectionMessageTypes } from '@types';
 
 interface DomainCanvasData {
   domainNodes: Node[];
@@ -69,10 +70,14 @@ export const getDomainsCanvasData = async (): Promise<DomainCanvasData> => {
     } as Node);
   }
 
-  // Get all messages for version resolution
-  const allMessages = await getCollection('events')
-    .then((events) => Promise.all([events, getCollection('commands'), getCollection('queries')]))
-    .then(([events, commands, queries]) => [...events, ...commands, ...queries]);
+  // Get all messages for version resolution in parallel
+  const [events, commands, queries] = await Promise.all([
+    getCollection('events'),
+    getCollection('commands'),
+    getCollection('queries'),
+  ]);
+  const allMessages = [...events, ...commands, ...queries];
+  const messageMap = createVersionedMap(allMessages);
 
   // Map to track unique messages and their publishers/consumers across domains
   const messageRelationships = new Map<
@@ -89,9 +94,9 @@ export const getDomainsCanvasData = async (): Promise<DomainCanvasData> => {
     domainData.services.forEach((service: any) => {
       // Track messages this service sends
       const sendsRaw = service.data.sends ?? [];
+
       const sendsHydrated = sendsRaw
-        .map((message: any) => getItemsFromCollectionByIdAndSemverOrLatest(allMessages, message.id, message.version))
-        .flat()
+        .map((message: any) => findInMap(messageMap, message.id, message.version))
         .filter((e: any) => e !== undefined);
 
       sendsHydrated.forEach((sentMessage: any) => {
@@ -115,8 +120,7 @@ export const getDomainsCanvasData = async (): Promise<DomainCanvasData> => {
       // Track messages this service receives
       const receivesRaw = service.data.receives ?? [];
       const receivesHydrated = receivesRaw
-        .map((message: any) => getItemsFromCollectionByIdAndSemverOrLatest(allMessages, message.id, message.version))
-        .flat()
+        .map((message: any) => findInMap(messageMap, message.id, message.version))
         .filter((e: any) => e !== undefined);
 
       receivesHydrated.forEach((receivedMessage: any) => {
@@ -154,7 +158,7 @@ export const getDomainsCanvasData = async (): Promise<DomainCanvasData> => {
 
     if (crossesDomainBoundary) {
       // Find the actual message object
-      const messageObject = allMessages.find((m) => m.data.id === message.id && m.data.version === message.version);
+      const messageObject = findInMap(messageMap, message.id, message.version) as CollectionEntry<CollectionMessageTypes>;
 
       if (messageObject) {
         const messageNodeId = `message-${messageKey}`;

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

@@ -9,7 +9,7 @@ import {
 } 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';
+import { createVersionedMap, findInMap } from '@utils/collections/util';
 import type { Node } from '@xyflow/react';
 import { getProducersOfMessage } from '@utils/collections/services';
 
@@ -25,22 +25,29 @@ export const getNodesAndEdgesForDomainContextMap = async ({ defaultFlow = null }
   let nodes = [] as any,
     edges = [] as any;
 
-  const allDomains = await getCollection('domains');
-  const domains = allDomains.filter((domain) => !domain.id.includes('/versioned'));
-  const services = await getCollection('services');
-
-  const events = await getCollection('events');
-  const commands = await getCollection('commands');
-  const queries = await getCollection('queries');
+  // 1. Parallel Fetching
+  const [allDomains, services, events, commands, queries] = await Promise.all([
+    getCollection('domains'),
+    getCollection('services'),
+    getCollection('events'),
+    getCollection('commands'),
+    getCollection('queries'),
+  ]);
 
+  const domains = allDomains.filter((domain) => !domain.id.includes('/versioned'));
   const messages = [...events, ...commands, ...queries];
 
+  // 2. Build optimized maps
+  const serviceMap = createVersionedMap(services);
+  const messageMap = createVersionedMap(messages);
+
   domains.forEach((domain, index) => {
     const nodeId = generateIdForNode(domain);
     const rawServices = domain.data.services ?? [];
+
+    // Optimized service resolution
     const domainServices = rawServices
-      .map((service) => getItemsFromCollectionByIdAndSemverOrLatest(services, service.id, service.version))
-      .flat()
+      .map((service) => findInMap(serviceMap, service.id, service.version))
       .filter((e) => e !== undefined);
 
     // Calculate domain node size based on services
@@ -60,14 +67,12 @@ export const getNodesAndEdgesForDomainContextMap = async ({ defaultFlow = null }
     const rowIndex = Math.floor(index / DOMAINS_PER_ROW);
     const colIndex = index % DOMAINS_PER_ROW;
 
-    const test = servicesCount * SERVICE_HEIGHT + PADDING * 2;
-
     nodes.push({
       id: nodeId,
       type: 'group',
       position: {
-        x: colIndex * (domainWidth + 400), // Increased from 100 to 400px gap between domains
-        y: rowIndex * (domainHeight + 300), // Increased from 100 to 300px gap between rows
+        x: colIndex * (domainWidth + 400),
+        y: rowIndex * (domainHeight + 300),
       },
       style: {
         width: domainWidth,
@@ -107,7 +112,6 @@ export const getNodesAndEdgesForDomainContextMap = async ({ defaultFlow = null }
       domainServices.forEach((service, serviceIndex) => {
         const row = Math.floor(serviceIndex / SERVICES_PER_ROW);
         const col = serviceIndex % SERVICES_PER_ROW;
-        const serviceNodeId = `service-${domain.id}-${service.id}`;
 
         // Add spacing between services
         const SERVICE_MARGIN = 25;
@@ -136,10 +140,13 @@ export const getNodesAndEdgesForDomainContextMap = async ({ defaultFlow = null }
         const rawReceives = service.data.receives ?? [];
         const rawSends = service.data.sends ?? [];
 
+        // Optimized message resolution
         const receives = rawReceives
-          .map((receive) => getItemsFromCollectionByIdAndSemverOrLatest(messages, receive.id, receive.version))
-          .flat();
-        const sends = rawSends.map((send) => getItemsFromCollectionByIdAndSemverOrLatest(messages, send.id, send.version)).flat();
+          .map((receive) => findInMap(messageMap, receive.id, receive.version))
+          .filter((msg): msg is any => !!msg); // Filter undefined
+
+        // Note: 'sends' was defined but not used in the original loop logic for edges?
+        // Based on original code, it iterates `receives`.
 
         for (const receive of receives) {
           const producers = getProducersOfMessage(services, receive);
@@ -148,19 +155,6 @@ export const getNodesAndEdgesForDomainContextMap = async ({ defaultFlow = null }
             const isSameDomain = domainServices.some((domainService) => domainService.data.id === producer.data.id);
 
             if (!isSameDomain) {
-              // WIP... adding messages?
-              // edges.push(createEdge({
-              //   id: generatedIdForEdge(receive, service),
-              //   source: generateIdForNode(receive),
-              //   target: generateIdForNode(service),
-              //   label: getEdgeLabelForServiceAsTarget(receive),
-              //   zIndex: 1000,
-              // }));
-
-              // Find the producer and consumer nodes to get their positions
-              // const producerNode = nodes.find(n => n.id === generateIdForNode(producer));
-              // const consumerNode = nodes.find(n => n.id === generateIdForNode(service));
-
               edges.push(
                 createEdge({
                   id: generatedIdForEdge(producer, service),
@@ -170,32 +164,6 @@ export const getNodesAndEdgesForDomainContextMap = async ({ defaultFlow = null }
                   zIndex: 1000,
                 })
               );
-
-              // // Calculate middle position between producer and consumer
-              // const messageX = (producerNode?.position?.x ?? 0) +
-              //   ((consumerNode?.position?.x ?? 0) - (producerNode?.position?.x ?? 0)) / 2;
-              // const messageY = (producerNode?.position?.y ?? 0) +
-              //   ((consumerNode?.position?.y ?? 0) - (producerNode?.position?.y ?? 0)) / 2;
-
-              // nodes.push({
-              //   id: generateIdForNode(receive),
-              //   type: receive.collection,
-              //   sourcePosition: 'right',
-              //   targetPosition: 'left',
-              //   data: {
-              //     message: receive,
-              //     mode: 'full',
-              //   },
-              //   position: { x: messageX, y: messageY },
-              // });
-
-              // edges.push(createEdge({
-              //   id: generatedIdForEdge(producer, receive),
-              //   source: generateIdForNode(producer),
-              //   target: generateIdForNode(receive),
-              //   label: getEdgeLabelForServiceAsTarget(receive),
-              //   zIndex: 1000,
-              // }));
             }
           }
         }
@@ -230,7 +198,8 @@ export const getNodesAndEdges = async ({
   let nodes = new Map(),
     edges = new Map();
 
-  const domains = await getCollection('domains');
+  // 1. Parallel Fetching
+  const [domains, services] = await Promise.all([getCollection('domains'), getCollection('services')]);
 
   const domain = domains.find((service) => service.data.id === id && service.data.version === version);
 
@@ -242,19 +211,22 @@ export const getNodesAndEdges = async ({
     };
   }
 
+  // 2. Build optimized maps
+  const serviceMap = createVersionedMap(services);
+  const domainMap = createVersionedMap(domains);
+
   const rawServices = domain?.data.services || [];
   const rawSubDomains = domain?.data.domains || [];
 
-  const servicesCollection = await getCollection('services');
-
+  // Optimized hydration
   const domainServicesWithVersion = rawServices
-    .map((service) => getItemsFromCollectionByIdAndSemverOrLatest(servicesCollection, service.id, service.version))
-    .flat()
+    .map((service) => findInMap(serviceMap, service.id, service.version))
+    .filter((s): s is any => !!s)
     .map((svc) => ({ id: svc.data.id, version: svc.data.version }));
 
   const domainSubDomainsWithVersion = rawSubDomains
-    .map((subDomain) => getItemsFromCollectionByIdAndSemverOrLatest(domains, subDomain.id, subDomain.version))
-    .flat()
+    .map((subDomain) => findInMap(domainMap, subDomain.id, subDomain.version))
+    .filter((d): d is any => !!d)
     .map((svc) => ({ id: svc.data.id, version: svc.data.version }));
 
   // Get all the nodes for everyhing

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

@@ -3,7 +3,7 @@ import dagre from 'dagre';
 import { createDagreGraph, calculatedNodes } from '@utils/node-graphs/utils/utils';
 import { MarkerType } from '@xyflow/react';
 import type { Node as NodeType } from '@xyflow/react';
-import { getItemsFromCollectionByIdAndSemverOrLatest } from '@utils/collections/util';
+import { createVersionedMap, findInMap } from '@utils/collections/util';
 
 type DagreGraph = any;
 
@@ -15,9 +15,8 @@ interface Props {
   renderAllEdges?: boolean;
 }
 
-const getServiceNode = (step: any, services: CollectionEntry<'services'>[]) => {
-  const servicesForVersion = getItemsFromCollectionByIdAndSemverOrLatest(services, step.service.id, step.service.version);
-  const service = servicesForVersion?.[0];
+const getServiceNode = (step: any, serviceMap: Map<string, any[]>) => {
+  const service = findInMap(serviceMap, step.service.id, step.service.version);
   return {
     ...step,
     type: service ? service.collection : 'step',
@@ -25,9 +24,8 @@ const getServiceNode = (step: any, services: CollectionEntry<'services'>[]) => {
   };
 };
 
-const getFlowNode = (step: any, flows: CollectionEntry<'flows'>[]) => {
-  const flowsForVersion = getItemsFromCollectionByIdAndSemverOrLatest(flows, step.flow.id, step.flow.version);
-  const flow = flowsForVersion?.[0];
+const getFlowNode = (step: any, flowMap: Map<string, any[]>) => {
+  const flow = findInMap(flowMap, step.flow.id, step.flow.version);
   return {
     ...step,
     type: flow ? flow.collection : 'step',
@@ -35,9 +33,8 @@ const getFlowNode = (step: any, flows: CollectionEntry<'flows'>[]) => {
   };
 };
 
-const getMessageNode = (step: any, messages: CollectionEntry<'events' | 'commands' | 'queries'>[]) => {
-  const messagesForVersion = getItemsFromCollectionByIdAndSemverOrLatest(messages, step.message.id, step.message.version);
-  const message = messagesForVersion[0];
+const getMessageNode = (step: any, messageMap: Map<string, any[]>) => {
+  const message = findInMap(messageMap, step.message.id, step.message.version);
   return {
     ...step,
     type: message ? message.collection : 'step',
@@ -50,7 +47,15 @@ export const getNodesAndEdges = async ({ id, defaultFlow, version, mode = 'simpl
   const nodes = [] as any,
     edges = [] as any;
 
-  const flows = await getCollection('flows');
+  // Fetch all collections in parallel
+  const [flows, events, commands, queries, services] = await Promise.all([
+    getCollection('flows'),
+    getCollection('events'),
+    getCollection('commands'),
+    getCollection('queries'),
+    getCollection('services'),
+  ]);
+
   const flow = flows.find((flow) => flow.data.id === id && flow.data.version === version);
 
   // Nothing found...
@@ -61,20 +66,19 @@ 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 services = await getCollection('services');
-
+  // Build maps for O(1) lookups
   const messages = [...events, ...commands, ...queries];
+  const messageMap = createVersionedMap(messages);
+  const serviceMap = createVersionedMap(services);
+  const flowMap = createVersionedMap(flows);
 
   const steps = flow?.data.steps || [];
 
   //  Hydrate the steps with information they may need.
   const hydratedSteps = steps.map((step: any) => {
-    if (step.service) return getServiceNode(step, services);
-    if (step.flow) return getFlowNode(step, flows);
-    if (step.message) return getMessageNode(step, messages);
+    if (step.service) return getServiceNode(step, serviceMap);
+    if (step.flow) return getFlowNode(step, flowMap);
+    if (step.message) return getMessageNode(step, messageMap);
     if (step.actor) return { ...step, type: 'actor', actor: step.actor };
     if (step.custom) return { ...step, type: 'custom', custom: step.custom };
     if (step.externalSystem) return { ...step, type: 'externalSystem', externalSystem: step.externalSystem };