@eventcatalog/core 5.0.0-beta.1 → 5.0.0-beta.10

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

@@ -0,0 +1,310 @@
+import { collectionToResourceMap, resourceKey, uniqueResources } from '@utils/collections/util';
+
+// What the Resources pages show: which resources each owner (domain, system, service, flow,
+// channel or message) lists, how each relates to the owner, and the links for each row.
+// Loading owners and their related resources lives in ./resource-owners.
+
+/** The kinds of resource a Resources page can list. */
+export type ResourceCollection =
+  | 'domains'
+  | 'systems'
+  | 'agents'
+  | 'services'
+  | 'flows'
+  | 'entities'
+  | 'data-products'
+  | 'containers'
+  | 'events'
+  | 'commands'
+  | 'queries'
+  | 'channels'
+  | 'adrs';
+
+/** How a resource relates to the page's owner: which way a message flows, how a data store is used, or how it belongs to the owner. */
+export type ResourceRelationship =
+  | 'receives'
+  | 'sends'
+  | 'sends-and-receives'
+  | 'reads'
+  | 'writes'
+  | 'reads-and-writes'
+  | 'contains'
+  | 'owns'
+  | 'appears-in'
+  | 'governed-by'
+  | 'includes'
+  | 'transports'
+  | 'produces-messages'
+  | 'receives-messages'
+  | 'produces-and-receives-messages'
+  | 'produces'
+  | 'consumes'
+  | 'produces-and-consumes'
+  | 'triggers'
+  | 'triggered-by'
+  | 'triggers-and-triggered-by';
+
+/** Any catalog entry a Resources page reads: a collection entry, possibly hydrated with extra fields. */
+export type ResourceEntry = {
+  collection: string;
+  data: { id: string; version: string; name?: string; summary?: string; [key: string]: any };
+  [key: string]: any;
+};
+
+export type ResourceOwnerCollection = 'systems' | 'domains' | 'services' | 'flows' | 'channels' | MessageOwnerCollection;
+type MessageOwnerCollection = 'events' | 'commands' | 'queries';
+const isMessageOwner = (collection: ResourceOwnerCollection): collection is MessageOwnerCollection =>
+  collection === 'events' || collection === 'commands' || collection === 'queries';
+
+/** Resources that point at the owner, rather than being listed in the owner's own frontmatter. */
+export interface RelatedResources {
+  /** Decision records whose `appliesTo` includes the owner. */
+  adrs?: ResourceEntry[];
+  /** Flows with a step that points at the owner (services only). */
+  stepFlows?: ResourceEntry[];
+  /** The resources a flow's steps point at (flows only). */
+  stepResources?: ResourceEntry[];
+  /** Services and agents that send to the channel, those that receive from it, and the messages on it (channels only). */
+  channelProducers?: ResourceEntry[];
+  channelConsumers?: ResourceEntry[];
+  channelMessages?: ResourceEntry[];
+  /** The channels, flows and messages a message connects to (messages only; its producers and consumers are on `data`). */
+  messageChannels?: ResourceEntry[];
+  messageFlows?: ResourceEntry[];
+  messageTriggers?: ResourceEntry[];
+  messageTriggeredBy?: ResourceEntry[];
+}
+
+/** A resource owner as the Resources page receives it: the collection entry with its related resources attached. */
+export type ResourceOwner = ResourceEntry & RelatedResources;
+
+export interface ResourceGroup {
+  collection: ResourceCollection;
+  items: ResourceEntry[];
+}
+
+const getMessages = (data: any) =>
+  uniqueResources([...(data.sends || []), ...(data.receives || [])].filter((message) => message?.collection));
+
+const messageGroups = (messages: any[]): ResourceGroup[] => [
+  { collection: 'events', items: messages.filter((message) => message.collection === 'events') },
+  { collection: 'commands', items: messages.filter((message) => message.collection === 'commands') },
+  { collection: 'queries', items: messages.filter((message) => message.collection === 'queries') },
+];
+
+// The collections a flow step can point at, in the order the page groups them.
+const FLOW_STEP_COLLECTIONS: ResourceCollection[] = [
+  'services',
+  'agents',
+  'flows',
+  'containers',
+  'data-products',
+  'events',
+  'commands',
+  'queries',
+];
+
+export const getResourceGroups = (
+  data: any,
+  ownerCollection: ResourceOwnerCollection,
+  related: RelatedResources = {}
+): ResourceGroup[] => {
+  const adrGroup: ResourceGroup = { collection: 'adrs', items: related.adrs || [] };
+
+  // A message's resources are what produces or consumes it, the channels it travels on, the
+  // flows it appears in, and the messages it triggers or is triggered by.
+  if (isMessageOwner(ownerCollection)) {
+    const endpoints = uniqueResources([...(data.producers || []), ...(data.consumers || [])]);
+    const endpointGroup = (collection: ResourceCollection): ResourceGroup => ({
+      collection,
+      items: endpoints.filter((endpoint) => endpoint.collection === collection),
+    });
+    return [
+      endpointGroup('services'),
+      endpointGroup('agents'),
+      endpointGroup('data-products'),
+      { collection: 'channels', items: related.messageChannels || [] },
+      { collection: 'flows', items: related.messageFlows || [] },
+      ...messageGroups(uniqueResources([...(related.messageTriggers || []), ...(related.messageTriggeredBy || [])])),
+      adrGroup,
+    ];
+  }
+
+  // A channel's resources are the services and agents that send to or receive from it, and the messages on it.
+  if (ownerCollection === 'channels') {
+    const endpoints = uniqueResources([...(related.channelProducers || []), ...(related.channelConsumers || [])]);
+    return [
+      { collection: 'services', items: endpoints.filter((endpoint) => endpoint.collection === 'services') },
+      { collection: 'agents', items: endpoints.filter((endpoint) => endpoint.collection === 'agents') },
+      ...messageGroups(related.channelMessages || []),
+      adrGroup,
+    ];
+  }
+
+  // A flow's resources are what its steps point at.
+  if (ownerCollection === 'flows') {
+    const stepResources = related.stepResources || [];
+    return [
+      ...FLOW_STEP_COLLECTIONS.map((collection) => ({
+        collection,
+        items: stepResources.filter((resource) => resource.collection === collection),
+      })),
+      adrGroup,
+    ];
+  }
+
+  // A service's resources are what it uses: the messages it sends and receives, its
+  // entities, the data stores it reads from or writes to, and the flows it appears in.
+  if (ownerCollection === 'services') {
+    return [
+      { collection: 'flows', items: uniqueResources([...(data.flows || []), ...(related.stepFlows || [])]) },
+      { collection: 'entities', items: data.entities || [] },
+      { collection: 'containers', items: uniqueResources([...(data.writesTo || []), ...(data.readsFrom || [])]) },
+      ...messageGroups(getMessages(data)),
+      adrGroup,
+    ];
+  }
+
+  const domainOnlyGroups: ResourceGroup[] =
+    ownerCollection === 'domains'
+      ? [
+          { collection: 'domains', items: data.domains || [] },
+          { collection: 'systems', items: data.systems || [] },
+          { collection: 'agents', items: data.agents || [] },
+          { collection: 'data-products', items: data['data-products'] || [] },
+        ]
+      : [];
+
+  return [
+    ...domainOnlyGroups,
+    { collection: 'services', items: data.services || [] },
+    { collection: 'flows', items: data.flows || [] },
+    { collection: 'entities', items: data.entities || [] },
+    { collection: 'containers', items: data.containers || [] },
+    ...messageGroups(ownerCollection === 'domains' ? getMessages(data) : []),
+    adrGroup,
+  ];
+};
+
+// The page loader attaches the RelatedResources fields to the owner (see _index.data.ts).
+export const hasResources = (owner: any, ownerCollection: ResourceOwnerCollection): boolean =>
+  getResourceGroups(owner?.data ?? {}, ownerCollection, owner ?? {}).some(({ items }) => items.length > 0);
+
+const includesResource = (resources: any[] | undefined, item: any) =>
+  (resources || []).some((resource) => resource?.data && resourceKey(resource) === resourceKey(item));
+
+/**
+ * How a resource relates to the page's owner: which way a message flows, how a data store
+ * is used, or whether the owner contains, owns or appears in it.
+ */
+export const getResourceRelationship = (
+  data: any,
+  ownerCollection: ResourceOwnerCollection,
+  collection: ResourceCollection,
+  item: any,
+  related: RelatedResources = {}
+): ResourceRelationship | undefined => {
+  if (collection === 'adrs') return 'governed-by';
+  if (ownerCollection === 'flows') return 'includes';
+  if (isMessageOwner(ownerCollection)) {
+    if (collection === 'channels') return 'transports';
+    if (collection === 'flows') return 'appears-in';
+    if (collection === 'events' || collection === 'commands' || collection === 'queries') {
+      const triggers = includesResource(related.messageTriggers, item);
+      const triggeredBy = includesResource(related.messageTriggeredBy, item);
+      if (triggers && triggeredBy) return 'triggers-and-triggered-by';
+      if (triggers) return 'triggers';
+      if (triggeredBy) return 'triggered-by';
+      return undefined;
+    }
+    const produces = includesResource(data.producers, item);
+    const consumes = includesResource(data.consumers, item);
+    if (produces && consumes) return 'produces-and-consumes';
+    if (produces) return 'produces';
+    if (consumes) return 'consumes';
+    return undefined;
+  }
+  // A channel transports messages; services and agents produce messages onto it or receive them from it.
+  if (ownerCollection === 'channels') {
+    if (collection !== 'services' && collection !== 'agents') return 'transports';
+    const produces = includesResource(related.channelProducers, item);
+    const receives = includesResource(related.channelConsumers, item);
+    if (produces && receives) return 'produces-and-receives-messages';
+    if (produces) return 'produces-messages';
+    if (receives) return 'receives-messages';
+    return undefined;
+  }
+  if (collection === 'events' || collection === 'commands' || collection === 'queries') {
+    const sends = includesResource(data.sends, item);
+    const receives = includesResource(data.receives, item);
+    if (sends && receives) return 'sends-and-receives';
+    if (sends) return 'sends';
+    if (receives) return 'receives';
+    return undefined;
+  }
+  if (collection === 'entities') return 'owns';
+  if (ownerCollection === 'services') {
+    if (collection === 'flows') return 'appears-in';
+    if (collection === 'containers') {
+      const writes = includesResource(data.writesTo, item);
+      const reads = includesResource(data.readsFrom, item);
+      if (writes && reads) return 'reads-and-writes';
+      if (writes) return 'writes';
+      if (reads) return 'reads';
+    }
+    return undefined;
+  }
+  // Everything else on a domain or system page is part of it.
+  return 'contains';
+};
+
+/**
+ * The schema page for a resource, matching the sidebar's Schema link: messages with an entry
+ * in the schemas collection (keyed `collection:id:version`), and data products with an output
+ * contract. Undefined for everything else.
+ */
+export const getSchemaPath = (collection: ResourceCollection, item: any, schemaKeys: Set<string>) => {
+  const { id, version } = item.data;
+  if (collection === 'events' || collection === 'commands' || collection === 'queries') {
+    return schemaKeys.has(`${collection}:${id}:${version}`) ? `/schemas/${collection}/${id}/${version}` : undefined;
+  }
+  if (collection === 'data-products') {
+    const contract = (item.data.outputs || []).find((output: any) => output.contract)?.contract;
+    return contract ? `/schemas/data-products/${id}/${version}?contract=${encodeURIComponent(contract.path)}` : undefined;
+  }
+  return undefined;
+};
+
+export const getDocsPath = (collection: ResourceCollection, item: any) =>
+  `/docs/${collection}/${item.data.id}/${item.data.version}`;
+
+// Collections the visualiser has a page for (domains and systems through their own routes).
+// Entities and decision records have none.
+const VISUALISER_COLLECTIONS = new Set<ResourceCollection>([
+  'domains',
+  'systems',
+  'agents',
+  'services',
+  'flows',
+  'containers',
+  'channels',
+  'data-products',
+  'events',
+  'commands',
+  'queries',
+]);
+
+/** The resource's visualiser page, unless the visualiser is off, has no page for it, or the resource opts out. */
+export const getVisualiserPath = (collection: ResourceCollection, item: any, visualiserEnabled: boolean) => {
+  if (!visualiserEnabled || !VISUALISER_COLLECTIONS.has(collection) || item.data.visualiser === false) return undefined;
+  return `/visualiser/${collection}/${item.data.id}/${item.data.version}`;
+};
+
+/** Same key and badge as the favorite button on the resource's docs page. */
+export const getFavorite = (collection: ResourceCollection, item: any) => {
+  const resourceType = collectionToResourceMap[collection];
+  return {
+    nodeKey: `${resourceType}:${item.data.id}:${item.data.version}`,
+    badge: resourceType.charAt(0).toUpperCase() + resourceType.slice(1),
+  };
+};

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

