@auto-engineer/pipeline 0.0.1 → 0.15.0

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.specs.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest';
+import { evolve, type LatestRunDocument } from './latest-run-projection';
+
+describe('LatestRunProjection', () => {
+  describe('evolve', () => {
+    it('tracks latest correlationId when PipelineRunStarted applied', () => {
+      const event = {
+        type: 'PipelineRunStarted' as const,
+        data: { correlationId: 'c1', triggerCommand: 'StartPipeline' },
+      };
+
+      const result = evolve(null, event);
+
+      expect(result).toEqual({
+        latestCorrelationId: 'c1',
+        triggerCommand: 'StartPipeline',
+      });
+    });
+
+    it('updates to newest correlationId when second PipelineRunStarted applied', () => {
+      const existing: LatestRunDocument = {
+        latestCorrelationId: 'c1',
+        triggerCommand: 'StartPipeline',
+      };
+      const event = {
+        type: 'PipelineRunStarted' as const,
+        data: { correlationId: 'c2', triggerCommand: 'StartPipeline' },
+      };
+
+      const result = evolve(existing, event);
+
+      expect(result).toEqual({
+        latestCorrelationId: 'c2',
+        triggerCommand: 'StartPipeline',
+      });
+    });
+  });
+});

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.specs.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it } from 'vitest';
+import {
+  type CommandDispatchedEvent,
+  type DomainEventEmittedEvent,
+  evolve,
+  type NodeStatusChangedLogEvent,
+  type PipelineRunStartedLogEvent,
+} from './message-log-projection';
+
+describe('MessageLogProjection', () => {
+  describe('CommandDispatched', () => {
+    it('creates message log entry for dispatched command', () => {
+      const event: CommandDispatchedEvent = {
+        type: 'CommandDispatched',
+        data: {
+          correlationId: 'c1',
+          requestId: 'r1',
+          commandType: 'CreateUser',
+          commandData: { name: 'Alice' },
+          timestamp: new Date('2025-01-01T00:00:00Z'),
+        },
+      };
+
+      const result = evolve(null, event);
+
+      expect(result).toEqual({
+        correlationId: 'c1',
+        requestId: 'r1',
+        messageType: 'command',
+        messageName: 'CreateUser',
+        messageData: { name: 'Alice' },
+        timestamp: new Date('2025-01-01T00:00:00Z'),
+      });
+    });
+  });
+
+  describe('DomainEventEmitted', () => {
+    it('creates message log entry for emitted domain event', () => {
+      const event: DomainEventEmittedEvent = {
+        type: 'DomainEventEmitted',
+        data: {
+          correlationId: 'c1',
+          requestId: 'r2',
+          eventType: 'UserCreated',
+          eventData: { userId: '123', name: 'Alice' },
+          timestamp: new Date('2025-01-01T00:00:01Z'),
+        },
+      };
+
+      const result = evolve(null, event);
+
+      expect(result).toEqual({
+        correlationId: 'c1',
+        requestId: 'r2',
+        messageType: 'event',
+        messageName: 'UserCreated',
+        messageData: { userId: '123', name: 'Alice' },
+        timestamp: new Date('2025-01-01T00:00:01Z'),
+      });
+    });
+  });
+
+  describe('PipelineRunStarted', () => {
+    it('creates message log entry for pipeline run started', () => {
+      const event: PipelineRunStartedLogEvent = {
+        type: 'PipelineRunStarted',
+        data: {
+          correlationId: 'c1',
+          triggerCommand: 'CreateUser',
+        },
+      };
+
+      const result = evolve(null, event);
+
+      expect(result).toEqual({
+        correlationId: 'c1',
+        requestId: 'c1',
+        messageType: 'event',
+        messageName: 'PipelineRunStarted',
+        messageData: { correlationId: 'c1', triggerCommand: 'CreateUser' },
+        timestamp: expect.any(Date),
+      });
+    });
+  });
+
+  describe('NodeStatusChanged', () => {
+    it('creates message log entry for node status changed', () => {
+      const event: NodeStatusChangedLogEvent = {
+        type: 'NodeStatusChanged',
+        data: {
+          correlationId: 'c1',
+          commandName: 'CreateUser',
+          status: 'running',
+          previousStatus: 'idle',
+          pendingCount: 1,
+          endedCount: 0,
+        },
+      };
+
+      const result = evolve(null, event);
+
+      expect(result).toEqual({
+        correlationId: 'c1',
+        requestId: expect.any(String),
+        messageType: 'event',
+        messageName: 'NodeStatusChanged',
+        messageData: {
+          nodeId: 'cmd:CreateUser',
+          status: 'running',
+          previousStatus: 'idle',
+          pendingCount: 1,
+          endedCount: 0,
+        },
+        timestamp: expect.any(Date),
+      });
+    });
+  });
+});

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.specs.ts

