@auto-engineer/pipeline 0.14.0 → 0.16.0

package/src/projections/await-tracker-projection.ts

@@ -0,0 +1,68 @@
+export interface AwaitTrackerDocument {
+  [key: string]: unknown;
+  correlationId: string;
+  pendingKeys: string[];
+  results: Record<string, unknown>;
+  status: 'pending' | 'completed';
+}
+
+export interface AwaitStartedEvent {
+  type: 'AwaitStarted';
+  data: {
+    correlationId: string;
+    keys: string[];
+  };
+}
+
+export interface AwaitItemCompletedEvent {
+  type: 'AwaitItemCompleted';
+  data: {
+    correlationId: string;
+    key: string;
+    result: unknown;
+  };
+}
+
+export interface AwaitCompletedEvent {
+  type: 'AwaitCompleted';
+  data: {
+    correlationId: string;
+  };
+}
+
+export type AwaitEvent = AwaitStartedEvent | AwaitItemCompletedEvent | AwaitCompletedEvent;
+
+export function evolve(document: AwaitTrackerDocument | null, event: AwaitEvent): AwaitTrackerDocument {
+  switch (event.type) {
+    case 'AwaitStarted': {
+      const { correlationId, keys } = event.data;
+      return {
+        correlationId,
+        pendingKeys: [...keys],
+        results: {},
+        status: 'pending',
+      };
+    }
+    case 'AwaitItemCompleted': {
+      if (document === null) {
+        throw new Error('Cannot apply AwaitItemCompleted to null document');
+      }
+      const { key, result } = event.data;
+      const newPendingKeys = document.pendingKeys.filter((k) => k !== key);
+      return {
+        ...document,
+        pendingKeys: newPendingKeys,
+        results: { ...document.results, [key]: result },
+      };
+    }
+    case 'AwaitCompleted': {
+      if (document === null) {
+        throw new Error('Cannot apply AwaitCompleted to null document');
+      }
+      return {
+        ...document,
+        status: 'completed',
+      };
+    }
+  }
+}

package/src/projections/index.ts

@@ -0,0 +1,11 @@
+export {
+  evolve as evolveItemStatus,
+  type ItemStatusChangedEvent,
+  type ItemStatusDocument,
+} from './item-status-projection';
+export { evolve as evolveLatestRun, type LatestRunDocument } from './latest-run-projection';
+export {
+  evolve as evolveNodeStatus,
+  type NodeStatusChangedEvent,
+  type NodeStatusDocument,
+} from './node-status-projection';

package/src/projections/item-status-projection.specs.ts

