@eventcatalog/core 4.12.2 → 5.0.0-beta.0

package/eventcatalog/src/utils/feature.ts

@@ -1,7 +1,10 @@
+import fs from 'node:fs';
+import { join } from 'node:path';
 // Feature checks also run during Astro config evaluation, before @config exists.
 import config from './eventcatalog-config/source';
 
-// Open-source feature flags
+const projectDirectory = () => process.env.PROJECT_DIR || process.cwd();
+
 export const isEventCatalogChatVisible = () => config?.chat?.enabled ?? true;
 export const isSSR = () => config?.output === 'server';
 export const isVisualiserEnabled = () => config?.visualiser?.enabled ?? true;
@@ -15,25 +18,13 @@ export const isMarkdownDownloadEnabled = () => config?.llmsTxt?.enabled ?? true;
 export const isFullCatalogAPIEnabled = () => config?.api?.fullCatalogAPIEnabled ?? false;
 export const isDevMode = () => process.env.EVENTCATALOG_DEV_MODE === 'true';
 
-// Re-export enterprise feature flags for backwards compatibility.
-// These functions are subject to the EventCatalog Commercial License.
-// See /packages/core/eventcatalog/src/enterprise/LICENSE
-export {
-  isEventCatalogStarterEnabled,
-  isEventCatalogScaleEnabled,
-  isPrivateRemoteSchemaEnabled,
-  isEmbedEnabled,
-  showEventCatalogBranding,
-  showCustomBranding,
-  isCustomDocsEnabled,
-  isResourceDocsEnabled,
-  isEventCatalogChatEnabled,
-  isEventCatalogUpgradeEnabled,
-  isCustomLandingPageEnabled,
-  isCustomPagesEnabled,
-  isAuthEnabled,
-  isCustomStylesEnabled,
-  isEventCatalogMCPEnabled,
-  isEventCatalogMCPAuthEnabled,
-  isIntegrationsEnabled,
-} from '../enterprise/feature';
+// The assistant needs a model configured (eventcatalog.chat.js) and a server to run on
+export const isEventCatalogChatEnabled = () =>
+  fs.existsSync(join(projectDirectory(), 'eventcatalog.chat.js')) && isSSR() && isEventCatalogChatVisible();
+
+// Authentication needs providers configured (eventcatalog.auth.js) and a server to run on
+export const isAuthEnabled = () =>
+  (config?.auth?.enabled ?? false) && fs.existsSync(join(projectDirectory(), 'eventcatalog.auth.js')) && isSSR();
+
+export const isEventCatalogMCPEnabled = () => isSSR() && (config?.mcp?.enabled ?? true);
+export const isEventCatalogMCPAuthEnabled = () => isEventCatalogMCPEnabled() && (config?.mcp?.auth?.enabled ?? false);

package/eventcatalog/src/utils/license.ts

