@eventcatalog/core 1.2.7 → 2.0.0

package/src/utils/domains/node-graph.ts

@@ -0,0 +1,60 @@
+// import { getColor } from '@utils/colors';
+import { getCollection } from 'astro:content';
+import dagre from 'dagre';
+import { getNodesAndEdges as getServicesNodeAndEdges } from '../services/node-graph';
+
+type DagreGraph = any;
+
+// Creates a new dagre graph
+export const getDagreGraph = () => {
+  const graph = new dagre.graphlib.Graph({ compound: true });
+  graph.setGraph({ rankdir: 'LR', ranksep: 200, nodesep: 200 });
+  graph.setDefaultEdgeLabel(() => ({}));
+  return graph;
+};
+
+interface Props {
+  id: string;
+  version: string;
+  defaultFlow?: DagreGraph;
+  mode?: 'simple' | 'full';
+}
+
+export const getNodesAndEdges = async ({ id, version, defaultFlow, mode = 'simple' }: Props) => {
+  const flow = defaultFlow || getDagreGraph();
+  let nodes = [] as any,
+    edges = [] as any;
+
+  const domains = await getCollection('domains');
+
+  const domain = domains.find((service) => service.data.id === id && service.data.version === version);
+
+  // Nothing found...
+  if (!domain) {
+    return {
+      nodes: [],
+      edges: [],
+    };
+  }
+
+  const rawServices = domain?.data.services || [];
+
+  // Get all the nodes for everyhing
+
+  for (const service of rawServices) {
+    const { nodes: serviceNodes, edges: serviceEdges } = await getServicesNodeAndEdges({
+      id: service.id,
+      version: service.version,
+      defaultFlow: flow,
+      mode,
+      renderAllEdges: true,
+    });
+    nodes = [...nodes, ...serviceNodes];
+    edges = [...edges, ...serviceEdges];
+  }
+
+  return {
+    nodes: nodes,
+    edges: edges,
+  };
+};

package/src/utils/events/node-graph.ts

@@ -0,0 +1,108 @@
+// import { getColor } from '@utils/colors';
+import { getEvents } from '@utils/events';
+import type { CollectionEntry } from 'astro:content';
+import dagre from 'dagre';
+import { calculatedNodes, createDagreGraph, generatedIdForEdge, generateIdForNode } from '../node-graph-utils/utils';
+
+type DagreGraph = any;
+
+interface Props {
+  id: string;
+  version: string;
+  defaultFlow?: DagreGraph;
+  mode?: 'simple' | 'full';
+}
+
+export const getNodesAndEdges = async ({ id, version, defaultFlow, mode = 'simple' }: Props) => {
+  const flow = defaultFlow || createDagreGraph({ ranksep: 180, nodesep: 50 });
+  const nodes = [] as any,
+    edges = [] as any;
+
+  const events = await getEvents();
+
+  const event = events.find((event) => event.data.id === id && event.data.version === version);
+
+  // Nothing found...
+  if (!event) {
+    return {
+      nodes: [],
+      edges: [],
+    };
+  }
+
+  const producers = (event.data.producers as CollectionEntry<'services'>[]) || [];
+  const consumers = (event.data.consumers as CollectionEntry<'services'>[]) || [];
+
+  if (producers && producers.length > 0) {
+    producers.forEach((producer) => {
+      nodes.push({
+        id: generateIdForNode(producer),
+        type: producer?.collection,
+        sourcePosition: 'right',
+        targetPosition: 'left',
+        data: { mode, service: producer, showTarget: false },
+        position: { x: 250, y: 0 },
+      });
+      edges.push({
+        id: generatedIdForEdge(producer, event),
+        source: generateIdForNode(producer),
+        target: generateIdForNode(event),
+        type: 'smoothstep',
+        label: 'publishes event',
+        animated: false,
+        markerEnd: {
+          type: 'arrow',
+        },
+      });
+    });
+  }
+
+  // The event itself
+  nodes.push({
+    id: generateIdForNode(event),
+    sourcePosition: 'right',
+    targetPosition: 'left',
+    data: { mode, message: event, showTarget: producers.length > 0, showSource: consumers.length > 0 },
+    position: { x: 0, y: 0 },
+    type: event.collection,
+  });
+
+  // The messages the service sends
+  consumers.forEach((consumer) => {
+    nodes.push({
+      id: generateIdForNode(consumer),
+      sourcePosition: 'right',
+      targetPosition: 'left',
+      data: { title: consumer?.data.id, mode, service: consumer, showSource: false },
+      position: { x: 0, y: 0 },
+      type: consumer?.collection,
+    });
+    edges.push({
+      id: generatedIdForEdge(event, consumer),
+      source: generateIdForNode(event),
+      target: generateIdForNode(consumer),
+      type: 'smoothstep',
+      label: 'subscribed by',
+      animated: false,
+      markerEnd: {
+        type: 'arrow',
+      },
+    });
+  });
+
+  nodes.forEach((node: any) => {
+    flow.setNode(node.id, { width: 150, height: 100 });
+  });
+
+  edges.forEach((edge: any) => {
+    flow.setEdge(edge.source, edge.target);
+  });
+
+  // Render the diagram in memory getting hte X and Y
+  dagre.layout(flow);
+
+  return {
+    nodes: calculatedNodes(flow, nodes),
+    edges: edges,
+  };
+};

