@auto-engineer/pipeline 1.128.2 → 1.129.0

package/ketchup-plan.md

@@ -0,0 +1,10 @@
+# Ketchup Plan: Fix Pipeline Diagram Wrong Status for Retried Commands
+
+## TODO
+
+## DONE
+
+- [x] Burst 1: Fix `addStatusToCommandNode` to use `nodeStatus.status` when no extractor exists and pendingCount is 0 [depends: none] (cf3f1034)
+- [x] Burst 2: Add `autoRegisterItemKeyExtractor` and call from `registerCommandHandlers` [depends: Burst 1] (0bd4e2a7)
+- [x] Burst 3: Covered by Bursts 1+2 tests [depends: Burst 2]
+- [x] Burst 4: Test manual extractor takes precedence over auto-derived [depends: Burst 2]

package/package.json

@@ -15,8 +15,8 @@
     "jose": "^5.9.6",
     "nanoid": "^5.0.0",
     "uuid": "^11.0.0",
-    "@auto-engineer/file-store": "1.128.2",
-    "@auto-engineer/message-bus": "1.128.2"
+    "@auto-engineer/file-store": "1.129.0",
+    "@auto-engineer/message-bus": "1.129.0"
   },
   "devDependencies": {
     "@types/cors": "^2.8.17",
@@ -25,7 +25,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.128.2",
+  "version": "1.129.0",
   "scripts": {
     "build": "tsc && tsx ../../scripts/fix-esm-imports.ts",
     "test": "vitest run --reporter=dot",

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

@@ -2049,7 +2049,7 @@ describe('PipelineServer', () => {
       await server.stop();
     });
 
-    it('documents behavior: status remains error after retry without itemKey extractor (fix: register extractor)', async () => {
+    it('should show success status after retry succeeds even without itemKey extractor', async () => {
       let callCount = 0;
       const handler = {
         name: 'RetryNoExtractor',
@@ -2076,7 +2076,16 @@ describe('PipelineServer', () => {
       await new Promise((r) => setTimeout(r, 50));
 
       const afterFailure = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
-      expect(afterFailure.nodes.find((n) => n.id === 'cmd:RetryNoExtractor')?.status).toBe('error');
+      const failNode = afterFailure.nodes.find((n) => n.id === 'cmd:RetryNoExtractor');
+      expect(failNode).toEqual({
+        id: 'cmd:RetryNoExtractor',
+        type: 'command',
+        label: 'RetryNoExtractor',
+        status: 'error',
+        pendingCount: 0,
+        endedCount: 1,
+        lastDurationMs: expect.any(Number),
+      });
 
       await fetch(`http://localhost:${server.port}/command`, {
         method: 'POST',
@@ -2086,9 +2095,173 @@ describe('PipelineServer', () => {
       await new Promise((r) => setTimeout(r, 50));
 
       const afterRetry = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
-      const node = afterRetry.nodes.find((n) => n.id === 'cmd:RetryNoExtractor');
-      expect(node?.status).toBe('error');
-      expect(node?.endedCount).toBe(2);
+      const retryNode = afterRetry.nodes.find((n) => n.id === 'cmd:RetryNoExtractor');
+      expect(retryNode).toEqual({
+        id: 'cmd:RetryNoExtractor',
+        type: 'command',
+        label: 'RetryNoExtractor',
+        status: 'success',
+        pendingCount: 0,
+        endedCount: 2,
+        lastDurationMs: expect.any(Number),
+      });
+
+      await server.stop();
+    });
+
+    it('should show running status via nodeStatus fallback when command is in-flight without extractor', async () => {
+      let resolveHandler: () => void = () => {};
+      const handlerPromise = new Promise<void>((resolve) => {
+        resolveHandler = resolve;
+      });
+      const handler = {
+        name: 'SlowNoExtractor',
+        events: ['SlowNoExtractorDone'],
+        handle: async () => {
+          await handlerPromise;
+          return { type: 'SlowNoExtractorDone', data: {} };
+        },
+      };
+      const pipeline = define('test').on('Trigger').emit('SlowNoExtractor', {}).build();
+      const server = new PipelineServer({ port: 0 });
+      server.registerCommandHandlers([handler]);
+      server.registerPipeline(pipeline);
+      await server.start();
+
+      await fetch(`http://localhost:${server.port}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ type: 'SlowNoExtractor', data: {} }),
+      });
+
+      await new Promise((r) => setTimeout(r, 50));
+
+      const data = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
+      const cmdNode = data.nodes.find((n) => n.id === 'cmd:SlowNoExtractor');
+      expect(cmdNode).toEqual({
+        id: 'cmd:SlowNoExtractor',
+        type: 'command',
+        label: 'SlowNoExtractor',
+        status: 'running',
+        pendingCount: 1,
+        endedCount: 0,
+      });
+
+      resolveHandler();
+      await server.stop();
+    });
+  });
+
+  describe('auto-derived item key extractors', () => {
+    it('should deduplicate retried items via auto-derived extractor showing success after retry', async () => {
+      let callCount = 0;
+      const handler = {
+        name: 'AutoKeyCmd',
+        events: ['AutoKeyDone', 'AutoKeyFailed'],
+        fields: {
+          targetDirectory: { type: 'string', required: true },
+        },
+        handle: async () => {
+          callCount++;
+          if (callCount === 1) {
+            return { type: 'AutoKeyFailed', data: {} };
+          }
+          return { type: 'AutoKeyDone', data: {} };
+        },
+      };
+      const pipeline = define('test').on('Trigger').emit('AutoKeyCmd', {}).build();
+      const server = new PipelineServer({ port: 0 });
+      server.registerCommandHandlers([handler]);
+      server.registerPipeline(pipeline);
+      await server.start();
+
+      await fetch(`http://localhost:${server.port}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ type: 'AutoKeyCmd', data: { targetDirectory: '/slice1' } }),
+      });
+      await new Promise((r) => setTimeout(r, 50));
+
+      await fetch(`http://localhost:${server.port}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ type: 'AutoKeyCmd', data: { targetDirectory: '/slice1' } }),
+      });
+      await new Promise((r) => setTimeout(r, 50));
+
+      const data = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
+      const node = data.nodes.find((n) => n.id === 'cmd:AutoKeyCmd');
+      expect(node).toEqual({
+        id: 'cmd:AutoKeyCmd',
+        type: 'command',
+        label: 'AutoKeyCmd',
+        status: 'success',
+        pendingCount: 0,
+        endedCount: 1,
+        lastDurationMs: expect.any(Number),
+      });
+
+      await server.stop();
+    });
+
+    it('should preserve manual extractor when handler also has fields', async () => {
+      let callCount = 0;
+      const handler = {
+        name: 'ManualKeyCmd',
+        events: ['ManualKeyDone', 'ManualKeyFailed'],
+        fields: {
+          targetDirectory: { type: 'string', required: true },
+          customId: { type: 'string', required: false },
+        },
+        handle: async () => {
+          callCount++;
+          if (callCount === 1) {
+            return { type: 'ManualKeyFailed', data: {} };
+          }
+          return { type: 'ManualKeyDone', data: {} };
+        },
+      };
+      const pipeline = define('test').on('Trigger').emit('ManualKeyCmd', {}).build();
+      const server = new PipelineServer({ port: 0 });
+      server.registerItemKeyExtractor('ManualKeyCmd', (d) => {
+        const data = d as Record<string, string>;
+        return data['customId'];
+      });
+      server.registerCommandHandlers([handler]);
+      server.registerPipeline(pipeline);
+      await server.start();
+
+      await fetch(`http://localhost:${server.port}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          type: 'ManualKeyCmd',
+          data: { targetDirectory: '/a', customId: 'my-key' },
+        }),
+      });
+      await new Promise((r) => setTimeout(r, 50));
+
+      await fetch(`http://localhost:${server.port}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          type: 'ManualKeyCmd',
+          data: { targetDirectory: '/b', customId: 'my-key' },
+        }),
+      });
+      await new Promise((r) => setTimeout(r, 50));
+
+      const data = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
+      const node = data.nodes.find((n) => n.id === 'cmd:ManualKeyCmd');
+      expect(node).toEqual({
+        id: 'cmd:ManualKeyCmd',
+        type: 'command',
+        label: 'ManualKeyCmd',
+        status: 'success',
+        pendingCount: 0,
+        endedCount: 1,
+        lastDurationMs: expect.any(Number),
+      });
 
       await server.stop();
     });

package/src/server/pipeline-server.ts

@@ -131,9 +131,31 @@ export class PipelineServer {
       this.commandHandlers.set(handler.name, handler);
       this.messageBus.registerCommandHandler(handler);
       this.eventCommandMapper.addHandler(handler);
+      this.autoRegisterItemKeyExtractor(handler);
     }
   }
 
+  private autoRegisterItemKeyExtractor(handler: CommandHandlerWithMetadata): void {
+    if (this.itemKeyExtractors.has(handler.name)) return;
+    if (!handler.fields) return;
+    const requiredFieldNames: string[] = [];
+    for (const [name, def] of Object.entries(handler.fields)) {
+      if (typeof def !== 'object' || def === null) continue;
+      if (!('required' in def)) continue;
+      if (def.required !== true) continue;
+      requiredFieldNames.push(name);
+    }
+    if (requiredFieldNames.length === 0) return;
+    const fieldSet = new Set(requiredFieldNames);
+    this.registerItemKeyExtractor(handler.name, (data: unknown) => {
+      if (typeof data !== 'object' || data === null) return undefined;
+      for (const [key, value] of Object.entries(data)) {
+        if (fieldSet.has(key) && typeof value === 'string') return value;
+      }
+      return undefined;
+    });
+  }
+
   getRegisteredCommands(): string[] {
     return Array.from(this.commandHandlers.keys());
   }
@@ -598,9 +620,19 @@ export class PipelineServer {
     }
     const stats = await this.computeCommandStats(correlationId, commandName);
     const nodeStatus = await this.eventStoreContext.readModel.getNodeStatus(correlationId, commandName);
+
+    let status: NodeStatus;
+    if (stats.pendingCount > 0) {
+      status = 'running';
+    } else if (!this.itemKeyExtractors.has(commandName) && nodeStatus !== null) {
+      status = nodeStatus.status;
+    } else {
+      status = stats.aggregateStatus;
+    }
+
     return {
       ...node,
-      status: stats.aggregateStatus,
+      status,
       pendingCount: stats.pendingCount,
       endedCount: stats.endedCount,
       lastDurationMs: nodeStatus?.lastDurationMs,