@genfeedai/workflow-engine 0.2.0

package/dist/workflow-engine/src/execution/resume-handler.js

@@ -0,0 +1,102 @@
+import { planPartialExecution, } from '@workflow-engine/execution/partial-execution';
+export function analyzeForResume(previousRun, nodes, edges) {
+    if (previousRun.status !== 'failed') {
+        return {
+            canResume: false,
+            completedNodeIds: [],
+            executionPlan: null,
+            nodesToReExecute: [],
+            previousOutputs: new Map(),
+            reason: `Cannot resume: run status is ${previousRun.status}, expected 'failed'`,
+            resumeFromNodeId: null,
+        };
+    }
+    if (!previousRun.failedNodeId) {
+        return {
+            canResume: false,
+            completedNodeIds: [],
+            executionPlan: null,
+            nodesToReExecute: [],
+            previousOutputs: new Map(),
+            reason: 'Cannot resume: no failed node ID recorded',
+            resumeFromNodeId: null,
+        };
+    }
+    const failedNode = nodes.find((n) => n.id === previousRun.failedNodeId);
+    if (!failedNode) {
+        return {
+            canResume: false,
+            completedNodeIds: [],
+            executionPlan: null,
+            nodesToReExecute: [],
+            previousOutputs: new Map(),
+            reason: `Cannot resume: failed node ${previousRun.failedNodeId} no longer exists in workflow`,
+            resumeFromNodeId: null,
+        };
+    }
+    const completedNodeIds = [];
+    const previousOutputs = new Map();
+    for (const result of previousRun.nodeResults) {
+        if (result.status === 'completed' && result.output !== undefined) {
+            completedNodeIds.push(result.nodeId);
+            previousOutputs.set(result.nodeId, result.output);
+        }
+    }
+    const nodesToReExecute = findNodesToReExecute(previousRun.failedNodeId, nodes, edges);
+    const executionPlan = planPartialExecution(nodesToReExecute, nodes, edges, previousOutputs);
+    return {
+        canResume: executionPlan.isValid,
+        completedNodeIds,
+        executionPlan,
+        nodesToReExecute,
+        previousOutputs,
+        reason: executionPlan.isValid ? undefined : executionPlan.errors.join('; '),
+        resumeFromNodeId: previousRun.failedNodeId,
+    };
+}
+function findNodesToReExecute(failedNodeId, nodes, edges) {
+    const result = new Set();
+    result.add(failedNodeId);
+    const forwardEdges = new Map();
+    for (const node of nodes) {
+        forwardEdges.set(node.id, []);
+    }
+    for (const edge of edges) {
+        const targets = forwardEdges.get(edge.source) ?? [];
+        targets.push(edge.target);
+        forwardEdges.set(edge.source, targets);
+    }
+    const queue = [failedNodeId];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current) {
+            continue;
+        }
+        for (const downstream of forwardEdges.get(current) ?? []) {
+            if (!result.has(downstream)) {
+                result.add(downstream);
+                queue.push(downstream);
+            }
+        }
+    }
+    return Array.from(result);
+}
+export function createCacheFromRun(previousRun) {
+    const cache = new Map();
+    for (const result of previousRun.nodeResults) {
+        if (result.status === 'completed' && result.output !== undefined) {
+            cache.set(result.nodeId, result.output);
+        }
+    }
+    return cache;
+}
+export function mergeExecutionResults(previousRun, currentResults) {
+    const resultMap = new Map();
+    for (const result of previousRun.nodeResults) {
+        resultMap.set(result.nodeId, result);
+    }
+    for (const result of currentResults) {
+        resultMap.set(result.nodeId, result);
+    }
+    return Array.from(resultMap.values());
+}

package/dist/workflow-engine/src/execution/resume-handler.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=resume-handler.spec.d.ts.map

package/dist/workflow-engine/src/execution/resume-handler.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resume-handler.spec.d.ts","sourceRoot":"","sources":["../../../../src/execution/resume-handler.spec.ts"],"names":[],"mappings":""}

package/dist/workflow-engine/src/execution/resume-handler.spec.js