package/src/utils/events.ts

@@ -0,0 +1,62 @@
+import { getCollection } from 'astro:content';
+import type { CollectionEntry } from 'astro:content';
+import path from 'path';
+import { getVersionForCollectionItem, getVersions } from './collections/util';
+
+type Event = CollectionEntry<'events'> & {
+  catalog: {
+    path: string;
+    filePath: string;
+    type: string;
+  };
+};
+
+interface Props {
+  getAllVersions?: boolean;
+}
+
+export const getEvents = async ({ getAllVersions = true }: Props = {}): Promise<Event[]> => {
+  const events = await getCollection('events', (event) => {
+    return (getAllVersions || !event.slug.includes('versioned')) && event.data.hidden !== true;
+  });
+
+  const services = await getCollection('services');
+
+  return events.map((event) => {
+    const { latestVersion, versions } = getVersionForCollectionItem(event, events);
+
+    const producers = services.filter((service) => {
+      if (!service.data.sends) return false;
+      return service.data.sends.find((item) => {
+        return item.id === event.data.id && item.version === event.data.version;
+      });
+    });
+
+    const consumers = services.filter((service) => {
+      if (!service.data.receives) return false;
+      return service.data.receives.find((item) => {
+        return item.id === event.data.id && item.version === event.data.version;
+
+        // If no version has been found, then get try find the latest one
+        // return item.id == event.data.id
+      });
+    });
+
+    return {
+      ...event,
+      data: {
+        ...event.data,
+        producers,
+        consumers,
+        versions,
+        latestVersion,
+      },
+      catalog: {
+        path: path.join(event.collection, event.id.replace('/index.mdx', '')),
+        filePath: path.join(process.cwd(), 'src', 'catalog-files', event.collection, event.id.replace('/index.mdx', '')),
+        publicPath: path.join('/generated', event.collection, event.id.replace('/index.mdx', '')),
+        type: 'event',
+      },
+    };
+  });
+};

package/src/utils/example-remark-plugin.mjs

@@ -0,0 +1,6 @@
+export function exampleRemarkPlugin() {
+  // All remark and rehype plugins return a separate function
+  return function (tree, file) {
+    file.data.astro.frontmatter.customProperty = 'Generated property';
+  };
+}

package/src/utils/messages.ts

@@ -0,0 +1,7 @@
+// // import type { Domain, Message } from '@eventcatalog/types';
+// import { getCollection,  } from 'astro:content';
+
+// export const getMessages = async (): Promise<Message[]> => {
+//   const commands = await getCollection('commands');
+//   return commands.map((message: any) => message.data);
+// };

package/src/utils/node-graph-utils/utils.ts

@@ -0,0 +1,31 @@
+import type { CollectionEntry } from 'astro:content';
+import type { Node } from 'reactflow';
+import dagre from 'dagre';
+
+type DagreGraph = any;
+
+export const generateIdForNode = (node: CollectionEntry<'events' | 'services' | 'commands'>) => {
+  return `${node.data.id}-${node.data.version}`;
+};
+
+export const generatedIdForEdge = (
+  source: CollectionEntry<'events' | 'services' | 'commands'>,
+  target: CollectionEntry<'events' | 'services' | 'commands'>
+) => {
+  return `${source.data.id}-${source.data.version}-${target.data.id}-${target.data.version}`;
+};
+
+export const calculatedNodes = (flow: dagre.graphlib.Graph, nodes: Node[]) => {
+  return nodes.map((node: any) => {
+    const { x, y } = flow.node(node.id);
+    return { ...node, position: { x, y } };
+  });
+};
+
+// Creates a new dagre graph
+export const createDagreGraph = ({ ranksep = 180, nodesep = 50 }: any) => {
+  const graph = new dagre.graphlib.Graph({ compound: true });
+  graph.setGraph({ rankdir: 'LR', ranksep, nodesep });
+  graph.setDefaultEdgeLabel(() => ({}));
+  return graph;
+};

