@auto-engineer/pipeline 1.68.0 → 1.70.0

package/src/store/pipeline-read-model.specs.ts

@@ -3,8 +3,6 @@ import { beforeEach, describe, expect, it } from 'vitest';
 import type { ItemStatusDocument } from '../projections/item-status-projection';
 import type { MessageLogDocument } from '../projections/message-log-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 type { StatsDocument } from '../projections/stats-projection';
 import { PipelineReadModel } from './pipeline-read-model';
 
@@ -602,569 +600,4 @@ describe('PipelineReadModel', () => {
       });
     });
   });
-
-  describe('getSettledInstance', () => {
-    it('should return null when no settled instance exists', async () => {
-      const result = await readModel.getSettledInstance('template-CmdA', 'c1');
-
-      expect(result).toBeNull();
-    });
-
-    it('should return settled instance from collection', async () => {
-      const collection = database.collection<WithId<SettledInstanceDocument>>('SettledInstance');
-      await collection.insertOne({
-        _id: 'template-CmdA-c1',
-        instanceId: 'template-CmdA-c1',
-        templateId: 'template-CmdA',
-        correlationId: 'c1',
-        commandTrackers: [{ commandType: 'CmdA', hasStarted: true, hasCompleted: false, events: [] }],
-        status: 'active',
-        firedCount: 0,
-      });
-
-      const result = await readModel.getSettledInstance('template-CmdA', 'c1');
-
-      expect(result).toMatchObject({
-        instanceId: 'template-CmdA-c1',
-        templateId: 'template-CmdA',
-        correlationId: 'c1',
-        status: 'active',
-      });
-    });
-
-    it('should return null for different templateId', async () => {
-      const collection = database.collection<WithId<SettledInstanceDocument>>('SettledInstance');
-      await collection.insertOne({
-        _id: 'template-CmdA-c1',
-        instanceId: 'template-CmdA-c1',
-        templateId: 'template-CmdA',
-        correlationId: 'c1',
-        commandTrackers: [],
-        status: 'active',
-        firedCount: 0,
-      });
-
-      const result = await readModel.getSettledInstance('template-CmdB', 'c1');
-
-      expect(result).toBeNull();
-    });
-
-    it('should return null for different correlationId', async () => {
-      const collection = database.collection<WithId<SettledInstanceDocument>>('SettledInstance');
-      await collection.insertOne({
-        _id: 'template-CmdA-c1',
-        instanceId: 'template-CmdA-c1',
-        templateId: 'template-CmdA',
-        correlationId: 'c1',
-        commandTrackers: [],
-        status: 'active',
-        firedCount: 0,
-      });
-
-      const result = await readModel.getSettledInstance('template-CmdA', 'c2');
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('getActiveSettledInstances', () => {
-    it('should return empty array when no instances exist', async () => {
-      const result = await readModel.getActiveSettledInstances('c1');
-
-      expect(result).toEqual([]);
-    });
-
-    it('should return only active instances for correlationId', async () => {
-      const collection = database.collection<WithId<SettledInstanceDocument>>('SettledInstance');
-      await collection.insertOne({
-        _id: 'template-CmdA-c1',
-        instanceId: 'template-CmdA-c1',
-        templateId: 'template-CmdA',
-        correlationId: 'c1',
-        commandTrackers: [],
-        status: 'active',
-        firedCount: 0,
-      });
-      await collection.insertOne({
-        _id: 'template-CmdB-c1',
-        instanceId: 'template-CmdB-c1',
-        templateId: 'template-CmdB',
-        correlationId: 'c1',
-        commandTrackers: [],
-        status: 'fired',
-        firedCount: 1,
-      });
-
-      const result = await readModel.getActiveSettledInstances('c1');
-
-      expect(result).toHaveLength(1);
-      expect(result[0].templateId).toBe('template-CmdA');
-    });
-
-    it('should filter by correlationId', async () => {
-      const collection = database.collection<WithId<SettledInstanceDocument>>('SettledInstance');
-      await collection.insertOne({
-        _id: 'template-CmdA-c1',
-        instanceId: 'template-CmdA-c1',
-        templateId: 'template-CmdA',
-        correlationId: 'c1',
-        commandTrackers: [],
-        status: 'active',
-        firedCount: 0,
-      });
-      await collection.insertOne({
-        _id: 'template-CmdA-c2',
-        instanceId: 'template-CmdA-c2',
-        templateId: 'template-CmdA',
-        correlationId: 'c2',
-        commandTrackers: [],
-        status: 'active',
-        firedCount: 0,
-      });
-
-      const result = await readModel.getActiveSettledInstances('c1');
-
-      expect(result).toHaveLength(1);
-      expect(result[0].correlationId).toBe('c1');
-    });
-
-    it('should exclude cleaned instances', async () => {
-      const collection = database.collection<WithId<SettledInstanceDocument>>('SettledInstance');
-      await collection.insertOne({
-        _id: 'template-CmdA-c1',
-        instanceId: 'template-CmdA-c1',
-        templateId: 'template-CmdA',
-        correlationId: 'c1',
-        commandTrackers: [],
-        status: 'cleaned',
-        firedCount: 0,
-      });
-
-      const result = await readModel.getActiveSettledInstances('c1');
-
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe('getPhasedExecution', () => {
-    it('should return null when no execution exists', async () => {
-      const result = await readModel.getPhasedExecution('exec-1');
-
-      expect(result).toBeNull();
-    });
-
-    it('should return execution from collection', async () => {
-      const collection = database.collection<WithId<PhasedExecutionDocument>>('PhasedExecution');
-      const triggerEvent = { type: 'TestEvent', correlationId: 'c1', data: {} };
-      await collection.insertOne({
-        _id: 'exec-1',
-        executionId: 'exec-1',
-        correlationId: 'c1',
-        handlerId: 'handler-1',
-        triggerEvent,
-        items: [{ key: 'a', phase: 'prepare', dispatched: false, completed: false }],
-        phases: ['prepare'],
-        currentPhaseIndex: 0,
-        status: 'active',
-        failedItems: [],
-      });
-
-      const result = await readModel.getPhasedExecution('exec-1');
-
-      expect(result).toMatchObject({
-        executionId: 'exec-1',
-        correlationId: 'c1',
-        handlerId: 'handler-1',
-        status: 'active',
-      });
-    });
-
-    it('should return null for different executionId', async () => {
-      const collection = database.collection<WithId<PhasedExecutionDocument>>('PhasedExecution');
-      const triggerEvent = { type: 'TestEvent', correlationId: 'c1', data: {} };
-      await collection.insertOne({
-        _id: 'exec-1',
-        executionId: 'exec-1',
-        correlationId: 'c1',
-        handlerId: 'handler-1',
-        triggerEvent,
-        items: [],
-        phases: ['prepare'],
-        currentPhaseIndex: 0,
-        status: 'active',
-        failedItems: [],
-      });
-
-      const result = await readModel.getPhasedExecution('exec-2');
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('getActivePhasedExecutions', () => {
-    it('should return empty array when no executions exist', async () => {
-      const result = await readModel.getActivePhasedExecutions('c1');
-
-      expect(result).toEqual([]);
-    });
-
-    it('should return only active executions for correlationId', async () => {
-      const collection = database.collection<WithId<PhasedExecutionDocument>>('PhasedExecution');
-      const triggerEvent = { type: 'TestEvent', correlationId: 'c1', data: {} };
-      await collection.insertOne({
-        _id: 'exec-1',
-        executionId: 'exec-1',
-        correlationId: 'c1',
-        handlerId: 'handler-1',
-        triggerEvent,
-        items: [],
-        phases: ['prepare'],
-        currentPhaseIndex: 0,
-        status: 'active',
-        failedItems: [],
-      });
-      await collection.insertOne({
-        _id: 'exec-2',
-        executionId: 'exec-2',
-        correlationId: 'c1',
-        handlerId: 'handler-2',
-        triggerEvent,
-        items: [],
-        phases: ['prepare'],
-        currentPhaseIndex: 0,
-        status: 'completed',
-        failedItems: [],
-      });
-
-      const result = await readModel.getActivePhasedExecutions('c1');
-
-      expect(result).toHaveLength(1);
-      expect(result[0].executionId).toBe('exec-1');
-    });
-
-    it('should filter by correlationId', async () => {
-      const collection = database.collection<WithId<PhasedExecutionDocument>>('PhasedExecution');
-      const triggerEvent1 = { type: 'TestEvent', correlationId: 'c1', data: {} };
-      const triggerEvent2 = { type: 'TestEvent', correlationId: 'c2', data: {} };
-      await collection.insertOne({
-        _id: 'exec-1',
-        executionId: 'exec-1',
-        correlationId: 'c1',
-        handlerId: 'handler-1',
-        triggerEvent: triggerEvent1,
-        items: [],
-        phases: ['prepare'],
-        currentPhaseIndex: 0,
-        status: 'active',
-        failedItems: [],
-      });
-      await collection.insertOne({
-        _id: 'exec-2',
-        executionId: 'exec-2',
-        correlationId: 'c2',
-        handlerId: 'handler-1',
-        triggerEvent: triggerEvent2,
-        items: [],
-        phases: ['prepare'],
-        currentPhaseIndex: 0,
-        status: 'active',
-        failedItems: [],
-      });
-
-      const result = await readModel.getActivePhasedExecutions('c1');
-
-      expect(result).toHaveLength(1);
-      expect(result[0].correlationId).toBe('c1');
-    });
-
-    it('should exclude failed executions', async () => {
-      const collection = database.collection<WithId<PhasedExecutionDocument>>('PhasedExecution');
-      const triggerEvent = { type: 'TestEvent', correlationId: 'c1', data: {} };
-      await collection.insertOne({
-        _id: 'exec-1',
-        executionId: 'exec-1',
-        correlationId: 'c1',
-        handlerId: 'handler-1',
-        triggerEvent,
-        items: [],
-        phases: ['prepare'],
-        currentPhaseIndex: 0,
-        status: 'failed',
-        failedItems: [{ key: 'a', error: { message: 'Failed' } }],
-      });
-
-      const result = await readModel.getActivePhasedExecutions('c1');
-
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe('computeSettledStats', () => {
-    it('should return idle when no instance exists', async () => {
-      const result = await readModel.computeSettledStats('c1', 'template-A');
-
-      expect(result).toEqual({
-        status: 'idle',
-        pendingCount: 0,
-        endedCount: 0,
-      });
-    });
-
-    it('should return pendingCount=1 and status=running when instance is active', async () => {
-      const collection = database.collection<WithId<SettledInstanceDocument>>('SettledInstance');
-      await collection.insertOne({
-        _id: 'template-CheckTests,CheckTypes,CheckLint-c1',
-        instanceId: 'template-CheckTests,CheckTypes,CheckLint-c1',
-        templateId: 'template-CheckTests,CheckTypes,CheckLint',
-        correlationId: 'c1',
-        commandTrackers: [
-          { commandType: 'CheckTests', hasStarted: true, hasCompleted: false, events: [] },
-          { commandType: 'CheckTypes', hasStarted: true, hasCompleted: false, events: [] },
-          { commandType: 'CheckLint', hasStarted: true, hasCompleted: false, events: [] },
-        ],
-        status: 'active',
-        firedCount: 0,
-      });
-
-      const result = await readModel.computeSettledStats('c1', 'template-CheckTests,CheckTypes,CheckLint');
-
-      expect(result).toEqual({
-        status: 'running',
-        pendingCount: 1,
-        endedCount: 0,
-      });
-    });
-
-    it('should return status=error when any collected event contains Failed', async () => {
-      const collection = database.collection<WithId<SettledInstanceDocument>>('SettledInstance');
-      await collection.insertOne({
-        _id: 'template-CheckTests,CheckTypes,CheckLint-c1',
-        instanceId: 'template-CheckTests,CheckTypes,CheckLint-c1',
-        templateId: 'template-CheckTests,CheckTypes,CheckLint',
-        correlationId: 'c1',
-        commandTrackers: [
-          {
-            commandType: 'CheckTests',
-            hasStarted: true,
-            hasCompleted: true,
-            events: [{ type: 'TestsPassed', correlationId: 'c1', data: {} }],
-          },
-          {
-            commandType: 'CheckTypes',
-            hasStarted: true,
-            hasCompleted: true,
-            events: [{ type: 'TypeCheckFailed', correlationId: 'c1', data: { errors: 'TS2322' } }],
-          },
-          { commandType: 'CheckLint', hasStarted: true, hasCompleted: false, events: [] },
-        ],
-        status: 'active',
-        firedCount: 0,
-      });
-
-      const result = await readModel.computeSettledStats('c1', 'template-CheckTests,CheckTypes,CheckLint');
-
-      expect(result).toEqual({
-        status: 'error',
-        pendingCount: 1,
-        endedCount: 0,
-      });
-    });
-
-    it('should return endedCount=1 and status=success after handler fires without failures', async () => {
-      const collection = database.collection<WithId<SettledInstanceDocument>>('SettledInstance');
-      await collection.insertOne({
-        _id: 'template-CheckTests,CheckTypes,CheckLint-c1',
-        instanceId: 'template-CheckTests,CheckTypes,CheckLint-c1',
-        templateId: 'template-CheckTests,CheckTypes,CheckLint',
-        correlationId: 'c1',
-        commandTrackers: [
-          { commandType: 'CheckTests', hasStarted: true, hasCompleted: false, events: [] },
-          { commandType: 'CheckTypes', hasStarted: true, hasCompleted: false, events: [] },
-          { commandType: 'CheckLint', hasStarted: true, hasCompleted: false, events: [] },
-        ],
-        status: 'active',
-        firedCount: 1,
-      });
-
-      const result = await readModel.computeSettledStats('c1', 'template-CheckTests,CheckTypes,CheckLint');
-
-      expect(result).toEqual({
-        status: 'success',
-        pendingCount: 1,
-        endedCount: 1,
-      });
-    });
-
-    it('should return pendingCount=0 and endedCount when instance status is fired', async () => {
-      const collection = database.collection<WithId<SettledInstanceDocument>>('SettledInstance');
-      await collection.insertOne({
-        _id: 'template-CheckTests-c1',
-        instanceId: 'template-CheckTests-c1',
-        templateId: 'template-CheckTests',
-        correlationId: 'c1',
-        commandTrackers: [
-          {
-            commandType: 'CheckTests',
-            hasStarted: true,
-            hasCompleted: true,
-            events: [{ type: 'TestsPassed', correlationId: 'c1', data: {} }],
-          },
-        ],
-        status: 'fired',
-        firedCount: 2,
-      });
-
-      const result = await readModel.computeSettledStats('c1', 'template-CheckTests');
-
-      expect(result).toEqual({
-        status: 'success',
-        pendingCount: 0,
-        endedCount: 2,
-      });
-    });
-
-    it('should return status=error when fired instance has failed events', async () => {
-      const collection = database.collection<WithId<SettledInstanceDocument>>('SettledInstance');
-      await collection.insertOne({
-        _id: 'template-CheckTests-c1',
-        instanceId: 'template-CheckTests-c1',
-        templateId: 'template-CheckTests',
-        correlationId: 'c1',
-        commandTrackers: [
-          {
-            commandType: 'CheckTests',
-            hasStarted: true,
-            hasCompleted: true,
-            events: [{ type: 'TestsFailed', correlationId: 'c1', data: {} }],
-          },
-        ],
-        status: 'fired',
-        firedCount: 1,
-      });
-
-      const result = await readModel.computeSettledStats('c1', 'template-CheckTests');
-
-      expect(result).toEqual({
-        status: 'error',
-        pendingCount: 0,
-        endedCount: 1,
-      });
-    });
-
-    it('should return pendingCount=0 and endedCount when instance status is cleaned', async () => {
-      const collection = database.collection<WithId<SettledInstanceDocument>>('SettledInstance');
-      await collection.insertOne({
-        _id: 'template-CheckTests-c1',
-        instanceId: 'template-CheckTests-c1',
-        templateId: 'template-CheckTests',
-        correlationId: 'c1',
-        commandTrackers: [
-          {
-            commandType: 'CheckTests',
-            hasStarted: true,
-            hasCompleted: true,
-            events: [{ type: 'TestsPassed', correlationId: 'c1', data: {} }],
-          },
-        ],
-        status: 'cleaned',
-        firedCount: 3,
-      });
-
-      const result = await readModel.computeSettledStats('c1', 'template-CheckTests');
-
-      expect(result).toEqual({
-        status: 'success',
-        pendingCount: 0,
-        endedCount: 3,
-      });
-    });
-
-    it('should return pendingCount=0 when active instance has firedCount but all commands completed (BUG: settled showing running)', async () => {
-      const collection = database.collection<WithId<SettledInstanceDocument>>('SettledInstance');
-      await collection.insertOne({
-        _id: 'template-CheckTests,CheckTypes,CheckLint-c1',
-        instanceId: 'template-CheckTests,CheckTypes,CheckLint-c1',
-        templateId: 'template-CheckTests,CheckTypes,CheckLint',
-        correlationId: 'c1',
-        commandTrackers: [
-          {
-            commandType: 'CheckTests',
-            hasStarted: true,
-            hasCompleted: true,
-            events: [{ type: 'TestsPassed', correlationId: 'c1', data: {} }],
-          },
-          {
-            commandType: 'CheckTypes',
-            hasStarted: true,
-            hasCompleted: true,
-            events: [{ type: 'TypeCheckPassed', correlationId: 'c1', data: {} }],
-          },
-          {
-            commandType: 'CheckLint',
-            hasStarted: true,
-            hasCompleted: true,
-            events: [{ type: 'LintCheckPassed', correlationId: 'c1', data: {} }],
-          },
-        ],
-        status: 'active',
-        firedCount: 7,
-      });
-
-      const result = await readModel.computeSettledStats('c1', 'template-CheckTests,CheckTypes,CheckLint');
-
-      expect(result).toEqual({
-        status: 'success',
-        pendingCount: 0,
-        endedCount: 7,
-      });
-    });
-
-    it('should default endedCount to 0 when firedCount is undefined', async () => {
-      const collection = database.collection<WithId<SettledInstanceDocument>>('SettledInstance');
-      await collection.insertOne({
-        _id: 'template-CheckTests-c1',
-        instanceId: 'template-CheckTests-c1',
-        templateId: 'template-CheckTests',
-        correlationId: 'c1',
-        commandTrackers: [{ commandType: 'CheckTests', hasStarted: true, hasCompleted: false, events: [] }],
-        status: 'active',
-      } as SettledInstanceDocument);
-
-      const result = await readModel.computeSettledStats('c1', 'template-CheckTests');
-
-      expect(result).toEqual({
-        status: 'running',
-        pendingCount: 1,
-        endedCount: 0,
-      });
-    });
-
-    it('should return status=idle when fired instance has zero firedCount', async () => {
-      const collection = database.collection<WithId<SettledInstanceDocument>>('SettledInstance');
-      await collection.insertOne({
-        _id: 'template-CheckTests-c1',
-        instanceId: 'template-CheckTests-c1',
-        templateId: 'template-CheckTests',
-        correlationId: 'c1',
-        commandTrackers: [
-          {
-            commandType: 'CheckTests',
-            hasStarted: true,
-            hasCompleted: true,
-            events: [{ type: 'TestsPassed', correlationId: 'c1', data: {} }],
-          },
-        ],
-        status: 'fired',
-        firedCount: 0,
-      });
-
-      const result = await readModel.computeSettledStats('c1', 'template-CheckTests');
-
-      expect(result).toEqual({
-        status: 'idle',
-        pendingCount: 0,
-        endedCount: 0,
-      });
-    });
-  });
 });

package/src/store/pipeline-read-model.ts

@@ -5,8 +5,6 @@ import type { ItemStatusDocument } from '../projections/item-status-projection';
 import type { LatestRunDocument } from '../projections/latest-run-projection';
 import type { MessageLogDocument } from '../projections/message-log-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 type { StatsDocument } from '../projections/stats-projection';
 
 export interface CommandStats {
@@ -15,12 +13,6 @@ export interface CommandStats {
   aggregateStatus: NodeStatus;
 }
 
-export interface SettledStats {
-  status: NodeStatus;
-  pendingCount: number;
-  endedCount: number;
-}
-
 export interface MessageStats {
   totalMessages: number;
   totalCommands: number;
@@ -33,8 +25,6 @@ export class PipelineReadModel {
   private readonly messageLogCollection;
   private readonly statsCollection;
   private readonly latestRunCollection;
-  private readonly settledInstanceCollection;
-  private readonly phasedExecutionCollection;
   private readonly awaitTrackerCollection;
 
   constructor(database: InMemoryDatabase) {
@@ -43,8 +33,6 @@ export class PipelineReadModel {
     this.messageLogCollection = database.collection<MessageLogDocument>('MessageLog');
     this.statsCollection = database.collection<StatsDocument>('Stats');
     this.latestRunCollection = database.collection<LatestRunDocument>('LatestRun');
-    this.settledInstanceCollection = database.collection<SettledInstanceDocument>('SettledInstance');
-    this.phasedExecutionCollection = database.collection<PhasedExecutionDocument>('PhasedExecution');
     this.awaitTrackerCollection = database.collection<AwaitTrackerDocument>('AwaitTracker');
   }
 
@@ -152,32 +140,6 @@ export class PipelineReadModel {
     return docs[0].latestCorrelationId;
   }
 
-  async getSettledInstance(templateId: string, correlationId: string): Promise<SettledInstanceDocument | null> {
-    const instances = await this.settledInstanceCollection.find(
-      (doc) => doc.templateId === templateId && doc.correlationId === correlationId,
-    );
-    if (instances.length === 0) {
-      return null;
-    }
-    return instances[0];
-  }
-
-  async getActiveSettledInstances(correlationId: string): Promise<SettledInstanceDocument[]> {
-    return this.settledInstanceCollection.find((doc) => doc.correlationId === correlationId && doc.status === 'active');
-  }
-
-  async getPhasedExecution(executionId: string): Promise<PhasedExecutionDocument | null> {
-    const executions = await this.phasedExecutionCollection.find((doc) => doc.executionId === executionId);
-    if (executions.length === 0) {
-      return null;
-    }
-    return executions[0];
-  }
-
-  async getActivePhasedExecutions(correlationId: string): Promise<PhasedExecutionDocument[]> {
-    return this.phasedExecutionCollection.find((doc) => doc.correlationId === correlationId && doc.status === 'active');
-  }
-
   async getAwaitState(correlationId: string): Promise<AwaitTrackerDocument | null> {
     const docs = await this.awaitTrackerCollection.find(
       (doc) => doc.correlationId === correlationId && doc.status === 'pending',
@@ -187,37 +149,4 @@ export class PipelineReadModel {
     }
     return docs[0];
   }
-
-  async computeSettledStats(correlationId: string, templateId: string): Promise<SettledStats> {
-    const instance = await this.getSettledInstance(templateId, correlationId);
-
-    if (instance === null) {
-      return { status: 'idle', pendingCount: 0, endedCount: 0 };
-    }
-
-    const endedCount = instance.firedCount ?? 0;
-
-    if (instance.status === 'active') {
-      const hasFailure = this.hasFailedEvent(instance);
-      const hasFiredBefore = endedCount > 0;
-      const allCompleted = instance.commandTrackers.every((t) => t.hasCompleted);
-      const isPending = !allCompleted;
-      const status = hasFailure ? 'error' : hasFiredBefore ? 'success' : 'running';
-      return { status, pendingCount: isPending ? 1 : 0, endedCount };
-    }
-
-    const status = this.hasFailedEvent(instance) ? 'error' : endedCount > 0 ? 'success' : 'idle';
-    return { status, pendingCount: 0, endedCount };
-  }
-
-  private hasFailedEvent(instance: SettledInstanceDocument): boolean {
-    for (const tracker of instance.commandTrackers) {
-      for (const event of tracker.events) {
-        if (event.type.includes('Failed')) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
 }