@@ -0,0 +1,111 @@
+import {
+  analyzeForResume,
+  createCacheFromRun,
+  mergeExecutionResults,
+} from '@workflow-engine/execution/resume-handler';
+import { describe, expect, it } from 'vitest';
+
+const nodes = [
+  { config: {}, id: 'a', inputs: [], label: 'A', type: 'text' },
+  { config: {}, id: 'b', inputs: ['a'], label: 'B', type: 'text' },
+  { config: {}, id: 'c', inputs: ['b'], label: 'C', type: 'text' },
+];
+const edges = [
+  { id: 'e1', source: 'a', target: 'b' },
+  { id: 'e2', source: 'b', target: 'c' },
+];
+function makeRun(overrides) {
+  return {
+    creditsUsed: 0,
+    executedNodeIds: ['a', 'b'],
+    failedNodeId: 'b',
+    nodeResults: [
+      {
+        completedAt: new Date(),
+        creditsUsed: 0,
+        nodeId: 'a',
+        output: 'output-a',
+        retryCount: 0,
+        startedAt: new Date(),
+        status: 'completed',
+      },
+      {
+        completedAt: new Date(),
+        creditsUsed: 0,
+        error: 'some error',
+        nodeId: 'b',
+        retryCount: 0,
+        startedAt: new Date(),
+        status: 'failed',
+      },
+    ],
+    runId: 'run-1',
+    startedAt: new Date(),
+    status: 'failed',
+    ...overrides,
+  };
+}
+describe('analyzeForResume', () => {
+  it('can resume from failed run', () => {
+    const analysis = analyzeForResume(makeRun({}), nodes, edges);
+    expect(analysis.canResume).toBe(true);
+    expect(analysis.resumeFromNodeId).toBe('b');
+    expect(analysis.nodesToReExecute).toContain('b');
+    expect(analysis.nodesToReExecute).toContain('c');
+    expect(analysis.completedNodeIds).toEqual(['a']);
+  });
+  it('cannot resume completed run', () => {
+    const analysis = analyzeForResume(
+      makeRun({ status: 'completed' }),
+      nodes,
+      edges,
+    );
+    expect(analysis.canResume).toBe(false);
+    expect(analysis.reason).toContain('completed');
+  });
+  it('cannot resume without failedNodeId', () => {
+    const analysis = analyzeForResume(
+      makeRun({ failedNodeId: undefined }),
+      nodes,
+      edges,
+    );
+    expect(analysis.canResume).toBe(false);
+    expect(analysis.reason).toContain('no failed node');
+  });
+  it('cannot resume when failed node removed from workflow', () => {
+    const analysis = analyzeForResume(
+      makeRun({ failedNodeId: 'x' }),
+      nodes,
+      edges,
+    );
+    expect(analysis.canResume).toBe(false);
+    expect(analysis.reason).toContain('no longer exists');
+  });
+});
+describe('createCacheFromRun', () => {
+  it('creates cache from completed results', () => {
+    const cache = createCacheFromRun(makeRun({}));
+    expect(cache.get('a')).toBe('output-a');
+    expect(cache.has('b')).toBe(false);
+  });
+});
+describe('mergeExecutionResults', () => {
+  it('merges previous and current results', () => {
+    const current = [
+      {
+        completedAt: new Date(),
+        creditsUsed: 1,
+        nodeId: 'b',
+        output: 'output-b',
+        retryCount: 1,
+        startedAt: new Date(),
+        status: 'completed',
+      },
+    ];
+    const merged = mergeExecutionResults(makeRun({}), current);
+    expect(merged.length).toBe(2);
+    const bResult = merged.find((r) => r.nodeId === 'b');
+    expect(bResult?.status).toBe('completed');
+    expect(bResult?.output).toBe('output-b');
+  });
+});

package/dist/workflow-engine/src/execution/retry-handler.d.ts

@@ -0,0 +1,10 @@
+import type { RetryConfig } from '@workflow-engine/types';
+export declare function calculateRetryDelay(attemptNumber: number, config?: RetryConfig): number;
+export declare function sleep(ms: number): Promise<void>;
+export declare function isRetryableError(error: unknown): boolean;
+export declare function withRetry<T>(fn: () => Promise<T>, config?: RetryConfig, onRetry?: (attemptNumber: number, error: Error, delayMs: number) => void): Promise<T>;
+export declare function createRetryHandler(config?: Partial<RetryConfig>): {
+    withRetry: <T>(fn: () => Promise<T>, onRetry?: (attemptNumber: number, error: Error, delayMs: number) => void) => Promise<T>;
+    config: RetryConfig;
+};
+//# sourceMappingURL=retry-handler.d.ts.map