package/src/utils/services/node-graph.ts

@@ -0,0 +1,133 @@
+// import { getColor } from '@utils/colors';
+import { getCollection, type CollectionEntry } from 'astro:content';
+import dagre from 'dagre';
+import { getVersion } from './services';
+import { createDagreGraph, generateIdForNode, generatedIdForEdge, calculatedNodes } from '@utils/node-graph-utils/utils';
+
+type DagreGraph = any;
+
+interface Props {
+  id: string;
+  version: string;
+  defaultFlow?: DagreGraph;
+  mode?: 'simple' | 'full';
+  renderAllEdges?: boolean;
+}
+
+export const getNodesAndEdges = async ({ id, defaultFlow, version, mode = 'simple', renderAllEdges = false }: Props) => {
+  const flow = defaultFlow || createDagreGraph({ ranksep: 200, nodesep: 50 });
+  const nodes = [] as any,
+    edges = [] as any;
+
+  const services = await getCollection('services');
+
+  const service = services.find((service) => service.data.id === id && service.data.version === version);
+
+  // Nothing found...
+  if (!service) {
+    return {
+      nodes: [],
+      edges: [],
+    };
+  }
+
+  const receivesRaw = service?.data.receives || [];
+  const sendsRaw = service?.data.sends || [];
+
+  const events = await getCollection('events');
+  const commands = await getCollection('commands');
+
+  const messages = [...events, ...commands];
+
+  const receivesHydrated = receivesRaw
+    .map((message) => {
+      return getVersion(messages, message.id, message.version);
+    })
+    .filter((e) => e !== undefined);
+
+  const sendsHydrated = sendsRaw
+    .map((message) => {
+      return getVersion(messages, message.id, message.version);
+      // return messages.find((message) => message.data.id === messageId);
+    })
+    .filter((e) => e !== undefined);
+
+  const receives = (receivesHydrated as CollectionEntry<'events' | 'commands'>[]) || [];
+  const sends = (sendsHydrated as CollectionEntry<'events' | 'commands'>[]) || [];
+
+  // Get all the data from them
+
+  if (receives && receives.length > 0) {
+    //All the messages the service receives
+    receives.forEach((receive, index) => {
+      nodes.push({
+        id: generateIdForNode(receive),
+        type: receive?.collection,
+        sourcePosition: 'right',
+        targetPosition: 'left',
+        data: { mode, message: receive, showTarget: renderAllEdges },
+        position: { x: 250, y: 0 },
+      });
+      edges.push({
+        id: generatedIdForEdge(receive, service),
+        source: generateIdForNode(receive),
+        target: generateIdForNode(service),
+        type: 'smoothstep',
+        label: receive?.collection === 'events' ? 'receives event' : 'accepts',
+        animated: false,
+        markerEnd: {
+          type: 'arrow',
+        },
+      });
+    });
+  }
+
+  // The service itself
+  nodes.push({
+    id: generateIdForNode(service),
+    sourcePosition: 'right',
+    targetPosition: 'left',
+    data: { mode, service: service, showSource: sends.length > 0, showTarget: receives.length > 0 },
+    position: { x: 0, y: 0 },
+    type: service.collection,
+  });
+
+  // The messages the service sends
+  sends.forEach((send) => {
+    nodes.push({
+      id: generateIdForNode(send),
+      sourcePosition: 'right',
+      targetPosition: 'left',
+      data: { mode, message: send, showSource: renderAllEdges },
+      position: { x: 0, y: 0 },
+      type: send?.collection,
+    });
+    edges.push({
+      id: generatedIdForEdge(service, send),
+      source: generateIdForNode(service),
+      target: generateIdForNode(send),
+      type: 'smoothstep',
+      label: send?.collection === 'events' ? 'publishes event' : 'invokes command',
+      animated: false,
+      markerEnd: {
+        type: 'arrow',
+      },
+    });
+  });
+
+  nodes.forEach((node: any) => {
+    flow.setNode(node.id, { width: 150, height: 100 });
+  });
+
+  edges.forEach((edge: any) => {
+    flow.setEdge(edge.source, edge.target);
+  });
+
+  // Render the diagram in memory getting hte X and Y
+  dagre.layout(flow);
+
+  return {
+    nodes: calculatedNodes(flow, nodes),
+    edges: edges,
+  };
+};

