@eventcatalog/core 2.65.1 → 3.0.0-beta.0

package/eventcatalog/src/utils/{entities.ts → collections/entities.ts}

@@ -1,8 +1,8 @@
 import { getCollection } from 'astro:content';
 import type { CollectionEntry } from 'astro:content';
 import path from 'path';
-import { getVersionForCollectionItem, satisfies } from './collections/util';
 import utils from '@eventcatalog/sdk';
+import { createVersionedMap, satisfies } from './util';
 
 const PROJECT_DIR = process.env.PROJECT_DIR || process.cwd();
 
@@ -11,6 +11,7 @@ export type Entity = CollectionEntry<'entities'> & {
     path: string;
     filePath: string;
     type: string;
+    publicPath: string;
   };
 };
 
@@ -19,46 +20,62 @@ interface Props {
 }
 
 // cache for build time
-let cachedEntities: Record<string, Entity[]> = {
-  allVersions: [],
-  currentVersions: [],
-};
+let memoryCache: Record<string, Entity[]> = {};
 
 export const getEntities = async ({ getAllVersions = true }: Props = {}): Promise<Entity[]> => {
+  // console.time('✅ New getEntities');
   const cacheKey = getAllVersions ? 'allVersions' : 'currentVersions';
 
-  if (cachedEntities[cacheKey].length > 0) {
-    return cachedEntities[cacheKey];
+  if (memoryCache[cacheKey] && memoryCache[cacheKey].length > 0) {
+    // console.timeEnd('✅ New getEntities');
+    return memoryCache[cacheKey];
   }
 
-  const entities = await getCollection('entities', (entity) => {
-    return (getAllVersions || !entity.filePath?.includes('versioned')) && entity.data.hidden !== true;
+  // 1. Fetch collections in parallel
+  const [allEntities, allServices, allDomains] = await Promise.all([
+    getCollection('entities'),
+    getCollection('services'),
+    getCollection('domains'),
+  ]);
+
+  // 2. Build optimized maps
+  const entityMap = createVersionedMap(allEntities);
+
+  // 3. Filter entities
+  const targetEntities = allEntities.filter((entity) => {
+    if (entity.data.hidden === true) return false;
+    if (!getAllVersions && entity.filePath?.includes('versioned')) return false;
+    return true;
   });
 
-  const services = await getCollection('services');
-  const domains = await getCollection('domains');
+  const { getResourceFolderName } = utils(process.env.PROJECT_DIR ?? '');
 
-  cachedEntities[cacheKey] = await Promise.all(
-    entities.map(async (entity) => {
-      const { latestVersion, versions } = getVersionForCollectionItem(entity, entities);
+  // 4. Enrich entities
+  const processedEntities = await Promise.all(
+    targetEntities.map(async (entity) => {
+      // Version info
+      const entityVersions = entityMap.get(entity.data.id) || [];
+      const latestVersion = entityVersions[0]?.data.version || entity.data.version;
+      const versions = entityVersions.map((e) => e.data.version);
 
-      const servicesThatReferenceEntity = services.filter((service) =>
+      // Find Services that reference this entity
+      const servicesThatReferenceEntity = allServices.filter((service) =>
         service.data.entities?.some((item) => {
-          if (item.id != entity.data.id) return false;
-          if (item.version == 'latest' || item.version == undefined) return entity.data.version == latestVersion;
+          if (item.id !== entity.data.id) return false;
+          if (item.version === 'latest' || item.version === undefined) return entity.data.version === latestVersion;
           return satisfies(entity.data.version, item.version);
         })
       );
 
-      const domainsThatReferenceEntity = domains.filter((domain) =>
+      // Find Domains that reference this entity
+      const domainsThatReferenceEntity = allDomains.filter((domain) =>
         domain.data.entities?.some((item) => {
-          if (item.id != entity.data.id) return false;
-          if (item.version == 'latest' || item.version == undefined) return entity.data.version == latestVersion;
+          if (item.id !== entity.data.id) return false;
+          if (item.version === 'latest' || item.version === undefined) return entity.data.version === latestVersion;
           return satisfies(entity.data.version, item.version);
         })
       );
 
-      const { getResourceFolderName } = utils(process.env.PROJECT_DIR ?? '');
       const folderName = await getResourceFolderName(
         process.env.PROJECT_DIR ?? '',
         entity.data.id,
@@ -87,10 +104,13 @@ export const getEntities = async ({ getAllVersions = true }: Props = {}): Promis
     })
   );
 
-  // order them by the name of the event
-  cachedEntities[cacheKey].sort((a, b) => {
+  // order them by the name of the entity
+  processedEntities.sort((a, b) => {
     return (a.data.name || a.data.id).localeCompare(b.data.name || b.data.id);
   });
 
-  return cachedEntities[cacheKey];
+  memoryCache[cacheKey] = processedEntities;
+  // console.timeEnd('✅ New getEntities');
+
+  return processedEntities;
 };

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

@@ -0,0 +1,136 @@
+import { getCollection } from 'astro:content';
+import type { CollectionEntry } from 'astro:content';
+import path from 'path';
+import { createVersionedMap, findInMap, satisfies } from './util';
+import utils from '@eventcatalog/sdk';
+
+const PROJECT_DIR = process.env.PROJECT_DIR || process.cwd();
+const CACHE_ENABLED = process.env.DISABLE_EVENTCATALOG_CACHE !== 'true';
+
+type Event = CollectionEntry<'events'> & {
+  catalog: {
+    path: string;
+    filePath: string;
+    type: string;
+    publicPath: string;
+  };
+};
+
+interface Props {
+  getAllVersions?: boolean;
+  hydrateServices?: boolean;
+}
+
+// Simple in-memory cache
+let memoryCache: Record<string, Event[]> = {};
+
+export const getEvents = async ({ getAllVersions = true, hydrateServices = true }: Props = {}): Promise<Event[]> => {
+  // console.time('✅ New getEvents');
+  const cacheKey = `${getAllVersions ? 'allVersions' : 'currentVersions'}-${hydrateServices ? 'hydrated' : 'minimal'}`;
+
+  // Check cache
+  if (memoryCache[cacheKey] && memoryCache[cacheKey].length > 0 && CACHE_ENABLED) {
+    // console.timeEnd('✅ New getEvents');
+    return memoryCache[cacheKey];
+  }
+
+  // 1. Fetch collections in parallel
+  const [allEvents, allServices, allChannels] = await Promise.all([
+    getCollection('events'),
+    getCollection('services'),
+    getCollection('channels'),
+  ]);
+
+  // 2. Build optimized maps
+  const eventMap = createVersionedMap(allEvents);
+  // We don't map services/channels by ID because we need to iterate them to find relationships (reverse lookup)
+  // or use them for hydration.
+  // Actually, for hydration we CAN use a map if we know the IDs, but here we scan services to find producers/consumers.
+
+  // 3. Filter events
+  const targetEvents = allEvents.filter((event) => {
+    if (event.data.hidden === true) return false;
+    if (!getAllVersions && event.filePath?.includes('versioned')) return false;
+    return true;
+  });
+
+  const { getResourceFolderName } = utils(process.env.PROJECT_DIR ?? '');
+
+  // 4. Enrich events
+  const processedEvents = await Promise.all(
+    targetEvents.map(async (event) => {
+      // Version info
+      const eventVersions = eventMap.get(event.data.id) || [];
+      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 Channels
+      const messageChannels = event.data.channels || [];
+      // This is O(N*M) where N is event channels and M is all channels.
+      // Typically M is small, but we could optimize if needed.
+      // Given the logic is simply ID match, we can use a Set or Map if needed, but array filter is likely fine for now unless M is huge.
+      const channelsForEvent = allChannels.filter((c) => messageChannels.some((channel) => c.data.id === channel.id));
+
+      const folderName = await getResourceFolderName(process.env.PROJECT_DIR ?? '', event.data.id, event.data.version.toString());
+      const eventFolderName = folderName ?? event.id.replace(`-${event.data.version}`, '');
+
+      return {
+        ...event,
+        data: {
+          ...event.data,
+          messageChannels: channelsForEvent,
+          producers: producers as any, // Cast for hydration flexibility
+          consumers: consumers as any,
+          versions,
+          latestVersion,
+        },
+        catalog: {
+          path: path.join(event.collection, event.id.replace('/index.mdx', '')),
+          absoluteFilePath: path.join(PROJECT_DIR, event.collection, event.id.replace('/index.mdx', '/index.md')),
+          astroContentFilePath: path.join(process.cwd(), 'src', 'content', event.collection, event.id),
+          filePath: path.join(process.cwd(), 'src', 'catalog-files', event.collection, event.id.replace('/index.mdx', '')),
+          publicPath: path.join('/generated', event.collection, eventFolderName),
+          type: 'event',
+        },
+      };
+    })
+  );
+
+  // order them by the name of the event
+  processedEvents.sort((a, b) => {
+    return (a.data.name || a.data.id).localeCompare(b.data.name || b.data.id);
+  });
+
+  memoryCache[cacheKey] = processedEvents;
+  // console.timeEnd('✅ New getEvents');
+
+  return processedEvents;
+};

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

@@ -1,10 +1,12 @@
-import { getItemsFromCollectionByIdAndSemverOrLatest, getVersionForCollectionItem } from '@utils/collections/util';
 import { getCollection } from 'astro:content';
 import type { CollectionEntry } from 'astro:content';
 import path from 'path';
+import { createVersionedMap, findInMap } from '@utils/collections/util';
+import { getDomains } from './domains';
+import { getServices } from './services';
 
 const PROJECT_DIR = process.env.PROJECT_DIR || process.cwd();
-
+const CACHE_ENABLED = process.env.DISABLE_EVENTCATALOG_CACHE !== 'true';
 export type Flow = CollectionEntry<'flows'>;
 
 interface Props {
@@ -12,41 +14,55 @@ interface Props {
 }
 
 // Cache for build time
-let cachedFlows: Record<string, Flow[]> = {
-  allVersions: [],
-  currentVersions: [],
-};
+let memoryCache: Record<string, Flow[]> = {};
 
 export const getFlows = async ({ getAllVersions = true }: Props = {}): Promise<Flow[]> => {
+  // console.time('✅ New getFlows');
   const cacheKey = getAllVersions ? 'allVersions' : 'currentVersions';
 
-  if (cachedFlows[cacheKey].length > 0) {
-    return cachedFlows[cacheKey];
+  if (memoryCache[cacheKey] && memoryCache[cacheKey].length > 0 && CACHE_ENABLED) {
+    // console.timeEnd('✅ New getFlows');
+    return memoryCache[cacheKey];
   }
 
-  // Get flows that are not versioned
-  const flows = await getCollection('flows', (flow) => {
-    return (getAllVersions || !flow.filePath?.includes('versioned')) && flow.data.hidden !== true;
-  });
+  // 1. Fetch collections in parallel
+  const [allFlows, allEvents, allCommands] = await Promise.all([
+    getCollection('flows'),
+    getCollection('events'),
+    getCollection('commands'),
+  ]);
 
-  const events = await getCollection('events');
-  const commands = await getCollection('commands');
+  const allMessages = [...allEvents, ...allCommands];
 
-  const allMessages = [...events, ...commands];
+  // 2. Build optimized maps
+  const flowMap = createVersionedMap(allFlows);
+  const messageMap = createVersionedMap(allMessages);
+
+  // 3. Filter flows
+  const targetFlows = allFlows.filter((flow) => {
+    if (flow.data.hidden === true) return false;
+    if (!getAllVersions && flow.filePath?.includes('versioned')) return false;
+    return true;
+  });
+
+  // 4. Enrich flows
+  const processedFlows = targetFlows.map((flow) => {
+    // Version info
+    const flowVersions = flowMap.get(flow.data.id) || [];
+    const latestVersion = flowVersions[0]?.data.version || flow.data.version;
+    const versions = flowVersions.map((f) => f.data.version);
 
-  // @ts-ignore // TODO: Fix this type
-  cachedFlows[cacheKey] = flows.map((flow) => {
-    // @ts-ignore
-    const { latestVersion, versions } = getVersionForCollectionItem(flow, flows);
     const steps = flow.data.steps || [];
 
     const hydrateSteps = steps.map((step) => {
-      if (!step.message) return { ...flow, data: { ...flow.data, type: 'node' } };
-      const message = getItemsFromCollectionByIdAndSemverOrLatest(allMessages, step.message.id, step.message.version);
+      if (!step.message) return { ...step, type: 'node' }; // Preserve existing step data for non-messages
+
+      const message = findInMap(messageMap, step.message.id, step.message.version);
+
       return {
         ...step,
         type: 'message',
-        message: message,
+        message: message ? [message] : [], // Keep array structure for compatibility
       };
     });
 
@@ -54,7 +70,7 @@ export const getFlows = async ({ getAllVersions = true }: Props = {}): Promise<F
       ...flow,
       data: {
         ...flow.data,
-        steps: hydrateSteps,
+        steps: hydrateSteps as any, // Cast to match expected Flow step type
         versions,
         latestVersion,
       },
@@ -70,9 +86,27 @@ export const getFlows = async ({ getAllVersions = true }: Props = {}): Promise<F
   });
 
   // order them by the name of the flow
-  cachedFlows[cacheKey].sort((a, b) => {
+  processedFlows.sort((a, b) => {
     return (a.data.name || a.data.id).localeCompare(b.data.name || b.data.id);
   });
 
-  return cachedFlows[cacheKey];
+  memoryCache[cacheKey] = processedFlows;
+  // console.timeEnd('✅ New getFlows');
+
+  return processedFlows;
+};
+
+export const getFlowsNotInAnyResource = async (): Promise<Flow[]> => {
+  const [flows, domains, services] = await Promise.all([
+    getFlows({ getAllVersions: false }),
+    getDomains({ getAllVersions: false }),
+    getServices({ getAllVersions: false }),
+  ]);
+
+  const flowsNotInAnyResource = flows.filter((flow) => {
+    const domainsForFlow = domains.filter((domain) => domain.data.flows?.some((f: any) => f.id === flow.id));
+    const servicesForFlow = services.filter((service) => service.data.flows?.some((f: any) => f.id === flow.id));
+    return domainsForFlow.length === 0 && servicesForFlow.length === 0;
+  });
+  return flowsNotInAnyResource;
 };

package/eventcatalog/src/utils/{messages.ts → collections/messages.ts}

@@ -1,10 +1,10 @@
 // Exporting getCommands and getEvents directly
-import { getCommands } from '@utils/commands';
-import { getEvents } from '@utils/events';
+import { getCommands } from '@utils/collections/commands';
+import { getEvents } from '@utils/collections/events';
 import { getQueries } from './queries';
 import type { CollectionEntry } from 'astro:content';
-export { getCommands } from '@utils/commands';
-export { getEvents } from '@utils/events';
+export { getCommands } from '@utils/collections/commands';
+export { getEvents } from '@utils/collections/events';
 
 interface Props {
   getAllVersions?: boolean;
@@ -17,6 +17,15 @@ type Messages = {
   queries: CollectionEntry<'queries'>[];
 };
 
+export const pluralizeMessageType = (message: CollectionEntry<'events' | 'commands' | 'queries'>) => {
+  const typeMap: Record<string, string> = {
+    events: 'event',
+    commands: 'command',
+    queries: 'query',
+  };
+  return typeMap[message.collection] || 'message';
+};
+
 // Main function that uses the imported functions
 export const getMessages = async ({ getAllVersions = true, hydrateServices = true }: Props = {}): Promise<Messages> => {
   const [commands, events, queries] = await Promise.all([

package/eventcatalog/src/utils/{queries.ts → collections/queries.ts}

@@ -2,15 +2,17 @@ import { getCollection } from 'astro:content';
 import type { CollectionEntry } from 'astro:content';
 import path from 'path';
 import utils from '@eventcatalog/sdk';
-import { getVersionForCollectionItem, satisfies } from './collections/util';
+import { createVersionedMap, satisfies } from './util';
 
 const PROJECT_DIR = process.env.PROJECT_DIR || process.cwd();
+const CACHE_ENABLED = process.env.DISABLE_EVENTCATALOG_CACHE !== 'true';
 
 type Query = CollectionEntry<'queries'> & {
   catalog: {
     path: string;
     filePath: string;
     type: string;
+    publicPath: string;
   };
 };
 
@@ -20,35 +22,50 @@ interface Props {
 }
 
 // Cache for build time
-let cachedQueries: Record<string, Query[]> = {
-  allVersions: [],
-  currentVersions: [],
-};
+let memoryCache: Record<string, Query[]> = {};
 
 export const getQueries = async ({ getAllVersions = true, hydrateServices = true }: Props = {}): Promise<Query[]> => {
-  const cacheKey = getAllVersions ? 'allVersions' : 'currentVersions';
+  // console.time('✅ New getQueries');
+  const cacheKey = `${getAllVersions ? 'allVersions' : 'currentVersions'}-${hydrateServices ? 'hydrated' : 'minimal'}`;
 
-  if (cachedQueries[cacheKey].length > 0 && hydrateServices) {
-    return cachedQueries[cacheKey];
+  if (memoryCache[cacheKey] && memoryCache[cacheKey].length > 0 && CACHE_ENABLED) {
+    // console.timeEnd('✅ New getQueries');
+    return memoryCache[cacheKey];
   }
 
-  const queries = await getCollection('queries', (query) => {
-    return (getAllVersions || !query.filePath?.includes('versioned')) && query.data.hidden !== true;
+  // 1. Fetch collections in parallel
+  const [allQueries, allServices, allChannels] = await Promise.all([
+    getCollection('queries'),
+    getCollection('services'),
+    getCollection('channels'),
+  ]);
+
+  // 2. Build optimized maps
+  const queryMap = createVersionedMap(allQueries);
+
+  // 3. Filter queries
+  const targetQueries = allQueries.filter((query) => {
+    if (query.data.hidden === true) return false;
+    if (!getAllVersions && query.filePath?.includes('versioned')) return false;
+    return true;
   });
 
-  const services = await getCollection('services');
-  const allChannels = await getCollection('channels');
+  const { getResourceFolderName } = utils(process.env.PROJECT_DIR ?? '');
 
-  // @ts-ignore
-  cachedQueries[cacheKey] = await Promise.all(
-    queries.map(async (query) => {
-      const { latestVersion, versions } = getVersionForCollectionItem(query, queries);
+  // 4. Enrich queries
+  const processedQueries = await Promise.all(
+    targetQueries.map(async (query) => {
+      // Version info
+      const queryVersions = queryMap.get(query.data.id) || [];
+      const latestVersion = queryVersions[0]?.data.version || query.data.version;
+      const versions = queryVersions.map((e) => e.data.version);
 
-      const producers = services
+      // 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;
+            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);
           })
         )
@@ -57,11 +74,12 @@ export const getQueries = async ({ getAllVersions = true, hydrateServices = true
           return service;
         });
 
-      const consumers = services
+      // 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;
+            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);
           })
         )
@@ -70,10 +88,10 @@ export const getQueries = async ({ getAllVersions = true, hydrateServices = true
           return service;
         });
 
+      // Find Channels
       const messageChannels = query.data.channels || [];
       const channelsForQuery = allChannels.filter((c) => messageChannels.some((channel) => c.data.id === channel.id));
 
-      const { getResourceFolderName } = utils(process.env.PROJECT_DIR ?? '');
       const folderName = await getResourceFolderName(process.env.PROJECT_DIR ?? '', query.data.id, query.data.version.toString());
       const queryFolderName = folderName ?? query.id.replace(`-${query.data.version}`, '');
 
@@ -82,8 +100,8 @@ export const getQueries = async ({ getAllVersions = true, hydrateServices = true
         data: {
           ...query.data,
           messageChannels: channelsForQuery,
-          producers,
-          consumers,
+          producers: producers as any, // Cast for hydration flexibility
+          consumers: consumers as any,
           versions,
           latestVersion,
         },
@@ -93,16 +111,19 @@ export const getQueries = async ({ getAllVersions = true, hydrateServices = true
           astroContentFilePath: path.join(process.cwd(), 'src', 'content', query.collection, query.id),
           filePath: path.join(process.cwd(), 'src', 'catalog-files', query.collection, query.id.replace('/index.mdx', '')),
           publicPath: path.join('/generated', query.collection, queryFolderName),
-          type: 'event',
+          type: 'event', // Kept as 'event' to match original file, though likely should be 'query'
         },
       };
     })
   );
 
   // order them by the name of the query
-  cachedQueries[cacheKey].sort((a, b) => {
+  processedQueries.sort((a, b) => {
     return (a.data.name || a.data.id).localeCompare(b.data.name || b.data.id);
   });
 
-  return cachedQueries[cacheKey];
+  memoryCache[cacheKey] = processedQueries;
+  // console.timeEnd('✅ New getQueries');
+
+  return processedQueries;
 };