@genfeedai/workflow-engine 0.2.0

package/src/executors/saas/brand-executor.spec.ts

@@ -0,0 +1,93 @@
+import type { ExecutionContext } from '@workflow-engine/execution/engine';
+import { createBrandExecutor } from '@workflow-engine/executors/saas/brand-executor';
+import { describe, expect, it, vi } from 'vitest';
+
+const ctx: ExecutionContext = {
+  organizationId: 'org-1',
+  runId: 'r',
+  userId: 'u',
+  workflowId: 'w',
+};
+const brandData = {
+  brandId: 'b-1',
+  colors: null,
+  fonts: null,
+  handle: '@t',
+  label: 'Test',
+  models: null,
+  voice: null,
+};
+
+describe('BrandExecutor', () => {
+  it('validates with brandId', () => {
+    expect(
+      createBrandExecutor().validate({
+        config: { brandId: 'b-1' },
+        id: '1',
+        inputs: [],
+        label: 'B',
+        type: 'brand',
+      }).valid,
+    ).toBe(true);
+  });
+  it('invalid without brandId', () => {
+    expect(
+      createBrandExecutor().validate({
+        config: {},
+        id: '1',
+        inputs: [],
+        label: 'B',
+        type: 'brand',
+      }).valid,
+    ).toBe(false);
+  });
+  it('throws without resolver', async () => {
+    await expect(
+      createBrandExecutor().execute({
+        context: ctx,
+        inputs: new Map(),
+        node: {
+          config: { brandId: 'b-1' },
+          id: '1',
+          inputs: [],
+          label: 'B',
+          type: 'brand',
+        },
+      }),
+    ).rejects.toThrow('resolver');
+  });
+  it('resolves brand', async () => {
+    const resolver = vi.fn().mockResolvedValue(brandData);
+    const exec = createBrandExecutor(resolver);
+    const result = await exec.execute({
+      context: ctx,
+      inputs: new Map(),
+      node: {
+        config: { brandId: 'b-1' },
+        id: '1',
+        inputs: [],
+        label: 'B',
+        type: 'brand',
+      },
+    });
+    expect(result.data).toEqual(brandData);
+    expect(result.metadata?.brandId).toBe('b-1');
+  });
+  it('throws when not found', async () => {
+    const resolver = vi.fn().mockResolvedValue(null);
+    const exec = createBrandExecutor(resolver);
+    await expect(
+      exec.execute({
+        context: ctx,
+        inputs: new Map(),
+        node: {
+          config: { brandId: 'b-x' },
+          id: '1',
+          inputs: [],
+          label: 'B',
+          type: 'brand',
+        },
+      }),
+    ).rejects.toThrow('not found');
+  });
+});

package/src/executors/saas/brand-executor.ts

@@ -0,0 +1,85 @@
+import {
+  BaseExecutor,
+  type ExecutorInput,
+  type ExecutorOutput,
+} from '@workflow-engine/executors/base-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+
+export interface BrandContextOutput {
+  brandId: string;
+  label: string;
+  handle: string;
+  voice: string | null;
+  colors: {
+    primary: string;
+    secondary: string;
+    background: string;
+  } | null;
+  fonts: string | null;
+  models: {
+    video: string | null;
+    image: string | null;
+    imageToVideo: string | null;
+    music: string | null;
+  } | null;
+}
+
+export type BrandResolver = (
+  brandId: string,
+  organizationId: string,
+) => Promise<BrandContextOutput | null>;
+
+export class BrandExecutor extends BaseExecutor {
+  readonly nodeType = 'brand';
+  private resolver: BrandResolver | null = null;
+
+  setResolver(resolver: BrandResolver): void {
+    this.resolver = resolver;
+  }
+
+  validate(node: ExecutableNode): { valid: boolean; errors: string[] } {
+    const baseValidation = super.validate(node);
+    const errors = [...baseValidation.errors];
+
+    const brandId = node.config.brandId;
+    if (!brandId || typeof brandId !== 'string') {
+      errors.push('Brand ID is required');
+    }
+
+    return {
+      errors,
+      valid: errors.length === 0,
+    };
+  }
+
+  async execute(input: ExecutorInput): Promise<ExecutorOutput> {
+    const { node, context } = input;
+
+    if (!this.resolver) {
+      throw new Error('Brand resolver not configured');
+    }
+
+    const brandId = this.getRequiredConfig<string>(node.config, 'brandId');
+    const brandContext = await this.resolver(brandId, context.organizationId);
+
+    if (!brandContext) {
+      throw new Error(`Brand ${brandId} not found or not accessible`);
+    }
+
+    return {
+      data: brandContext,
+      metadata: {
+        brandId: brandContext.brandId,
+        brandLabel: brandContext.label,
+      },
+    };
+  }
+}
+
+export function createBrandExecutor(resolver?: BrandResolver): BrandExecutor {
+  const executor = new BrandExecutor();
+  if (resolver) {
+    executor.setResolver(resolver);
+  }
+  return executor;
+}