@@ -0,0 +1,114 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { clearCache, hasCommercialLicense, verifyOfflineLicense } from '@eventcatalog/license';
+
+export { LICENSE_FAQ_URL, LICENSE_RENEW_URL } from './trial';
+
+// Details from the license token
+export type LicenseDetails = { org?: string; licenseId?: string; issuedAt?: Date };
+
+// Scale and Starter plans, licensed with a license key instead of a license.jwt
+export type LicensePlan = 'scale' | 'starter';
+
+export type LicenseStatus =
+  | { state: 'none' }
+  | ({ state: 'licensed'; expiresAt: Date } & LicenseDetails)
+  | { state: 'plan'; plan: LicensePlan }
+  | ({ state: 'expired'; expiresAt?: Date } & LicenseDetails)
+  | { state: 'invalid'; reason: string };
+
+const toDate = (seconds: unknown) => (typeof seconds === 'number' ? new Date(seconds * 1000) : undefined);
+
+const getDetails = (claims: Record<string, unknown>): LicenseDetails => ({
+  org: typeof claims.org === 'string' ? claims.org : undefined,
+  licenseId: typeof claims.licenseId === 'string' ? claims.licenseId : undefined,
+  issuedAt: toDate(claims.iat),
+});
+
+const INVALID_REASONS: Record<string, string> = {
+  LICENSE_FILE_EMPTY: 'the file is empty',
+  LICENSE_NOT_YET_VALID: 'it is not valid yet',
+  LICENSE_SIGNATURE_INVALID: 'its signature is invalid',
+  LICENSE_VALIDATION_FAILED: 'it was not issued by EventCatalog',
+};
+
+// The license file: EC_LICENSE, or license.jwt in the root of the catalog
+export const getLicenseFilePath = (projectDirectory: string) =>
+  process.env.EC_LICENSE || path.join(projectDirectory, 'license.jwt');
+
+// The token's claims, without verifying it (for an expired license, which the verifier rejects)
+const readClaims = (licenseFilePath: string): Record<string, unknown> => {
+  try {
+    const payload = fs.readFileSync(licenseFilePath, 'utf8').trim().split('.')[1];
+    return JSON.parse(Buffer.from(payload, 'base64url').toString('utf8'));
+  } catch {
+    return {};
+  }
+};
+
+// Verified statuses by license file and its last change, so a license is checked once per change
+const statusCache = new Map<string, Promise<LicenseStatus>>();
+
+/**
+ * The Scale or Starter plan, checked by the CLI with its license key and passed to Astro
+ * (see checkPlanLicense in the CLI's license-status).
+ */
+export const getLicensePlan = (): LicensePlan | undefined => {
+  if (process.env.EVENTCATALOG_SCALE === 'true') return 'scale';
+  if (process.env.EVENTCATALOG_STARTER === 'true') return 'starter';
+};
+
+/**
+ * Verifies the catalog's license.jwt offline (signature, issuer, audience and dates).
+ * Cached until the license file changes.
+ */
+export const getCommercialLicenseStatus = (
+  projectDirectory = process.env.PROJECT_DIR || process.cwd()
+): Promise<LicenseStatus> => {
+  const licensePath = getLicenseFilePath(projectDirectory);
+  const modifiedAt = fs.statSync(licensePath, { throwIfNoEntry: false })?.mtimeMs;
+  if (modifiedAt === undefined) return Promise.resolve({ state: 'none' });
+
+  const key = `${licensePath}:${modifiedAt}`;
+  if (!statusCache.has(key)) statusCache.set(key, verifyLicense(licensePath));
+  return statusCache.get(key)!;
+};
+
+/**
+ * The catalog's license: a commercial license (license.jwt) first, then a Scale or Starter plan.
+ */
+export const getLicenseStatus = async (projectDirectory?: string): Promise<LicenseStatus> => {
+  const license = await getCommercialLicenseStatus(projectDirectory);
+  if (license.state === 'licensed') return license;
+  const plan = getLicensePlan();
+  return plan ? { state: 'plan', plan } : license;
+};
+
+const verifyLicense = async (licensePath: string): Promise<LicenseStatus> => {
+  // The license package logs its own errors; callers report the status instead
+  const consoleError = console.error;
+  console.error = () => {};
+  try {
+    // The package keeps the first license it verifies; this file may have changed since
+    clearCache();
+    if (await hasCommercialLicense()) {
+      const entitlements = await verifyOfflineLicense({ licensePath });
+      return { state: 'licensed', ...getDetails(entitlements), expiresAt: new Date(entitlements.exp! * 1000) };
+    }
+
+    // Not a commercial license: verify it again to report why
+    clearCache();
+    const entitlements = await verifyOfflineLicense({ licensePath });
+    if (typeof entitlements.exp !== 'number') return { state: 'invalid', reason: 'it has no expiry date' };
+    // Verified within the verifier's clock tolerance, but past its expiry date
+    return { state: 'expired', ...getDetails(entitlements), expiresAt: new Date(entitlements.exp * 1000) };
+  } catch (error: any) {
+    if (error?.code === 'LICENSE_EXPIRED') {
+      const claims = readClaims(licensePath);
+      return { state: 'expired', ...getDetails(claims), expiresAt: toDate(claims.exp) };
+    }
+    return { state: 'invalid', reason: INVALID_REASONS[error?.code] || error?.message || String(error) };
+  } finally {
+    console.error = consoleError;
+  }
+};

package/eventcatalog/src/utils/node-graphs/architecture-diagram-types.ts

