@auto-engineer/pipeline 1.67.0 → 1.69.0

package/src/server/v2-runtime-bridge.ts

@@ -0,0 +1,246 @@
+import type { Command, Event } from '@auto-engineer/message-bus';
+import type { SettledHandlerDescriptor } from '../core/descriptors.js';
+import type { SettledInput, SettledOutput, SettledState } from '../engine/workflows/settled-workflow.js';
+import { decide, evolve, initialState } from '../engine/workflows/settled-workflow.js';
+
+type NodeStatus = 'idle' | 'running' | 'success' | 'error';
+
+export interface SettledStats {
+  status: NodeStatus;
+  pendingCount: number;
+  endedCount: number;
+}
+
+interface V2RuntimeBridgeOptions {
+  onDispatch: (commandType: string, data: unknown, correlationId: string) => void;
+}
+
+interface RegisteredSettled {
+  templateId: string;
+  descriptor: SettledHandlerDescriptor;
+  commandTypes: readonly string[];
+  maxRetries: number;
+}
+
+type SettledEvent = SettledInput | SettledOutput;
+
+function rebuildState(events: SettledEvent[], maxRetries: number): SettledState {
+  let state: SettledState = { ...initialState(), maxRetries };
+  for (const event of events) {
+    state = evolve(state, event);
+  }
+  return state;
+}
+
+function processInput(input: SettledInput, history: SettledEvent[], maxRetries: number): SettledOutput[] {
+  history.push(input);
+  const state = rebuildState(history, maxRetries);
+  const result = decide(input, state);
+  const outputs = Array.isArray(result) ? result : [result];
+  for (const output of outputs) {
+    history.push(output);
+  }
+  return outputs;
+}
+
+export function createV2RuntimeBridge(options: V2RuntimeBridgeOptions) {
+  const registrations = new Map<string, RegisteredSettled>();
+  const commandToTemplateIds = new Map<string, Set<string>>();
+  const eventBuffer = new Map<string, Event[]>();
+  const settledCounts = new Map<string, number>();
+  const keyedHistories = new Map<string, SettledEvent[]>();
+
+  function bufferKey(templateId: string, correlationId: string, commandType: string): string {
+    return `${templateId}-${correlationId}-${commandType}`;
+  }
+
+  function compositeKey(templateId: string, correlationId: string): string {
+    return `${templateId}-${correlationId}`;
+  }
+
+  function isValidId(id: string | undefined): id is string {
+    return id !== undefined && id !== null && id !== '';
+  }
+
+  function ensureBuffer(templateId: string, correlationId: string, commandType: string): Event[] {
+    const key = bufferKey(templateId, correlationId, commandType);
+    let events = eventBuffer.get(key);
+    if (!events) {
+      events = [];
+      eventBuffer.set(key, events);
+    }
+    return events;
+  }
+
+  function collectBufferedEvents(
+    templateId: string,
+    correlationId: string,
+    commandTypes: readonly string[],
+  ): Record<string, Event[]> {
+    const result: Record<string, Event[]> = {};
+    for (const ct of commandTypes) {
+      result[ct] = ensureBuffer(templateId, correlationId, ct);
+    }
+    return result;
+  }
+
+  function clearBuffer(templateId: string, correlationId: string, commandTypes: readonly string[]): void {
+    for (const ct of commandTypes) {
+      eventBuffer.delete(bufferKey(templateId, correlationId, ct));
+    }
+  }
+
+  function getHistory(templateId: string, correlationId: string): SettledEvent[] {
+    const key = compositeKey(templateId, correlationId);
+    let history = keyedHistories.get(key);
+    if (!history) {
+      history = [];
+      keyedHistories.set(key, history);
+    }
+    return history;
+  }
+
+  function resetHistory(templateId: string, correlationId: string): void {
+    keyedHistories.delete(compositeKey(templateId, correlationId));
+  }
+
+  function handleOutputs(outputs: SettledOutput[], registration: RegisteredSettled, correlationId: string): void {
+    for (const output of outputs) {
+      if (output.type === 'AllSettled') {
+        const events = collectBufferedEvents(registration.templateId, correlationId, registration.commandTypes);
+
+        const send = (commandType: string, data: unknown) => {
+          options.onDispatch(commandType, data, correlationId);
+        };
+
+        const handlerResult = registration.descriptor.handler(events, send);
+        const persist =
+          handlerResult !== null &&
+          handlerResult !== undefined &&
+          typeof handlerResult === 'object' &&
+          'persist' in handlerResult &&
+          handlerResult.persist === true;
+
+        const countKey = compositeKey(registration.templateId, correlationId);
+        settledCounts.set(countKey, (settledCounts.get(countKey) ?? 0) + 1);
+
+        if (persist) {
+          resetHistory(registration.templateId, correlationId);
+          clearBuffer(registration.templateId, correlationId, registration.commandTypes);
+        }
+      }
+
+      if (output.type === 'RetryCommands') {
+        for (const ct of output.data.commandTypes) {
+          options.onDispatch(ct, {}, correlationId);
+          eventBuffer.delete(bufferKey(registration.templateId, correlationId, ct));
+        }
+      }
+    }
+  }
+
+  return {
+    registerSettled(descriptor: SettledHandlerDescriptor, config?: { maxRetries?: number }): void {
+      const commandTypes = descriptor.commandTypes;
+      const templateId = `template-${commandTypes.join(',')}`;
+
+      const registration: RegisteredSettled = {
+        templateId,
+        descriptor,
+        commandTypes,
+        maxRetries: config?.maxRetries ?? 3,
+      };
+
+      registrations.set(templateId, registration);
+
+      for (const ct of commandTypes) {
+        const existing = commandToTemplateIds.get(ct) ?? new Set<string>();
+        existing.add(templateId);
+        commandToTemplateIds.set(ct, existing);
+      }
+    },
+
+    onCommandStarted(command: Command): void {
+      const { type: commandType, correlationId, requestId } = command;
+
+      if (!isValidId(correlationId) || !isValidId(requestId)) {
+        return;
+      }
+
+      const templateIds = commandToTemplateIds.get(commandType);
+      if (!templateIds) {
+        return;
+      }
+
+      for (const templateId of templateIds) {
+        const registration = registrations.get(templateId);
+        if (registration) {
+          const history = getHistory(templateId, correlationId);
+          const input: SettledInput = {
+            type: 'StartSettled',
+            data: { correlationId, commandTypes: [...registration.commandTypes] },
+          };
+          processInput(input, history, registration.maxRetries);
+        }
+      }
+    },
+
+    onEventReceived(event: Event, sourceCommandType: string, result: 'success' | 'failure' = 'success'): void {
+      const correlationId = event.correlationId;
+
+      if (!isValidId(correlationId)) {
+        return;
+      }
+
+      const templateIds = commandToTemplateIds.get(sourceCommandType);
+      if (!templateIds) {
+        return;
+      }
+
+      for (const templateId of templateIds) {
+        const registration = registrations.get(templateId)!;
+        const existing = ensureBuffer(templateId, correlationId, sourceCommandType);
+        existing.push(event);
+
+        const history = getHistory(templateId, correlationId);
+        const input: SettledInput = {
+          type: 'CommandCompleted',
+          data: {
+            commandType: sourceCommandType,
+            result,
+            event: { ...event.data },
+          },
+        };
+        const outputs = processInput(input, history, registration.maxRetries);
+
+        handleOutputs(outputs, registration, correlationId);
+      }
+    },
+
+    getSettledStats(correlationId: string, templateId: string): SettledStats {
+      const registration = registrations.get(templateId);
+      if (!registration) {
+        return { status: 'idle', pendingCount: 0, endedCount: 0 };
+      }
+
+      const history = getHistory(templateId, correlationId);
+      const state = rebuildState(history, registration.maxRetries);
+      const countKey = compositeKey(templateId, correlationId);
+      const endedCount = settledCounts.get(countKey) ?? 0;
+
+      if (state.status === 'idle') {
+        return { status: 'idle', pendingCount: 0, endedCount: 0 };
+      }
+
+      if (state.status === 'waiting') {
+        return { status: 'running', pendingCount: 1, endedCount };
+      }
+
+      const hasFailure = Object.values(state.completions).some((c) => c.result === 'failure');
+      if (hasFailure) {
+        return { status: 'error', pendingCount: 0, endedCount };
+      }
+      return { status: 'success', pendingCount: 0, endedCount };
+    },
+  };
+}

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

