@eventcatalog/core 3.48.4 → 4.0.0-beta.0

package/eventcatalog/src/stores/sidebar-store/state.ts

@@ -5,6 +5,7 @@ import { getAdrAliasNodeKey, getAdrNodeKey, getAdrs, type Adr } from '@utils/col
 import { ADR_STATUS_VALUES, formatAdrStatus } from '@utils/collections/adr-constants';
 import { getContainers } from '@utils/collections/containers';
 import { getDomains } from '@utils/collections/domains';
+import { getSystems } from '@utils/collections/systems';
 import { getServices } from '@utils/collections/services';
 import { getMessages, pluralizeMessageType } from '@utils/collections/messages';
 import { getOwner } from '@utils/collections/owners';
@@ -19,6 +20,7 @@ import { buildUrl } from '@utils/url-builder';
 import type { NavigationData, NavNode, ChildRef } from './builders/shared';
 import { buildAgentNode } from './builders/agent';
 import { buildDomainNode } from './builders/domain';
+import { buildSystemNode } from './builders/system';
 import { buildServiceNode } from './builders/service';
 import { buildMessageNode } from './builders/message';
 import { buildContainerNode } from './builders/container';
@@ -274,6 +276,7 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
 
   const [
     domains,
+    systems,
     agents,
     services,
     { events, commands, queries },
@@ -293,6 +296,7 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
     resourceDocCategories,
   ] = await Promise.all([
     getDomains({ getAllVersions: false, includeServicesInSubdomains: false }),
+    getSystems({ getAllVersions: false }),
     getAgents({ getAllVersions: false }),
     getServices({ getAllVersions: false }),
     getMessages({ getAllVersions: false }),
@@ -322,6 +326,7 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
     agents,
     services,
     domains,
+    systems,
     events,
     commands,
     queries,
@@ -392,6 +397,15 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
     })
   );
 