@@ -0,0 +1,127 @@
+import { describe, expect, it } from 'vitest';
+import { evolve, type NodeStatusChangedEvent, type NodeStatusDocument } from './node-status-projection';
+
+describe('NodeStatusProjection', () => {
+  describe('evolve', () => {
+    it('creates node document with running status when command starts', () => {
+      const event: NodeStatusChangedEvent = {
+        type: 'NodeStatusChanged',
+        data: {
+          correlationId: 'c1',
+          commandName: 'ProcessItem',
+          nodeId: 'cmd:ProcessItem',
+          status: 'running',
+          previousStatus: 'idle',
+          pendingCount: 1,
+          endedCount: 0,
+        },
+      };
+
+      const result = evolve(null, event);
+
+      expect(result).toEqual({
+        correlationId: 'c1',
+        commandName: 'ProcessItem',
+        status: 'running',
+        pendingCount: 1,
+        endedCount: 0,
+      });
+    });
+
+    it('updates node document to success status when command completes', () => {
+      const existing: NodeStatusDocument = {
+        correlationId: 'c1',
+        commandName: 'ProcessItem',
+        status: 'running',
+        pendingCount: 1,
+        endedCount: 0,
+      };
+      const event: NodeStatusChangedEvent = {
+        type: 'NodeStatusChanged',
+        data: {
+          correlationId: 'c1',
+          commandName: 'ProcessItem',
+          nodeId: 'cmd:ProcessItem',
+          status: 'success',
+          previousStatus: 'running',
+          pendingCount: 0,
+          endedCount: 1,
+        },
+      };
+
+      const result = evolve(existing, event);
+
+      expect(result).toEqual({
+        correlationId: 'c1',
+        commandName: 'ProcessItem',
+        status: 'success',
+        pendingCount: 0,
+        endedCount: 1,
+      });
+    });
+
+    it('updates node document to error status when command fails', () => {
+      const existing: NodeStatusDocument = {
+        correlationId: 'c1',
+        commandName: 'ProcessItem',
+        status: 'running',
+        pendingCount: 1,
+        endedCount: 0,
+      };
+      const event: NodeStatusChangedEvent = {
+        type: 'NodeStatusChanged',
+        data: {
+          correlationId: 'c1',
+          commandName: 'ProcessItem',
+          nodeId: 'cmd:ProcessItem',
+          status: 'error',
+          previousStatus: 'running',
+          pendingCount: 0,
+          endedCount: 1,
+        },
+      };
+
+      const result = evolve(existing, event);
+
+      expect(result).toEqual({
+        correlationId: 'c1',
+        commandName: 'ProcessItem',
+        status: 'error',
+        pendingCount: 0,
+        endedCount: 1,
+      });
+    });
+
+    it('tracks pending and ended counts for parallel items', () => {
+      const existing: NodeStatusDocument = {
+        correlationId: 'c1',
+        commandName: 'ProcessItem',
+        status: 'running',
+        pendingCount: 3,
+        endedCount: 2,
+      };
+      const event: NodeStatusChangedEvent = {
+        type: 'NodeStatusChanged',
+        data: {
+          correlationId: 'c1',
+          commandName: 'ProcessItem',
+          nodeId: 'cmd:ProcessItem',
+          status: 'running',
+          previousStatus: 'running',
+          pendingCount: 2,
+          endedCount: 3,
+        },
+      };
+
+      const result = evolve(existing, event);
+
+      expect(result).toEqual({
+        correlationId: 'c1',
+        commandName: 'ProcessItem',
+        status: 'running',
+        pendingCount: 2,
+        endedCount: 3,
+      });
+    });
+  });
+});

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,
+  };
+}