@auto-engineer/pipeline 0.14.0 → 0.16.0

package/src/store/pipeline-event-store.ts

@@ -0,0 +1,156 @@
+import {
+  getInMemoryDatabase,
+  getInMemoryEventStore,
+  type InMemoryDatabase,
+  type InMemoryEventStore,
+  type InMemoryReadEventMetadata,
+  inlineProjections,
+  inMemorySingleStreamProjection,
+} from '@event-driven-io/emmett';
+import type { AwaitEvent, AwaitTrackerDocument } from '../projections/await-tracker-projection';
+import { evolve as evolveAwaitTracker } from '../projections/await-tracker-projection';
+import type { ItemStatusChangedEvent, ItemStatusDocument } from '../projections/item-status-projection';
+import { evolve as evolveItemStatus } from '../projections/item-status-projection';
+import type { LatestRunDocument } from '../projections/latest-run-projection';
+import { evolve as evolveLatestRun } from '../projections/latest-run-projection';
+import type { MessageLogDocument, MessageLogEvent } from '../projections/message-log-projection';
+import { evolve as evolveMessageLog } from '../projections/message-log-projection';
+import type { NodeStatusChangedEvent, NodeStatusDocument } from '../projections/node-status-projection';
+import { evolve as evolveNodeStatus } from '../projections/node-status-projection';
+import type { PhasedExecutionDocument, PhasedExecutionEvent } from '../projections/phased-execution-projection';
+import { evolve as evolvePhasedExecution } from '../projections/phased-execution-projection';
+import type { SettledEvent, SettledInstanceDocument } from '../projections/settled-instance-projection';
+import { evolve as evolveSettledInstance } from '../projections/settled-instance-projection';
+import type { StatsDocument } from '../projections/stats-projection';
+import { evolve as evolveStats } from '../projections/stats-projection';
+import { PipelineReadModel } from './pipeline-read-model';
+
+interface PipelineRunStartedEvent {
+  type: 'PipelineRunStarted';
+  data: {
+    correlationId: string;
+    triggerCommand: string;
+  };
+}
+
+function createProjections() {
+  const itemStatusProjection = inMemorySingleStreamProjection<ItemStatusDocument, ItemStatusChangedEvent>({
+    collectionName: 'ItemStatus',
+    canHandle: ['ItemStatusChanged'],
+    getDocumentId: (event) => `${event.data.correlationId}-${event.data.commandType}-${event.data.itemKey}`,
+    evolve: (document: ItemStatusDocument | null, event: ItemStatusChangedEvent) => evolveItemStatus(document, event),
+  });
+
+  const nodeStatusProjection = inMemorySingleStreamProjection<NodeStatusDocument, NodeStatusChangedEvent>({
+    collectionName: 'NodeStatus',
+    canHandle: ['NodeStatusChanged'],
+    getDocumentId: (event) => `${event.data.correlationId}-${event.data.commandName}`,
+    evolve: (document: NodeStatusDocument | null, event: NodeStatusChangedEvent) => evolveNodeStatus(document, event),
+  });
+
+  const latestRunProjection = inMemorySingleStreamProjection<LatestRunDocument, PipelineRunStartedEvent>({
+    collectionName: 'LatestRun',
+    canHandle: ['PipelineRunStarted'],
+    getDocumentId: () => 'singleton',
+    evolve: (document: LatestRunDocument | null, event: PipelineRunStartedEvent) => evolveLatestRun(document, event),
+  });
+
+  const messageLogProjection = inMemorySingleStreamProjection<MessageLogDocument, MessageLogEvent>({
+    collectionName: 'MessageLog',
+    canHandle: ['CommandDispatched', 'DomainEventEmitted', 'PipelineRunStarted', 'NodeStatusChanged'],
+    getDocumentId: (event) => {
+      if (event.type === 'PipelineRunStarted') {
+        return `prs-${event.data.correlationId}`;
+      }
+      if (event.type === 'NodeStatusChanged') {
+        return `nsc-${event.data.correlationId}-${event.data.commandName}-${event.data.status}`;
+      }
+      if (event.type === 'DomainEventEmitted') {
+        return `dee-${event.data.requestId}-${event.data.eventType}`;
+      }
+      return `cmd-${event.data.requestId}`;
+    },
+    evolve: (document: MessageLogDocument | null, event: MessageLogEvent) => evolveMessageLog(document, event),
+  });
+
+  const statsProjection = inMemorySingleStreamProjection<StatsDocument, MessageLogEvent>({
+    collectionName: 'Stats',
+    canHandle: ['CommandDispatched', 'DomainEventEmitted'],
+    getDocumentId: () => 'global',
+    evolve: (document: StatsDocument | null, event: MessageLogEvent) => evolveStats(document, event),
+  });
+
+  const settledInstanceProjection = inMemorySingleStreamProjection<SettledInstanceDocument, SettledEvent>({
+    collectionName: 'SettledInstance',
+    canHandle: [
+      'SettledInstanceCreated',
+      'SettledCommandStarted',
+      'SettledEventReceived',
+      'SettledHandlerFired',
+      'SettledInstanceReset',
+      'SettledInstanceCleaned',
+    ],
+    getDocumentId: (event) => `${event.data.templateId}-${event.data.correlationId}`,
+    evolve: (document: SettledInstanceDocument | null, event: SettledEvent) => evolveSettledInstance(document, event),
+  });
+
+  const phasedExecutionProjection = inMemorySingleStreamProjection<PhasedExecutionDocument, PhasedExecutionEvent>({
+    collectionName: 'PhasedExecution',
+    canHandle: [
+      'PhasedExecutionStarted',
+      'PhasedItemDispatched',
+      'PhasedItemCompleted',
+      'PhasedItemFailed',
+      'PhasedPhaseAdvanced',
+      'PhasedExecutionCompleted',
+    ],
+    getDocumentId: (event) => event.data.executionId,
+    evolve: (document: PhasedExecutionDocument | null, event: PhasedExecutionEvent) =>
+      evolvePhasedExecution(document, event),
+  });
+
+  const awaitTrackerProjection = inMemorySingleStreamProjection<AwaitTrackerDocument, AwaitEvent>({
+    collectionName: 'AwaitTracker',
+    canHandle: ['AwaitStarted', 'AwaitItemCompleted', 'AwaitCompleted'],
+    getDocumentId: (event) => event.data.correlationId,
+    evolve: (document: AwaitTrackerDocument | null, event: AwaitEvent) => evolveAwaitTracker(document, event),
+  });
+
+  return inlineProjections<InMemoryReadEventMetadata>([
+    itemStatusProjection,
+    nodeStatusProjection,
+    latestRunProjection,
+    messageLogProjection,
+    statsProjection,
+    settledInstanceProjection,
+    phasedExecutionProjection,
+    awaitTrackerProjection,
+  ] as Parameters<typeof inlineProjections<InMemoryReadEventMetadata>>[0]);
+}
+
+export interface PipelineEventStoreContext {
+  eventStore: InMemoryEventStore;
+  database: InMemoryDatabase;
+  readModel: PipelineReadModel;
+  close: () => Promise<void>;
+}
+
+export function createPipelineEventStore(): PipelineEventStoreContext {
+  const database = getInMemoryDatabase();
+  const eventStore = getInMemoryEventStore({
+    database,
+    projections: createProjections() as Parameters<typeof getInMemoryEventStore>[0] extends { projections?: infer P }
+      ? P
+      : never,
+  });
+  const readModel = new PipelineReadModel(database);
+
+  return {
+    eventStore,
+    database,
+    readModel,
+    close: async () => {
+      // No-op for in-memory store
+    },
+  };
+}