@@ -291,6 +291,37 @@ export const createVersionedMap = <T extends { data: { id: string; version?: str
   return map;
 };
 
+const versionedMapCache = new WeakMap<object, Map<string, any[]>>();
+
+/**
+ * createVersionedMap, built once per list. Use it in helpers that search the same list once per
+ * resource, so a catalog-wide pass does not rebuild the map every time.
+ */
+export const getVersionedMap = <T extends { data: { id: string; version?: string } }>(items: T[]): Map<string, T[]> => {
+  let map = versionedMapCache.get(items);
+  if (!map) {
+    map = createVersionedMap(items);
+    versionedMapCache.set(items, map);
+  }
+  return map as Map<string, T[]>;
+};
+
+type KeyedResource = { collection: string; data: { id: string; version?: string } };
+
+/** Identifies a resource across collections: a service and an agent can share an id and version. */
+export const resourceKey = (resource: KeyedResource) => `${resource.collection}:${resource.data.id}:${resource.data.version}`;
+
+/** The resources without repeats (by collection, id and version), keeping the first of each in order. */
+export const uniqueResources = <T extends KeyedResource>(resources: T[]): T[] => {
+  const seen = new Map<string, T>();
+  for (const resource of resources) {
+    if (!resource?.data?.id) continue;
+    const key = resourceKey(resource);
+    if (!seen.has(key)) seen.set(key, resource);
+  }
+  return [...seen.values()];
+};
+
 // Merge as many given maps as you want
 export const mergeMaps = <T>(...maps: Map<string, T[]>[]): Map<string, T[]> => {
   return maps.reduce((acc, map) => {

package/eventcatalog/src/utils/feature.ts

@@ -27,4 +27,12 @@ export const isAuthEnabled = () =>
   (config?.auth?.enabled ?? false) && fs.existsSync(join(projectDirectory(), 'eventcatalog.auth.js')) && isSSR();
 
 export const isEventCatalogMCPEnabled = () => isSSR() && (config?.mcp?.enabled ?? true);
+
+// Collaborative canvases (EventCatalog Studio, /studio) are an experiment: on the dev server (unless studio.enabled is
+// false), and in production (server output) when studio.enabled is set. With sign-in on, only signed-in people can
+// open them.
+export const isCanvasEnabled = () => {
+  const enabled = config?.studio?.enabled;
+  return enabled !== false && (isDevMode() || (isSSR() && enabled === true));
+};
 export const isEventCatalogMCPAuthEnabled = () => isEventCatalogMCPEnabled() && (config?.mcp?.auth?.enabled ?? false);

package/eventcatalog/src/utils/git.ts

@@ -1,7 +1,6 @@
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import shell from 'shelljs';
 
 type Commit = { timestamp: number; author: string };
 
@@ -9,10 +8,6 @@ const COMMIT_MARKER = '\x1e';
 
 const newestCommitsByRepository = new Map<string, Map<string, Commit> | undefined>();
 
-export function hasGit() {
-  return !!shell.which('git');
-}
-
 const runGit = (args: string[]) => {
   try {
     return execFileSync('git', ['-c', 'log.showSignature=false', ...args], {
@@ -25,6 +20,17 @@ const runGit = (args: string[]) => {
   }
 };
 
+// Checked once per PATH, as git history is read for every page
+const gitInstalledByPath = new Map<string | undefined, boolean>();
+
+export function hasGit() {
+  const searchPath = process.env.PATH;
+  if (!gitInstalledByPath.has(searchPath)) {
+    gitInstalledByPath.set(searchPath, runGit(['--version']) !== undefined);
+  }
+  return gitInstalledByPath.get(searchPath)!;
+}
+
 const parseCommit = (header: string): Commit => {
   const [timestamp, ...author] = header.split(',');
   return { timestamp: Number(timestamp) * 1_000, author: author.join(',') };

package/eventcatalog/src/utils/node-graphs/export-mermaid.ts

@@ -38,7 +38,6 @@ const NODE_SHAPE_MAP: Record<string, [string, string]> = {
   'context-actor': ['((', '))'], // circle
   flows: ['([', '])'], // stadium (rounded)
   flow: ['([', '])'],
-  systems: ['[[', ']]'],
   system: ['[[', ']]'],
   step: ['[', ']'], // rectangle
   user: ['((', '))'], // circle
@@ -79,7 +78,6 @@ const NODE_STYLE_CLASSES: Record<string, string> = {
   domains: 'fill:#eab308,stroke:#a16207,color:#000',
   domain: 'fill:#eab308,stroke:#a16207,color:#000',
   'context-domain': 'fill:#eab308,stroke:#a16207,color:#000',
-  systems: 'fill:#7c3aed,stroke:#5b21b6,color:#fff',
   'context-actor': 'fill:#8b5cf6,stroke:#6d28d9,color:#fff',
   flows: 'fill:#14b8a6,stroke:#0f766e,color:#fff',
   flow: 'fill:#14b8a6,stroke:#0f766e,color:#fff',

package/eventcatalog/src/utils/trial.ts

@@ -1,4 +1,4 @@
-export const TRIAL_LENGTH_DAYS = 90;
+export const TRIAL_LENGTH_DAYS = 60;
 
 export const LICENSE_FAQ_URL = 'https://www.eventcatalog.dev/license-faq';
 

package/package.json

@@ -7,7 +7,7 @@
   },
   "license": "BUSL-1.1",
   "type": "module",
-  "version": "5.0.0-beta.1",
+  "version": "5.0.0-beta.10",
   "publishConfig": {
     "access": "public"
   },
@@ -54,13 +54,17 @@
     "@astrojs/rss": "^4.0.19",
     "@asyncapi/avro-schema-parser": "3.0.24",
     "@asyncapi/parser": "^3.6.0",
-    "@asyncapi/react-component": "3.1.0",
+    "@asyncapi/react-component": "3.2.1",
     "@auth/core": "^0.41.3",
     "@eventcatalog/license": "^0.0.9",
     "@fontsource/inter": "^5.2.5",
     "@headlessui/react": "^2.0.3",
     "@heroicons/react": "^2.1.3",
+    "@hocuspocus/provider": "^4.7.0",
+    "@hocuspocus/server": "^4.7.0",
     "@iconify-json/logos": "^1.2.4",
+    "@mcp-b/webmcp-local-relay": "5.1.0",
+    "@mcp-b/webmcp-polyfill": "5.1.0",
     "@mermaid-js/layout-elk": "^0.2.0",
     "@modelcontextprotocol/ext-apps": "^1.7.5",
     "@modelcontextprotocol/sdk": "^1.30.0",
@@ -75,11 +79,11 @@
     "@tailwindcss/typography": "^0.5.16",
     "@tailwindcss/vite": "^4.3.1",
     "@tanstack/react-table": "^8.17.3",
-    "@xyflow/react": "^12.3.6",
+    "@xyflow/react": "^12.12.0",
     "ai": "^7.0.106",
     "astro": "7.3.3",
     "astro-expressive-code": "^0.44.0",
-    "astro-seo": "^0.8.4",
+    "astro-seo": "^1.2.0",
     "boxen": "^8.0.1",
     "commander": "^12.1.0",
     "cross-env": "^7.0.3",
@@ -93,7 +97,7 @@
     "elkjs": "^0.10.0",
     "glob": "^13.0.6",
     "gray-matter": "^4.0.3",
-    "hono": "4.13.5",
+    "hono": "^4.13.7",
     "html-to-image": "^1.11.11",
     "js-yaml": "^4.3.2",
     "jsonpath-plus": "^10.4.0",
@@ -111,8 +115,9 @@
     "parse5": "^7.3.0",
     "picocolors": "^1.1.1",
     "picomatch": "^4.0.4",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "react-hotkeys-hook": "^5.3.3",
     "react-markdown": "^10.1.0",
     "react-syntax-highlighter": "^16.1.1",
     "recast": "^0.23.11",
@@ -125,7 +130,6 @@
     "rimraf": "^6.1.3",
     "semver": "7.6.3",
     "set-cookie-parser": "^2.7.1",
-    "shelljs": "^0.9.0",
     "sonner": "^2.0.7",
     "sql.js": "^1.12.0",
     "tailwindcss": "^4.3.1",
@@ -133,10 +137,12 @@
     "unist-util-visit": "^5.0.0",
     "update-notifier": "^7.3.1",
     "uuid": "^11.1.1",
+    "y-protocols": "^1.0.7",
+    "yjs": "^13.6.33",
     "zod": "^4.3.6",
-    "@eventcatalog/linter": "1.2.0-beta.0",
-    "@eventcatalog/visualiser": "^5.0.0-beta.0",
-    "@eventcatalog/sdk": "2.30.0-beta.0"
+    "@eventcatalog/visualiser": "^5.0.0-beta.4",
+    "@eventcatalog/sdk": "2.30.0-beta.1",
+    "@eventcatalog/linter": "1.2.0-beta.2"
   },
   "devDependencies": {
     "@astrojs/check": "^0.9.10",
@@ -156,7 +162,6 @@
     "@types/react-syntax-highlighter": "^15.5.13",
     "@types/semver": "^7.5.8",
     "@types/set-cookie-parser": "^2.4.10",
-    "@types/shelljs": "^0.8.15",
     "@types/update-notifier": "^6.0.8",
     "@types/uuid": "^10.0.0",
     "jsdom": "27.0.0",

package/dist/runtime-dependencies/shelljs.mjs

@@ -1,3 +0,0 @@
-export * from "shelljs";
-import * as dependency from "shelljs";
-export default dependency.default;