@genfeedai/workflow-engine 0.2.0

package/src/execution/retry-handler.ts

@@ -0,0 +1,101 @@
+import type { RetryConfig } from '@workflow-engine/types';
+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: number,
+  config: RetryConfig = DEFAULT_RETRY_CONFIG,
+): number {
+  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: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function isRetryableError(error: unknown): boolean {
+  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<T>(
+  fn: () => Promise<T>,
+  config: RetryConfig = DEFAULT_RETRY_CONFIG,
+  onRetry?: (attemptNumber: number, error: Error, delayMs: number) => void,
+): Promise<T> {
+  let lastError: Error | undefined;
+
+  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: Partial<RetryConfig> = {}): {
+  withRetry: <T>(
+    fn: () => Promise<T>,
+    onRetry?: (attemptNumber: number, error: Error, delayMs: number) => void,
+  ) => Promise<T>;
+  config: RetryConfig;
+} {
+  const finalConfig: RetryConfig = { ...DEFAULT_RETRY_CONFIG, ...config };
+
+  return {
+    config: finalConfig,
+    withRetry: <T>(
+      fn: () => Promise<T>,
+      onRetry?: (attemptNumber: number, error: Error, delayMs: number) => void,
+    ) => withRetry(fn, finalConfig, onRetry),
+  };
+}

package/src/executors/base-executor.spec.ts

@@ -0,0 +1,120 @@
+import {
+  BaseExecutor,
+  createSimpleExecutor,
+  type ExecutorInput,
+  type ExecutorOutput,
+  NoopExecutor,
+} from '@workflow-engine/executors/base-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+import { describe, expect, it } from 'vitest';
+
+class TestExecutor extends BaseExecutor {
+  readonly nodeType = 'test';
+
+  async execute(input: ExecutorInput): Promise<ExecutorOutput> {
+    return { data: input.inputs.get('key') ?? null };
+  }
+}
+
+function makeNode(type: string): ExecutableNode {
+  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<string, unknown>();
+    expect(() => (exec as any).getRequiredInput(inputs, 'missing')).toThrow(
+      'Missing required input',
+    );
+  });
+
+  it('getOptionalInput returns default on missing key', () => {
+    const exec = new TestExecutor();
+    const inputs = new Map<string, unknown>();
+    expect((exec as any).getOptionalInput(inputs, 'missing', 'default')).toBe(
+      'default',
+    );
+  });
+
+  it('getRequiredConfig throws on missing key', () => {
+    const exec = new TestExecutor();
+    expect(() => (exec as any).getRequiredConfig({}, 'missing')).toThrow(
+      'Missing required config',
+    );
+  });
+
+  it('getOptionalConfig returns default on missing key', () => {
+    const exec = new TestExecutor();
+    expect((exec as any).getOptionalConfig({}, 'missing', 42)).toBe(42);
+  });
+});
+
+describe('NoopExecutor', () => {
+  it('passes through first input', async () => {
+    const exec = new NoopExecutor();
+    const inputs = new Map<string, unknown>([['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');
+  });
+});

package/src/executors/base-executor.ts

@@ -0,0 +1,107 @@
+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 abstract class BaseExecutor implements INodeExecutor {
+  abstract readonly nodeType: string;
+
+  abstract execute(input: ExecutorInput): Promise<ExecutorOutput>;
+
+  validate(node: ExecutableNode): { valid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    if (node.type !== this.nodeType) {
+      errors.push(`Expected node type ${this.nodeType}, got ${node.type}`);
+    }
+
+    return {
+      errors,
+      valid: errors.length === 0,
+    };
+  }
+
+  estimateCost(_node: ExecutableNode): number {
+    return 0;
+  }
+
+  protected getRequiredInput<T>(inputs: Map<string, unknown>, key: string): T {
+    const value = inputs.get(key);
+    if (value === undefined) {
+      throw new Error(`Missing required input: ${key}`);
+    }
+    return value as T;
+  }
+
+  protected getOptionalInput<T>(
+    inputs: Map<string, unknown>,
+    key: string,
+    defaultValue: T,
+  ): T {
+    const value = inputs.get(key);
+    return (value as T) ?? defaultValue;
+  }
+
+  protected getRequiredConfig<T>(
+    config: Record<string, unknown>,
+    key: string,
+  ): T {
+    const value = config[key];
+    if (value === undefined) {
+      throw new Error(`Missing required config: ${key}`);
+    }
+    return value as T;
+  }
+
+  protected getOptionalConfig<T>(
+    config: Record<string, unknown>,
+    key: string,
+    defaultValue: T,
+  ): T {
+    const value = config[key];
+    return (value as T) ?? defaultValue;
+  }
+}
+
+export class NoopExecutor extends BaseExecutor {
+  readonly nodeType = 'noop';
+
+  execute(input: ExecutorInput): Promise<ExecutorOutput> {
+    const firstInput = input.inputs.values().next().value;
+    return Promise.resolve({
+      data: firstInput ?? null,
+      metadata: {
+        passthrough: true,
+      },
+    });
+  }
+}
+
+export function createSimpleExecutor(
+  nodeType: string,
+  executeFn: (input: ExecutorInput) => Promise<unknown>,
+): INodeExecutor {
+  return {
+    async execute(input: ExecutorInput): Promise<ExecutorOutput> {
+      const data = await executeFn(input);
+      return { data };
+    },
+    nodeType,
+  };
+}

package/src/executors/executor-registry.spec.ts

@@ -0,0 +1,132 @@
+import {
+  createExecutorRegistry,
+  EXECUTOR_REGISTRY,
+  getExecutor,
+  getExecutorMetadata,
+  getRegisteredNodeTypes,
+  hasExecutor,
+} from '@workflow-engine/executors/executor-registry';
+import { describe, expect, it } from 'vitest';
+
+describe('executor-registry', () => {
+  describe('EXECUTOR_REGISTRY', () => {
+    it('has all expected node types', () => {
+      const types = Object.keys(EXECUTOR_REGISTRY);
+      expect(types).toContain('brand');
+      expect(types).toContain('publish');
+      expect(types).toContain('condition');
+      expect(types).toContain('delay');
+      expect(types).toContain('noop');
+    });
+  });
+
+  describe('getExecutor', () => {
+    it('returns executor for known type', () => {
+      const exec = getExecutor('noop');
+      expect(exec).toBeDefined();
+      expect(exec?.nodeType).toBe('noop');
+    });
+
+    it('returns undefined for unknown type', () => {
+      expect(getExecutor('nonexistent')).toBeUndefined();
+    });
+  });
+
+  describe('hasExecutor', () => {
+    it('returns true for known type', () => {
+      expect(hasExecutor('brand')).toBe(true);
+    });
+    it('returns false for unknown type', () => {
+      expect(hasExecutor('nonexistent')).toBe(false);
+    });
+  });
+
+  describe('getRegisteredNodeTypes', () => {
+    it('returns array of node types', () => {
+      const types = getRegisteredNodeTypes();
+      expect(types.length).toBeGreaterThan(10);
+      expect(types).toContain('noop');
+    });
+  });
+
+  describe('getExecutorMetadata', () => {
+    it('returns metadata for known type', () => {
+      const meta = getExecutorMetadata('brand');
+      expect(meta).toBeDefined();
+      expect(meta?.nodeType).toBe('brand');
+      expect(meta?.requiresResolver).toBe(true);
+    });
+
+    it('returns undefined for unknown type', () => {
+      expect(getExecutorMetadata('nonexistent')).toBeUndefined();
+    });
+  });
+
+  describe('ExecutorRegistryInstance', () => {
+    it('creates registry with all executors', () => {
+      const registry = createExecutorRegistry();
+      expect(registry.has('noop')).toBe(true);
+      expect(registry.has('brand')).toBe(true);
+    });
+
+    it('gets typed executors', () => {
+      const registry = createExecutorRegistry();
+      expect(registry.getConditionExecutor()).toBeDefined();
+      expect(registry.getDelayExecutor()).toBeDefined();
+      expect(registry.getBrandExecutor()).toBeDefined();
+      expect(registry.getBrandContextExecutor()).toBeDefined();
+      expect(registry.getBrandAssetExecutor()).toBeDefined();
+      expect(registry.getPublishExecutor()).toBeDefined();
+      expect(registry.getTweetInputExecutor()).toBeDefined();
+      expect(registry.getTweetRemixExecutor()).toBeDefined();
+      expect(registry.getRssInputExecutor()).toBeDefined();
+      expect(registry.getSocialPublishExecutor()).toBeDefined();
+      expect(registry.getTrendTriggerExecutor()).toBeDefined();
+      expect(registry.getSoundOverlayExecutor()).toBeDefined();
+      expect(registry.getVideoInputExecutor()).toBeDefined();
+      expect(registry.getMusicSourceExecutor()).toBeDefined();
+      expect(registry.getBeatAnalysisExecutor()).toBeDefined();
+      expect(registry.getBeatSyncEditorExecutor()).toBeDefined();
+      expect(registry.getCinematicColorGradeExecutor()).toBeDefined();
+      expect(registry.getColorGradeExecutor()).toBeDefined();
+      expect(registry.getFilmGrainExecutor()).toBeDefined();
+      expect(registry.getLensEffectsExecutor()).toBeDefined();
+      expect(registry.getPostReplyExecutor()).toBeDefined();
+      expect(registry.getSendDmExecutor()).toBeDefined();
+      expect(registry.getNewFollowerTriggerExecutor()).toBeDefined();
+      expect(registry.getMentionTriggerExecutor()).toBeDefined();
+      expect(registry.getNewLikeTriggerExecutor()).toBeDefined();
+      expect(registry.getNewRepostTriggerExecutor()).toBeDefined();
+      expect(registry.getImageGenExecutor()).toBeDefined();
+      expect(registry.getKeywordTriggerExecutor()).toBeDefined();
+      expect(registry.getEngagementTriggerExecutor()).toBeDefined();
+    });
+
+    it('allows setting custom executor', () => {
+      const registry = createExecutorRegistry();
+      const custom = {
+        execute: async () => ({ data: null }),
+        nodeType: 'custom',
+      };
+      registry.set('custom', custom);
+      expect(registry.get('custom')).toBe(custom);
+    });
+
+    it('allows registering via function', () => {
+      const registry = createExecutorRegistry();
+      registry.register('myNode', async () => 'result');
+      const exec = registry.get('myNode');
+      expect(exec).toBeDefined();
+      expect(exec?.nodeType).toBe('myNode');
+    });
+
+    it('returns undefined for wrong type cast', () => {
+      const registry = createExecutorRegistry();
+      registry.set('condition', {
+        execute: async () => ({ data: null }),
+        nodeType: 'condition',
+      });
+      expect(registry.getConditionExecutor()).toBeUndefined();
+    });
+  });
+});