+  const systemWithOwners = await Promise.all(
+    systems.map(async (system) => {
+      const ownersInSystem = system.data.owners || [];
+      const owners = await Promise.all(ownersInSystem.map((owner) => getOwner(owner)));
+      const filteredOwners = owners.filter((o) => o !== undefined) as Array<NonNullable<(typeof owners)[0]>>;
+      return { system, owners: filteredOwners };
+    })
+  );
+
   const adrsWithOwners = await Promise.all(
     adrs.map(async (adr) => {
       const owners = await Promise.all((adr.data.owners || []).map((owner) => getOwner(owner)));
@@ -607,6 +621,19 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
     {} as Record<string, NavNode | string>
   );
 
+  const systemNodes = systemWithOwners.reduce(
+    (acc, { system, owners }) => {
+      const versionedKey = `system:${system.data.id}:${system.data.version}`;
+      acc[versionedKey] = withArchitectureDecisionsSection(buildSystemNode(system, owners, context), system, adrs);
+      if (system.data.latestVersion === system.data.version) {
+        // Store reference to versioned key instead of duplicating the full node
+        acc[`system:${system.data.id}`] = versionedKey;
+      }
+      return acc;
+    },
+    {} as Record<string, NavNode | string>
+  );
+
   // Get owners for data products
   const dataProductWithOwners = await Promise.all(
     dataProducts.map(async (dataProduct) => {
@@ -781,6 +808,7 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
     {} as Record<string, NavNode>
   );
 
+  const visualiserEnabled = config?.visualiser?.enabled !== false;
   const rootDomainsNodes: Record<string, NavNode> = {};
 
   if (rootDomains.length > 0) {
@@ -792,6 +820,22 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
     };
   }
 
+  const topLevelDiagramsNode =
+    visualiserEnabled && systems.length > 0
+      ? {
+          type: 'group' as const,
+          title: 'Top level diagrams',
+          icon: 'Workflow',
+          pages: [
+            {
+              type: 'item' as const,
+              title: 'System Context Map',
+              href: buildUrl('/visualiser/system-context-map'),
+            },
+          ],
+        }
+      : undefined;
+
   const createLeaf = (items: any[], node: NavNode) => (items.length > 0 ? node : undefined);
 
   const domainsList = createLeaf(domains, {
@@ -801,6 +845,38 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
     pages: sortByResourceName(domains).map((domain) => `domain:${domain.data.id}:${domain.data.version}`),
   });
 
+  // Split systems by scope (defaults to internal). When there are systems of both
+  // scopes we show two sub-sections (Internal / External), each ordered by name;
+  // otherwise we keep a flat list so a single-scope catalog isn't over-nested.
+  const internalSystems = systems.filter((system) => (system.data.scope ?? 'internal') !== 'external');
+  const externalSystems = systems.filter((system) => system.data.scope === 'external');
+
+  const systemPageKeys = (items: typeof systems) =>
+    sortByResourceName(items).map((system) => `system:${system.data.id}:${system.data.version}`);
+
+  const internalSystemsList = createLeaf(internalSystems, {
+    type: 'group',
+    title: 'Internal',
+    icon: 'Group',
+    pages: systemPageKeys(internalSystems),
+  });
+
+  const externalSystemsScopedList = createLeaf(externalSystems, {
+    type: 'group',
+    title: 'External',
+    icon: 'Group',
+    pages: systemPageKeys(externalSystems),
+  });
+
+  const hasBothSystemScopes = internalSystems.length > 0 && externalSystems.length > 0;
+
+  const systemsList = createLeaf(systems, {
+    type: 'item',
+    title: 'Systems',
+    icon: 'Group',
+    pages: hasBothSystemScopes ? ['list:systems-internal', 'list:systems-external'] : systemPageKeys(systems),
+  });
+
   const agentsList = createLeaf(agents, {
     type: 'item',
     title: 'Agents',
@@ -811,7 +887,7 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
   const adrsList = createLeaf(adrs, {
     type: 'item',
     title: 'Decision Records',
-    icon: 'BookText',
+    icon: 'ClipboardList',
     pages: groupAdrsByStatus(adrs),
   });
 
@@ -939,6 +1015,7 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
 
   const allChildrenKeys = [
     'list:domains',
+    'list:systems',
     'list:services',
     'list:agents',
     'list:adrs',
@@ -954,6 +1031,7 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
   ];
   const allChildrenNodes = [
     domainsList,
+    systemsList,
     servicesList,
     agentsList,
     adrsList,
@@ -968,10 +1046,22 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
     peopleList,
   ];
 
+  // The Browse list leads with the resources people reach for most — Domains,
+  // Systems, Services then Messages — and falls back to A-Z for everything else.
+  const browseOrderPriority = ['list:domains', 'list:systems', 'list:services', 'list:messages'];
+  const browseRank = (key: string) => {
+    const index = browseOrderPriority.indexOf(key);
+    return index === -1 ? browseOrderPriority.length : index;
+  };
+
   const validAllChildren = allChildrenKeys
     .map((key, idx) => ({ key, node: allChildrenNodes[idx] }))
     .filter((item): item is { key: string; node: NavNode } => item.node !== undefined)
-    .sort((a, b) => a.node.title.localeCompare(b.node.title))
+    .sort((a, b) => {
+      const rankDifference = browseRank(a.key) - browseRank(b.key);
+      if (rankDifference !== 0) return rankDifference;
+      return a.node.title.localeCompare(b.node.title);
+    })
     .map((item) => item.key);
 
   let allList;
@@ -986,6 +1076,9 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
 
   const allNodes: Record<string, NavNode> = {
     ...(domainsList ? { 'list:domains': domainsList } : {}),
+    ...(systemsList ? { 'list:systems': systemsList } : {}),
+    ...(internalSystemsList ? { 'list:systems-internal': internalSystemsList } : {}),
+    ...(externalSystemsScopedList ? { 'list:systems-external': externalSystemsScopedList } : {}),
     ...(servicesList ? { 'list:services': servicesList } : {}),
     ...(agentsList ? { 'list:agents': agentsList } : {}),
     ...(adrsList ? { 'list:adrs': adrsList } : {}),
@@ -1008,7 +1101,6 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
 
   // System-level views (only show if visualiser is enabled and there are domains)
   const systemNode: Record<string, NavNode> = {};
-  const visualiserEnabled = config?.visualiser?.enabled !== false;
 
   if (visualiserEnabled && domains.length > 0) {
     systemNode['list:system'] = {
@@ -1027,7 +1119,9 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
 
   const allGeneratedNodes = {
     ...rootDomainsNodes,
+    ...(topLevelDiagramsNode ? { 'list:top-level-diagrams': topLevelDiagramsNode } : {}),
     ...domainNodes,
+    ...systemNodes,
     ...agentNodes,
     ...adrNodes,
     ...serviceNodes,
@@ -1047,9 +1141,8 @@ export const getNestedSideBarData = async (): Promise<NavigationData> => {
 
   // only filter if child is string
   const defaultPages = ['list:top-level-domains', 'list:all'];
-  // Add system section if it exists
-  if (systemNode['list:system']) {
-    defaultPages.push('list:system');
+  if (topLevelDiagramsNode) {
+    defaultPages.splice(1, 0, 'list:top-level-diagrams');
   }
   const rootNavigationConfig = config?.navigation?.pages || defaultPages;
 

package/eventcatalog/src/types/index.ts

@@ -5,6 +5,7 @@ export type CollectionTypes =
   | 'events'
   | 'queries'
   | 'domains'
+  | 'systems'
   | 'services'
   | 'flows'
   | 'channels'
@@ -22,6 +23,7 @@ export type PageTypes =
   | 'queries'
   | 'services'
   | 'domains'
+  | 'systems'
   | 'channels'
   | 'flows'
   | 'entities'

package/eventcatalog/src/utils/collection-colors.ts

@@ -10,7 +10,8 @@ export type CollectionColor =
   | 'gray'
   | 'cyan'
   | 'sky'
-  | 'indigo';
+  | 'indigo'
+  | 'violet';
 
 export const getColorForCollection = (collection: string): CollectionColor => {
   switch (collection) {
@@ -34,6 +35,8 @@ export const getColorForCollection = (collection: string): CollectionColor => {
       return 'purple';
     case 'domains':
       return 'yellow';
+    case 'systems':
+      return 'violet';
     case 'agents':
       return 'sky';
     case 'adrs':
@@ -62,6 +65,7 @@ export const tailwind500RgbByColor: Record<CollectionColor, string> = {
   cyan: '6 182 212',
   sky: '14 165 233',
   indigo: '99 102 241',
+  violet: '139 92 246',
 };
 
 export const collectionTextColorClassByColor: Record<CollectionColor, string> = {
@@ -77,6 +81,7 @@ export const collectionTextColorClassByColor: Record<CollectionColor, string> =
   cyan: 'text-cyan-500',
   sky: 'text-sky-500',
   indigo: 'text-indigo-500',
+  violet: 'text-violet-500',
 };
 
 export const getCollectionTextColorClass = (color: string, fallback = 'text-gray-500'): string =>

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

@@ -123,6 +123,7 @@ export const getDomains = async ({
     allServices,
     allEntities,
     allFlows,
+    allSystems,
     allEvents,
     allCommands,
     allQueries,
@@ -134,6 +135,7 @@ export const getDomains = async ({
     getCollection('services'),
     getCollection('entities'),
     getCollection('flows'),
+    getCollection('systems'),
     getCollection('events'),
     getCollection('commands'),
     getCollection('queries'),
@@ -151,6 +153,7 @@ export const getDomains = async ({
   const serviceMap = createVersionedMap(allServices);
   const entityMap = createVersionedMap(allEntities);
   const flowMap = createVersionedMap(allFlows);
+  const systemMap = createVersionedMap(allSystems);
   const dataProductMap = createVersionedMap(allDataProducts);
 
   // 3. Filter the domains we actually want to process/return
@@ -220,6 +223,37 @@ export const getDomains = async ({
         .map((flow: { id: string; version: string | undefined }) => findInMap(flowMap, flow.id, flow.version))
         .filter((f): f is CollectionEntry<'flows'> => !!f);
 
+      // Resolve Systems (and hydrate each system's services so they can be
+      // rendered in the domain's architecture view, like subdomains)
+      const systemsInDomain = domain.data.systems || [];
+      const systems = systemsInDomain
+        .map((system: { id: string; version: string | undefined }) => findInMap(systemMap, system.id, system.version))
+        .filter((s): s is CollectionEntry<'systems'> => !!s)
+        .map((system: any) => {
+          const systemServices = enrichServices
+            ? hydrateServices(system.data.services || [], serviceMap, messageMap, containerMap)
+            : (system.data.services || [])
+                .map((service: { id: string; version: string | undefined }) => findInMap(serviceMap, service.id, service.version))
+                .filter((s: any) => !!s);
+
+          // Hydrate the system's data stores (containers) so they can be
+          // rendered in the domain's architecture view.
+          const systemContainers = (system.data.containers || [])
+            .map((container: { id: string; version: string | undefined }) =>
+              findInMap(containerMap, container.id, container.version)
+            )
+            .filter((c: any) => !!c);
+
+          return {
+            ...system,
+            data: {
+              ...system.data,
+              services: systemServices as any,
+              containers: systemContainers as any,
+            },
+          };
+        });
+
       // Resolve Data Products
       const dataProductsInDomain = domain.data['data-products'] || [];
       const dataProducts = dataProductsInDomain
@@ -274,6 +308,7 @@ export const getDomains = async ({
           agents: agents as any,
           services: services as any, // Cast to avoid deep type issues with enriched data
           domains: subDomains as any,
+          systems: systems as any,
           entities: entities as any,
           flows: flows as any,
           'data-products': dataProducts as any,

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

@@ -9,20 +9,21 @@ import {
   UserIcon,
   ArrowsRightLeftIcon,
   VariableIcon,
-  MapIcon,
   CubeIcon,
 } from '@heroicons/react/24/outline';
-import { BookText, Bot, Box, DatabaseIcon } from 'lucide-react';
+import { BookText, Bot, Box, ClipboardList, DatabaseIcon, Group } from 'lucide-react';
 import { getColorForCollection } from '@utils/collection-colors';
 
 export const getIconForCollection = (collection: string) => {
   switch (collection) {
     case 'domains':
       return RectangleGroupIcon;
+    case 'systems':
+      return Group;
     case 'agents':
       return Bot;
     case 'adrs':
-      return BookText;
+      return ClipboardList;
     case 'services':
       return ServerIcon;
     case 'events':
@@ -43,8 +44,6 @@ export const getIconForCollection = (collection: string) => {
       return VariableIcon;
     case 'ubiquitousLanguages':
       return BookText;
-    case 'bounded-context-map':
-      return MapIcon;
     case 'entities':
       return Box;
     case 'containers':

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

@@ -0,0 +1,110 @@
+import { getCollection } from 'astro:content';
+import type { CollectionEntry } from 'astro:content';
+import { createVersionedMap, findInMap } from './util';
+
+const CACHE_ENABLED = process.env.DISABLE_EVENTCATALOG_CACHE !== 'true';
+export type System = CollectionEntry<'systems'>;
+
+interface Props {
+  getAllVersions?: boolean;
+}
+
+// cache for build time
+let memoryCache: Record<string, System[]> = {};
+
+export const getSystems = async ({ getAllVersions = true }: Props = {}): Promise<System[]> => {
+  const cacheKey = getAllVersions ? 'allVersions' : 'currentVersions';
+
+  if (memoryCache[cacheKey] && memoryCache[cacheKey].length > 0 && CACHE_ENABLED) {
+    return memoryCache[cacheKey];
+  }
+
+  const [allSystems, allServices, allFlows, allEntities, allContainers] = await Promise.all([
+    getCollection('systems'),
+    getCollection('services'),
+    getCollection('flows'),
+    getCollection('entities'),
+    getCollection('containers'),
+  ]);
+
+  // Build optimized map of id -> versions (sorted latest first)
+  const systemMap = createVersionedMap(allSystems);
+  const serviceMap = createVersionedMap(allServices);
+  const flowMap = createVersionedMap(allFlows);
+  const entityMap = createVersionedMap(allEntities);
+  const containerMap = createVersionedMap(allContainers);
+
+  // Filter systems
+  const targetSystems = allSystems.filter((system) => {
+    if (system.data.hidden === true) return false;
+    if (!getAllVersions && system.filePath?.includes('versioned')) return false;
+    return true;
+  });
+
+  // Enrich systems with version info
+  const processedSystems = targetSystems.map((system) => {
+    const systemVersions = systemMap.get(system.data.id) || [];
+    const latestVersion = systemVersions[0]?.data.version || system.data.version;
+    const versions = systemVersions.map((s) => s.data.version);
+
+    // Resolve service pointers to their full collection entries
+    const services = (system.data.services || [])
+      .map((service: { id: string; version?: string }) => findInMap(serviceMap, service.id, service.version))
+      .filter((s): s is NonNullable<typeof s> => !!s);
+
+    // Resolve flow pointers to their full collection entries
+    const flows = (system.data.flows || [])
+      .map((flow: { id: string; version?: string }) => findInMap(flowMap, flow.id, flow.version))
+      .filter((f): f is NonNullable<typeof f> => !!f);
+
+    // Resolve entity pointers to their full collection entries
+    const entities = (system.data.entities || [])
+      .map((entity: { id: string; version?: string }) => findInMap(entityMap, entity.id, entity.version))
+      .filter((e): e is NonNullable<typeof e> => !!e);
+
+    // Resolve container (data store) pointers to their full collection entries
+    const containers = (system.data.containers || [])
+      .map((container: { id: string; version?: string }) => findInMap(containerMap, container.id, container.version))
+      .filter((c): c is NonNullable<typeof c> => !!c);
+
+    // Resolve system-to-system relationship pointers (used by the System Diagram).
+    // Each relationship resolves to its target system while keeping the edge `label`.
+    // Dangling targets are dropped; relationships keep their label even if absent (the
+    // diagram decides whether to draw an edge based on the presence of a label).
+    const relationships = (system.data.relationships || [])
+      .map((relationship: { id: string; version?: string; label?: string }) => {
+        const target = findInMap(systemMap, relationship.id, relationship.version);
+        if (!target) return null;
+        return {
+          id: target.data.id,
+          version: target.data.version,
+          label: relationship.label,
+          data: target.data,
+        };
+      })
+      .filter((r): r is NonNullable<typeof r> => !!r);
+
+    return {
+      ...system,
+      data: {
+        ...system.data,
+        versions,
+        latestVersion,
+        services: services as any,
+        flows: flows as any,
+        entities: entities as any,
+        containers: containers as any,
+        relationships: relationships as any,
+      },
+    };
+  });
+
+  // order them by the name of the system
+  processedSystems.sort((a, b) => {
+    return (a.data.name || a.data.id).localeCompare(b.data.name || b.data.id);
+  });
+
+  memoryCache[cacheKey] = processedSystems;
+
+  return processedSystems;
+};

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

@@ -16,16 +16,18 @@ export const getTeams = async (): Promise<Team[]> => {
   }
 
   // 1. Fetch all collections in parallel
-  const [allTeams, allAgents, allDomains, allServices, allEvents, allCommands, allQueries, allAdrs] = await Promise.all([
-    getCollection('teams'),
-    getCollection('agents'),
-    getCollection('domains'),
-    getCollection('services'),
-    getCollection('events'),
-    getCollection('commands'),
-    getCollection('queries'),
-    getAdrs({ getAllVersions: false }),
-  ]);
+  const [allTeams, allAgents, allDomains, allSystems, allServices, allEvents, allCommands, allQueries, allAdrs] =
+    await Promise.all([
+      getCollection('teams'),
+      getCollection('agents'),
+      getCollection('domains'),
+      getCollection('systems'),
+      getCollection('services'),
+      getCollection('events'),
+      getCollection('commands'),
+      getCollection('queries'),
+      getAdrs({ getAllVersions: false }),
+    ]);
 
   // 2. Filter teams
   const targetTeams = allTeams.filter((team) => team.data.hidden !== true);
@@ -50,6 +52,7 @@ export const getTeams = async (): Promise<Team[]> => {
 
   addToIndex(allAgents);
   addToIndex(allDomains);
+  addToIndex(allSystems);
   addToIndex(allServices);
   addToIndex(allEvents);
   addToIndex(allCommands);
@@ -64,6 +67,7 @@ export const getTeams = async (): Promise<Team[]> => {
     // Categorize items
     const ownedAgents = ownedItems.filter((i) => i.collection === 'agents') as CollectionEntry<'agents'>[];
     const ownedDomains = ownedItems.filter((i) => i.collection === 'domains') as CollectionEntry<'domains'>[];
+    const ownedSystems = ownedItems.filter((i) => i.collection === 'systems') as CollectionEntry<'systems'>[];
     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'>[];
@@ -76,6 +80,7 @@ export const getTeams = async (): Promise<Team[]> => {
         ...team.data,
         ownedAgents,
         ownedDomains,
+        ownedSystems,
         ownedServices,
         ownedCommands,
         ownedQueries,

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

@@ -17,19 +17,19 @@ export const getUsers = async (): Promise<User[]> => {
   }
 
   // 1. Fetch all collections in parallel
-  const [allUsers, allAgents, allDomains, allServices, allEvents, allCommands, allQueries, allTeams, allAdrs] = await Promise.all(
-    [
+  const [allUsers, allAgents, allDomains, allSystems, allServices, allEvents, allCommands, allQueries, allTeams, allAdrs] =
+    await Promise.all([
       getCollection('users'),
       getCollection('agents'),
       getCollection('domains'),
+      getCollection('systems'),
       getCollection('services'),
       getCollection('events'),
       getCollection('commands'),
       getCollection('queries'),
       getCollection('teams'),
       getAdrs({ getAllVersions: false }),
-    ]
-  );
+    ]);
 
   // 2. Filter users
   const targetUsers = allUsers.filter((user) => user.data.hidden !== true);
@@ -59,6 +59,7 @@ export const getUsers = async (): Promise<User[]> => {
 
   addToIndex(allAgents);
   addToIndex(allDomains);
+  addToIndex(allSystems);
   addToIndex(allServices);
   addToIndex(allEvents);
   addToIndex(allCommands);
@@ -93,6 +94,7 @@ export const getUsers = async (): Promise<User[]> => {
     // Categorize items
     const ownedAgents = allOwnedItems.filter((i) => i.collection === 'agents') as CollectionEntry<'agents'>[];
     const ownedDomains = allOwnedItems.filter((i) => i.collection === 'domains') as CollectionEntry<'domains'>[];
+    const ownedSystems = allOwnedItems.filter((i) => i.collection === 'systems') as CollectionEntry<'systems'>[];
     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'>[];
@@ -105,6 +107,7 @@ export const getUsers = async (): Promise<User[]> => {
         ...user.data,
         ownedAgents,
         ownedDomains,
+        ownedSystems,
         ownedServices,
         ownedEvents,
         ownedCommands,

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

@@ -180,6 +180,7 @@ export const resourceToCollectionMap = {
   command: 'commands',
   query: 'queries',
   domain: 'domains',
+  system: 'systems',
   flow: 'flows',
   channel: 'channels',
   user: 'users',
@@ -198,6 +199,7 @@ export const collectionToResourceMap = {
   commands: 'command',
   queries: 'query',
   domains: 'domain',
+  systems: 'system',
   flows: 'flow',
   channels: 'channel',
   users: 'user',

package/eventcatalog/src/utils/icon-map.ts

@@ -14,10 +14,13 @@ import {
   ArrowDownToLine,
   ArrowRightLeft,
   ArrowUpFromLine,
+  BotMessageSquare,
   BookOpen,
   BookText,
   Box,
   Boxes,
+  ClipboardCheck,
+  ClipboardList,
   Code,
   Database,
   File,
@@ -25,12 +28,19 @@ import {
   FileCode,
   FileImage,
   FileJson,
+  FileWarning,
   Globe,
+  ListChecks,
   Mail,
   Package,
+  Radar,
+  Radio,
+  Route,
   Search,
   Server,
+  ShieldCheck,
   ShoppingCart,
+  Sparkles,
   SquareMousePointer,
   Telescope,
   Terminal,
@@ -47,10 +57,13 @@ export const LUCIDE_ICON_MAP: Record<string, LucideIcon> = {
   ArrowDownToLine,
   ArrowRightLeft,
   ArrowUpFromLine,
+  BotMessageSquare,
   BookOpen,
   BookText,
   Box,
   Boxes,
+  ClipboardCheck,
+  ClipboardList,
   Code,
   Database,
   File,
@@ -58,12 +71,19 @@ export const LUCIDE_ICON_MAP: Record<string, LucideIcon> = {
   FileCode,
   FileImage,
   FileJson,
+  FileWarning,
   Globe,
+  ListChecks,
   Mail,
   Package,
+  Radar,
+  Radio,
+  Route,
   Search,
   Server,
+  ShieldCheck,
   ShoppingCart,
+  Sparkles,
   SquareMousePointer,
   Telescope,
   Terminal,