package/src/executors/saas/cinematic-camera-presets.spec.ts

@@ -0,0 +1,34 @@
+import {
+  CINEMATIC_CAMERA_PRESETS,
+  getCinematicCameraPreset,
+  listCinematicCameraPresetIds,
+} from '@workflow-engine/executors/saas/cinematic-camera-presets';
+import { describe, expect, it } from 'vitest';
+
+describe('cinematic-camera-presets', () => {
+  it('has 6 presets', () => {
+    expect(listCinematicCameraPresetIds().length).toBe(6);
+  });
+
+  it('gets preset by id', () => {
+    const preset = getCinematicCameraPreset('hollywood_blockbuster');
+    expect(preset).toBeDefined();
+    expect(preset?.camera).toBe('ARRI Alexa Mini LF');
+  });
+
+  it('returns undefined for unknown id', () => {
+    expect(getCinematicCameraPreset('nonexistent')).toBeUndefined();
+  });
+
+  it('each preset has required fields', () => {
+    for (const [id, preset] of Object.entries(CINEMATIC_CAMERA_PRESETS)) {
+      expect(preset.id).toBe(id);
+      expect(preset.name).toBeTruthy();
+      expect(preset.camera).toBeTruthy();
+      expect(preset.promptFragment).toBeTruthy();
+      expect(preset.colorGrade).toBeDefined();
+      expect(preset.filmGrain).toBeDefined();
+      expect(preset.lensEffects).toBeDefined();
+    }
+  });
+});

package/src/executors/saas/cinematic-camera-presets.ts

