@genfeedai/workflow-engine 0.2.0

package/src/executors/saas/film-grain-executor.spec.ts

@@ -0,0 +1,203 @@
+import type { ExecutionContext } from '@workflow-engine/execution/engine';
+import type { ExecutorInput } from '@workflow-engine/executors/base-executor';
+import {
+  buildFilmGrainFilter,
+  createFilmGrainExecutor,
+  FilmGrainExecutor,
+} from '@workflow-engine/executors/saas/film-grain-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+function makeInput(
+  config: Record<string, unknown>,
+  inputData?: Record<string, unknown>,
+): ExecutorInput {
+  const node: ExecutableNode = {
+    config,
+    id: 'grain-1',
+    inputs: [],
+    label: 'Film Grain',
+    type: 'filmGrain',
+  };
+  const inputs = new Map<string, unknown>();
+  if (inputData) {
+    for (const [k, v] of Object.entries(inputData)) {
+      inputs.set(k, v);
+    }
+  }
+  const context: ExecutionContext = {
+    organizationId: 'org-1',
+    runId: 'run-1',
+    userId: 'user-1',
+    workflowId: 'wf-1',
+  };
+  return { context, inputs, node };
+}
+
+describe('FilmGrainExecutor', () => {
+  let executor: FilmGrainExecutor;
+
+  beforeEach(() => {
+    executor = new FilmGrainExecutor();
+  });
+
+  describe('validate', () => {
+    it('passes with valid config', () => {
+      const input = makeInput({
+        colorGrain: false,
+        intensity: 50,
+        size: 'medium',
+        stock: '35mm_fine',
+      });
+      const result = executor.validate(input.node);
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('rejects invalid stock', () => {
+      const input = makeInput({ stock: 'invalid' });
+      const result = executor.validate(input.node);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some((e) => e.includes('Invalid stock'))).toBe(true);
+    });
+
+    it('rejects intensity out of range', () => {
+      const input = makeInput({ intensity: 150 });
+      const result = executor.validate(input.node);
+      expect(result.valid).toBe(false);
+    });
+
+    it('rejects invalid size', () => {
+      const input = makeInput({ size: 'huge' });
+      const result = executor.validate(input.node);
+      expect(result.valid).toBe(false);
+    });
+
+    it('rejects non-boolean colorGrain', () => {
+      const input = makeInput({ colorGrain: 'yes' });
+      const result = executor.validate(input.node);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some((e) => e.includes('colorGrain'))).toBe(true);
+    });
+  });
+
+  describe('execute', () => {
+    it('calls processor with filter chain', async () => {
+      const processor = vi.fn().mockResolvedValue({
+        jobId: 'job-123',
+        outputUrl: 'https://cdn.example.com/output.mp4',
+      });
+      executor.setProcessor(processor);
+
+      const input = makeInput(
+        {
+          colorGrain: true,
+          intensity: 80,
+          size: 'coarse',
+          stock: '35mm_heavy',
+        },
+        { videoUrl: 'https://cdn.example.com/input.mp4' },
+      );
+
+      const result = await executor.execute(input);
+
+      expect(processor).toHaveBeenCalledOnce();
+      const call = processor.mock.calls[0][0];
+      expect(call.videoUrl).toBe('https://cdn.example.com/input.mp4');
+      expect(call.stock).toBe('35mm_heavy');
+      expect(call.filterChain).toBeTruthy();
+      expect(result.data).toBe('https://cdn.example.com/output.mp4');
+    });
+
+    it('throws if processor not set', async () => {
+      const input = makeInput({}, { videoUrl: 'https://example.com/v.mp4' });
+      await expect(executor.execute(input)).rejects.toThrow(
+        'Film grain processor not configured',
+      );
+    });
+
+    it('throws if videoUrl missing', async () => {
+      executor.setProcessor(vi.fn());
+      const input = makeInput({}, {});
+      await expect(executor.execute(input)).rejects.toThrow(
+        'Missing required input: videoUrl',
+      );
+    });
+  });
+
+  describe('estimateCost', () => {
+    it('returns 0', () => {
+      const input = makeInput({});
+      expect(executor.estimateCost(input.node)).toBe(0);
+    });
+  });
+});
+
+describe('buildFilmGrainFilter', () => {
+  it('generates noise filter for 35mm_fine', () => {
+    const filter = buildFilmGrainFilter({
+      colorGrain: false,
+      intensity: 100,
+      size: 'medium',
+      stock: '35mm_fine',
+    });
+    expect(filter).toContain('noise=alls=');
+    expect(filter).toContain('allf=t+u');
+  });
+
+  it('generates per-channel noise for color grain', () => {
+    const filter = buildFilmGrainFilter({
+      colorGrain: true,
+      intensity: 100,
+      size: 'medium',
+      stock: '35mm_fine',
+    });
+    expect(filter).toContain('c0s=');
+    expect(filter).toContain('c1s=');
+    expect(filter).toContain('c2s=');
+  });
+
+  it('returns empty string for zero intensity', () => {
+    const filter = buildFilmGrainFilter({
+      colorGrain: false,
+      intensity: 0,
+      size: 'medium',
+      stock: '35mm_fine',
+    });
+    expect(filter).toBe('');
+  });
+
+  it('adds tmix for 8mm stock', () => {
+    const filter = buildFilmGrainFilter({
+      colorGrain: false,
+      intensity: 100,
+      size: 'medium',
+      stock: '8mm',
+    });
+    expect(filter).toContain('tmix');
+  });
+
+  it('does not add temporal flag for digital_noise', () => {
+    const filter = buildFilmGrainFilter({
+      colorGrain: false,
+      intensity: 100,
+      size: 'medium',
+      stock: 'digital_noise',
+    });
+    expect(filter).not.toContain('t+u');
+    expect(filter).toContain('allf=u');
+  });
+});
+
+describe('createFilmGrainExecutor', () => {
+  it('creates executor without processor', () => {
+    const executor = createFilmGrainExecutor();
+    expect(executor.nodeType).toBe('filmGrain');
+  });
+
+  it('creates executor with processor', () => {
+    const processor = vi.fn();
+    const executor = createFilmGrainExecutor(processor);
+    expect(executor.nodeType).toBe('filmGrain');
+  });
+});