@@ -1,8 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import type { ItemStatusDocument } from '../projections/item-status-projection';
 import type { NodeStatusDocument } from '../projections/node-status-projection';
-import type { PhasedExecutionDocument } from '../projections/phased-execution-projection';
-import type { SettledInstanceDocument } from '../projections/settled-instance-projection';
 import { createPipelineEventStore } from './pipeline-event-store';
 
 describe('PipelineEventStore', () => {
@@ -219,139 +217,4 @@ describe('PipelineEventStore', () => {
       }
     });
   });
-
-  describe('settled instance projection', () => {
-    it('should project SettledInstanceCreated events', async () => {
-      const { eventStore, database, close } = createPipelineEventStore();
-      try {
-        await eventStore.appendToStream('settled-c1', [
-          {
-            type: 'SettledInstanceCreated',
-            data: {
-              templateId: 'template-CmdA,CmdB',
-              correlationId: 'c1',
-              commandTypes: ['CmdA', 'CmdB'],
-            },
-          },
-        ]);
-
-        const collection = database.collection<SettledInstanceDocument & { _id: string }>('SettledInstance');
-        const instances = await collection.find();
-
-        expect(instances.length).toBe(1);
-        expect(instances[0]?.status).toBe('active');
-        expect(instances[0]?.commandTrackers).toHaveLength(2);
-      } finally {
-        await close();
-      }
-    });
-
-    it('should update settled instance through lifecycle events', async () => {
-      const { eventStore, database, close } = createPipelineEventStore();
-      try {
-        await eventStore.appendToStream('settled-c1', [
-          {
-            type: 'SettledInstanceCreated',
-            data: {
-              templateId: 'template-CmdA',
-              correlationId: 'c1',
-              commandTypes: ['CmdA'],
-            },
-          },
-          {
-            type: 'SettledCommandStarted',
-            data: {
-              templateId: 'template-CmdA',
-              correlationId: 'c1',
-              commandType: 'CmdA',
-            },
-          },
-        ]);
-
-        const collection = database.collection<SettledInstanceDocument & { _id: string }>('SettledInstance');
-        const instances = await collection.find();
-
-        expect(instances.length).toBe(1);
-        expect(instances[0]?.commandTrackers[0]?.hasStarted).toBe(true);
-        expect(instances[0]?.commandTrackers[0]?.hasCompleted).toBe(false);
-      } finally {
-        await close();
-      }
-    });
-  });
-
-  describe('phased execution projection', () => {
-    it('should project PhasedExecutionStarted events', async () => {
-      const { eventStore, database, close } = createPipelineEventStore();
-      try {
-        await eventStore.appendToStream('phased-c1', [
-          {
-            type: 'PhasedExecutionStarted',
-            data: {
-              executionId: 'exec-1',
-              correlationId: 'c1',
-              handlerId: 'handler-1',
-              triggerEvent: { type: 'TestEvent', correlationId: 'c1', data: {} },
-              items: [{ key: 'a', phase: 'prepare', dispatched: false, completed: false }],
-              phases: ['prepare', 'execute'],
-            },
-          },
-        ]);
-
-        const collection = database.collection<PhasedExecutionDocument & { _id: string }>('PhasedExecution');
-        const executions = await collection.find();
-
-        expect(executions.length).toBe(1);
-        expect(executions[0]?.status).toBe('active');
-        expect(executions[0]?.items).toHaveLength(1);
-      } finally {
-        await close();
-      }
-    });
-
-    it('should update phased execution through lifecycle events', async () => {
-      const { eventStore, database, close } = createPipelineEventStore();
-      try {
-        await eventStore.appendToStream('phased-c1', [
-          {
-            type: 'PhasedExecutionStarted',
-            data: {
-              executionId: 'exec-1',
-              correlationId: 'c1',
-              handlerId: 'handler-1',
-              triggerEvent: { type: 'TestEvent', correlationId: 'c1', data: {} },
-              items: [{ key: 'a', phase: 'prepare', dispatched: false, completed: false }],
-              phases: ['prepare'],
-            },
-          },
-          {
-            type: 'PhasedItemDispatched',
-            data: { executionId: 'exec-1', itemKey: 'a', phase: 'prepare' },
-          },
-          {
-            type: 'PhasedItemCompleted',
-            data: {
-              executionId: 'exec-1',
-              itemKey: 'a',
-              resultEvent: { type: 'ItemDone', correlationId: 'c1', data: {} },
-            },
-          },
-          {
-            type: 'PhasedExecutionCompleted',
-            data: { executionId: 'exec-1', success: true, results: ['a'] },
-          },
-        ]);
-
-        const collection = database.collection<PhasedExecutionDocument & { _id: string }>('PhasedExecution');
-        const executions = await collection.find();
-
-        expect(executions.length).toBe(1);
-        expect(executions[0]?.status).toBe('completed');
-        expect(executions[0]?.items[0]?.dispatched).toBe(true);
-        expect(executions[0]?.items[0]?.completed).toBe(true);
-      } finally {
-        await close();
-      }
-    });
-  });
 });

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

@@ -17,10 +17,6 @@ import type { MessageLogDocument, MessageLogEvent } from '../projections/message
 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';
@@ -80,35 +76,6 @@ function createProjections() {
     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'],
@@ -122,8 +89,6 @@ function createProjections() {
     latestRunProjection,
     messageLogProjection,
     statsProjection,
-    settledInstanceProjection,
-    phasedExecutionProjection,
     awaitTrackerProjection,
   ] as Parameters<typeof inlineProjections<InMemoryReadEventMetadata>>[0]);
 }