package/dist/workflow-engine/src/execution/retry-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-handler.d.ts","sourceRoot":"","sources":["../../../../src/execution/retry-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAuB1D,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,MAAM,EACrB,MAAM,GAAE,WAAkC,GACzC,MAAM,CAIR;AAED,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAgBxD;AAED,wBAAsB,SAAS,CAAC,CAAC,EAC/B,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,MAAM,GAAE,WAAkC,EAC1C,OAAO,CAAC,EAAE,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,GACvE,OAAO,CAAC,CAAC,CAAC,CAwBZ;AAED,wBAAgB,kBAAkB,CAAC,MAAM,GAAE,OAAO,CAAC,WAAW,CAAM,GAAG;IACrE,SAAS,EAAE,CAAC,CAAC,EACX,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,KACrE,OAAO,CAAC,CAAC,CAAC,CAAC;IAChB,MAAM,EAAE,WAAW,CAAC;CACrB,CAUA"}

package/dist/workflow-engine/src/execution/retry-handler.js

@@ -0,0 +1,67 @@
+import { DEFAULT_RETRY_CONFIG } from '@workflow-engine/types';
+const RETRYABLE_PATTERNS = [
+    'network',
+    'timeout',
+    'econnreset',
+    'rate limit',
+    '429',
+    'too many requests',
+    '503',
+    '502',
+    'service unavailable',
+];
+const NON_RETRYABLE_PATTERNS = [
+    'invalid',
+    'unauthorized',
+    'forbidden',
+    'not found',
+    'validation',
+];
+export function calculateRetryDelay(attemptNumber, config = DEFAULT_RETRY_CONFIG) {
+    const delay = config.baseDelayMs * config.backoffMultiplier ** attemptNumber;
+    const jitter = delay * 0.1 * Math.random();
+    return Math.min(delay + jitter, config.maxDelayMs);
+}
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function isRetryableError(error) {
+    if (!(error instanceof Error)) {
+        return true;
+    }
+    const message = error.message.toLowerCase();
+    if (RETRYABLE_PATTERNS.some((pattern) => message.includes(pattern))) {
+        return true;
+    }
+    if (NON_RETRYABLE_PATTERNS.some((pattern) => message.includes(pattern))) {
+        return false;
+    }
+    return true;
+}
+export async function withRetry(fn, config = DEFAULT_RETRY_CONFIG, onRetry) {
+    let lastError;
+    for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (attempt >= config.maxRetries || !isRetryableError(error)) {
+                throw lastError;
+            }
+            const delay = calculateRetryDelay(attempt, config);
+            if (onRetry) {
+                onRetry(attempt + 1, lastError, delay);
+            }
+            await sleep(delay);
+        }
+    }
+    throw lastError ?? new Error('Retry failed with unknown error');
+}
+export function createRetryHandler(config = {}) {
+    const finalConfig = { ...DEFAULT_RETRY_CONFIG, ...config };
+    return {
+        config: finalConfig,
+        withRetry: (fn, onRetry) => withRetry(fn, finalConfig, onRetry),
+    };
+}

package/dist/workflow-engine/src/execution/retry-handler.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=retry-handler.spec.d.ts.map

package/dist/workflow-engine/src/execution/retry-handler.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-handler.spec.d.ts","sourceRoot":"","sources":["../../../../src/execution/retry-handler.spec.ts"],"names":[],"mappings":""}

package/dist/workflow-engine/src/execution/retry-handler.spec.js