@@ -0,0 +1,32 @@
+/**
+ * The resources that have an architecture diagram, and the shape of a diagram. Has no imports so
+ * it can be shared by the diagram builders, the MCP tools and the MCP App view bundled for the browser.
+ */
+
+export const ARCHITECTURE_DIAGRAM_COLLECTIONS = [
+  'events',
+  'commands',
+  'queries',
+  'agents',
+  'services',
+  'domains',
+  'systems',
+  'flows',
+  'containers',
+  'data-products',
+] as const;
+
+export type ArchitectureDiagramCollection = (typeof ARCHITECTURE_DIAGRAM_COLLECTIONS)[number];
+
+export const isArchitectureDiagramCollection = (collection: string): collection is ArchitectureDiagramCollection =>
+  (ARCHITECTURE_DIAGRAM_COLLECTIONS as readonly string[]).includes(collection);
+
+export type ArchitectureDiagramDetail = 'overview' | 'full';
+
+export type Graph = { nodes: any[]; edges: any[] };
+
+/**
+ * The diagram with its levels, as the Diagram page shows it: the detailed graph, and for
+ * domains and systems the level 1 overview and the graph without messages and channels.
+ */
+export type ArchitectureDiagramView = Graph & { overview?: Graph; hiddenMessages?: Graph };

package/eventcatalog/src/utils/node-graphs/architecture-diagram.ts

@@ -0,0 +1,84 @@
+/**
+ * The architecture diagram for a resource, built the same way as its Diagram page
+ * in the visualiser. Shared by the `.mermaid` visualiser route and the architecture
+ * diagram tool used by AI Chat and the MCP server, so they show the same thing.
+ */
+import config from '@config';
+import { getNodesAndEdges as getNodesAndEdgesForService } from '@utils/node-graphs/services-node-graph';
+import { getNodesAndEdges as getNodesAndEdgesForAgent } from '@utils/node-graphs/agents-node-graph';
+import {
+  getNodesAndEdgesForCommands,
+  getNodesAndEdgesForEvents,
+  getNodesAndEdgesForQueries,
+} from '@utils/node-graphs/message-node-graph';
+import { getNodesAndEdges as getNodesAndEdgesForFlows } from '@utils/node-graphs/flows-node-graph';
+import { getNodesAndEdges as getNodesAndEdgesForDataProduct } from '@utils/node-graphs/data-products-node-graph';
+import { getNodesAndEdges as getNodesAndEdgesForContainer } from '@utils/node-graphs/container-node-graph';
+import { getNodesAndEdges as getNodesAndEdgesForDomainLevels } from '@utils/node-graphs/domain-levels-node-graph';
+import { getNodesAndEdges as getNodesAndEdgesForSystemLevels } from '@utils/node-graphs/system-levels-node-graph';
+import type {
+  ArchitectureDiagramCollection,
+  ArchitectureDiagramDetail,
+  ArchitectureDiagramView,
+  Graph,
+} from '@utils/node-graphs/architecture-diagram-types';
+
+// Domains and systems are shown in levels: level 1 (`overview`) is the domains and
+// systems and how they relate, and the detailed graph expands systems into their
+// services, messages and channels
+const getLevelsFunctions = {
+  domains: getNodesAndEdgesForDomainLevels,
+  systems: getNodesAndEdgesForSystemLevels,
+};
+
+// A graph builder for every other collection with a diagram
+const getNodesAndEdgesFunctions = {
+  agents: getNodesAndEdgesForAgent,
+  services: getNodesAndEdgesForService,
+  events: getNodesAndEdgesForEvents,
+  commands: getNodesAndEdgesForCommands,
+  queries: getNodesAndEdgesForQueries,
+  flows: getNodesAndEdgesForFlows,
+  containers: getNodesAndEdgesForContainer,
+  'data-products': getNodesAndEdgesForDataProduct,
+} satisfies Record<Exclude<ArchitectureDiagramCollection, keyof typeof getLevelsFunctions>, unknown>;
+
+export async function getArchitectureDiagramView({
+  collection,
+  id,
+  version,
+}: {
+  collection: ArchitectureDiagramCollection;
+  id: string;
+  version: string;
+}): Promise<ArchitectureDiagramView> {
+  const options = {
+    id,
+    version,
+    mode: 'full' as const,
+    channelRenderMode: config.visualiser?.channels?.renderMode === 'single' ? ('single' as const) : ('flat' as const),
+  };
+
+  if (collection === 'domains' || collection === 'systems') {
+    const { nodes, edges, overview, hiddenMessages } = await getLevelsFunctions[collection](options);
+    return { nodes, edges, overview, hiddenMessages };
+  }
+
+  const { nodes, edges } = await getNodesAndEdgesFunctions[collection](options);
+  return { nodes, edges };
+}
+
+export async function getArchitectureDiagramGraph({
+  detail = 'full',
+  ...resource
+}: {
+  collection: ArchitectureDiagramCollection;
+  id: string;
+  version: string;
+  detail?: ArchitectureDiagramDetail;
+}): Promise<Graph> {
+  const view = await getArchitectureDiagramView(resource);
+  // A domain without systems or subdomains has no level 1, so it shows the full diagram
+  const graph = detail === 'overview' && view.overview ? view.overview : view;
+  return { nodes: graph.nodes, edges: graph.edges };
+}