@@ -0,0 +1,130 @@
+import { describe, expect, it } from 'vitest';
+import { evolve, type ItemStatusChangedEvent, type ItemStatusDocument } from './item-status-projection';
+
+describe('ItemStatusProjection', () => {
+  describe('evolve', () => {
+    it('creates item document with running status when item starts', () => {
+      const event: ItemStatusChangedEvent = {
+        type: 'ItemStatusChanged',
+        data: {
+          correlationId: 'c1',
+          commandType: 'ProcessItem',
+          itemKey: 'item-1',
+          requestId: 'req-1',
+          status: 'running',
+          attemptCount: 1,
+        },
+      };
+
+      const result = evolve(null, event);
+
+      expect(result).toEqual({
+        correlationId: 'c1',
+        commandType: 'ProcessItem',
+        itemKey: 'item-1',
+        currentRequestId: 'req-1',
+        status: 'running',
+        attemptCount: 1,
+      });
+    });
+
+    it('updates item document to success status when item completes', () => {
+      const existing: ItemStatusDocument = {
+        correlationId: 'c1',
+        commandType: 'ProcessItem',
+        itemKey: 'item-1',
+        currentRequestId: 'req-1',
+        status: 'running',
+        attemptCount: 1,
+      };
+      const event: ItemStatusChangedEvent = {
+        type: 'ItemStatusChanged',
+        data: {
+          correlationId: 'c1',
+          commandType: 'ProcessItem',
+          itemKey: 'item-1',
+          requestId: 'req-1',
+          status: 'success',
+          attemptCount: 1,
+        },
+      };
+
+      const result = evolve(existing, event);
+
+      expect(result).toEqual({
+        correlationId: 'c1',
+        commandType: 'ProcessItem',
+        itemKey: 'item-1',
+        currentRequestId: 'req-1',
+        status: 'success',
+        attemptCount: 1,
+      });
+    });
+
+    it('updates item document to error status when item fails', () => {
+      const existing: ItemStatusDocument = {
+        correlationId: 'c1',
+        commandType: 'ProcessItem',
+        itemKey: 'item-1',
+        currentRequestId: 'req-1',
+        status: 'running',
+        attemptCount: 1,
+      };
+      const event: ItemStatusChangedEvent = {
+        type: 'ItemStatusChanged',
+        data: {
+          correlationId: 'c1',
+          commandType: 'ProcessItem',
+          itemKey: 'item-1',
+          requestId: 'req-1',
+          status: 'error',
+          attemptCount: 1,
+        },
+      };
+
+      const result = evolve(existing, event);
+
+      expect(result).toEqual({
+        correlationId: 'c1',
+        commandType: 'ProcessItem',
+        itemKey: 'item-1',
+        currentRequestId: 'req-1',
+        status: 'error',
+        attemptCount: 1,
+      });
+    });
+
+    it('increments attempt count on retry', () => {
+      const existing: ItemStatusDocument = {
+        correlationId: 'c1',
+        commandType: 'ProcessItem',
+        itemKey: 'item-1',
+        currentRequestId: 'req-1',
+        status: 'error',
+        attemptCount: 1,
+      };
+      const event: ItemStatusChangedEvent = {
+        type: 'ItemStatusChanged',
+        data: {
+          correlationId: 'c1',
+          commandType: 'ProcessItem',
+          itemKey: 'item-1',
+          requestId: 'req-2',
+          status: 'running',
+          attemptCount: 2,
+        },
+      };
+
+      const result = evolve(existing, event);
+
+      expect(result).toEqual({
+        correlationId: 'c1',
+        commandType: 'ProcessItem',
+        itemKey: 'item-1',
+        currentRequestId: 'req-2',
+        status: 'running',
+        attemptCount: 2,
+      });
+    });
+  });
+});

package/src/projections/item-status-projection.ts

@@ -0,0 +1,32 @@
+export interface ItemStatusDocument {
+  [key: string]: unknown;
+  correlationId: string;
+  commandType: string;
+  itemKey: string;
+  currentRequestId: string;
+  status: 'running' | 'success' | 'error';
+  attemptCount: number;
+}
+
+export interface ItemStatusChangedEvent {
+  type: 'ItemStatusChanged';
+  data: {
+    correlationId: string;
+    commandType: string;
+    itemKey: string;
+    requestId: string;
+    status: 'running' | 'success' | 'error';
+    attemptCount: number;
+  };
+}
+
+export function evolve(_document: ItemStatusDocument | null, event: ItemStatusChangedEvent): ItemStatusDocument {
+  return {
+    correlationId: event.data.correlationId,
+    commandType: event.data.commandType,
+    itemKey: event.data.itemKey,
+    currentRequestId: event.data.requestId,
+    status: event.data.status,
+    attemptCount: event.data.attemptCount,
+  };
+}

package/src/projections/latest-run-projection.ts

@@ -0,0 +1,20 @@
+export interface LatestRunDocument {
+  [key: string]: unknown;
+  latestCorrelationId: string;
+  triggerCommand: string;
+}
+
+interface PipelineRunStartedEvent {
+  type: 'PipelineRunStarted';
+  data: {
+    correlationId: string;
+    triggerCommand: string;
+  };
+}
+
+export function evolve(_document: LatestRunDocument | null, event: PipelineRunStartedEvent): LatestRunDocument {
+  return {
+    latestCorrelationId: event.data.correlationId,
+    triggerCommand: event.data.triggerCommand,
+  };
+}

