@eventcatalog/core 2.65.1 → 3.0.0-beta.0

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

@@ -1,81 +1,95 @@
-import { getItemsFromCollectionByIdAndSemverOrLatest, getVersionForCollectionItem } from '@utils/collections/util';
 import { getCollection } from 'astro:content';
 import type { CollectionEntry } from 'astro:content';
 import path from 'path';
 import semver from 'semver';
-import type { CollectionTypes } from '@types';
+import type { CollectionMessageTypes, CollectionTypes } from '@types';
 const PROJECT_DIR = process.env.PROJECT_DIR || process.cwd();
-import utils from '@eventcatalog/sdk';
+import utils, { type Domain } from '@eventcatalog/sdk';
+import { getDomains, getDomainsForService } from './domains';
+import { createVersionedMap, findInMap } from '@utils/collections/util';
 
 export type Service = CollectionEntry<'services'>;
 
+const CACHE_ENABLED = process.env.DISABLE_EVENTCATALOG_CACHE !== 'true';
 interface Props {
   getAllVersions?: boolean;
+  returnBody?: boolean;
 }
 
-// Cache for build time
-let cachedServices: Record<string, Service[]> = {
-  allVersions: [],
-  currentVersions: [],
-};
+// Simple in-memory cache
+let memoryCache: Record<string, Service[]> = {};
 
