@auto-engineer/job-graph-processor 1.12.1

package/src/retry-manager.specs.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createRetryManager } from './retry-manager';
+
+describe('createRetryManager', () => {
+  it('schedules retry with initial backoff on first failure', () => {
+    vi.useFakeTimers();
+    const onRetry = vi.fn();
+    const manager = createRetryManager(onRetry);
+
+    manager.recordFailure('job-a', { maxRetries: 3, backoffMs: 100, maxBackoffMs: 5000 });
+    vi.advanceTimersByTime(100);
+
+    expect(onRetry).toHaveBeenCalledWith('job-a', 1);
+    vi.useRealTimers();
+  });
+
+  it('uses exponential backoff on subsequent failures', () => {
+    vi.useFakeTimers();
+    const onRetry = vi.fn();
+    const manager = createRetryManager(onRetry);
+    const config = { maxRetries: 3, backoffMs: 100, maxBackoffMs: 5000 };
+
+    manager.recordFailure('job-a', config);
+    vi.advanceTimersByTime(100);
+    manager.recordFailure('job-a', config);
+    vi.advanceTimersByTime(199);
+    expect(onRetry).toHaveBeenCalledTimes(1);
+    vi.advanceTimersByTime(1);
+
+    expect(onRetry).toHaveBeenCalledTimes(2);
+    expect(onRetry).toHaveBeenLastCalledWith('job-a', 2);
+    vi.useRealTimers();
+  });
+
+  it('returns true when max retries exhausted', () => {
+    vi.useFakeTimers();
+    const onRetry = vi.fn();
+    const manager = createRetryManager(onRetry);
+    const config = { maxRetries: 1, backoffMs: 100, maxBackoffMs: 5000 };
+
+    manager.recordFailure('job-a', config);
+    vi.advanceTimersByTime(100);
+    const exhausted = manager.recordFailure('job-a', config);
+
+    expect(exhausted).toBe(true);
+    expect(onRetry).toHaveBeenCalledTimes(1);
+    vi.useRealTimers();
+  });
+
+  it('caps backoff at maxBackoffMs', () => {
+    vi.useFakeTimers();
+    const onRetry = vi.fn();
+    const manager = createRetryManager(onRetry);
+    const config = { maxRetries: 10, backoffMs: 1000, maxBackoffMs: 2000 };
+
+    manager.recordFailure('job-a', config);
+    vi.advanceTimersByTime(1000);
+    manager.recordFailure('job-a', config);
+    vi.advanceTimersByTime(2000);
+    manager.recordFailure('job-a', config);
+    vi.advanceTimersByTime(2000);
+
+    expect(onRetry).toHaveBeenCalledTimes(3);
+    vi.useRealTimers();
+  });
+});

package/src/retry-manager.ts

@@ -0,0 +1,29 @@
+export interface RetryConfig {
+  maxRetries: number;
+  backoffMs: number;
+  maxBackoffMs: number;
+}
+
+export interface RetryManager {
+  recordFailure(jobId: string, config: RetryConfig): boolean;
+}
+
+export function createRetryManager(onRetry: (jobId: string, attempt: number) => void): RetryManager {
+  const attempts = new Map<string, number>();
+
+  return {
+    recordFailure(jobId: string, config: RetryConfig): boolean {
+      const current = attempts.get(jobId) ?? 0;
+      const next = current + 1;
+
+      if (next > config.maxRetries) {
+        return true;
+      }
+
+      attempts.set(jobId, next);
+      const delay = Math.min(config.backoffMs * 2 ** (next - 1), config.maxBackoffMs);
+      setTimeout(() => onRetry(jobId, next), delay);
+      return false;
+    },
+  };
+}

package/src/timeout-manager.specs.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createTimeoutManager } from './timeout-manager';
+
+describe('createTimeoutManager', () => {
+  it('fires callback when timer expires', () => {
+    vi.useFakeTimers();
+    const onTimeout = vi.fn();
+    const manager = createTimeoutManager(onTimeout);
+
+    manager.start('job-a', 1000);
+    vi.advanceTimersByTime(1000);
+
+    expect(onTimeout).toHaveBeenCalledWith('job-a');
+    vi.useRealTimers();
+  });
+
+  it('does not fire callback before timeout', () => {
+    vi.useFakeTimers();
+    const onTimeout = vi.fn();
+    const manager = createTimeoutManager(onTimeout);
+
+    manager.start('job-a', 1000);
+    vi.advanceTimersByTime(999);
+
+    expect(onTimeout).not.toHaveBeenCalled();
+    vi.useRealTimers();
+  });
+
+  it('cancels timer and prevents callback', () => {
+    vi.useFakeTimers();
+    const onTimeout = vi.fn();
+    const manager = createTimeoutManager(onTimeout);
+
+    manager.start('job-a', 1000);
+    manager.clear('job-a');
+    vi.advanceTimersByTime(1000);
+
+    expect(onTimeout).not.toHaveBeenCalled();
+    vi.useRealTimers();
+  });
+
+  it('clearAll cancels all active timers', () => {
+    vi.useFakeTimers();
+    const onTimeout = vi.fn();
+    const manager = createTimeoutManager(onTimeout);
+
+    manager.start('job-a', 1000);
+    manager.start('job-b', 2000);
+    manager.clearAll();
+    vi.advanceTimersByTime(2000);
+
+    expect(onTimeout).not.toHaveBeenCalled();
+    vi.useRealTimers();
+  });
+});

package/src/timeout-manager.ts

@@ -0,0 +1,34 @@
+export interface TimeoutManager {
+  start(jobId: string, timeoutMs: number): void;
+  clear(jobId: string): void;
+  clearAll(): void;
+}
+
+export function createTimeoutManager(onTimeout: (jobId: string) => void): TimeoutManager {
+  const timers = new Map<string, ReturnType<typeof setTimeout>>();
+
+  return {
+    start(jobId: string, timeoutMs: number) {
+      timers.set(
+        jobId,
+        setTimeout(() => {
+          timers.delete(jobId);
+          onTimeout(jobId);
+        }, timeoutMs),
+      );
+    },
+    clear(jobId: string) {
+      const timer = timers.get(jobId);
+      if (timer !== undefined) {
+        clearTimeout(timer);
+        timers.delete(jobId);
+      }
+    },
+    clearAll() {
+      for (const timer of timers.values()) {
+        clearTimeout(timer);
+      }
+      timers.clear();
+    },
+  };
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "composite": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/vitest.config.ts

@@ -0,0 +1,22 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['src/**/*.specs.ts'],
+    passWithNoTests: true,
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      thresholds: {
+        lines: 100,
+        functions: 100,
+        branches: 100,
+        statements: 100,
+      },
+      include: ['src/**/*.ts'],
+      exclude: ['src/**/*.specs.ts', 'src/**/index.ts'],
+    },
+  },
+});