package/src/projections/message-log-projection.ts

@@ -0,0 +1,113 @@
+import { nanoid } from 'nanoid';
+import type { NodeStatus } from '../graph/types';
+
+export interface MessageLogDocument {
+  [key: string]: unknown;
+  correlationId: string;
+  requestId: string;
+  messageType: 'command' | 'event';
+  messageName: string;
+  messageData: Record<string, unknown>;
+  timestamp: Date;
+}
+
+export interface CommandDispatchedEvent {
+  type: 'CommandDispatched';
+  data: {
+    correlationId: string;
+    requestId: string;
+    commandType: string;
+    commandData: Record<string, unknown>;
+    timestamp: Date;
+  };
+}
+
+export interface DomainEventEmittedEvent {
+  type: 'DomainEventEmitted';
+  data: {
+    correlationId: string;
+    requestId: string;
+    eventType: string;
+    eventData: Record<string, unknown>;
+    timestamp: Date;
+  };
+}
+
+export interface PipelineRunStartedLogEvent {
+  type: 'PipelineRunStarted';
+  data: {
+    correlationId: string;
+    triggerCommand: string;
+  };
+}
+
+export interface NodeStatusChangedLogEvent {
+  type: 'NodeStatusChanged';
+  data: {
+    correlationId: string;
+    commandName: string;
+    status: NodeStatus;
+    previousStatus: NodeStatus;
+    pendingCount: number;
+    endedCount: number;
+  };
+}
+
+export type MessageLogEvent =
+  | CommandDispatchedEvent
+  | DomainEventEmittedEvent
+  | PipelineRunStartedLogEvent
+  | NodeStatusChangedLogEvent;
+
+export function evolve(_document: MessageLogDocument | null, event: MessageLogEvent): MessageLogDocument {
+  if (event.type === 'CommandDispatched') {
+    return {
+      correlationId: event.data.correlationId,
+      requestId: event.data.requestId,
+      messageType: 'command',
+      messageName: event.data.commandType,
+      messageData: event.data.commandData,
+      timestamp: event.data.timestamp,
+    };
+  }
+
+  if (event.type === 'DomainEventEmitted') {
+    return {
+      correlationId: event.data.correlationId,
+      requestId: event.data.requestId,
+      messageType: 'event',
+      messageName: event.data.eventType,
+      messageData: event.data.eventData,
+      timestamp: event.data.timestamp,
+    };
+  }
+
+  if (event.type === 'PipelineRunStarted') {
+    return {
+      correlationId: event.data.correlationId,
+      requestId: event.data.correlationId,
+      messageType: 'event',
+      messageName: 'PipelineRunStarted',
+      messageData: {
+        correlationId: event.data.correlationId,
+        triggerCommand: event.data.triggerCommand,
+      },
+      timestamp: new Date(),
+    };
+  }
+
+  return {
+    correlationId: event.data.correlationId,
+    requestId: nanoid(),
+    messageType: 'event',
+    messageName: 'NodeStatusChanged',
+    messageData: {
+      nodeId: `cmd:${event.data.commandName}`,
+      status: event.data.status,
+      previousStatus: event.data.previousStatus,
+      pendingCount: event.data.pendingCount,
+      endedCount: event.data.endedCount,
+    },
+    timestamp: new Date(),
+  };
+}

package/src/projections/node-status-projection.ts