-export const getServices = async ({ getAllVersions = true }: Props = {}): Promise<Service[]> => {
-  const cacheKey = getAllVersions ? 'allVersions' : 'currentVersions';
+export const getServices = async ({ getAllVersions = true, returnBody = false }: Props = {}): Promise<Service[]> => {
+  // console.time('✅ New getServices');
+  const cacheKey = `${getAllVersions ? 'allVersions' : 'currentVersions'}-${returnBody ? 'withBody' : 'noBody'}`;
 
-  // Check if we have cached domains for this specific getAllVersions value
-  if (cachedServices[cacheKey].length > 0) {
-    return cachedServices[cacheKey];
+  // Check if we have cached services
+  if (memoryCache[cacheKey] && memoryCache[cacheKey].length > 0 && CACHE_ENABLED) {
+    // console.timeEnd('✅ New getServices');
+    return memoryCache[cacheKey];
   }
 
-  // Get services that are not versioned
-  const services = await getCollection('services', (service) => {
-    return (getAllVersions || !service.filePath?.includes('versioned')) && service.data.hidden !== true;
+  // 1. Fetch all collections in parallel
+  const [allServices, allEvents, allCommands, allQueries, allEntities, allContainers, allFlows] = await Promise.all([
+    getCollection('services'),
+    getCollection('events'),
+    getCollection('commands'),
+    getCollection('queries'),
+    getCollection('entities'),
+    getCollection('containers'),
+    getCollection('flows'),
+  ]);
+
+  const allMessages = [...allEvents, ...allCommands, ...allQueries];
+
+  // 2. Build optimized maps
+  const serviceMap = createVersionedMap(allServices);
+  const messageMap = createVersionedMap(allMessages);
+  const entityMap = createVersionedMap(allEntities);
+  const containerMap = createVersionedMap(allContainers);
+  const flowMap = createVersionedMap(allFlows);
+
+  // 3. Filter services
+  const targetServices = allServices.filter((service) => {
+    if (service.data.hidden === true) return false;
+    if (!getAllVersions && service.filePath?.includes('versioned')) return false;
+    return true;
   });
 
-  const events = await getCollection('events');
-  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];
+  const { getResourceFolderName } = utils(process.env.PROJECT_DIR ?? '');
+
+  // 4. Enrich services using Map lookups (O(1))
+  const processedServices = await Promise.all(
+    targetServices.map(async (service) => {
+      // Version info
+      const serviceVersions = serviceMap.get(service.data.id) || [];
+      const latestVersion = serviceVersions[0]?.data.version || service.data.version;
+      const versions = serviceVersions.map((s) => s.data.version);
+
+      const sends = (service.data.sends || [])
+        .map((m) => findInMap(messageMap, m.id, m.version))
+        .filter((e): e is CollectionEntry<CollectionMessageTypes> => !!e);
+
+      const receives = (service.data.receives || [])
+        .map((m) => findInMap(messageMap, m.id, m.version))
+        .filter((e): e is CollectionEntry<CollectionMessageTypes> => !!e);
+
+      const mappedEntities = (service.data.entities || [])
+        .map((e) => findInMap(entityMap, e.id, e.version))
+        .filter((e): e is CollectionEntry<'entities'> => !!e);
+
+      const mappedWritesTo = (service.data.writesTo || [])
+        .map((c) => findInMap(containerMap, c.id, c.version))
+        .filter((e): e is CollectionEntry<'containers'> => !!e);
+
+      const mappedReadsFrom = (service.data.readsFrom || [])
+        .map((c) => findInMap(containerMap, c.id, c.version))
+        .filter((e): e is CollectionEntry<'containers'> => !!e);
+
+      const mappedFlows = (service.data.flows || [])
+        .map((f) => findInMap(flowMap, f.id, f.version))
+        .filter((f): f is CollectionEntry<'flows'> => !!f);
 
-  // @ts-ignore // TODO: Fix this type
-  cachedServices[cacheKey] = await Promise.all(
-    services.map(async (service) => {
-      const { latestVersion, versions } = getVersionForCollectionItem(service, services);
-
-      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))
-        .flat()
-        .filter((e: any) => e !== undefined);
-
-      const receives = receivesMessages
-        .map((message: any) => getItemsFromCollectionByIdAndSemverOrLatest(allMessages, message.id, message.version))
-        .flat()
-        .filter((e: any) => e !== undefined);
-
-      const mappedEntities = serviceEntities
-        .map((entity: any) => getItemsFromCollectionByIdAndSemverOrLatest(entities, entity.id, entity.version))
-        .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);
-
-      const { getResourceFolderName } = utils(process.env.PROJECT_DIR ?? '');
       const folderName = await getResourceFolderName(
         process.env.PROJECT_DIR ?? '',
         service.data.id,
@@ -87,18 +101,19 @@ export const getServices = async ({ getAllVersions = true }: Props = {}): Promis
         ...service,
         data: {
           ...service.data,
-          writesTo: mappedWritesTo,
-          readsFrom: mappedReadsFrom,
-          receives,
-          sends,
+          writesTo: mappedWritesTo as any,
+          readsFrom: mappedReadsFrom as any,
+          flows: mappedFlows as any,
+          receives: receives as any,
+          sends: sends as any,
           versions,
           latestVersion,
-          entities: mappedEntities,
+          entities: mappedEntities as any,
         },
         // TODO: verify if it could be deleted.
         nodes: {
-          receives,
-          sends,
+          receives: receives as any,
+          sends: sends as any,
         },
         catalog: {
           // TODO: avoid use string replace at path due to win32
@@ -110,16 +125,20 @@ export const getServices = async ({ getAllVersions = true }: Props = {}): Promis
           publicPath: path.join('/generated', service.collection, serviceFolderName),
           type: 'service',
         },
+        body: returnBody ? service.body : undefined,
       };
     })
   );
 
   // order them by the name of the service
-  cachedServices[cacheKey].sort((a, b) => {
+  processedServices.sort((a, b) => {
     return (a.data.name || a.data.id).localeCompare(b.data.name || b.data.id);
   });
 
-  return cachedServices[cacheKey];
+  memoryCache[cacheKey] = processedServices;
+  // console.timeEnd('✅ New getServices');
+
+  return processedServices;
 };
 
 export const getProducersOfMessage = (services: Service[], message: CollectionEntry<'events' | 'commands' | 'queries'>) => {
@@ -209,3 +228,16 @@ export const getProducersAndConsumersForChannel = async (channel: CollectionEntr
     consumers: consumers ?? [],
   };
 };
+export const getServicesNotInAnyDomain = async (): Promise<Service[]> => {
+  const services = await getServices({ getAllVersions: false });
+
+  // We need an async-aware filter: run all lookups, then filter by the results
+  const domainCountsForServices = await Promise.all(
+    services.map(async (service) => {
+      const domainsForService = await getDomainsForService(service);
+      return domainsForService.length;
+    })
+  );
+
+  return services.filter((_, index) => domainCountsForServices[index] === 0);
+};

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

@@ -0,0 +1,94 @@
+import type { CollectionTypes } from '@types';
+import { getCollection } from 'astro:content';
+import type { CollectionEntry } from 'astro:content';
+import path from 'path';
+
+export type Team = CollectionEntry<'teams'>;
+const CACHE_ENABLED = process.env.DISABLE_EVENTCATALOG_CACHE !== 'true';
+// Cache for build time
+let memoryCache: Team[] = [];
+
+export const getTeams = async (): Promise<Team[]> => {
+  // console.time('✅ New getTeams');
+  if (memoryCache.length > 0 && CACHE_ENABLED) {
+    // console.timeEnd('✅ New getTeams');
+    return memoryCache;
+  }
+
+  // 1. Fetch all collections in parallel
+  const [allTeams, allDomains, allServices, allEvents, allCommands, allQueries] = await Promise.all([
+    getCollection('teams'),
+    getCollection('domains'),
+    getCollection('services'),
+    getCollection('events'),
+    getCollection('commands'),
+    getCollection('queries'),
+  ]);
+
+  // 2. Filter teams
+  const targetTeams = allTeams.filter((team) => team.data.hidden !== true);
+
+  // 3. Build Owner Index: Map<OwnerID, Item[]>
+  // This index groups all items (domains, services, etc.) by their owner IDs.
+  // This allows O(1) lookup to find all items owned by a specific team.
+  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);
+
+  // 4. Enrich teams using the ownership index
+  const processedTeams = targetTeams.map((team) => {
+    const teamId = team.data.id;
+    const ownedItems = ownershipMap.get(teamId) || [];
+
+    // Categorize items
+    const ownedDomains = ownedItems.filter((i) => i.collection === 'domains') as CollectionEntry<'domains'>[];
+    const ownedServices = ownedItems.filter((i) => i.collection === 'services') as CollectionEntry<'services'>[];
+    const ownedEvents = ownedItems.filter((i) => i.collection === 'events') as CollectionEntry<'events'>[];
+    const ownedCommands = ownedItems.filter((i) => i.collection === 'commands') as CollectionEntry<'commands'>[];
+    const ownedQueries = ownedItems.filter((i) => i.collection === 'queries') as CollectionEntry<'queries'>[];
+
+    return {
+      ...team,
+      data: {
+        ...team.data,
+        ownedDomains,
+        ownedServices,
+        ownedCommands,
+        ownedQueries,
+        ownedEvents,
+      },
+      catalog: {
+        path: path.join(team.collection, team.id.replace('/index.mdx', '')),
+        filePath: path.join(process.cwd(), 'src', 'catalog-files', team.collection, team.id.replace('/index.mdx', '')),
+        type: 'team',
+      },
+    };
+  });
+
+  // order them by the name of the team
+  processedTeams.sort((a, b) => {
+    return (a.data.name || a.data.id).localeCompare(b.data.name || b.data.id);
+  });
+
+  memoryCache = processedTeams;
+  // console.timeEnd('✅ New getTeams');
+
+  return processedTeams;
+};

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,5 +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}`;