@auto-engineer/pipeline 1.65.0 → 1.67.0

package/src/engine/workflow-processor.specs.ts

@@ -0,0 +1,37 @@
+import { createWorkflowProcessor } from './workflow-processor.js';
+import { createSettledWorkflow } from './workflows/settled-workflow.js';
+
+describe('WorkflowProcessor', () => {
+  it('processes input event through workflow decide/evolve cycle', () => {
+    const processor = createWorkflowProcessor();
+    processor.register({
+      id: 'test-settled',
+      workflow: createSettledWorkflow({ commandTypes: ['A', 'B'] }),
+      inputEvents: ['StartSettled', 'CommandCompleted'],
+    });
+
+    const startResult = processor.process({
+      type: 'StartSettled',
+      data: { correlationId: 'c1', commandTypes: ['A', 'B'] },
+    });
+    expect(startResult).toEqual([]);
+
+    const completeA = processor.process({
+      type: 'CommandCompleted',
+      data: { commandType: 'A', result: 'success', event: {} },
+    });
+    expect(completeA).toEqual([]);
+
+    const completeB = processor.process({
+      type: 'CommandCompleted',
+      data: { commandType: 'B', result: 'success', event: {} },
+    });
+    expect(completeB).toEqual([expect.objectContaining({ type: 'AllSettled' })]);
+  });
+
+  it('returns empty for unregistered event types', () => {
+    const processor = createWorkflowProcessor();
+    const result = processor.process({ type: 'Unknown', data: {} });
+    expect(result).toEqual([]);
+  });
+});

package/src/engine/workflow-processor.ts

@@ -0,0 +1,57 @@
+type Event = { type: string; data: Record<string, unknown> };
+
+type WorkflowDef = {
+  decide: (input: Event, state: unknown) => Event | Event[];
+  evolve: (state: unknown, event: Event) => unknown;
+  initialState: () => unknown;
+};
+
+export type WorkflowRegistration = {
+  id: string;
+  workflow: WorkflowDef;
+  inputEvents: string[];
+};
+
+export function createWorkflowProcessor() {
+  const registrations = new Map<string, WorkflowRegistration>();
+  const eventsByWorkflow = new Map<string, Event[]>();
+
+  function rebuildState(reg: WorkflowRegistration, events: Event[]): unknown {
+    let state = reg.workflow.initialState();
+    for (const event of events) {
+      state = reg.workflow.evolve(state, event);
+    }
+    return state;
+  }
+
+  return {
+    register(registration: WorkflowRegistration): void {
+      registrations.set(registration.id, registration);
+      eventsByWorkflow.set(registration.id, []);
+    },
+
+    process(event: Event): Event[] {
+      const outputs: Event[] = [];
+
+      for (const [id, reg] of registrations) {
+        if (!reg.inputEvents.includes(event.type)) {
+          continue;
+        }
+
+        const history = eventsByWorkflow.get(id)!;
+        history.push(event);
+
+        const state = rebuildState(reg, history);
+        const result = reg.workflow.decide(event, state);
+        const resultEvents = Array.isArray(result) ? result : [result];
+
+        for (const outputEvent of resultEvents) {
+          history.push(outputEvent);
+          outputs.push(outputEvent);
+        }
+      }
+
+      return outputs;
+    },
+  };
+}

package/src/engine/workflows/await-workflow.specs.ts