@@ -0,0 +1,249 @@
+import type { CinematicColorGradeConfig } from '@workflow-engine/executors/saas/cinematic-color-grade-executor';
+import type { FilmGrainConfig } from '@workflow-engine/executors/saas/film-grain-executor';
+import type { LensEffectsConfig } from '@workflow-engine/executors/saas/lens-effects-executor';
+
+export interface CinematicCameraPreset {
+  id: string;
+  name: string;
+  camera: string;
+  description: string;
+  promptFragment: string;
+  colorGrade: CinematicColorGradeConfig;
+  filmGrain: FilmGrainConfig;
+  lensEffects: LensEffectsConfig;
+}
+
+const off = { enabled: false } as const;
+
+export const CINEMATIC_CAMERA_PRESETS: Record<string, CinematicCameraPreset> = {
+  // -------------------------------------------------------------------------
+  // 6. Commercial Clean — Sony Venice 2
+  // -------------------------------------------------------------------------
+  commercial_clean: {
+    camera: 'Sony Venice 2',
+    colorGrade: {
+      cameraProfile: 'sony_slog3',
+      contrast: 5,
+      highlights: 0,
+      lutIntensity: 0,
+      midtones: 5,
+      saturation: 5,
+      shadows: 0,
+      temperature: 6500,
+    },
+    description:
+      'Clean, polished look with accurate colors and minimal grain. Broadcast and commercial ready.',
+    filmGrain: {
+      animateGrain: false,
+      colorGrain: false,
+      intensity: 8,
+      size: 'fine',
+      stock: 'digital_noise',
+    },
+    id: 'commercial_clean',
+    lensEffects: {
+      barrelDistortion: { ...off, amount: 0 },
+      bloom: { enabled: true, intensity: 10, threshold: 90 },
+      chromaticAberration: { ...off, intensity: 0 },
+      vignette: { enabled: true, intensity: 8, softness: 90 },
+    },
+    name: 'Commercial Clean',
+    promptFragment:
+      'shot on Sony Venice 2, clean cinematic look, accurate colors, soft lighting, polished, commercial',
+  },
+
+  // -------------------------------------------------------------------------
+  // 2. Documentary Raw — RED V-Raptor XL
+  // -------------------------------------------------------------------------
+  documentary_raw: {
+    camera: 'RED V-Raptor XL',
+    colorGrade: {
+      cameraProfile: 'red_ippc2',
+      contrast: 25,
+      highlights: -5,
+      lutIntensity: 0,
+      midtones: 0,
+      saturation: -20,
+      shadows: -10,
+      temperature: 6200,
+    },
+    description:
+      'High-contrast, desaturated look with sharp detail. Raw and authentic feel.',
+    filmGrain: {
+      animateGrain: true,
+      colorGrain: true,
+      intensity: 35,
+      size: 'medium',
+      stock: '35mm_heavy',
+    },
+    id: 'documentary_raw',
+    lensEffects: {
+      barrelDistortion: { amount: 10, enabled: true },
+      bloom: { ...off, intensity: 0, threshold: 80 },
+      chromaticAberration: { ...off, intensity: 0 },
+      vignette: { enabled: true, intensity: 15, softness: 50 },
+    },
+    name: 'Documentary Raw',
+    promptFragment:
+      'shot on RED V-Raptor XL, handheld, natural lighting, documentary style, 8K downscaled',
+  },
+  // -------------------------------------------------------------------------
+  // 1. Hollywood Blockbuster — ARRI Alexa Mini LF
+  // -------------------------------------------------------------------------
+  hollywood_blockbuster: {
+    camera: 'ARRI Alexa Mini LF',
+    colorGrade: {
+      cameraProfile: 'arri_logc4',
+      contrast: 15,
+      highlights: 10,
+      lutIntensity: 0,
+      midtones: 5,
+      saturation: -10,
+      shadows: -15,
+      temperature: 5800,
+    },
+    description:
+      'Rich cinematic look with deep shadows and warm highlights. The gold standard for feature films.',
+    filmGrain: {
+      animateGrain: true,
+      colorGrain: false,
+      intensity: 25,
+      size: 'fine',
+      stock: '35mm_fine',
+    },
+    id: 'hollywood_blockbuster',
+    lensEffects: {
+      barrelDistortion: { amount: 0, enabled: false },
+      bloom: { enabled: true, intensity: 15, threshold: 85 },
+      chromaticAberration: { enabled: true, intensity: 8 },
+      vignette: { enabled: true, intensity: 30, softness: 70 },
+    },
+    name: 'Hollywood Blockbuster',
+    promptFragment:
+      'shot on ARRI Alexa Mini LF, anamorphic lens, cinematic lighting, film grain, shallow depth of field',
+  },
+
+  // -------------------------------------------------------------------------
+  // 4. Indie Film — Blackmagic Pocket 6K Pro
+  // -------------------------------------------------------------------------
+  indie_film: {
+    camera: 'Blackmagic Pocket 6K Pro',
+    colorGrade: {
+      cameraProfile: 'bmpcc_film',
+      contrast: 30,
+      highlights: -10,
+      lutIntensity: 0,
+      midtones: -5,
+      saturation: -15,
+      shadows: -25,
+      temperature: 5500,
+    },
+    description:
+      'Gritty, textured look with crushed blacks and muted tones. Festival-ready aesthetic.',
+    filmGrain: {
+      animateGrain: true,
+      colorGrain: true,
+      intensity: 45,
+      size: 'medium',
+      stock: '16mm',
+    },
+    id: 'indie_film',
+    lensEffects: {
+      barrelDistortion: { amount: 8, enabled: true },
+      bloom: { ...off, intensity: 0, threshold: 80 },
+      chromaticAberration: { enabled: true, intensity: 15 },
+      vignette: { enabled: true, intensity: 40, softness: 50 },
+    },
+    name: 'Indie Film',
+    promptFragment:
+      'shot on Blackmagic Pocket 6K Pro, indie film look, moody lighting, crushed blacks, textured',
+  },
+
+  // -------------------------------------------------------------------------
+  // 3. Social Media Cinematic — Canon C70
+  // -------------------------------------------------------------------------
+  social_media_cinematic: {
+    camera: 'Canon C70',
+    colorGrade: {
+      cameraProfile: 'canon_clog3',
+      contrast: 10,
+      highlights: 5,
+      lutIntensity: 0,
+      midtones: 10,
+      saturation: 20,
+      shadows: 5,
+      temperature: 6800,
+    },
+    description:
+      'Vibrant, punchy colors optimized for mobile screens. Bright and engaging.',
+    filmGrain: {
+      animateGrain: true,
+      colorGrain: false,
+      intensity: 10,
+      size: 'fine',
+      stock: '35mm_fine',
+    },
+    id: 'social_media_cinematic',
+    lensEffects: {
+      barrelDistortion: { ...off, amount: 0 },
+      bloom: { enabled: true, intensity: 20, threshold: 75 },
+      chromaticAberration: { ...off, intensity: 0 },
+      vignette: { enabled: true, intensity: 10, softness: 80 },
+    },
+    name: 'Social Media Cinematic',
+    promptFragment:
+      'shot on Canon C70, vibrant colors, soft lighting, social media ready, vertical format',
+  },
+
+  // -------------------------------------------------------------------------
+  // 5. Vintage 35mm — Kodak Vision3 500T
+  // -------------------------------------------------------------------------
+  vintage_35mm: {
+    camera: 'Kodak Vision3 500T',
+    colorGrade: {
+      cameraProfile: 'kodak_500t',
+      contrast: 20,
+      highlights: 15,
+      lutIntensity: 0,
+      midtones: 10,
+      saturation: -5,
+      shadows: -10,
+      temperature: 4800,
+    },
+    description:
+      'Warm, nostalgic film look with heavy grain and halation. Classic celluloid aesthetic.',
+    filmGrain: {
+      animateGrain: true,
+      colorGrain: true,
+      intensity: 60,
+      size: 'coarse',
+      stock: '35mm_heavy',
+    },
+    id: 'vintage_35mm',
+    lensEffects: {
+      barrelDistortion: { ...off, amount: 0 },
+      bloom: { enabled: true, intensity: 35, threshold: 70 },
+      chromaticAberration: { enabled: true, intensity: 20 },
+      vignette: { enabled: true, intensity: 35, softness: 60 },
+    },
+    name: 'Vintage 35mm',
+    promptFragment:
+      'shot on Kodak Vision3 500T film stock, 35mm, warm tones, heavy grain, halation, nostalgic',
+  },
+};
+
+/**
+ * Get a camera preset by id.
+ */
+export function getCinematicCameraPreset(
+  id: string,
+): CinematicCameraPreset | undefined {
+  return CINEMATIC_CAMERA_PRESETS[id];
+}
+
+/**
+ * List all available camera preset ids.
+ */
+export function listCinematicCameraPresetIds(): string[] {
+  return Object.keys(CINEMATIC_CAMERA_PRESETS);
+}