package/src/executors/saas/film-grain-executor.ts

@@ -0,0 +1,227 @@
+import {
+  BaseExecutor,
+  type ExecutorInput,
+  type ExecutorOutput,
+} from '@workflow-engine/executors/base-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+
+export type FilmStock =
+  | '35mm_fine'
+  | '35mm_heavy'
+  | '16mm'
+  | '8mm'
+  | 'digital_noise';
+
+export type GrainSize = 'fine' | 'medium' | 'coarse';
+
+export interface FilmGrainParams {
+  stock: FilmStock;
+  intensity: number;
+  size: GrainSize;
+  colorGrain: boolean;
+}
+
+/** Extended config used by cinematic camera presets */
+export interface FilmGrainConfig extends FilmGrainParams {
+  enabled?: boolean;
+  animateGrain?: boolean;
+}
+
+export interface FilmGrainResult {
+  outputUrl: string;
+  jobId: string;
+}
+
+/**
+ * Stock preset mappings to FFmpeg noise parameters.
+ */
+const STOCK_PRESETS: Record<
+  FilmStock,
+  { strength: number; temporal: boolean; heavyTemporal: boolean }
+> = {
+  '8mm': { heavyTemporal: true, strength: 25, temporal: true },
+  '16mm': { heavyTemporal: false, strength: 20, temporal: true },
+  '35mm_fine': { heavyTemporal: false, strength: 10, temporal: true },
+  '35mm_heavy': { heavyTemporal: false, strength: 30, temporal: true },
+  digital_noise: { heavyTemporal: false, strength: 15, temporal: false },
+};
+
+const SIZE_MULTIPLIERS: Record<GrainSize, number> = {
+  coarse: 1.4,
+  fine: 0.7,
+  medium: 1.0,
+};
+
+const VALID_STOCKS: FilmStock[] = [
+  '35mm_fine',
+  '35mm_heavy',
+  '16mm',
+  '8mm',
+  'digital_noise',
+];
+
+const VALID_SIZES: GrainSize[] = ['fine', 'medium', 'coarse'];
+
+/**
+ * Builds an FFmpeg filter string for film grain simulation.
+ */
+export function buildFilmGrainFilter(params: FilmGrainParams): string {
+  const preset = STOCK_PRESETS[params.stock];
+  const sizeMultiplier = SIZE_MULTIPLIERS[params.size];
+
+  const baseStrength =
+    preset.strength * (params.intensity / 100) * sizeMultiplier;
+  const strength = Math.max(0, Math.min(100, Math.round(baseStrength)));
+
+  if (strength === 0) return '';
+
+  const flags: string[] = [];
+  if (preset.temporal) flags.push('t');
+  flags.push('u');
+  const flagStr = flags.join('+');
+
+  const filters: string[] = [];
+
+  if (!params.colorGrain) {
+    filters.push(`noise=alls=${strength}:allf=${flagStr}`);
+  } else {
+    const rStrength = strength;
+    const gStrength = Math.round(strength * 0.85);
+    const bStrength = Math.round(strength * 0.9);
+    filters.push(
+      `noise=c0s=${rStrength}:c0f=${flagStr}:c1s=${gStrength}:c1f=${flagStr}:c2s=${bStrength}:c2f=${flagStr}`,
+    );
+  }
+
+  if (preset.heavyTemporal) {
+    filters.push('tmix=frames=2:weights=1 0.5');
+  }
+
+  return filters.join(',');
+}
+
+export type FilmGrainProcessor = (params: {
+  organizationId: string;
+  videoUrl: string;
+  filterChain: string;
+  stock: FilmStock;
+  intensity: number;
+}) => Promise<FilmGrainResult>;
+
+/**
+ * Film Grain Executor
+ *
+ * Applies cinematic film grain to video via FFmpeg noise filters.
+ * Supports stock emulation (35mm, 16mm, 8mm) and digital noise,
+ * with configurable intensity, size, and chromatic grain toggle.
+ *
+ * Node Type: filmGrain
+ * Category: effects
+ */
+export class FilmGrainExecutor extends BaseExecutor {
+  readonly nodeType = 'filmGrain';
+  private processor: FilmGrainProcessor | null = null;
+
+  setProcessor(processor: FilmGrainProcessor): void {
+    this.processor = processor;
+  }
+
+  validate(node: ExecutableNode): { valid: boolean; errors: string[] } {
+    const baseValidation = super.validate(node);
+    const errors = [...baseValidation.errors];
+
+    const stock = node.config.stock as string | undefined;
+    if (stock && !VALID_STOCKS.includes(stock as FilmStock)) {
+      errors.push(`Invalid stock. Must be one of: ${VALID_STOCKS.join(', ')}`);
+    }
+
+    const intensity = node.config.intensity;
+    if (
+      intensity !== undefined &&
+      (typeof intensity !== 'number' || intensity < 0 || intensity > 100)
+    ) {
+      errors.push('intensity must be a number between 0 and 100');
+    }
+
+    const size = node.config.size as string | undefined;
+    if (size && !VALID_SIZES.includes(size as GrainSize)) {
+      errors.push(`Invalid size. Must be one of: ${VALID_SIZES.join(', ')}`);
+    }
+
+    const colorGrain = node.config.colorGrain;
+    if (colorGrain !== undefined && typeof colorGrain !== 'boolean') {
+      errors.push('colorGrain must be a boolean');
+    }
+
+    return {
+      errors,
+      valid: errors.length === 0,
+    };
+  }
+
+  estimateCost(_node: ExecutableNode): number {
+    return 0;
+  }
+
+  async execute(input: ExecutorInput): Promise<ExecutorOutput> {
+    const { node, inputs, context } = input;
+
+    if (!this.processor) {
+      throw new Error('Film grain processor not configured');
+    }
+
+    const videoUrl = this.getRequiredInput<string>(inputs, 'videoUrl');
+
+    const stock = this.getOptionalConfig<FilmStock>(
+      node.config,
+      'stock',
+      '35mm_fine',
+    );
+    const intensity = this.getOptionalConfig<number>(
+      node.config,
+      'intensity',
+      50,
+    );
+    const size = this.getOptionalConfig<GrainSize>(
+      node.config,
+      'size',
+      'medium',
+    );
+    const colorGrain = this.getOptionalConfig<boolean>(
+      node.config,
+      'colorGrain',
+      false,
+    );
+
+    const params: FilmGrainParams = { colorGrain, intensity, size, stock };
+    const filterChain = buildFilmGrainFilter(params);
+
+    const result = await this.processor({
+      filterChain,
+      intensity,
+      organizationId: context.organizationId,
+      stock,
+      videoUrl,
+    });
+
+    return {
+      data: result.outputUrl,
+      metadata: {
+        filterChain,
+        jobId: result.jobId,
+        params,
+        stock,
+      },
+    };
+  }
+}
+
+export function createFilmGrainExecutor(
+  processor?: FilmGrainProcessor,
+): FilmGrainExecutor {
+  const executor = new FilmGrainExecutor();
+  if (processor) {
+    executor.setProcessor(processor);
+  }
+  return executor;
+}

