@auto-engineer/job-graph-processor 1.28.0 → 1.30.0

package/src/commands/process-job-graph.ts

@@ -1,12 +1,13 @@
 import type { Command, Event, MessageBus } from '@auto-engineer/message-bus';
 import type { FailurePolicy } from '../evolve';
-import type { DispatchFn } from '../graph-processor';
+import type { DispatchFn, PublishEventFn } from '../graph-processor';
 import { createGraphProcessor, type ProcessGraphCommand } from '../graph-processor';
 import type { Job } from '../graph-validator';
 
 interface ContextWithMessageBus {
   messageBus: MessageBus;
   sendCommand?: (type: string, data: unknown, correlationId?: string) => Promise<void>;
+  emit?: (type: string, data: unknown) => Promise<void>;
 }
 
 function isContextWithMessageBus(context: unknown): context is ContextWithMessageBus {
@@ -27,6 +28,15 @@ function buildDispatch(context: ContextWithMessageBus): DispatchFn | undefined {
   return (cmd) => ctxSendCommand(cmd.type, cmd.data, cmd.correlationId);
 }
 
+function buildPublishEvent(context: ContextWithMessageBus): PublishEventFn | undefined {
+  if (typeof context.emit !== 'function') return undefined;
+  const ctxEmit = context.emit;
+  return (event) => {
+    context.messageBus.publishEvent(event);
+    ctxEmit(event.type, event.data);
+  };
+}
+
 function toProcessGraphCommand(command: Command): ProcessGraphCommand {
   const data = command.data as { graphId: string; jobs: Job[]; failurePolicy: FailurePolicy };
   return { type: command.type, data };
@@ -60,6 +70,7 @@ export const commandHandler = {
     { name: 'GraphDispatched', displayName: 'Graph Dispatched' },
     { name: 'GraphFailed', displayName: 'Graph Failed' },
     { name: 'GraphProcessed', displayName: 'Graph Processed' },
+    { name: 'GraphProcessingFailed', displayName: 'Graph Processing Failed' },
   ],
   handle: async (command: Command, context?: unknown): Promise<Event | Event[]> => {
     const { graphId } = command.data;
@@ -72,7 +83,11 @@ export const commandHandler = {
     }
 
     const dispatch = buildDispatch(context);
-    const processor = createGraphProcessor(context.messageBus, dispatch ? { dispatch } : undefined);
+    const publishEvent = buildPublishEvent(context);
+    const processor = createGraphProcessor(context.messageBus, {
+      ...(dispatch !== undefined && { dispatch }),
+      ...(publishEvent !== undefined && { publishEvent }),
+    });
     return processor.submit(toProcessGraphCommand(command));
   },
 };

package/src/evolve.specs.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { evolve, getReadyJobs, getTransitiveDependents, initialState, isGraphComplete } from './evolve';
+import { evolve, getReadyJobs, getTransitiveDependents, hasFailedJobs, initialState, isGraphComplete } from './evolve';
 
 describe('evolve', () => {
   it('ignores job events before graph submission', () => {
@@ -233,3 +233,75 @@ describe('isGraphComplete', () => {
     expect(isGraphComplete(state)).toBe(true);
   });
 });
+
+describe('hasFailedJobs', () => {
+  it('returns false before graph submission', () => {
+    expect(hasFailedJobs(initialState())).toBe(false);
+  });
+
+  it('returns false when all jobs succeeded', () => {
+    let state = evolve(initialState(), {
+      type: 'GraphSubmitted',
+      data: {
+        graphId: 'g1',
+        jobs: [{ id: 'a', dependsOn: [], target: 'build', payload: {} }],
+        failurePolicy: 'halt',
+      },
+    });
+    state = evolve(state, {
+      type: 'JobDispatched',
+      data: { jobId: 'a', target: 'build', correlationId: 'graph:g1:a' },
+    });
+    state = evolve(state, { type: 'JobSucceeded', data: { jobId: 'a' } });
+
+    expect(hasFailedJobs(state)).toBe(false);
+  });
+
+  it('returns true when a job failed', () => {
+    let state = evolve(initialState(), {
+      type: 'GraphSubmitted',
+      data: {
+        graphId: 'g1',
+        jobs: [{ id: 'a', dependsOn: [], target: 'build', payload: {} }],
+        failurePolicy: 'halt',
+      },
+    });
+    state = evolve(state, {
+      type: 'JobDispatched',
+      data: { jobId: 'a', target: 'build', correlationId: 'graph:g1:a' },
+    });
+    state = evolve(state, { type: 'JobFailed', data: { jobId: 'a', error: 'build error' } });
+
+    expect(hasFailedJobs(state)).toBe(true);
+  });
+
+  it('returns true when a job was skipped', () => {
+    let state = evolve(initialState(), {
+      type: 'GraphSubmitted',
+      data: {
+        graphId: 'g1',
+        jobs: [{ id: 'a', dependsOn: [], target: 'build', payload: {} }],
+        failurePolicy: 'halt',
+      },
+    });
+    state = evolve(state, { type: 'JobSkipped', data: { jobId: 'a', reason: 'dependency failed' } });
+
+    expect(hasFailedJobs(state)).toBe(true);
+  });
+
+  it('returns false when jobs are still pending', () => {
+    const state = evolve(initialState(), {
+      type: 'GraphSubmitted',
+      data: {
+        graphId: 'g1',
+        jobs: [
+          { id: 'a', dependsOn: [], target: 'build', payload: {} },
+          { id: 'b', dependsOn: ['a'], target: 'test', payload: {} },
+        ],
+        failurePolicy: 'halt',
+      },
+    });
+
+    expect(hasFailedJobs(state)).toBe(false);
+  });
+});

package/src/evolve.ts

@@ -85,6 +85,16 @@ export function isGraphComplete(state: GraphState): boolean {
   return true;
 }
 
+const FAILED_STATUSES: ReadonlySet<JobStatus> = new Set(['failed', 'skipped', 'timed-out']);
+
+export function hasFailedJobs(state: GraphState): boolean {
+  if (state.status !== 'processing') return false;
+  for (const job of state.jobs.values()) {
+    if (FAILED_STATUSES.has(job.status)) return true;
+  }
+  return false;
+}
+
 export function getTransitiveDependents(state: GraphState, jobId: string): string[] {
   if (state.status !== 'processing') return [];
   const dependents: Set<string> = new Set();

package/src/graph-processor.specs.ts

@@ -297,14 +297,56 @@ describe('createGraphProcessor', () => {
     });
   });
 
-  it('applies halt policy when job fails via correlation', async () => {
+  it('uses custom publishEvent instead of messageBus.publishEvent when provided', async () => {
+    const bus = createMessageBus();
+    const published: Array<{ type: string; data: Record<string, unknown> }> = [];
+    const busPublished: Array<{ type: string; data: Record<string, unknown> }> = [];
+    bus.subscribeToEvent('GraphProcessed', {
+      name: 'busTracker',
+      handle: (event) => {
+        busPublished.push(event);
+      },
+    });
+    const processor = createGraphProcessor(bus, {
+      publishEvent: (event) => {
+        published.push(event as { type: string; data: Record<string, unknown> });
+      },
+    });
+
+    processor.submit({
+      type: 'ProcessGraph',
+      data: {
+        graphId: 'g1',
+        jobs: [{ id: 'a', dependsOn: [], target: 'build', payload: {} }],
+        failurePolicy: 'halt',
+      },
+    });
+
+    await bus.publishEvent({
+      type: 'BuildCompleted',
+      data: { output: 'ok' },
+      correlationId: 'graph:g1:a',
+    });
+
+    expect(published).toEqual([{ type: 'GraphProcessed', data: { graphId: 'g1' } }]);
+    expect(busPublished).toEqual([]);
+  });
+
+  it('publishes GraphProcessingFailed when a job fails via correlation', async () => {
     const bus = createMessageBus();
     const processor = createGraphProcessor(bus);
-    const completed: Array<{ type: string; data: Record<string, unknown> }> = [];
+    const failed: Array<{ type: string; data: Record<string, unknown> }> = [];
+    const succeeded: Array<{ type: string; data: Record<string, unknown> }> = [];
+    bus.subscribeToEvent('GraphProcessingFailed', {
+      name: 'failureTracker',
+      handle: (event) => {
+        failed.push(event);
+      },
+    });
     bus.subscribeToEvent('GraphProcessed', {
-      name: 'completionTracker',
+      name: 'successTracker',
       handle: (event) => {
-        completed.push(event);
+        succeeded.push(event);
       },
     });
 
@@ -326,6 +368,7 @@ describe('createGraphProcessor', () => {
       correlationId: 'graph:g1:a',
     });
 
-    expect(completed).toEqual([{ type: 'GraphProcessed', data: { graphId: 'g1' } }]);
+    expect(failed).toEqual([{ type: 'GraphProcessingFailed', data: { graphId: 'g1' } }]);
+    expect(succeeded).toEqual([]);
   });
 });

package/src/graph-processor.ts

@@ -1,7 +1,7 @@
 import type { Event, MessageBus } from '@auto-engineer/message-bus';
 import { applyPolicy } from './apply-policy';
 import type { FailurePolicy, GraphState } from './evolve';
-import { evolve, getReadyJobs, initialState, isGraphComplete } from './evolve';
+import { evolve, getReadyJobs, hasFailedJobs, initialState, isGraphComplete } from './evolve';
 import type { Job } from './graph-validator';
 import { validateGraph } from './graph-validator';
 import { classifyJobEvent } from './handle-job-event';
@@ -24,7 +24,12 @@ interface DispatchedJob {
 
 export type DispatchFn = (command: { type: string; data: unknown; correlationId: string }) => Promise<void>;
 
-export function createGraphProcessor(messageBus: MessageBus, options?: { dispatch?: DispatchFn }) {
+export type PublishEventFn = (event: Event) => void;
+
+export function createGraphProcessor(
+  messageBus: MessageBus,
+  options?: { dispatch?: DispatchFn; publishEvent?: PublishEventFn },
+) {
   const dispatch: DispatchFn =
     options?.dispatch ??
     ((cmd) =>
@@ -33,6 +38,7 @@ export function createGraphProcessor(messageBus: MessageBus, options?: { dispatc
         data: cmd.data as Record<string, unknown>,
         correlationId: cmd.correlationId,
       }));
+  const publishEvent: PublishEventFn = options?.publishEvent ?? ((event) => messageBus.publishEvent(event));
   const graphs = new Map<string, { state: GraphState; jobById: Record<string, Job> }>();
 
   function submit(command: ProcessGraphCommand): Event {
@@ -113,7 +119,8 @@ export function createGraphProcessor(messageBus: MessageBus, options?: { dispatc
 
     if (isGraphComplete(state)) {
       graphs.delete(graphId);
-      messageBus.publishEvent({ type: 'GraphProcessed', data: { graphId } });
+      const eventType = hasFailedJobs(state) ? 'GraphProcessingFailed' : 'GraphProcessed';
+      publishEvent({ type: eventType, data: { graphId } });
     }
   }
 

package/src/index.ts

@@ -5,7 +5,7 @@ export const COMMANDS = [processJobGraphHandler];
 export { applyPolicy } from './apply-policy';
 export type { FailurePolicy, GraphState, JobGraphEvent, JobStatus } from './evolve';
 
-export { evolve, getReadyJobs, getTransitiveDependents, initialState, isGraphComplete } from './evolve';
+export { evolve, getReadyJobs, getTransitiveDependents, hasFailedJobs, initialState, isGraphComplete } from './evolve';
 export { createGraphProcessor } from './graph-processor';
 export type { Job } from './graph-validator';
 export { validateGraph } from './graph-validator';

package/src/pipeline-e2e.specs.ts

@@ -0,0 +1,157 @@
+import type { Command, Event } from '@auto-engineer/message-bus';
+import type { CommandHandlerWithMetadata } from '@auto-engineer/pipeline';
+import { define, PipelineServer } from '@auto-engineer/pipeline';
+import { describe, expect, it } from 'vitest';
+import { commandHandler as processJobGraphHandler } from './commands/process-job-graph';
+
+interface StoredMessage {
+  message: { type: string; data?: Record<string, unknown> };
+  messageType: string;
+}
+
+async function fetchJson<T>(url: string, options?: RequestInit): Promise<T> {
+  const res = await fetch(url, options);
+  return res.json() as Promise<T>;
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+describe('Job Graph Pipeline E2E', () => {
+  it('routes GraphProcessed through pipeline to trigger downstream command', async () => {
+    const implementCalls: Command[] = [];
+
+    const mockJobHandler: CommandHandlerWithMetadata = {
+      name: 'MockJob',
+      events: ['MockJobCompleted'],
+      handle: async () => ({ type: 'MockJobCompleted', data: { result: 'ok' } }),
+    };
+
+    const implementHandler: CommandHandlerWithMetadata = {
+      name: 'ImplementReactApp',
+      events: ['ReactAppImplemented'],
+      handle: async (cmd: Command) => {
+        implementCalls.push(cmd);
+        return { type: 'ReactAppImplemented', data: { clientDir: cmd.data.clientDir } };
+      },
+    };
+
+    const pipeline = define('job-graph-e2e')
+      .on('JobGraphReady')
+      .emit('ProcessJobGraph', (e: Event) => ({
+        graphId: e.data.graphId,
+        jobs: e.data.jobs,
+        failurePolicy: e.data.failurePolicy,
+      }))
+      .on('GraphProcessed')
+      .emit('ImplementReactApp', { clientDir: './client' })
+      .build();
+
+    const server = new PipelineServer({ port: 0 });
+    server.registerCommandHandlers([
+      processJobGraphHandler as CommandHandlerWithMetadata,
+      mockJobHandler,
+      implementHandler,
+    ]);
+    server.registerPipeline(pipeline);
+    await server.start();
+
+    const triggerEvent: Event = {
+      type: 'JobGraphReady',
+      data: {
+        graphId: 'e2e-happy',
+        jobs: [
+          { id: 'a', dependsOn: [], target: 'MockJob', payload: {} },
+          { id: 'b', dependsOn: ['a'], target: 'MockJob', payload: {} },
+        ],
+        failurePolicy: 'halt',
+      },
+    };
+
+    await server.getMessageBus().publishEvent(triggerEvent);
+    await server.emitPipelineStartedEvent();
+
+    await fetchJson(`http://localhost:${server.port}/command`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ type: 'ProcessJobGraph', data: triggerEvent.data }),
+    });
+
+    await delay(500);
+
+    const messages = await fetchJson<StoredMessage[]>(`http://localhost:${server.port}/messages`);
+    const eventTypes = messages.filter((m) => m.messageType === 'event').map((m) => m.message.type);
+
+    expect(eventTypes).toContain('GraphDispatched');
+    expect(eventTypes).toContain('GraphProcessed');
+    expect(eventTypes).toContain('ReactAppImplemented');
+    expect(implementCalls.length).toBeGreaterThanOrEqual(1);
+
+    await server.stop();
+  });
+
+  it('routes GraphProcessingFailed and does NOT trigger downstream success handler', async () => {
+    const implementCalls: Command[] = [];
+
+    const failingJobHandler: CommandHandlerWithMetadata = {
+      name: 'FailingJob',
+      events: ['FailingJobFailed'],
+      handle: async () => ({
+        type: 'FailingJobFailed',
+        data: { error: 'build failed' },
+      }),
+    };
+
+    const implementHandler: CommandHandlerWithMetadata = {
+      name: 'ImplementReactApp',
+      events: ['ReactAppImplemented'],
+      handle: async (cmd: Command) => {
+        implementCalls.push(cmd);
+        return { type: 'ReactAppImplemented', data: { clientDir: cmd.data.clientDir } };
+      },
+    };
+
+    const pipeline = define('job-graph-fail-e2e')
+      .on('GraphProcessed')
+      .emit('ImplementReactApp', { clientDir: './client' })
+      .build();
+
+    const server = new PipelineServer({ port: 0 });
+    server.registerCommandHandlers([
+      processJobGraphHandler as CommandHandlerWithMetadata,
+      failingJobHandler,
+      implementHandler,
+    ]);
+    server.registerPipeline(pipeline);
+    await server.start();
+
+    await fetchJson(`http://localhost:${server.port}/command`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        type: 'ProcessJobGraph',
+        data: {
+          graphId: 'e2e-fail',
+          jobs: [
+            { id: 'a', dependsOn: [], target: 'FailingJob', payload: {} },
+            { id: 'b', dependsOn: ['a'], target: 'FailingJob', payload: {} },
+          ],
+          failurePolicy: 'halt',
+        },
+      }),
+    });
+
+    await delay(500);
+
+    const messages = await fetchJson<StoredMessage[]>(`http://localhost:${server.port}/messages`);
+    const eventTypes = messages.filter((m) => m.messageType === 'event').map((m) => m.message.type);
+
+    expect(eventTypes).toContain('GraphDispatched');
+    expect(eventTypes).toContain('GraphProcessingFailed');
+    expect(eventTypes).not.toContain('GraphProcessed');
+    expect(implementCalls).toEqual([]);
+
+    await server.stop();
+  });
+});