package/src/utils/services/services.ts

@@ -0,0 +1,88 @@
+import { getVersionForCollectionItem, getVersions } from '@utils/collections/util';
+import { getCollection } from 'astro:content';
+import type { CollectionEntry } from 'astro:content';
+import path from 'path';
+// import { getEvents } from './events';
+// import { getCommands } from './commands';
+
+// import type { Service as ServiceInterface } from '../types/index'
+
+export type Service = CollectionEntry<'services'>;
+
+export const getVersion = (collection: CollectionEntry<'events' | 'commands'>[], id: string, version?: string) => {
+  const data = collection;
+  if (version) {
+    return data.find((event) => event.data.version === version && event.data.id === id);
+  }
+
+  const filteredEvents = data.filter((event) => event.data.id === id);
+
+  // Order by version
+  const sorted = filteredEvents.sort((a, b) => {
+    return a.data.version.localeCompare(b.data.version);
+  });
+
+  // latest version
+  return sorted[sorted.length - 1];
+};
+
+interface Props {
+  getAllVersions?: boolean;
+}
+
+export const getServices = async ({ getAllVersions = true }: Props = {}): Promise<Service[]> => {
+  // Get services that are not versioned
+  const services = await getCollection('services', (service) => {
+    return (getAllVersions || !service.slug.includes('versioned')) && service.data.hidden !== true;
+  });
+  const events = await getCollection('events');
+  const commands = await getCollection('commands');
+
+  const allMessages = [...events, ...commands];
+
+  // @ts-ignore // TODO: Fix this type
+  return services.map((service) => {
+    const { latestVersion, versions } = getVersionForCollectionItem(service, services);
+
+    // const receives = service.data.receives || [];
+    const sendsMessages = service.data.sends || [];
+    const receivesMessages = service.data.receives || [];
+
+    const sends = sendsMessages
+      .map((message) => {
+        const event = getVersion(allMessages, message.id, message.version);
+        // const event = allMessages.find((_message) => _message.data.id === message.id && _message.data.version === message.version);
+        return event;
+      })
+      .filter((e) => e !== undefined);
+
+    const receives = receivesMessages
+      .map((message) => {
+        const event = getVersion(allMessages, message.id, message.version);
+        // const event = allMessages.find((_message) => _message.data.id === message.id && _message.data.version === message.version);
+        return event;
+      })
+      .filter((e) => e !== undefined);
+
+    return {
+      ...service,
+      data: {
+        ...service.data,
+        receives,
+        sends,
+        versions,
+        latestVersion,
+      },
+      nodes: {
+        receives,
+        sends,
+      },
+      catalog: {
+        path: path.join(service.collection, service.id.replace('/index.mdx', '')),
+        filePath: path.join(process.cwd(), 'src', 'catalog-files', service.collection, service.id.replace('/index.mdx', '')),
+        publicPath: path.join('/generated', service.collection, service.id.replace('/index.mdx', '')),
+        type: 'service',
+      },
+    };
+  });
+};

package/src/utils/teams.ts

@@ -0,0 +1,47 @@
+import { getCollection } from 'astro:content';
+import type { CollectionEntry } from 'astro:content';
+import path from 'path';
+
+export type Team = CollectionEntry<'teams'>;
+
+export const getTeams = async (): Promise<Team[]> => {
+  // Get services that are not versioned
+  const teams = await getCollection('teams', (team) => {
+    return team.data.hidden !== true;
+  });
+
+  // What do they own?
+  const services = await getCollection('services');
+  // What do they own?
+  const events = await getCollection('events');
+  const commands = await getCollection('commands');
+
+  return teams.map((team) => {
+    const ownedServices = services.filter((service) => {
+      return service.data.owners?.find((owner) => owner.slug === team.data.id);
+    });
+
+    const ownedEvents = events.filter((event) => {
+      return event.data.owners?.find((owner) => owner.slug === team.data.id);
+    });
+
+    const ownedCommands = commands.filter((command) => {
+      return command.data.owners?.find((owner) => owner.slug === team.data.id);
+    });
+
+    return {
+      ...team,
+      data: {
+        ...team.data,
+        ownedServices,
+        ownedCommands,
+        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',
+      },
+    };
+  });
+};