@@ -0,0 +1,33 @@
+import type { NodeStatus } from '../graph/types';
+
+export interface NodeStatusDocument {
+  [key: string]: unknown;
+  correlationId: string;
+  commandName: string;
+  status: NodeStatus;
+  pendingCount: number;
+  endedCount: number;
+}
+
+export interface NodeStatusChangedEvent {
+  type: 'NodeStatusChanged';
+  data: {
+    correlationId: string;
+    commandName: string;
+    nodeId: string;
+    status: NodeStatus;
+    previousStatus: NodeStatus;
+    pendingCount: number;
+    endedCount: number;
+  };
+}
+
+export function evolve(_document: NodeStatusDocument | null, event: NodeStatusChangedEvent): NodeStatusDocument {
+  return {
+    correlationId: event.data.correlationId,
+    commandName: event.data.commandName,
+    status: event.data.status,
+    pendingCount: event.data.pendingCount,
+    endedCount: event.data.endedCount,
+  };
+}

package/src/projections/phased-execution-projection.specs.ts

@@ -0,0 +1,202 @@
+import type { Event } from '@auto-engineer/message-bus';
+import { describe, expect, it } from 'vitest';
+import type { PhasedExecutionDocument, PhasedExecutionEvent } from './phased-execution-projection';
+import { evolve } from './phased-execution-projection';
+
+describe('PhasedExecutionProjection', () => {
+  const triggerEvent: Event = { type: 'TestEvent', correlationId: 'c1', data: { items: ['a', 'b'] } };
+
+  describe('PhasedExecutionStarted', () => {
+    it('should create initial document with items and phases', () => {
+      const event: PhasedExecutionEvent = {
+        type: 'PhasedExecutionStarted',
+        data: {
+          executionId: 'exec-1',
+          correlationId: 'c1',
+          handlerId: 'handler-1',
+          triggerEvent,
+          items: [
+            { key: 'a', phase: 'prepare', dispatched: false, completed: false },
+            { key: 'b', phase: 'execute', dispatched: false, completed: false },
+          ],
+          phases: ['prepare', 'execute'],
+        },
+      };
+
+      const result = evolve(null, event);
+
+      expect(result.executionId).toBe('exec-1');
+      expect(result.correlationId).toBe('c1');
+      expect(result.handlerId).toBe('handler-1');
+      expect(result.status).toBe('active');
+      expect(result.currentPhaseIndex).toBe(0);
+      expect(result.items).toHaveLength(2);
+      expect(result.phases).toEqual(['prepare', 'execute']);
+      expect(result.failedItems).toEqual([]);
+    });
+  });
+
+  describe('PhasedItemDispatched', () => {
+    it('should mark item as dispatched', () => {
+      const doc: PhasedExecutionDocument = {
+        executionId: 'exec-1',
+        correlationId: 'c1',
+        handlerId: 'handler-1',
+        triggerEvent,
+        items: [
+          { key: 'a', phase: 'prepare', dispatched: false, completed: false },
+          { key: 'b', phase: 'execute', dispatched: false, completed: false },
+        ],
+        phases: ['prepare', 'execute'],
+        currentPhaseIndex: 0,
+        status: 'active',
+        failedItems: [],
+      };
+
+      const event: PhasedExecutionEvent = {
+        type: 'PhasedItemDispatched',
+        data: { executionId: 'exec-1', itemKey: 'a', phase: 'prepare' },
+      };
+
+      const result = evolve(doc, event);
+
+      expect(result.items.find((i) => i.key === 'a')?.dispatched).toBe(true);
+      expect(result.items.find((i) => i.key === 'b')?.dispatched).toBe(false);
+    });
+
+    it('should throw when document is null', () => {
+      const event: PhasedExecutionEvent = {
+        type: 'PhasedItemDispatched',
+        data: { executionId: 'exec-1', itemKey: 'a', phase: 'prepare' },
+      };
+
+      expect(() => evolve(null, event)).toThrow('Cannot apply PhasedItemDispatched to null document');
+    });
+  });
+
+  describe('PhasedItemCompleted', () => {
+    it('should mark item as completed', () => {
+      const doc: PhasedExecutionDocument = {
+        executionId: 'exec-1',
+        correlationId: 'c1',
+        handlerId: 'handler-1',
+        triggerEvent,
+        items: [{ key: 'a', phase: 'prepare', dispatched: true, completed: false }],
+        phases: ['prepare'],
+        currentPhaseIndex: 0,
+        status: 'active',
+        failedItems: [],
+      };
+
+      const resultEvent: Event = { type: 'ItemDone', correlationId: 'c1', data: {} };
+      const event: PhasedExecutionEvent = {
+        type: 'PhasedItemCompleted',
+        data: { executionId: 'exec-1', itemKey: 'a', resultEvent },
+      };
+
+      const result = evolve(doc, event);
+
+      expect(result.items.find((i) => i.key === 'a')?.completed).toBe(true);
+    });
+  });
+
+  describe('PhasedItemFailed', () => {
+    it('should add item to failedItems', () => {
+      const doc: PhasedExecutionDocument = {
+        executionId: 'exec-1',
+        correlationId: 'c1',
+        handlerId: 'handler-1',
+        triggerEvent,
+        items: [{ key: 'a', phase: 'prepare', dispatched: true, completed: false }],
+        phases: ['prepare'],
+        currentPhaseIndex: 0,
+        status: 'active',
+        failedItems: [],
+      };
+
+      const event: PhasedExecutionEvent = {
+        type: 'PhasedItemFailed',
+        data: { executionId: 'exec-1', itemKey: 'a', error: { message: 'Failed' } },
+      };
+
+      const result = evolve(doc, event);
+
+      expect(result.failedItems).toHaveLength(1);
+      expect(result.failedItems[0].key).toBe('a');
+      expect(result.failedItems[0].error).toEqual({ message: 'Failed' });
+    });
+  });
+
+  describe('PhasedPhaseAdvanced', () => {
+    it('should update currentPhaseIndex', () => {
+      const doc: PhasedExecutionDocument = {
+        executionId: 'exec-1',
+        correlationId: 'c1',
+        handlerId: 'handler-1',
+        triggerEvent,
+        items: [{ key: 'a', phase: 'prepare', dispatched: true, completed: true }],
+        phases: ['prepare', 'execute'],
+        currentPhaseIndex: 0,
+        status: 'active',
+        failedItems: [],
+      };
+
+      const event: PhasedExecutionEvent = {
+        type: 'PhasedPhaseAdvanced',
+        data: { executionId: 'exec-1', fromPhase: 0, toPhase: 1 },
+      };
+
+      const result = evolve(doc, event);
+
+      expect(result.currentPhaseIndex).toBe(1);
+    });
+  });
+
+  describe('PhasedExecutionCompleted', () => {
+    it('should set status to completed on success', () => {
+      const doc: PhasedExecutionDocument = {
+        executionId: 'exec-1',
+        correlationId: 'c1',
+        handlerId: 'handler-1',
+        triggerEvent,
+        items: [{ key: 'a', phase: 'prepare', dispatched: true, completed: true }],
+        phases: ['prepare'],
+        currentPhaseIndex: 1,
+        status: 'active',
+        failedItems: [],
+      };
+
+      const event: PhasedExecutionEvent = {
+        type: 'PhasedExecutionCompleted',
+        data: { executionId: 'exec-1', success: true, results: ['a'] },
+      };
+
+      const result = evolve(doc, event);
+
+      expect(result.status).toBe('completed');
+    });
+
+    it('should set status to failed on failure', () => {
+      const doc: PhasedExecutionDocument = {
+        executionId: 'exec-1',
+        correlationId: 'c1',
+        handlerId: 'handler-1',
+        triggerEvent,
+        items: [{ key: 'a', phase: 'prepare', dispatched: true, completed: false }],
+        phases: ['prepare'],
+        currentPhaseIndex: 0,
+        status: 'active',
+        failedItems: [{ key: 'a', error: { message: 'Failed' } }],
+      };
+
+      const event: PhasedExecutionEvent = {
+        type: 'PhasedExecutionCompleted',
+        data: { executionId: 'exec-1', success: false, results: [] },
+      };
+
+      const result = evolve(doc, event);
+
+      expect(result.status).toBe('failed');
+    });
+  });
+});