@eventcatalog/core 2.65.0 → 3.0.0-beta.0

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;
 };

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;
+};