package/src/utils/users.ts

@@ -0,0 +1,59 @@
+import { getCollection } from 'astro:content';
+import type { CollectionEntry } from 'astro:content';
+import path from 'path';
+
+export type User = CollectionEntry<'users'>;
+
+export const getUsers = async (): Promise<User[]> => {
+  // Get services that are not versioned
+  const users = await getCollection('users', (user) => {
+    return user.data.hidden !== true;
+  });
+
+  // What do they own?
+  const services = await getCollection('services');
+
+  // What do they own?
+  const events = await getCollection('events');
+
+  // What do they own?
+  const commands = await getCollection('commands');
+
+  const teams = await getCollection('teams', (team) => {
+    return team.data.hidden !== true;
+  });
+
+  return users.map((user) => {
+    const ownedServices = services.filter((service) => {
+      return service.data.owners?.find((owner) => owner.slug === user.data.id);
+    });
+
+    const ownedEvents = events.filter((event) => {
+      return event.data.owners?.find((owner) => owner.slug === user.data.id);
+    });
+
+    const ownedCommands = commands.filter((command) => {
+      return command.data.owners?.find((owner) => owner.slug === user.data.id);
+    });
+
+    const associatedTeams = teams.filter((team) => {
+      return team.data.members?.find((member) => member.slug === user.data.id);
+    });
+
+    return {
+      ...user,
+      data: {
+        ...user.data,
+        ownedServices,
+        ownedEvents,
+        ownedCommands,
+        associatedTeams,
+      },
+      catalog: {
+        path: path.join(user.collection, user.id.replace('/index.mdx', '')),
+        filePath: path.join(process.cwd(), 'src', 'catalog-files', user.collection, user.id.replace('/index.mdx', '')),
+        type: 'user',
+      },
+    };
+  });
+};

package/tailwind.config.mjs

@@ -0,0 +1,24 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+  content: ['./src/**/*.{astro,html,js,jsx,md,mdx,svelte,ts,tsx,vue}'],
+  theme: {
+    extend: {},
+  },
+  safelist: [
+    {pattern: /border-.*-(200|400|500)/},
+    {pattern: /bg-.*-(100|200|400|500)/},
+    {pattern: /text-.*-(400|500|800)/},
+    'border-blue-200',
+    'border-green-300',
+    'bg-blue-600',
+    'bg-orange-600',
+    'bg-red-50',
+    'bg-yellow-50',
+    'bg-indigo-50',
+    'border-l-red-500',
+    'border-l-yellow-500',
+    'border-l-blue-500',
+  ],
+
+  plugins: [require('@tailwindcss/typography')],
+};

package/tsconfig.json

@@ -1,32 +1,17 @@
 {
+  "extends": "astro/tsconfigs/strict",
   "compilerOptions": {
-    "target": "es5",
-    "lib": ["dom", "dom.iterable", "esnext"],
-    "allowJs": true,
-    "skipLibCheck": true,
-    "strict": false,
-    "forceConsistentCasingInFileNames": true,
-    "noEmit": true,
-    "incremental": true,
-    "esModuleInterop": true,
-    "module": "esnext",
-    "moduleResolution": "node",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
+    "strict": true,
     "baseUrl": ".",
     "paths": {
-      "@/components/*": ["components/*"],
-      "@/modules/*": ["modules/*"],
-      "@/hooks/*": ["hooks/*"],
-      "@/types/*": ["types/*"],
-      "@/contexts/*": ["contexts/*"],
-      "@/data/*": ["data/*"],
-      "@/lib/*": ["lib/*"],
-      "@/utils/*": ["utils/*"],
-      "@/styles/*": ["styles/*"]
+      "@config": ["./eventcatalog.config.js"],
+      "@eventcatalog": ["src/utils/config/catalog.ts"],
+      "@components/*": ["src/components/*"],
+      "@types": ["src/types/index.ts"],
+      "@utils/*": ["src/utils/*"],
+      "@layouts/*": ["src/layouts/*"]
     },
-    "jsx": "preserve"
-  },
-  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", "hooks/EventCatalog.tsx", "scripts/generate.js"],
-  "exclude": ["node_modules"]
+    "jsx": "react-jsx",
+    "jsxImportSource": "react"
+  }
 }

package/.next/BUILD_ID

@@ -1 +0,0 @@
-wZIh57Hs672ULoPeUaYa1