package/eventcatalog/src/utils/node-graphs/catalog-force-graph.ts

@@ -245,6 +245,7 @@ export const getCatalogForceGraph = async (): Promise<{ nodes: CatalogGraphNode[
     const key = nodeKey('flows', flow.data.id);
     for (const step of (flow.data as any).steps ?? []) {
       addLink(key, nodeKey('services', refId(step.service)!), 'references');
+      addLink(key, nodeKey('systems', refId(step.systems || step.system)!), 'references');
       addLink(key, nodeKey('agents', refId(step.agent)!), 'references');
       addLink(key, nodeKey('flows', refId(step.flow)!), 'has sub-flow');
       addLink(key, nodeKey('containers', refId(step.container)!), 'references');

package/eventcatalog/src/utils/node-graphs/channel-node-graph.ts

@@ -4,8 +4,6 @@ import {
   buildContextMenuForMessage,
   buildContextMenuForResource,
   buildContextMenuForService,
-  calculatedNodes,
-  createDagreGraph,
   createEdge,
   createNode,
   generatedIdForEdge,
@@ -14,10 +12,8 @@ import {
   getEdgeLabelForMessageAsSource,
   getEdgeLabelForServiceAsTarget,
   getOperationFields,
-  DEFAULT_NODE_WIDTH,
-  DEFAULT_NODE_HEIGHT,
-  layoutDagreGraph,
 } from './utils/utils';
+import { layoutNodeGraph } from '@utils/node-graphs/layout-node-graph';
 import { createVersionedMap, findInMap } from '@utils/collections/util';
 import { getChannelChain, getChannels } from '@utils/collections/channels';
 import { type Node, type Edge } from '@xyflow/react';
@@ -111,12 +107,9 @@ type RoutedResource = {
   channelRoutes: ChannelRoute[];
 };
 
-type DagreGraph = any;
-
 interface Props {
   id: string;
   version: string;
-  defaultFlow?: DagreGraph;
   mode?: 'simple' | 'full';
   layout?: boolean;
 }
@@ -126,8 +119,7 @@ interface Props {
  * everything that consumes out of it on the right, and any channels it routes to (or is
  * routed from) either side of it.
  */
-export const getNodesAndEdges = async ({ id, version, defaultFlow, mode = 'simple', layout = true }: Props) => {
-  const flow = defaultFlow || createDagreGraph({ ranksep: 300, nodesep: 50 });
+export const getNodesAndEdges = async ({ id, version, mode = 'simple', layout = true }: Props) => {
   const nodes: any[] = [];
   const edges: any[] = [];
 
@@ -448,20 +440,7 @@ export const getNodesAndEdges = async ({ id, version, defaultFlow, mode = 'simpl
     );
   }
 
-  nodes.forEach((node) => {
-    flow.setNode(node.id, { width: DEFAULT_NODE_WIDTH, height: DEFAULT_NODE_HEIGHT });
-  });
-
-  edges.forEach((edge) => {
-    flow.setEdge(edge.source, edge.target);
-  });
+  if (!layout) return { nodes, edges };
 
-  if (layout) {
-    layoutDagreGraph(flow);
-  }
-
-  return {
-    nodes: calculatedNodes(flow, nodes),
-    edges,
-  };
+  return layoutNodeGraph({ nodes, edges });
 };

package/eventcatalog/src/utils/node-graphs/container-node-graph.ts

@@ -1,46 +1,31 @@
 import type { CollectionEntry } from 'astro:content';
 import {
-  calculatedNodes,
-  createDagreGraph,
   createEdge,
   generatedIdForEdge,
   generateIdForNode,
   buildContextMenuForService,
   buildContextMenuForResource,
-  DEFAULT_NODE_WIDTH,
-  DEFAULT_NODE_HEIGHT,
-  layoutDagreGraph,
 } from './utils/utils';
+import { layoutNodeGraph } from '@utils/node-graphs/layout-node-graph';
 import { MarkerType } from '@xyflow/react';
 import { findMatchingNodes } from '@utils/collections/util';
 import { getContainers } from '@utils/collections/containers';
 
-type DagreGraph = any;
-
 interface Props {
   id: string;
   version: string;
-  defaultFlow?: DagreGraph;
   mode?: 'simple' | 'full';
   channelRenderMode?: 'flat' | 'single';
   collection?: CollectionEntry<'containers'>[];
   layout?: boolean;
 }
 
-export const getNodesAndEdges = async ({
-  id,
-  version,
-  defaultFlow,
-  mode = 'simple',
-  channelRenderMode = 'flat',
-  layout = true,
-}: Props) => {
+export const getNodesAndEdges = async ({ id, version, mode = 'simple', channelRenderMode = 'flat', layout = true }: Props) => {
   // 1. Fetch data
   const containers = await getContainers();
 
-  const flow = defaultFlow || createDagreGraph({ ranksep: 300, nodesep: 50 });
-  const nodes = [] as any,
-    edges = [] as any;
+  const nodes: any[] = [],
+    edges: any[] = [];
 
   // Optimized: Use find since we're looking for a specific item
   const container = containers.find((container) => container.data.id === id && container.data.version === version);
@@ -80,7 +65,7 @@ export const getNodesAndEdges = async ({
           repository: service.data.repository as { url: string },
         }),
       },
-      position: { x: 250, y: 0 },
+      position: { x: 0, y: 0 },
     });
 
     if (!bothSentAndReceived.includes(service)) {
@@ -116,7 +101,7 @@ export const getNodesAndEdges = async ({
           version: dataProduct.data.version,
         }),
       },
-      position: { x: 250, y: 0 },
+      position: { x: 0, y: 0 },
     });
 
     if (!dataProductsBothSentAndReceived.includes(dataProduct)) {
@@ -244,7 +229,7 @@ export const getNodesAndEdges = async ({
     if (container) {
       edges.push(
         createEdge({
-          id: generatedIdForEdge(container, _service) + '-both',
+          id: generatedIdForEdge(_service, container) + '-both',
           source: generateIdForNode(_service),
           target: generateIdForNode(container),
           label: `read and writes to \n (${container.data.technology})`,
@@ -269,7 +254,7 @@ export const getNodesAndEdges = async ({
     if (container) {
       edges.push(
         createEdge({
-          id: generatedIdForEdge(container, _dataProduct) + '-both',
+          id: generatedIdForEdge(_dataProduct, container) + '-both',
           source: generateIdForNode(_dataProduct),
           target: generateIdForNode(container),
           label: `read and writes to \n (${container.data.technology})`,
@@ -289,21 +274,9 @@ export const getNodesAndEdges = async ({
     }
   });
 
-  nodes.forEach((node: any) => {
-    flow.setNode(node.id, { width: DEFAULT_NODE_WIDTH, height: DEFAULT_NODE_HEIGHT });
-  });
-
-  edges.forEach((edge: any) => {
-    flow.setEdge(edge.source, edge.target);
-  });
-
-  // Render the diagram in memory getting hte X and Y
-  if (layout) {
-    layoutDagreGraph(flow);
-  }
+  // Resources that both read and write are added twice (as a writer and as a reader), keep the first
+  const uniqueNodes = nodes.filter((node: any, index: number) => nodes.findIndex((n: any) => n.id === node.id) === index);
+  const graph = { nodes: uniqueNodes, edges };
 
-  return {
-    nodes: calculatedNodes(flow, nodes),
-    edges,
-  };
+  return layout ? await layoutNodeGraph(graph) : graph;
 };

package/eventcatalog/src/utils/node-graphs/data-products-node-graph.ts

@@ -1,16 +1,12 @@
 import { getCollection, type CollectionEntry } from 'astro:content';
 import {
-  createDagreGraph,
   generateIdForNode,
   generatedIdForEdge,
-  calculatedNodes,
   createEdge,
   getColorFromString,
   buildContextMenuForResource,
-  DEFAULT_NODE_WIDTH,
-  DEFAULT_NODE_HEIGHT,
-  layoutDagreGraph,
 } from '@utils/node-graphs/utils/utils';
+import { layoutNodeGraph } from '@utils/node-graphs/layout-node-graph';
 
 import { findInMap, createVersionedMap, mergeMaps, collectionToResourceMap } from '@utils/collections/util';
 import { MarkerType } from '@xyflow/react';
@@ -19,12 +15,9 @@ import { getProducersOfMessage } from '@utils/collections/services';
 import type { CollectionMessageTypes } from '@types';
 import { getNodesAndEdgesForProducedMessage } from './message-node-graph';
 
-type DagreGraph = any;
-
 interface Props {
   id: string;
   version: string;
-  defaultFlow?: DagreGraph;
   mode?: 'simple' | 'full';
   layout?: boolean;
 }
@@ -35,10 +28,9 @@ const getNodePropertyFromCollectionType = (type: string) => {
   return collectionToResourceMap[type as keyof typeof collectionToResourceMap];
 };
 
-export const getNodesAndEdges = async ({ id, defaultFlow, version, mode = 'simple', layout = true }: Props) => {
-  const flow = defaultFlow || createDagreGraph({ ranksep: 300, nodesep: 50 });
-  let nodes = [] as any,
-    edges = [] as any;
+export const getNodesAndEdges = async ({ id, version, mode = 'simple', layout = true }: Props) => {
+  let nodes: any[] = [],
+    edges: any[] = [];
 
   const [dataProducts, containers, services, events, queries, commands, channels] = await Promise.all([
     getCollection('data-products'),
@@ -93,6 +85,7 @@ export const getNodesAndEdges = async ({ id, defaultFlow, version, mode = 'simpl
 
       nodes.push({
         id: generateIdForNode(inputResource),
+        position: { x: 0, y: 0 },
         sourcePosition: 'right',
         targetPosition: 'left',
         data: { mode, [nodeDataKey]: { ...inputResource?.data } },
@@ -149,6 +142,7 @@ export const getNodesAndEdges = async ({ id, defaultFlow, version, mode = 'simpl
   // The data product itself
   nodes.push({
     id: generateIdForNode(dataProduct),
+    position: { x: 0, y: 0 },
     sourcePosition: 'right',
     targetPosition: 'left',
     data: {
@@ -181,6 +175,7 @@ export const getNodesAndEdges = async ({ id, defaultFlow, version, mode = 'simpl
 
       nodes.push({
         id: generateIdForNode(outputResource),
+        position: { x: 0, y: 0 },
         sourcePosition: 'right',
         targetPosition: 'left',
         data: { mode, [nodeDataKey]: { ...outputResource?.data } },
@@ -210,19 +205,6 @@ export const getNodesAndEdges = async ({ id, defaultFlow, version, mode = 'simpl
     );
   });
 
-  nodes.forEach((node: any) => {
-    flow.setNode(node.id, { width: DEFAULT_NODE_WIDTH, height: DEFAULT_NODE_HEIGHT });
-  });
-
-  edges.forEach((edge: any) => {
-    flow.setEdge(edge.source, edge.target);
-  });
-
-  if (layout) {
-    // Render the diagram in memory getting the X and Y
-    layoutDagreGraph(flow);
-  }
-
   // Find any duplicated edges, and merge them into one edge
   const uniqueEdgesById = new Map<string, any>();
   edges.forEach((edge: any) => {
@@ -232,8 +214,10 @@ export const getNodesAndEdges = async ({ id, defaultFlow, version, mode = 'simpl
   });
   const uniqueEdges = Array.from(uniqueEdgesById.values());
 
-  return {
-    nodes: calculatedNodes(flow, nodes),
+  const graph = {
+    nodes: nodes.map((node: any) => ({ ...node, position: node.position ?? { x: 0, y: 0 } })),
     edges: uniqueEdges,
   };
+
+  return layout ? await layoutNodeGraph(graph) : graph;
 };