@@ -0,0 +1,104 @@
+import { type AwaitInput, type AwaitState, createAwaitWorkflow, decide, evolve, initialState } from './await-workflow';
+
+describe('await workflow', () => {
+  describe('evolve', () => {
+    it('transitions from idle to waiting on StartAwait', () => {
+      const state = initialState();
+      const event = { type: 'StartAwait' as const, data: { correlationId: 'c1', keys: ['a', 'b', 'c'] } };
+      const result = evolve(state, event);
+      expect(result).toEqual({
+        status: 'waiting',
+        pendingKeys: ['a', 'b', 'c'],
+        results: {},
+      });
+    });
+
+    it('removes key from pending and stores result on KeyCompleted', () => {
+      const state: AwaitState = {
+        status: 'waiting',
+        pendingKeys: ['a', 'b'],
+        results: {},
+      };
+      const event = { type: 'KeyCompleted' as const, data: { key: 'a', result: { value: 42 } } };
+      const result = evolve(state, event);
+      expect(result).toEqual({
+        status: 'waiting',
+        pendingKeys: ['b'],
+        results: { a: { value: 42 } },
+      });
+    });
+
+    it('ignores KeyCompleted for unknown keys', () => {
+      const state: AwaitState = {
+        status: 'waiting',
+        pendingKeys: ['a'],
+        results: {},
+      };
+      const event = { type: 'KeyCompleted' as const, data: { key: 'z', result: { value: 1 } } };
+      const result = evolve(state, event);
+      expect(result).toEqual(state);
+    });
+  });
+
+  describe('decide', () => {
+    it('returns empty array when keys still pending', () => {
+      const state: AwaitState = {
+        status: 'waiting',
+        pendingKeys: ['b', 'c'],
+        results: { a: { value: 1 } },
+      };
+      const input: AwaitInput = {
+        type: 'KeyCompleted',
+        data: { key: 'a', result: { value: 1 } },
+      };
+      const result = decide(input, state);
+      expect(result).toEqual([]);
+    });
+
+    it('returns AwaitCompleted when all keys resolved', () => {
+      const state: AwaitState = {
+        status: 'waiting',
+        pendingKeys: [],
+        results: {
+          a: { value: 1 },
+          b: { value: 2 },
+          c: { value: 3 },
+        },
+      };
+      const input: AwaitInput = {
+        type: 'KeyCompleted',
+        data: { key: 'c', result: { value: 3 } },
+      };
+      const result = decide(input, state);
+      expect(result).toEqual({
+        type: 'AwaitCompleted',
+        data: {
+          results: {
+            a: { value: 1 },
+            b: { value: 2 },
+            c: { value: 3 },
+          },
+        },
+      });
+    });
+
+    it('returns empty array when status is idle', () => {
+      const state = initialState();
+      const input: AwaitInput = {
+        type: 'StartAwait',
+        data: { correlationId: 'c1', keys: ['a'] },
+      };
+      const result = decide(input, state);
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('createAwaitWorkflow', () => {
+    it('factory produces workflow with decide, evolve, initialState', () => {
+      const workflow = createAwaitWorkflow();
+      expect(workflow.decide).toBe(decide);
+      expect(workflow.evolve).toBe(evolve);
+      expect(workflow.initialState).toBe(initialState);
+    });
+  });
+});

package/src/engine/workflows/await-workflow.ts

@@ -0,0 +1,66 @@
+export type AwaitInput =
+  | { type: 'StartAwait'; data: { correlationId: string; keys: string[] } }
+  | { type: 'KeyCompleted'; data: { key: string; result: Record<string, unknown> } };
+
+export type AwaitOutput = {
+  type: 'AwaitCompleted';
+  data: { results: Record<string, Record<string, unknown>> };
+};
+
+export type AwaitState = {
+  status: 'idle' | 'waiting' | 'completed';
+  pendingKeys: string[];
+  results: Record<string, Record<string, unknown>>;
+};
+
+export function initialState(): AwaitState {
+  return {
+    status: 'idle',
+    pendingKeys: [],
+    results: {},
+  };
+}
+
+export function decide(input: AwaitInput, state: AwaitState): AwaitOutput | AwaitOutput[] {
+  if (state.status !== 'waiting' || state.pendingKeys.length > 0) {
+    return [];
+  }
+  return {
+    type: 'AwaitCompleted',
+    data: { results: state.results },
+  };
+}
+
+export function createAwaitWorkflow(): {
+  decide: typeof decide;
+  evolve: typeof evolve;
+  initialState: typeof initialState;
+} {
+  return { decide, evolve, initialState };
+}
+
+export function evolve(state: AwaitState, event: AwaitInput | AwaitOutput): AwaitState {
+  switch (event.type) {
+    case 'StartAwait':
+      return {
+        ...state,
+        status: 'waiting',
+        pendingKeys: event.data.keys,
+        results: {},
+      };
+    case 'KeyCompleted': {
+      if (!state.pendingKeys.includes(event.data.key)) {
+        return state;
+      }
+      return {
+        ...state,
+        pendingKeys: state.pendingKeys.filter((k) => k !== event.data.key),
+        results: { ...state.results, [event.data.key]: event.data.result },
+      };
+    }
+    case 'AwaitCompleted':
+      return { ...state, status: 'completed' };
+    default:
+      return state;
+  }
+}

package/src/engine/workflows/phased-workflow.specs.ts

@@ -0,0 +1,383 @@
+import type { PhasedInput, PhasedOutput, PhasedState } from './phased-workflow.js';
+import { createPhasedWorkflow, decide, evolve, initialState } from './phased-workflow.js';
+
+describe('phased workflow', () => {
+  describe('evolve', () => {
+    it('transitions from idle to running on StartPhased', () => {
+      const state = initialState();
+      const event: PhasedInput = {
+        type: 'StartPhased',
+        data: {
+          correlationId: 'corr-1',
+          items: [
+            { key: 'a', phase: 'p0' },
+            { key: 'b', phase: 'p1' },
+          ],
+          phases: ['p0', 'p1'],
+          stopOnFailure: true,
+        },
+      };
+
+      const result = evolve(state, event);
+
+      expect(result).toEqual({
+        status: 'running',
+        items: [
+          { key: 'a', phase: 'p0', status: 'pending' },
+          { key: 'b', phase: 'p1', status: 'pending' },
+        ],
+        phases: ['p0', 'p1'],
+        currentPhaseIndex: 0,
+        stopOnFailure: true,
+      });
+    });
+
+    it('marks item as dispatched on DispatchItem output', () => {
+      const state: PhasedState = {
+        status: 'running',
+        items: [
+          { key: 'a', phase: 'p0', status: 'pending' },
+          { key: 'b', phase: 'p1', status: 'pending' },
+        ],
+        phases: ['p0', 'p1'],
+        currentPhaseIndex: 0,
+        stopOnFailure: false,
+      };
+      const event: PhasedOutput = {
+        type: 'DispatchItem',
+        kind: 'Command',
+        data: { itemKey: 'a', phase: 'p0' },
+      };
+
+      const result = evolve(state, event);
+
+      expect(result).toEqual({
+        status: 'running',
+        items: [
+          { key: 'a', phase: 'p0', status: 'dispatched' },
+          { key: 'b', phase: 'p1', status: 'pending' },
+        ],
+        phases: ['p0', 'p1'],
+        currentPhaseIndex: 0,
+        stopOnFailure: false,
+      });
+    });
+
+    it('marks item as completed on ItemCompleted', () => {
+      const state: PhasedState = {
+        status: 'running',
+        items: [
+          { key: 'a', phase: 'p0', status: 'dispatched' },
+          { key: 'b', phase: 'p1', status: 'pending' },
+        ],
+        phases: ['p0', 'p1'],
+        currentPhaseIndex: 0,
+        stopOnFailure: false,
+      };
+      const event: PhasedInput = {
+        type: 'ItemCompleted',
+        data: { itemKey: 'a', result: { output: 'done' } },
+      };
+
+      const result = evolve(state, event);
+
+      expect(result).toEqual({
+        status: 'running',
+        items: [
+          { key: 'a', phase: 'p0', status: 'completed' },
+          { key: 'b', phase: 'p1', status: 'pending' },
+        ],
+        phases: ['p0', 'p1'],
+        currentPhaseIndex: 0,
+        stopOnFailure: false,
+      });
+    });
+
+    it('marks item as failed on ItemFailed', () => {
+      const state: PhasedState = {
+        status: 'running',
+        items: [
+          { key: 'a', phase: 'p0', status: 'dispatched' },
+          { key: 'b', phase: 'p1', status: 'pending' },
+        ],
+        phases: ['p0', 'p1'],
+        currentPhaseIndex: 0,
+        stopOnFailure: true,
+      };
+      const event: PhasedInput = {
+        type: 'ItemFailed',
+        data: { itemKey: 'a', error: { message: 'boom' } },
+      };
+
+      const result = evolve(state, event);
+
+      expect(result).toEqual({
+        status: 'running',
+        items: [
+          { key: 'a', phase: 'p0', status: 'failed' },
+          { key: 'b', phase: 'p1', status: 'pending' },
+        ],
+        phases: ['p0', 'p1'],
+        currentPhaseIndex: 0,
+        stopOnFailure: true,
+      });
+    });
+
+    it('sets status to completed on PhasedCompleted output', () => {
+      const state: PhasedState = {
+        status: 'running',
+        items: [{ key: 'a', phase: 'p0', status: 'completed' }],
+        phases: ['p0'],
+        currentPhaseIndex: 0,
+        stopOnFailure: false,
+      };
+      const event: PhasedOutput = {
+        type: 'PhasedCompleted',
+        data: { completedItems: ['a'] },
+      };
+
+      const result = evolve(state, event);
+
+      expect(result).toEqual({
+        status: 'completed',
+        items: [{ key: 'a', phase: 'p0', status: 'completed' }],
+        phases: ['p0'],
+        currentPhaseIndex: 0,
+        stopOnFailure: false,
+      });
+    });
+
+    it('sets status to failed on PhasedFailed output', () => {
+      const state: PhasedState = {
+        status: 'running',
+        items: [
+          { key: 'a', phase: 'p0', status: 'failed' },
+          { key: 'b', phase: 'p0', status: 'completed' },
+        ],
+        phases: ['p0'],
+        currentPhaseIndex: 0,
+        stopOnFailure: true,
+      };
+      const event: PhasedOutput = {
+        type: 'PhasedFailed',
+        data: { failedItems: ['a'], completedItems: ['b'] },
+      };
+
+      const result = evolve(state, event);
+
+      expect(result).toEqual({
+        status: 'failed',
+        items: [
+          { key: 'a', phase: 'p0', status: 'failed' },
+          { key: 'b', phase: 'p0', status: 'completed' },
+        ],
+        phases: ['p0'],
+        currentPhaseIndex: 0,
+        stopOnFailure: true,
+      });
+    });
+
+    it('advances currentPhaseIndex when dispatching item from next phase', () => {
+      const state: PhasedState = {
+        status: 'running',
+        items: [
+          { key: 'a', phase: 'p0', status: 'completed' },
+          { key: 'b', phase: 'p1', status: 'pending' },
+        ],
+        phases: ['p0', 'p1'],
+        currentPhaseIndex: 0,
+        stopOnFailure: false,
+      };
+      const event: PhasedOutput = {
+        type: 'DispatchItem',
+        kind: 'Command',
+        data: { itemKey: 'b', phase: 'p1' },
+      };
+
+      const result = evolve(state, event);
+
+      expect(result).toEqual({
+        status: 'running',
+        items: [
+          { key: 'a', phase: 'p0', status: 'completed' },
+          { key: 'b', phase: 'p1', status: 'dispatched' },
+        ],
+        phases: ['p0', 'p1'],
+        currentPhaseIndex: 1,
+        stopOnFailure: false,
+      });
+    });
+
+    it('does not change state for unknown event type', () => {
+      const state: PhasedState = {
+        status: 'running',
+        items: [{ key: 'a', phase: 'p0', status: 'pending' }],
+        phases: ['p0'],
+        currentPhaseIndex: 0,
+        stopOnFailure: false,
+      };
+      const event = { type: 'UnknownEvent', data: {} } as unknown as PhasedInput;
+
+      const result = evolve(state, event);
+
+      expect(result).toEqual(state);
+    });
+  });
+
+  describe('decide', () => {
+    it('dispatches next phase items when current phase completes', () => {
+      const state: PhasedState = {
+        status: 'running',
+        items: [
+          { key: 'a', phase: 'validate', status: 'completed' },
+          { key: 'b', phase: 'validate', status: 'completed' },
+          { key: 'c', phase: 'import', status: 'pending' },
+        ],
+        phases: ['validate', 'import'],
+        currentPhaseIndex: 0,
+        stopOnFailure: true,
+      };
+      const input: PhasedInput = {
+        type: 'ItemCompleted',
+        data: { itemKey: 'b', result: { ok: true } },
+      };
+      const result = decide(input, state);
+      expect(result).toEqual([{ type: 'DispatchItem', kind: 'Command', data: { itemKey: 'c', phase: 'import' } }]);
+    });
+
+    it('returns empty when current phase still has pending items', () => {
+      const state: PhasedState = {
+        status: 'running',
+        items: [
+          { key: 'a', phase: 'validate', status: 'completed' },
+          { key: 'b', phase: 'validate', status: 'dispatched' },
+        ],
+        phases: ['validate', 'import'],
+        currentPhaseIndex: 0,
+        stopOnFailure: true,
+      };
+      const input: PhasedInput = {
+        type: 'ItemCompleted',
+        data: { itemKey: 'a', result: { ok: true } },
+      };
+      const result = decide(input, state);
+      expect(result).toEqual([]);
+    });
+
+    it('returns PhasedFailed on item failure when stopOnFailure is true', () => {
+      const state: PhasedState = {
+        status: 'running',
+        items: [
+          { key: 'a', phase: 'validate', status: 'failed' },
+          { key: 'b', phase: 'validate', status: 'dispatched' },
+        ],
+        phases: ['validate', 'import'],
+        currentPhaseIndex: 0,
+        stopOnFailure: true,
+      };
+      const input: PhasedInput = {
+        type: 'ItemFailed',
+        data: { itemKey: 'a', error: { reason: 'invalid' } },
+      };
+      const result = decide(input, state);
+      expect(result).toEqual({
+        type: 'PhasedFailed',
+        data: { failedItems: ['a'], completedItems: [] },
+      });
+    });
+
+    it('returns empty on item failure when stopOnFailure is false', () => {
+      const state: PhasedState = {
+        status: 'running',
+        items: [
+          { key: 'a', phase: 'validate', status: 'failed' },
+          { key: 'b', phase: 'validate', status: 'dispatched' },
+        ],
+        phases: ['validate', 'import'],
+        currentPhaseIndex: 0,
+        stopOnFailure: false,
+      };
+      const input: PhasedInput = {
+        type: 'ItemFailed',
+        data: { itemKey: 'a', error: { reason: 'invalid' } },
+      };
+      const result = decide(input, state);
+      expect(result).toEqual([]);
+    });
+
+    it('returns PhasedCompleted when all items across all phases complete', () => {
+      const state: PhasedState = {
+        status: 'running',
+        items: [
+          { key: 'a', phase: 'validate', status: 'completed' },
+          { key: 'b', phase: 'import', status: 'completed' },
+        ],
+        phases: ['validate', 'import'],
+        currentPhaseIndex: 1,
+        stopOnFailure: true,
+      };
+      const input: PhasedInput = {
+        type: 'ItemCompleted',
+        data: { itemKey: 'b', result: { ok: true } },
+      };
+      const result = decide(input, state);
+      expect(result).toEqual({
+        type: 'PhasedCompleted',
+        data: { completedItems: ['a', 'b'] },
+      });
+    });
+
+    it('dispatches phase 0 items on StartPhased', () => {
+      const state: PhasedState = {
+        status: 'running',
+        items: [
+          { key: 'a', phase: 'validate', status: 'pending' },
+          { key: 'b', phase: 'validate', status: 'pending' },
+          { key: 'c', phase: 'import', status: 'pending' },
+        ],
+        phases: ['validate', 'import'],
+        currentPhaseIndex: 0,
+        stopOnFailure: true,
+      };
+      const input: PhasedInput = {
+        type: 'StartPhased',
+        data: {
+          correlationId: 'c1',
+          items: [
+            { key: 'a', phase: 'validate' },
+            { key: 'b', phase: 'validate' },
+            { key: 'c', phase: 'import' },
+          ],
+          phases: ['validate', 'import'],
+          stopOnFailure: true,
+        },
+      };
+      const result = decide(input, state);
+      expect(result).toEqual([
+        { type: 'DispatchItem', kind: 'Command', data: { itemKey: 'a', phase: 'validate' } },
+        { type: 'DispatchItem', kind: 'Command', data: { itemKey: 'b', phase: 'validate' } },
+      ]);
+    });
+  });
+
+  describe('initialState', () => {
+    it('returns idle state with empty collections', () => {
+      expect(initialState()).toEqual({
+        status: 'idle',
+        items: [],
+        phases: [],
+        currentPhaseIndex: 0,
+        stopOnFailure: false,
+      });
+    });
+  });
+
+  describe('createPhasedWorkflow', () => {
+    it('factory produces workflow with decide, evolve, initialState', () => {
+      const workflow = createPhasedWorkflow();
+      expect(workflow.decide).toBe(decide);
+      expect(workflow.evolve).toBe(evolve);
+      expect(workflow.initialState).toBe(initialState);
+    });
+  });
+});