@auto-engineer/pipeline 0.14.0 → 0.16.0

package/src/runtime/settled-tracker.ts

@@ -1,4 +1,6 @@
 import type { Command, Event } from '@auto-engineer/message-bus';
+import type { SettledEvent, SettledInstanceDocument } from '../projections/settled-instance-projection';
+import type { PipelineReadModel } from '../store/pipeline-read-model';
 
 type SendFunction = (commandType: string, data: unknown) => void;
 
@@ -9,45 +11,36 @@ interface SettledHandlerRegistration {
   handler: SettledHandler;
 }
 
-interface CommandTracker {
-  commandType: string;
-  hasStarted: boolean;
-  hasCompleted: boolean;
-  events: Event[];
-}
-
 interface HandlerTemplate {
   id: string;
   registration: SettledHandlerRegistration;
 }
 
-interface HandlerInstance {
-  templateId: string;
-  correlationId: string;
-  registration: SettledHandlerRegistration;
-  commandTrackers: Map<string, CommandTracker>;
-}
-
 interface SettledErrorContext {
   commandTypes: readonly string[];
   correlationId: string;
 }
 
 interface SettledTrackerOptions {
+  readModel: PipelineReadModel;
   onDispatch?: (commandType: string, data: unknown, correlationId: string) => void;
   onError?: (error: unknown, context: SettledErrorContext) => void;
+  onEventEmit?: (event: SettledEvent) => void | Promise<void>;
 }
 
 export class SettledTracker {
   private handlerTemplates = new Map<string, HandlerTemplate>();
-  private handlerInstances = new Map<string, HandlerInstance>();
   private commandToTemplateIds = new Map<string, Set<string>>();
+  private readonly readModel: PipelineReadModel;
   private readonly onDispatch?: (commandType: string, data: unknown, correlationId: string) => void;
   private readonly onError?: (error: unknown, context: SettledErrorContext) => void;
+  private readonly onEventEmit?: (event: SettledEvent) => void | Promise<void>;
 
-  constructor(options?: SettledTrackerOptions) {
-    this.onDispatch = options?.onDispatch;
-    this.onError = options?.onError;
+  constructor(options: SettledTrackerOptions) {
+    this.readModel = options.readModel;
+    this.onDispatch = options.onDispatch;
+    this.onError = options.onError;
+    this.onEventEmit = options.onEventEmit;
   }
 
   registerHandler(registration: SettledHandlerRegistration): void {
@@ -65,15 +58,7 @@ export class SettledTracker {
     }
   }
 
-  getRegisteredHandlerCount(): number {
-    return this.handlerTemplates.size;
-  }
-
-  getActiveInstanceCount(): number {
-    return this.handlerInstances.size;
-  }
-
-  onCommandStarted(command: Command): void {
+  async onCommandStarted(command: Command): Promise<void> {
     const { type: commandType, correlationId, requestId } = command;
 
     if (!this.isValidId(correlationId) || !this.isValidId(requestId)) {
@@ -88,41 +73,49 @@ export class SettledTracker {
     for (const templateId of templateIds) {
       const template = this.handlerTemplates.get(templateId);
       if (template) {
-        this.ensureInstanceExists(template, correlationId);
-        this.markCommandStarted(template.id, correlationId, commandType);
+        await this.ensureInstanceExists(template, correlationId);
+        await this.markCommandStarted(template.id, correlationId, commandType);
       }
     }
   }
 
-  isWaitingFor(correlationId: string, commandType: string): boolean {
-    for (const instance of this.handlerInstances.values()) {
-      if (instance.correlationId === correlationId) {
-        const tracker = instance.commandTrackers.get(commandType);
-        if (tracker?.hasStarted === true && tracker.hasCompleted === false) {
-          return true;
-        }
+  async isWaitingForAsync(correlationId: string, commandType: string): Promise<boolean> {
+    const instances = await this.readModel.getActiveSettledInstances(correlationId);
+    for (const instance of instances) {
+      const tracker = instance.commandTrackers.find((t) => t.commandType === commandType);
+      if (tracker?.hasStarted === true && tracker.hasCompleted === false) {
+        return true;
       }
     }
     return false;
   }
 
-  onEventReceived(event: Event, sourceCommandType: string): void {
+  async onEventReceived(event: Event, sourceCommandType: string): Promise<void> {
     const correlationId = event.correlationId;
 
     if (!this.isValidId(correlationId)) {
       return;
     }
 
-    for (const [instanceId, instance] of this.handlerInstances) {
-      if (instance.correlationId !== correlationId) {
-        continue;
-      }
+    const instances = await this.readModel.getActiveSettledInstances(correlationId);
 
-      const tracker = instance.commandTrackers.get(sourceCommandType);
+    for (const instanceDoc of instances) {
+      const tracker = instanceDoc.commandTrackers.find((t) => t.commandType === sourceCommandType);
       if (tracker && !tracker.hasCompleted) {
-        tracker.events.push(event);
-        tracker.hasCompleted = true;
-        this.checkAndFireHandler(instanceId, instance);
+        await this.emitEvent({
+          type: 'SettledEventReceived',
+          data: {
+            templateId: instanceDoc.templateId,
+            correlationId,
+            commandType: sourceCommandType,
+            event,
+          },
+        });
+
+        const updatedInstance = await this.readModel.getSettledInstance(instanceDoc.templateId, correlationId);
+        if (updatedInstance) {
+          await this.checkAndFireHandler(updatedInstance);
+        }
       }
     }
   }
@@ -135,84 +128,97 @@ export class SettledTracker {
     return `template-${registration.commandTypes.join(',')}`;
   }
 
-  private generateInstanceId(templateId: string, correlationId: string): string {
-    return `${templateId}-${correlationId}`;
-  }
-
-  private ensureInstanceExists(template: HandlerTemplate, correlationId: string): void {
-    const instanceId = this.generateInstanceId(template.id, correlationId);
-
-    if (this.handlerInstances.has(instanceId)) {
-      return;
-    }
+  private async ensureInstanceExists(template: HandlerTemplate, correlationId: string): Promise<boolean> {
+    const existing = await this.readModel.getSettledInstance(template.id, correlationId);
+    const isActiveInstance = existing !== null && existing.status === 'active';
 
-    const commandTrackers = new Map<string, CommandTracker>();
-    for (const commandType of template.registration.commandTypes) {
-      commandTrackers.set(commandType, {
-        commandType,
-        hasStarted: false,
-        hasCompleted: false,
-        events: [],
-      });
+    if (isActiveInstance) {
+      return false;
     }
 
-    this.handlerInstances.set(instanceId, {
-      templateId: template.id,
-      correlationId,
-      registration: template.registration,
-      commandTrackers,
+    await this.emitEvent({
+      type: 'SettledInstanceCreated',
+      data: {
+        templateId: template.id,
+        correlationId,
+        commandTypes: template.registration.commandTypes,
+      },
     });
+
+    return true;
   }
 
-  private markCommandStarted(templateId: string, correlationId: string, commandType: string): void {
-    const instanceId = this.generateInstanceId(templateId, correlationId);
-    const instance = this.handlerInstances.get(instanceId);
+  private async markCommandStarted(templateId: string, correlationId: string, commandType: string): Promise<void> {
+    await this.emitEvent({
+      type: 'SettledCommandStarted',
+      data: {
+        templateId,
+        correlationId,
+        commandType,
+      },
+    });
+  }
 
-    const tracker = instance?.commandTrackers.get(commandType);
-    if (tracker) {
-      tracker.hasStarted = true;
-      tracker.hasCompleted = false;
-    }
+  private async emitEvent(event: SettledEvent): Promise<void> {
+    await this.onEventEmit?.(event);
   }
 
-  private checkAndFireHandler(instanceId: string, instance: HandlerInstance): void {
-    const allComplete = Array.from(instance.commandTrackers.values()).every(
-      (tracker) => tracker.hasStarted && tracker.hasCompleted,
-    );
+  private async checkAndFireHandler(instanceDoc: SettledInstanceDocument): Promise<void> {
+    const allComplete = instanceDoc.commandTrackers.every((tracker) => tracker.hasStarted && tracker.hasCompleted);
 
     if (!allComplete) {
       return;
     }
 
-    const eventsByCommandType = this.collectEvents(instance);
+    const template = this.handlerTemplates.get(instanceDoc.templateId)!;
+    const eventsByCommandType = this.collectEventsFromDoc(instanceDoc);
 
     try {
       const send: SendFunction = (commandType, data) => {
         if (this.onDispatch) {
-          this.onDispatch(commandType, data, instance.correlationId);
+          this.onDispatch(commandType, data, instanceDoc.correlationId);
         }
       };
 
-      const result = instance.registration.handler(eventsByCommandType, send);
+      const result = template.registration.handler(eventsByCommandType, send);
+      const persist = this.shouldPersist(result);
 
-      if (this.shouldPersist(result)) {
-        this.resetTrackers(instance);
-      } else {
-        this.handlerInstances.delete(instanceId);
-      }
+      await this.emitEvent({
+        type: 'SettledHandlerFired',
+        data: {
+          templateId: instanceDoc.templateId,
+          correlationId: instanceDoc.correlationId,
+          persist,
+        },
+      });
+
+      await this.emitEvent({
+        type: 'SettledInstanceReset',
+        data: {
+          templateId: instanceDoc.templateId,
+          correlationId: instanceDoc.correlationId,
+        },
+      });
     } catch (error) {
+      const commandTypes = instanceDoc.commandTrackers.map((t) => t.commandType);
       this.onError?.(error, {
-        commandTypes: instance.registration.commandTypes,
-        correlationId: instance.correlationId,
+        commandTypes,
+        correlationId: instanceDoc.correlationId,
+      });
+      await this.emitEvent({
+        type: 'SettledInstanceCleaned',
+        data: {
+          templateId: instanceDoc.templateId,
+          correlationId: instanceDoc.correlationId,
+        },
       });
-      this.handlerInstances.delete(instanceId);
     }
   }
 
-  private collectEvents(instance: HandlerInstance): Record<string, Event[]> {
+  private collectEventsFromDoc(instanceDoc: SettledInstanceDocument): Record<string, Event[]> {
     const events: Record<string, Event[]> = {};
-    for (const [commandType, tracker] of instance.commandTrackers) {
-      events[commandType] = [...tracker.events];
+    for (const tracker of instanceDoc.commandTrackers) {
+      events[tracker.commandType] = [...tracker.events];
     }
     return events;
   }
@@ -226,12 +232,4 @@ export class SettledTracker {
       result.persist === true
     );
   }
-
-  private resetTrackers(instance: HandlerInstance): void {
-    for (const tracker of instance.commandTrackers.values()) {
-      tracker.hasStarted = false;
-      tracker.hasCompleted = false;
-      tracker.events = [];
-    }
-  }
 }

package/src/server/pipeline-server.e2e.specs.ts

@@ -20,11 +20,16 @@ interface PipelineNode {
   status?: string;
 }
 
+interface GraphNode {
+  id: string;
+  type: string;
+  label: string;
+}
+
 interface PipelineResponse {
-  nodes: PipelineNode[];
+  nodes: GraphNode[];
   edges: Array<{ from: string; to: string }>;
-  commandToEvents: Record<string, string[]>;
-  eventToCommand: Record<string, string>;
+  pipelineNodes: PipelineNode[];
 }
 
 interface CommandAck {
@@ -97,20 +102,9 @@ describe('PipelineServer E2E', () => {
 
       const pipelineRes = await fetchJson<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
 
-      expect(pipelineRes.commandToEvents).toEqual({ ExportSchema: ['SchemaExported'] });
-      expect(pipelineRes.eventToCommand).toEqual({ SchemaExported: 'GenerateServer' });
-      expect(pipelineRes.nodes.some((n) => n.id === 'ExportSchema')).toBe(true);
       expect(pipelineRes.nodes.some((n) => n.id === 'evt:SchemaExported')).toBe(true);
-
-      await server.stop();
-    });
-
-    it('should return sessions array', async () => {
-      const server = new PipelineServer({ port: 0 });
-      await server.start();
-
-      const sessions = await fetchJson<unknown[]>(`http://localhost:${server.port}/sessions`);
-      expect(Array.isArray(sessions)).toBe(true);
+      expect(pipelineRes.nodes.some((n) => n.id === 'cmd:GenerateServer')).toBe(true);
+      expect(pipelineRes.pipelineNodes.some((n) => n.id === 'ExportSchema')).toBe(true);
 
       await server.stop();
     });