package/src/executors/saas/cinematic-color-grade-executor.spec.ts

@@ -0,0 +1,240 @@
+import type { ExecutionContext } from '@workflow-engine/execution/engine';
+import type { ExecutorInput } from '@workflow-engine/executors/base-executor';
+import {
+  buildCinematicColorGradeFilterChain,
+  CAMERA_PROFILE_CURVES,
+  type CinematicColorGradeConfig,
+  type CinematicColorGradeExecutor,
+  type CinematicColorGradeProcessor,
+  createCinematicColorGradeExecutor,
+} from '@workflow-engine/executors/saas/cinematic-color-grade-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+function makeInput(
+  config: Record<string, unknown>,
+  videoUrl = 'https://example.com/video.mp4',
+): ExecutorInput {
+  const node: ExecutableNode = {
+    config,
+    id: 'cg-1',
+    inputs: [],
+    label: 'Cinematic Color Grade',
+    type: 'cinematicColorGrade',
+  };
+  const inputs = new Map<string, unknown>();
+  inputs.set('videoUrl', videoUrl);
+  const context: ExecutionContext = {
+    organizationId: 'org-1',
+    runId: 'run-1',
+    userId: 'user-1',
+    workflowId: 'wf-1',
+  };
+  return { context, inputs, node };
+}
+
+describe('buildCinematicColorGradeFilterChain', () => {
+  it('includes camera profile curves', () => {
+    const config: CinematicColorGradeConfig = {
+      cameraProfile: 'arri_logc4',
+      contrast: 0,
+      highlights: 0,
+      lutIntensity: 0,
+      midtones: 0,
+      saturation: 0,
+      shadows: 0,
+      temperature: 6500,
+    };
+    const chain = buildCinematicColorGradeFilterChain(config);
+    expect(chain).toContain(CAMERA_PROFILE_CURVES.arri_logc4);
+  });
+
+  it('includes colorbalance filter', () => {
+    const config: CinematicColorGradeConfig = {
+      cameraProfile: 'red_ippc2',
+      contrast: 10,
+      highlights: 5,
+      lutIntensity: 0,
+      midtones: -10,
+      saturation: -10,
+      shadows: 20,
+      temperature: 5000,
+    };
+    const chain = buildCinematicColorGradeFilterChain(config);
+    expect(chain).toContain('colorbalance=');
+    expect(chain).toContain('eq=contrast=');
+  });
+
+  it('adds LUT blend when customLUT is provided', () => {
+    const config: CinematicColorGradeConfig = {
+      cameraProfile: 'sony_slog3',
+      contrast: 0,
+      customLUT: '/path/to/lut.cube',
+      highlights: 0,
+      lutIntensity: 75,
+      midtones: 0,
+      saturation: 0,
+      shadows: 0,
+      temperature: 6500,
+    };
+    const chain = buildCinematicColorGradeFilterChain(config);
+    expect(chain).toContain('lut3d=');
+    expect(chain).toContain('blend=all_mode=normal:all_opacity=0.75');
+  });
+
+  it('skips LUT when lutIntensity is 0', () => {
+    const config: CinematicColorGradeConfig = {
+      cameraProfile: 'arri_logc4',
+      contrast: 0,
+      customLUT: '/path/to/lut.cube',
+      highlights: 0,
+      lutIntensity: 0,
+      midtones: 0,
+      saturation: 0,
+      shadows: 0,
+      temperature: 6500,
+    };
+    const chain = buildCinematicColorGradeFilterChain(config);
+    expect(chain).not.toContain('lut3d');
+  });
+
+  it('maps temperature to warm/cool shifts', () => {
+    const warm: CinematicColorGradeConfig = {
+      cameraProfile: 'arri_logc4',
+      contrast: 0,
+      highlights: 0,
+      lutIntensity: 0,
+      midtones: 0,
+      saturation: 0,
+      shadows: 0,
+      temperature: 9000,
+    };
+    const cool: CinematicColorGradeConfig = {
+      ...warm,
+      temperature: 3000,
+    };
+    const warmChain = buildCinematicColorGradeFilterChain(warm);
+    const coolChain = buildCinematicColorGradeFilterChain(cool);
+    // Warm should have positive rs, cool should have negative
+    expect(warmChain).not.toBe(coolChain);
+  });
+});
+
+describe('CinematicColorGradeExecutor', () => {
+  let executor: CinematicColorGradeExecutor;
+  let mockProcessor: CinematicColorGradeProcessor;
+
+  beforeEach(() => {
+    mockProcessor = vi.fn().mockResolvedValue({
+      jobId: 'job-123',
+      outputVideoUrl: 'https://cdn.example.com/graded.mp4',
+    });
+    executor = createCinematicColorGradeExecutor(mockProcessor);
+  });
+
+  describe('validate', () => {
+    it('passes with valid config', () => {
+      const result = executor.validate({
+        config: {
+          cameraProfile: 'arri_logc4',
+          contrast: 10,
+          saturation: -10,
+          temperature: 5500,
+        },
+        id: 'cg-1',
+        inputs: [],
+        label: 'CG',
+        type: 'cinematicColorGrade',
+      });
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('rejects invalid camera profile', () => {
+      const result = executor.validate({
+        config: { cameraProfile: 'nikon_nlog' },
+        id: 'cg-1',
+        inputs: [],
+        label: 'CG',
+        type: 'cinematicColorGrade',
+      });
+      expect(result.valid).toBe(false);
+      expect(result.errors[0]).toContain('cameraProfile');
+    });
+
+    it('rejects out-of-range contrast', () => {
+      const result = executor.validate({
+        config: { contrast: 200 },
+        id: 'cg-1',
+        inputs: [],
+        label: 'CG',
+        type: 'cinematicColorGrade',
+      });
+      expect(result.valid).toBe(false);
+      expect(result.errors[0]).toContain('contrast');
+    });
+
+    it('rejects out-of-range temperature', () => {
+      const result = executor.validate({
+        config: { temperature: 500 },
+        id: 'cg-1',
+        inputs: [],
+        label: 'CG',
+        type: 'cinematicColorGrade',
+      });
+      expect(result.valid).toBe(false);
+    });
+  });
+
+  describe('execute', () => {
+    it('calls processor with filter chain', async () => {
+      const input = makeInput({ cameraProfile: 'red_ippc2', contrast: 20 });
+      const result = await executor.execute(input);
+      expect(mockProcessor).toHaveBeenCalledOnce();
+      expect(result.data).toBe('https://cdn.example.com/graded.mp4');
+      expect(result.metadata?.filterChain).toBeTruthy();
+      expect(result.metadata?.cameraProfile).toBe('red_ippc2');
+    });
+
+    it('throws when processor not configured', async () => {
+      const bare = createCinematicColorGradeExecutor();
+      const input = makeInput({});
+      await expect(bare.execute(input)).rejects.toThrow(
+        'processor not configured',
+      );
+    });
+
+    it('throws when videoUrl input is missing', async () => {
+      const node: ExecutableNode = {
+        config: {},
+        id: 'cg-1',
+        inputs: [],
+        label: 'CG',
+        type: 'cinematicColorGrade',
+      };
+      const input: ExecutorInput = {
+        context: {
+          organizationId: 'org-1',
+          runId: 'run-1',
+          userId: 'user-1',
+          workflowId: 'wf-1',
+        },
+        inputs: new Map(),
+        node,
+      };
+      await expect(executor.execute(input)).rejects.toThrow('videoUrl');
+    });
+  });
+
+  it('estimateCost returns 2', () => {
+    expect(
+      executor.estimateCost({
+        config: {},
+        id: 'cg-1',
+        inputs: [],
+        label: 'CG',
+        type: 'cinematicColorGrade',
+      }),
+    ).toBe(2);
+  });
+});