@eventcatalog/core 2.65.0 → 3.0.0-beta.0

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

@@ -1,18 +1,19 @@
 import { getCollection } from 'astro:content';
 import type { CollectionEntry } from 'astro:content';
 import path from 'path';
-import { getItemsFromCollectionByIdAndSemverOrLatest, getVersionForCollectionItem, satisfies } from './collections/util';
-import { getMessages } from './messages';
+import { getItemsFromCollectionByIdAndSemverOrLatest, createVersionedMap, satisfies } from './util';
 import type { CollectionMessageTypes } from '@types';
 import utils from '@eventcatalog/sdk';
 
 const PROJECT_DIR = process.env.PROJECT_DIR || process.cwd();
+const CACHE_ENABLED = process.env.DISABLE_EVENTCATALOG_CACHE !== 'true';
 
 type Channel = CollectionEntry<'channels'> & {
   catalog: {
     path: string;
     filePath: string;
     type: string;
+    publicPath: string;
   };
 };
 
@@ -21,43 +22,89 @@ interface Props {
 }
 
 // cache for build time
-let cachedChannels: Record<string, Channel[]> = {
-  allVersions: [],
-  currentVersions: [],
-};
+let memoryCache: Record<string, Channel[]> = {};
 
 export const getChannels = async ({ getAllVersions = true }: Props = {}): Promise<Channel[]> => {
+  // console.time('✅ New getChannels');
   const cacheKey = getAllVersions ? 'allVersions' : 'currentVersions';
 
-  if (cachedChannels[cacheKey].length > 0) {
-    return cachedChannels[cacheKey];
+  if (memoryCache[cacheKey] && memoryCache[cacheKey].length > 0 && CACHE_ENABLED) {
+    // console.timeEnd('✅ New getChannels');
+    return memoryCache[cacheKey];
   }
 
-  const channels = await getCollection('channels', (query) => {
-    return (getAllVersions || !query.filePath?.includes('versioned')) && query.data.hidden !== true;
-  });
-
-  const { commands, events, queries } = await getMessages();
-  const allMessages = [...commands, ...events, ...queries];
-
-  cachedChannels[cacheKey] = await Promise.all(
-    channels.map(async (channel) => {
-      const { latestVersion, versions } = getVersionForCollectionItem(channel, channels);
-
-      const messagesForChannel = allMessages.filter((message) => {
-        return message.data.channels?.some((messageChannel) => {
-          if (messageChannel.id != channel.data.id) return false;
-          if (messageChannel.version == 'latest' || messageChannel.version == undefined)
-            return channel.data.version == latestVersion;
-          return satisfies(channel.data.version, messageChannel.version);
+  // 1. Fetch collections in parallel
+  const [allChannels, allEvents, allCommands, allQueries] = await Promise.all([
+    getCollection('channels'),
+    getCollection('events'),
+    getCollection('commands'),
+    getCollection('queries'),
+  ]);
+
+  const allMessages = [...allEvents, ...allCommands, ...allQueries];
+
+  // 2. Build optimized maps
+  const channelMap = createVersionedMap(allChannels);
+
+  // 3. Build Message Index by Channel ID (Reverse Index)
+  // Map<ChannelID, Array<{ message: Message, requiredVersion: string | undefined }>>
+  const messagesByChannelId = new Map<
+    string,
+    Array<{ message: CollectionEntry<CollectionMessageTypes>; requiredVersion?: string }>
+  >();
+
+  for (const message of allMessages) {
+    if (message.data.channels) {
+      for (const channelRef of message.data.channels) {
+        if (!messagesByChannelId.has(channelRef.id)) {
+          messagesByChannelId.set(channelRef.id, []);
+        }
+        messagesByChannelId.get(channelRef.id)!.push({
+          message,
+          requiredVersion: channelRef.version,
         });
-      });
+      }
+    }
+  }
 
-      const messages = messagesForChannel.map((message: CollectionEntry<CollectionMessageTypes>) => {
-        return { id: message.data.id, name: message.data.name, version: message.data.version, collection: message.collection };
+  // 4. Filter channels
+  const targetChannels = allChannels.filter((channel) => {
+    if (channel.data.hidden === true) return false;
+    if (!getAllVersions && channel.filePath?.includes('versioned')) return false;
+    return true;
+  });
+
+  const { getResourceFolderName } = utils(process.env.PROJECT_DIR ?? '');
+
+  // 5. Enrich channels
+  const processedChannels = await Promise.all(
+    targetChannels.map(async (channel) => {
+      // Version info
+      const channelVersions = channelMap.get(channel.data.id) || [];
+      const latestVersion = channelVersions[0]?.data.version || channel.data.version;
+      const versions = channelVersions.map((c) => c.data.version);
+
+      // Find messages for this channel version
+      const candidateMessages = messagesByChannelId.get(channel.data.id) || [];
+
+      const messagesForChannel = candidateMessages
+        .filter(({ requiredVersion }) => {
+          if (requiredVersion === 'latest' || requiredVersion === undefined) {
+            return channel.data.version === latestVersion;
+          }
+          return satisfies(channel.data.version, requiredVersion);
+        })
+        .map(({ message }) => message);
+
+      const messages = messagesForChannel.map((message) => {
+        return {
+          id: message.data.id,
+          name: message.data.name,
+          version: message.data.version,
+          collection: message.collection,
+        };
       });
 
-      const { getResourceFolderName } = utils(process.env.PROJECT_DIR ?? '');
       const folderName = await getResourceFolderName(
         process.env.PROJECT_DIR ?? '',
         channel.data.id,
@@ -86,11 +133,14 @@ export const getChannels = async ({ getAllVersions = true }: Props = {}): Promis
   );
 
   // order them by the name of the channel
-  cachedChannels[cacheKey].sort((a, b) => {
+  processedChannels.sort((a, b) => {
     return (a.data.name || a.data.id).localeCompare(b.data.name || b.data.id);
   });
 
-  return cachedChannels[cacheKey];
+  memoryCache[cacheKey] = processedChannels;
+  // console.timeEnd('✅ New getChannels');
+
+  return processedChannels;
 };
 
 // Could be recursive, we need to keep going until we find a loop or until we reach the target channel

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

@@ -0,0 +1,134 @@
+import { getCollection } from 'astro:content';
+import type { CollectionEntry } from 'astro:content';
+import path from 'path';
+import { createVersionedMap, 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 Command = CollectionEntry<'commands'> & {
+  catalog: {
+    path: string;
+    filePath: string;
+    type: string;
+    publicPath: string;
+  };
+};
+
+interface Props {
+  getAllVersions?: boolean;
+  hydrateServices?: boolean;
+}
+
+// Simple in-memory cache
+let memoryCache: Record<string, Command[]> = {};
+
+export const getCommands = async ({ getAllVersions = true, hydrateServices = true }: Props = {}): Promise<Command[]> => {
+  // console.time('✅ New getCommands');
+  const cacheKey = `${getAllVersions ? 'allVersions' : 'currentVersions'}-${hydrateServices ? 'hydrated' : 'minimal'}`;
+
+  // Check cache
+  if (memoryCache[cacheKey] && memoryCache[cacheKey].length > 0) {
+    // console.timeEnd('✅ New getCommands');
+    return memoryCache[cacheKey];
+  }
+
+  // 1. Fetch collections in parallel
+  const [allCommands, allServices, allChannels] = await Promise.all([
+    getCollection('commands'),
+    getCollection('services'),
+    getCollection('channels'),
+  ]);
+
+  // 2. Build optimized maps
+  const commandMap = createVersionedMap(allCommands);
+
+  // 3. Filter commands
+  const targetCommands = allCommands.filter((command) => {
+    if (command.data.hidden === true) return false;
+    if (!getAllVersions && command.filePath?.includes('versioned')) return false;
+    return true;
+  });
+
+  const { getResourceFolderName } = utils(process.env.PROJECT_DIR ?? '');
+
+  // 4. Enrich commands
+  const processedCommands = await Promise.all(
+    targetCommands.map(async (command) => {
+      // Version info
+      const commandVersions = commandMap.get(command.data.id) || [];
+      const latestVersion = commandVersions[0]?.data.version || command.data.version;
+      const versions = commandVersions.map((e) => e.data.version);
+
+      // Find Producers (Services that send this command)
+      const producers = allServices
+        .filter((service) =>
+          service.data.sends?.some((item) => {
+            if (item.id !== command.data.id) return false;
+            if (item.version === 'latest' || item.version === undefined) return command.data.version === latestVersion;
+            return satisfies(command.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 command)
+      const consumers = allServices
+        .filter((service) =>
+          service.data.receives?.some((item) => {
+            if (item.id !== command.data.id) return false;
+            if (item.version === 'latest' || item.version === undefined) return command.data.version === latestVersion;
+            return satisfies(command.data.version, item.version);
+          })
+        )
+        .map((service) => {
+          if (!hydrateServices) return { id: service.data.id, version: service.data.version };
+          return service;
+        });
+
+      // Find Channels
+      const messageChannels = command.data.channels || [];
+      const channelsForCommand = allChannels.filter((c) => messageChannels.some((channel) => c.data.id === channel.id));
+
+      const folderName = await getResourceFolderName(
+        process.env.PROJECT_DIR ?? '',
+        command.data.id,
+        command.data.version.toString()
+      );
+      const commandFolderName = folderName ?? command.id.replace(`-${command.data.version}`, '');
+
+      return {
+        ...command,
+        data: {
+          ...command.data,
+          messageChannels: channelsForCommand,
+          producers: producers as any, // Cast for hydration flexibility
+          consumers: consumers as any,
+          versions,
+          latestVersion,
+        },
+        catalog: {
+          path: path.join(command.collection, command.id.replace('/index.mdx', '')),
+          absoluteFilePath: path.join(PROJECT_DIR, command.collection, command.id.replace('/index.mdx', '/index.md')),
+          astroContentFilePath: path.join(process.cwd(), 'src', 'content', command.collection, command.id),
+          filePath: path.join(process.cwd(), 'src', 'catalog-files', command.collection, command.id.replace('/index.mdx', '')),
+          publicPath: path.join('/generated', command.collection, commandFolderName),
+          type: 'command',
+        },
+      };
+    })
+  );
+
+  // order them by the name of the command
+  processedCommands.sort((a, b) => {
+    return (a.data.name || a.data.id).localeCompare(b.data.name || b.data.id);
+  });
+
+  memoryCache[cacheKey] = processedCommands;
+  // console.timeEnd('✅ New getCommands');
+
+  return processedCommands;
+};

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

@@ -1,16 +1,17 @@
 import { getCollection } from 'astro:content';
 import type { CollectionEntry } from 'astro:content';
 import path from 'path';
-import { getVersionForCollectionItem, satisfies } from './util';
+import { createVersionedMap, 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';
 export type Entity = CollectionEntry<'containers'> & {
   catalog: {
     path: string;
     filePath: string;
     type: string;
+    publicPath: string;
   };
 };
 
@@ -19,54 +20,61 @@ interface Props {
 }
 
 // cache for build time
-let cachedEntities: Record<string, Entity[]> = {
-  allVersions: [],
-  currentVersions: [],
-};
+let memoryCache: Record<string, Entity[]> = {};
 
 export const getContainers = async ({ getAllVersions = true }: Props = {}): Promise<Entity[]> => {
+  // console.time('✅ New getContainers');
   const cacheKey = getAllVersions ? 'allVersions' : 'currentVersions';
 
-  if (cachedEntities[cacheKey].length > 0) {
-    return cachedEntities[cacheKey];
+  if (memoryCache[cacheKey] && memoryCache[cacheKey].length > 0 && CACHE_ENABLED) {
+    // console.timeEnd('✅ New getContainers');
+    return memoryCache[cacheKey];
   }
 
-  const containers = await getCollection('containers', (container) => {
-    return (getAllVersions || !container.filePath?.includes('versioned')) && container.data.hidden !== true;
-  });
+  // 1. Fetch collections in parallel
+  const [allContainers, allServices] = await Promise.all([getCollection('containers'), getCollection('services')]);
 
-  const services = await getCollection('services');
+  // 2. Build optimized maps
+  const containerMap = createVersionedMap(allContainers);
 
-  cachedEntities[cacheKey] = await Promise.all(
-    containers.map(async (container) => {
-      const { latestVersion, versions } = getVersionForCollectionItem(container, containers);
+  // 3. Filter containers
+  const targetContainers = allContainers.filter((container) => {
+    if (container.data.hidden === true) return false;
+    if (!getAllVersions && container.filePath?.includes('versioned')) return false;
+    return true;
+  });
 
-      const servicesThatReferenceContainer = services.filter((service) => {
-        const references = [...(service.data.writesTo || []), ...(service.data.readsFrom || [])];
-        return references.some((item) => {
-          if (item.id != container.data.id) return false;
-          if (item.version == 'latest' || item.version == undefined) return container.data.version == latestVersion;
-          return satisfies(container.data.version, item.version);
-        });
-      });
+  const { getResourceFolderName } = utils(process.env.PROJECT_DIR ?? '');
+
+  // 4. Enrich containers
+  const processedContainers = await Promise.all(
+    targetContainers.map(async (container) => {
+      // Version info
+      const containerVersions = containerMap.get(container.data.id) || [];
+      const latestVersion = containerVersions[0]?.data.version || container.data.version;
+      const versions = containerVersions.map((c) => c.data.version);
 
-      const servicesThatWriteToContainer = services.filter((service) => {
+      // Find Services that write to this container
+      const servicesThatWriteToContainer = allServices.filter((service) => {
         return service.data?.writesTo?.some((item) => {
-          if (item.id != container.data.id) return false;
-          if (item.version == 'latest' || item.version == undefined) return container.data.version == latestVersion;
+          if (item.id !== container.data.id) return false;
+          if (item.version === 'latest' || item.version === undefined) return container.data.version === latestVersion;
           return satisfies(container.data.version, item.version);
         });
       });
 
-      const servicesThatReadFromContainer = services.filter((service) => {
+      // Find Services that read from this container
+      const servicesThatReadFromContainer = allServices.filter((service) => {
         return service.data?.readsFrom?.some((item) => {
-          if (item.id != container.data.id) return false;
-          if (item.version == 'latest' || item.version == undefined) return container.data.version == latestVersion;
+          if (item.id !== container.data.id) return false;
+          if (item.version === 'latest' || item.version === undefined) return container.data.version === latestVersion;
           return satisfies(container.data.version, item.version);
         });
       });
 
-      const { getResourceFolderName } = utils(process.env.PROJECT_DIR ?? '');
+      // Combine references
+      const servicesThatReferenceContainer = [...new Set([...servicesThatWriteToContainer, ...servicesThatReadFromContainer])];
+
       const folderName = await getResourceFolderName(
         process.env.PROJECT_DIR ?? '',
         container.data.id,
@@ -102,10 +110,13 @@ export const getContainers = async ({ getAllVersions = true }: Props = {}): Prom
     })
   );
 
-  // order them by the name of the event
-  cachedEntities[cacheKey].sort((a, b) => {
+  // order them by the name of the container
+  processedContainers.sort((a, b) => {
     return (a.data.name || a.data.id).localeCompare(b.data.name || b.data.id);
   });
 
-  return cachedEntities[cacheKey];
+  memoryCache[cacheKey] = processedContainers;
+  // console.timeEnd('✅ New getContainers');
+
+  return processedContainers;
 };