package/src/executors/saas/image-gen-executor.spec.ts

@@ -0,0 +1,185 @@
+import type { ExecutionContext } from '@workflow-engine/execution/engine';
+import type { ExecutorInput } from '@workflow-engine/executors/base-executor';
+import {
+  createImageGenExecutor,
+  type ImageGenExecutor,
+} from '@workflow-engine/executors/saas/image-gen-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+function makeInput(
+  config: Record<string, unknown>,
+  inputMap?: Record<string, unknown>,
+): ExecutorInput {
+  return {
+    context: {
+      organizationId: 'org-1',
+      runId: 'run-1',
+      userId: 'user-1',
+      workflowId: 'wf-1',
+    } as ExecutionContext,
+    inputs: new Map<string, unknown>(Object.entries(inputMap ?? {})),
+    node: {
+      config,
+      id: 'ig-1',
+      inputs: [],
+      label: 'ImageGen',
+      type: 'imageGen',
+    } as ExecutableNode,
+  };
+}
+
+describe('ImageGenExecutor', () => {
+  let executor: ImageGenExecutor;
+
+  beforeEach(() => {
+    executor = createImageGenExecutor();
+    executor.setResolver(
+      vi.fn().mockResolvedValue({
+        filename: 'out.png',
+        imageUrl: 'http://img.png',
+        model: 'flux',
+        provider: 'replicate',
+      }),
+    );
+  });
+
+  describe('validate', () => {
+    it('valid with model', () => {
+      expect(
+        executor.validate({
+          config: { model: 'flux' },
+          id: '1',
+          inputs: [],
+          label: 'IG',
+          type: 'imageGen',
+        }).valid,
+      ).toBe(true);
+    });
+    it('invalid without model', () => {
+      expect(
+        executor.validate({
+          config: {},
+          id: '1',
+          inputs: [],
+          label: 'IG',
+          type: 'imageGen',
+        }).valid,
+      ).toBe(false);
+    });
+    it('invalid with non-string model', () => {
+      expect(
+        executor.validate({
+          config: { model: 123 },
+          id: '1',
+          inputs: [],
+          label: 'IG',
+          type: 'imageGen',
+        }).valid,
+      ).toBe(false);
+    });
+  });
+
+  it('estimateCost returns 5', () => {
+    expect(
+      executor.estimateCost({
+        config: {},
+        id: '1',
+        inputs: [],
+        label: 'IG',
+        type: 'imageGen',
+      }),
+    ).toBe(5);
+  });
+
+  describe('execute', () => {
+    it('throws without resolver', async () => {
+      const exec = createImageGenExecutor();
+      await expect(exec.execute(makeInput({ model: 'flux' }))).rejects.toThrow(
+        'resolver',
+      );
+    });
+
+    it('generates image with defaults', async () => {
+      const result = await executor.execute(makeInput({ model: 'flux' }));
+      expect(result.metadata?.model).toBe('flux');
+      expect(result.metadata?.provider).toBe('replicate');
+    });
+
+    it('uses prompt from input over config', async () => {
+      await executor.execute(
+        makeInput({ model: 'flux', prompt: 'config' }, { prompt: 'input' }),
+      );
+      // The resolver receives 'input' prompt
+    });
+
+    it('passes upstream image input as references and preserves image-guided params', async () => {
+      const resolver = vi.fn().mockResolvedValue({
+        filename: 'guided.png',
+        imageUrl: 'http://guided.png',
+        model: 'qwen-image',
+        provider: 'replicate',
+      });
+      executor.setResolver(resolver);
+
+      await executor.execute(
+        makeInput(
+          {
+            model: 'qwen-image',
+            negativePrompt: 'cartoonish, distorted geometry',
+            strength: 0.35,
+          },
+          {
+            image: 'https://example.com/source-room.jpg',
+            prompt: 'Stage this room realistically',
+          },
+        ),
+      );
+
+      expect(resolver).toHaveBeenCalledWith(
+        'qwen-image',
+        {
+          height: 1024,
+          negativePrompt: 'cartoonish, distorted geometry',
+          prompt: 'Stage this room realistically',
+          references: ['https://example.com/source-room.jpg'],
+          strength: 0.35,
+          width: 1024,
+        },
+        expect.objectContaining({
+          organizationId: 'org-1',
+          runId: 'run-1',
+          userId: 'user-1',
+          workflowId: 'wf-1',
+        }),
+        expect.objectContaining({
+          config: expect.objectContaining({
+            model: 'qwen-image',
+            negativePrompt: 'cartoonish, distorted geometry',
+            strength: 0.35,
+          }),
+          id: 'ig-1',
+          label: 'ImageGen',
+          type: 'imageGen',
+        }),
+      );
+    });
+
+    it('rethrows backend resolver failures', async () => {
+      const resolver = vi.fn().mockRejectedValue(new Error('replicate failed'));
+      executor.setResolver(resolver);
+
+      await expect(
+        executor.execute(
+          makeInput(
+            { model: 'black-forest-labs/flux-2-pro' },
+            {
+              image: 'https://example.com/floorplan.png',
+              prompt: 'Create a layout-faithful interior preview',
+            },
+          ),
+        ),
+      ).rejects.toThrow('replicate failed');
+    });
+  });
+});