@@ -0,0 +1,117 @@
+import {
+  calculateRetryDelay,
+  createRetryHandler,
+  isRetryableError,
+  sleep,
+  withRetry,
+} from '@workflow-engine/execution/retry-handler';
+import { DEFAULT_RETRY_CONFIG } from '@workflow-engine/types';
+import { describe, expect, it, vi } from 'vitest';
+
+describe('calculateRetryDelay', () => {
+  it('increases delay with attempt number', () => {
+    const d0 = calculateRetryDelay(0);
+    const d1 = calculateRetryDelay(1);
+    expect(d1).toBeGreaterThan(d0);
+  });
+  it('respects maxDelayMs', () => {
+    const delay = calculateRetryDelay(100, {
+      ...DEFAULT_RETRY_CONFIG,
+      maxDelayMs: 5000,
+    });
+    expect(delay).toBeLessThanOrEqual(5000);
+  });
+});
+describe('sleep', () => {
+  it('resolves after delay', async () => {
+    const start = Date.now();
+    await sleep(50);
+    expect(Date.now() - start).toBeGreaterThanOrEqual(40);
+  });
+});
+describe('isRetryableError', () => {
+  it('retries network errors', () => {
+    expect(isRetryableError(new Error('network timeout'))).toBe(true);
+  });
+  it('retries rate limit (429)', () => {
+    expect(isRetryableError(new Error('429 Too Many Requests'))).toBe(true);
+  });
+  it('does not retry validation errors', () => {
+    expect(isRetryableError(new Error('validation failed'))).toBe(false);
+  });
+  it('does not retry unauthorized', () => {
+    expect(isRetryableError(new Error('unauthorized'))).toBe(false);
+  });
+  it('retries non-Error values', () => {
+    expect(isRetryableError('some string')).toBe(true);
+  });
+  it('retries unknown errors', () => {
+    expect(isRetryableError(new Error('something random'))).toBe(true);
+  });
+});
+describe('withRetry', () => {
+  it('returns on first success', async () => {
+    const fn = vi.fn().mockResolvedValue('ok');
+    const result = await withRetry(fn, {
+      ...DEFAULT_RETRY_CONFIG,
+      maxRetries: 3,
+    });
+    expect(result).toBe('ok');
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+  it('retries on retryable error', async () => {
+    const fn = vi
+      .fn()
+      .mockRejectedValueOnce(new Error('network error'))
+      .mockResolvedValue('ok');
+    const onRetry = vi.fn();
+    const result = await withRetry(
+      fn,
+      { ...DEFAULT_RETRY_CONFIG, baseDelayMs: 1, maxRetries: 2 },
+      onRetry,
+    );
+    expect(result).toBe('ok');
+    expect(fn).toHaveBeenCalledTimes(2);
+    expect(onRetry).toHaveBeenCalledTimes(1);
+  });
+  it('throws on non-retryable error immediately', async () => {
+    const fn = vi.fn().mockRejectedValue(new Error('unauthorized'));
+    await expect(
+      withRetry(fn, {
+        ...DEFAULT_RETRY_CONFIG,
+        baseDelayMs: 1,
+        maxRetries: 3,
+      }),
+    ).rejects.toThrow('unauthorized');
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+  it('throws after max retries', async () => {
+    const fn = vi.fn().mockRejectedValue(new Error('network error'));
+    await expect(
+      withRetry(fn, {
+        ...DEFAULT_RETRY_CONFIG,
+        baseDelayMs: 1,
+        maxRetries: 1,
+      }),
+    ).rejects.toThrow('network error');
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+  it('wraps non-Error into Error', async () => {
+    const fn = vi.fn().mockRejectedValue('string error');
+    await expect(
+      withRetry(fn, { ...DEFAULT_RETRY_CONFIG, maxRetries: 0 }),
+    ).rejects.toThrow('string error');
+  });
+});
+describe('createRetryHandler', () => {
+  it('creates handler with merged config', () => {
+    const handler = createRetryHandler({ maxRetries: 5 });
+    expect(handler.config.maxRetries).toBe(5);
+    expect(handler.config.baseDelayMs).toBe(DEFAULT_RETRY_CONFIG.baseDelayMs);
+  });
+  it('withRetry function works', async () => {
+    const handler = createRetryHandler({ maxRetries: 0 });
+    const result = await handler.withRetry(async () => 'ok');
+    expect(result).toBe('ok');
+  });
+});

package/dist/workflow-engine/src/executors/base-executor.d.ts

@@ -0,0 +1,39 @@
+import type { ExecutionContext } from '@workflow-engine/execution/engine';
+import type { ExecutableNode } from '@workflow-engine/types';
+export interface ExecutorInput {
+    node: ExecutableNode;
+    inputs: Map<string, unknown>;
+    context: ExecutionContext;
+}
+export interface ExecutorOutput {
+    data: unknown;
+    metadata?: Record<string, unknown>;
+}
+export interface INodeExecutor {
+    readonly nodeType: string;
+    execute(input: ExecutorInput): Promise<ExecutorOutput>;
+    validate?(node: ExecutableNode): {
+        valid: boolean;
+        errors: string[];
+    };
+    estimateCost?(node: ExecutableNode): number;
+}
+export declare abstract class BaseExecutor implements INodeExecutor {
+    abstract readonly nodeType: string;
+    abstract execute(input: ExecutorInput): Promise<ExecutorOutput>;
+    validate(node: ExecutableNode): {
+        valid: boolean;
+        errors: string[];
+    };
+    estimateCost(_node: ExecutableNode): number;
+    protected getRequiredInput<T>(inputs: Map<string, unknown>, key: string): T;
+    protected getOptionalInput<T>(inputs: Map<string, unknown>, key: string, defaultValue: T): T;
+    protected getRequiredConfig<T>(config: Record<string, unknown>, key: string): T;
+    protected getOptionalConfig<T>(config: Record<string, unknown>, key: string, defaultValue: T): T;
+}
+export declare class NoopExecutor extends BaseExecutor {
+    readonly nodeType = "noop";
+    execute(input: ExecutorInput): Promise<ExecutorOutput>;
+}
+export declare function createSimpleExecutor(nodeType: string, executeFn: (input: ExecutorInput) => Promise<unknown>): INodeExecutor;
+//# sourceMappingURL=base-executor.d.ts.map

package/dist/workflow-engine/src/executors/base-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-executor.d.ts","sourceRoot":"","sources":["../../../../src/executors/base-executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,cAAc,CAAC;IACrB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7B,OAAO,EAAE,gBAAgB,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IACvD,QAAQ,CAAC,CAAC,IAAI,EAAE,cAAc,GAAG;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACtE,YAAY,CAAC,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CAAC;CAC7C;AAED,8BAAsB,YAAa,YAAW,aAAa;IACzD,QAAQ,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAEnC,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;IAE/D,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE;IAapE,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM;IAI3C,SAAS,CAAC,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC;IAQ3E,SAAS,CAAC,gBAAgB,CAAC,CAAC,EAC1B,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,CAAC,GACd,CAAC;IAKJ,SAAS,CAAC,iBAAiB,CAAC,CAAC,EAC3B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,GAAG,EAAE,MAAM,GACV,CAAC;IAQJ,SAAS,CAAC,iBAAiB,CAAC,CAAC,EAC3B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,CAAC,GACd,CAAC;CAIL;AAED,qBAAa,YAAa,SAAQ,YAAY;IAC5C,QAAQ,CAAC,QAAQ,UAAU;IAE3B,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;CASvD;AAED,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,OAAO,CAAC,OAAO,CAAC,GACpD,aAAa,CAQf"}

package/dist/workflow-engine/src/executors/base-executor.js

@@ -0,0 +1,58 @@
+export class BaseExecutor {
+    validate(node) {
+        const errors = [];
+        if (node.type !== this.nodeType) {
+            errors.push(`Expected node type ${this.nodeType}, got ${node.type}`);
+        }
+        return {
+            errors,
+            valid: errors.length === 0,
+        };
+    }
+    estimateCost(_node) {
+        return 0;
+    }
+    getRequiredInput(inputs, key) {
+        const value = inputs.get(key);
+        if (value === undefined) {
+            throw new Error(`Missing required input: ${key}`);
+        }
+        return value;
+    }
+    getOptionalInput(inputs, key, defaultValue) {
+        const value = inputs.get(key);
+        return value ?? defaultValue;
+    }
+    getRequiredConfig(config, key) {
+        const value = config[key];
+        if (value === undefined) {
+            throw new Error(`Missing required config: ${key}`);
+        }
+        return value;
+    }
+    getOptionalConfig(config, key, defaultValue) {
+        const value = config[key];
+        return value ?? defaultValue;
+    }
+}
+export class NoopExecutor extends BaseExecutor {
+    nodeType = 'noop';
+    execute(input) {
+        const firstInput = input.inputs.values().next().value;
+        return Promise.resolve({
+            data: firstInput ?? null,
+            metadata: {
+                passthrough: true,
+            },
+        });
+    }
+}
+export function createSimpleExecutor(nodeType, executeFn) {
+    return {
+        async execute(input) {
+            const data = await executeFn(input);
+            return { data };
+        },
+        nodeType,
+    };
+}

package/dist/workflow-engine/src/executors/base-executor.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=base-executor.spec.d.ts.map

package/dist/workflow-engine/src/executors/base-executor.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-executor.spec.d.ts","sourceRoot":"","sources":["../../../../src/executors/base-executor.spec.ts"],"names":[],"mappings":""}

package/dist/workflow-engine/src/executors/base-executor.spec.js

@@ -0,0 +1,103 @@
+import {
+  BaseExecutor,
+  createSimpleExecutor,
+  NoopExecutor,
+} from '@workflow-engine/executors/base-executor';
+import { describe, expect, it } from 'vitest';
+
+class TestExecutor extends BaseExecutor {
+  nodeType = 'test';
+  async execute(input) {
+    return { data: input.inputs.get('key') ?? null };
+  }
+}
+function makeNode(type) {
+  return { config: {}, id: '1', inputs: [], label: 'Test', type };
+}
+describe('BaseExecutor', () => {
+  it('validates correct node type', () => {
+    const exec = new TestExecutor();
+    expect(exec.validate(makeNode('test')).valid).toBe(true);
+  });
+  it('rejects wrong node type', () => {
+    const exec = new TestExecutor();
+    const result = exec.validate(makeNode('wrong'));
+    expect(result.valid).toBe(false);
+    expect(result.errors[0]).toContain('Expected node type test');
+  });
+  it('estimateCost returns 0 by default', () => {
+    const exec = new TestExecutor();
+    expect(exec.estimateCost(makeNode('test'))).toBe(0);
+  });
+  it('getRequiredInput throws on missing key', () => {
+    const exec = new TestExecutor();
+    const inputs = new Map();
+    expect(() => exec.getRequiredInput(inputs, 'missing')).toThrow(
+      'Missing required input',
+    );
+  });
+  it('getOptionalInput returns default on missing key', () => {
+    const exec = new TestExecutor();
+    const inputs = new Map();
+    expect(exec.getOptionalInput(inputs, 'missing', 'default')).toBe('default');
+  });
+  it('getRequiredConfig throws on missing key', () => {
+    const exec = new TestExecutor();
+    expect(() => exec.getRequiredConfig({}, 'missing')).toThrow(
+      'Missing required config',
+    );
+  });
+  it('getOptionalConfig returns default on missing key', () => {
+    const exec = new TestExecutor();
+    expect(exec.getOptionalConfig({}, 'missing', 42)).toBe(42);
+  });
+});
+describe('NoopExecutor', () => {
+  it('passes through first input', async () => {
+    const exec = new NoopExecutor();
+    const inputs = new Map([['a', 'value']]);
+    const result = await exec.execute({
+      context: {
+        organizationId: 'o',
+        runId: 'r',
+        userId: 'u',
+        workflowId: 'w',
+      },
+      inputs,
+      node: makeNode('noop'),
+    });
+    expect(result.data).toBe('value');
+    expect(result.metadata?.passthrough).toBe(true);
+  });
+  it('returns null when no inputs', async () => {
+    const exec = new NoopExecutor();
+    const result = await exec.execute({
+      context: {
+        organizationId: 'o',
+        runId: 'r',
+        userId: 'u',
+        workflowId: 'w',
+      },
+      inputs: new Map(),
+      node: makeNode('noop'),
+    });
+    expect(result.data).toBeNull();
+  });
+});
+describe('createSimpleExecutor', () => {
+  it('wraps function into executor', async () => {
+    const exec = createSimpleExecutor('simple', async () => 'result');
+    expect(exec.nodeType).toBe('simple');
+    const result = await exec.execute({
+      context: {
+        organizationId: 'o',
+        runId: 'r',
+        userId: 'u',
+        workflowId: 'w',
+      },
+      inputs: new Map(),
+      node: makeNode('simple'),
+    });
+    expect(result.data).toBe('result');
+  });
+});