@genfeedai/workflow-engine 0.2.0

package/src/executors/index.ts

@@ -0,0 +1,3 @@
+export * from '@workflow-engine/executors/base-executor';
+export * from '@workflow-engine/executors/executor-registry';
+export * from '@workflow-engine/executors/saas';

package/src/executors/saas/beat-analysis-executor.spec.ts

@@ -0,0 +1,126 @@
+import { BeatSensitivity } from '@genfeedai/enums';
+import type { ExecutionContext } from '@workflow-engine/execution/engine';
+import { createBeatAnalysisExecutor } from '@workflow-engine/executors/saas/beat-analysis-executor';
+import { describe, expect, it, vi } from 'vitest';
+
+const ctx: ExecutionContext = {
+  organizationId: 'o',
+  runId: 'r',
+  userId: 'u',
+  workflowId: 'w',
+};
+
+describe('BeatAnalysisExecutor', () => {
+  describe('validate', () => {
+    it('valid defaults', () => {
+      expect(
+        createBeatAnalysisExecutor().validate({
+          config: {},
+          id: '1',
+          inputs: [],
+          label: 'BA',
+          type: 'beatAnalysis',
+        }).valid,
+      ).toBe(true);
+    });
+    it('invalid minBpm < 20', () => {
+      expect(
+        createBeatAnalysisExecutor().validate({
+          config: { minBpm: 10 },
+          id: '1',
+          inputs: [],
+          label: 'BA',
+          type: 'beatAnalysis',
+        }).valid,
+      ).toBe(false);
+    });
+    it('invalid maxBpm > 300', () => {
+      expect(
+        createBeatAnalysisExecutor().validate({
+          config: { maxBpm: 400 },
+          id: '1',
+          inputs: [],
+          label: 'BA',
+          type: 'beatAnalysis',
+        }).valid,
+      ).toBe(false);
+    });
+    it('invalid minBpm > maxBpm', () => {
+      expect(
+        createBeatAnalysisExecutor().validate({
+          config: { maxBpm: 100, minBpm: 200 },
+          id: '1',
+          inputs: [],
+          label: 'BA',
+          type: 'beatAnalysis',
+        }).valid,
+      ).toBe(false);
+    });
+    it('invalid beatSensitivity', () => {
+      expect(
+        createBeatAnalysisExecutor().validate({
+          config: { beatSensitivity: 'ultra' },
+          id: '1',
+          inputs: [],
+          label: 'BA',
+          type: 'beatAnalysis',
+        }).valid,
+      ).toBe(false);
+    });
+  });
+
+  it('estimateCost returns 2', () => {
+    expect(
+      createBeatAnalysisExecutor().estimateCost({
+        config: {},
+        id: '1',
+        inputs: [],
+        label: 'BA',
+        type: 'beatAnalysis',
+      }),
+    ).toBe(2);
+  });
+
+  describe('execute', () => {
+    it('throws without analyzer', async () => {
+      await expect(
+        createBeatAnalysisExecutor().execute({
+          context: ctx,
+          inputs: new Map<string, unknown>([['musicUrl', 'http://m.mp3']]),
+          node: {
+            config: {},
+            id: '1',
+            inputs: [],
+            label: 'BA',
+            type: 'beatAnalysis',
+          },
+        }),
+      ).rejects.toThrow('analyzer');
+    });
+
+    it('analyzes beats', async () => {
+      const analyzer = vi.fn().mockResolvedValue({
+        analysisMethod: 'aubio',
+        beatCount: 3,
+        beatTimestamps: [0.5, 1.0],
+        confidence: 0.95,
+        downbeats: [0.5],
+        tempo: 120,
+      });
+      const exec = createBeatAnalysisExecutor(analyzer);
+      const result = await exec.execute({
+        context: ctx,
+        inputs: new Map<string, unknown>([['musicUrl', 'http://m.mp3']]),
+        node: {
+          config: { beatSensitivity: BeatSensitivity.HIGH },
+          id: '1',
+          inputs: [],
+          label: 'BA',
+          type: 'beatAnalysis',
+        },
+      });
+      expect((result.data as any).tempo).toBe(120);
+      expect(result.metadata?.analysisMethod).toBe('aubio');
+    });
+  });
+});

package/src/executors/saas/beat-analysis-executor.ts

@@ -0,0 +1,136 @@
+import { BeatSensitivity } from '@genfeedai/enums';
+import {
+  BaseExecutor,
+  type ExecutorInput,
+  type ExecutorOutput,
+} from '@workflow-engine/executors/base-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+
+export interface BeatAnalysisResult {
+  tempo: number;
+  beatTimestamps: number[];
+  downbeats: number[];
+  beatCount: number;
+  analysisMethod: 'aubio' | 'ffmpeg';
+  confidence: number;
+}
+
+export type BeatAnalyzer = (params: {
+  organizationId: string;
+  musicUrl: string;
+  minBpm: number;
+  maxBpm: number;
+  beatSensitivity: BeatSensitivity;
+}) => Promise<BeatAnalysisResult>;
+
+/**
+ * Beat Analysis Executor
+ *
+ * Detects tempo and beat timestamps from audio files.
+ * Uses aubio for accurate onset detection with FFmpeg fallback.
+ *
+ * Node Type: beatAnalysis
+ * Definition: @genfeedai/workflow-saas/nodes/beat-analysis.ts
+ */
+export class BeatAnalysisExecutor extends BaseExecutor {
+  readonly nodeType = 'beatAnalysis';
+  private analyzer: BeatAnalyzer | null = null;
+
+  setAnalyzer(analyzer: BeatAnalyzer): void {
+    this.analyzer = analyzer;
+  }
+
+  validate(node: ExecutableNode): { valid: boolean; errors: string[] } {
+    const baseValidation = super.validate(node);
+    const errors = [...baseValidation.errors];
+
+    const minBpm = node.config.minBpm;
+    if (
+      minBpm !== undefined &&
+      (typeof minBpm !== 'number' || minBpm < 20 || minBpm > 300)
+    ) {
+      errors.push('Min BPM must be between 20 and 300');
+    }
+
+    const maxBpm = node.config.maxBpm;
+    if (
+      maxBpm !== undefined &&
+      (typeof maxBpm !== 'number' || maxBpm < 20 || maxBpm > 300)
+    ) {
+      errors.push('Max BPM must be between 20 and 300');
+    }
+
+    if (minBpm != null && maxBpm != null && minBpm > maxBpm) {
+      errors.push('Min BPM cannot be greater than max BPM');
+    }
+
+    const beatSensitivity = node.config.beatSensitivity;
+    if (
+      beatSensitivity &&
+      !Object.values(BeatSensitivity).includes(
+        beatSensitivity as BeatSensitivity,
+      )
+    ) {
+      errors.push(
+        `Invalid beat sensitivity. Must be one of: ${Object.values(BeatSensitivity).join(', ')}`,
+      );
+    }
+
+    return {
+      errors,
+      valid: errors.length === 0,
+    };
+  }
+
+  estimateCost(_node: ExecutableNode): number {
+    return 2; // Beat analysis costs 2 credits
+  }
+
+  async execute(input: ExecutorInput): Promise<ExecutorOutput> {
+    const { node, inputs, context } = input;
+
+    if (!this.analyzer) {
+      throw new Error('Beat analyzer not configured');
+    }
+
+    const musicUrl = this.getRequiredInput<string>(inputs, 'musicUrl');
+    const minBpm = this.getOptionalConfig<number>(node.config, 'minBpm', 60);
+    const maxBpm = this.getOptionalConfig<number>(node.config, 'maxBpm', 200);
+    const beatSensitivity = this.getOptionalConfig<BeatSensitivity>(
+      node.config,
+      'beatSensitivity',
+      BeatSensitivity.MEDIUM,
+    );
+
+    const result = await this.analyzer({
+      beatSensitivity,
+      maxBpm,
+      minBpm,
+      musicUrl,
+      organizationId: context.organizationId,
+    });
+
+    return {
+      data: {
+        beatTimestamps: result.beatTimestamps,
+        downbeats: result.downbeats,
+        tempo: result.tempo,
+      },
+      metadata: {
+        analysisMethod: result.analysisMethod,
+        beatCount: result.beatCount,
+        confidence: result.confidence,
+      },
+    };
+  }
+}
+
+export function createBeatAnalysisExecutor(
+  analyzer?: BeatAnalyzer,
+): BeatAnalysisExecutor {
+  const executor = new BeatAnalysisExecutor();
+  if (analyzer) {
+    executor.setAnalyzer(analyzer);
+  }
+  return executor;
+}

package/src/executors/saas/beat-sync-editor-executor.spec.ts

@@ -0,0 +1,250 @@
+import { BeatSyncTransitionType } from '@genfeedai/enums';
+import type { ExecutionContext } from '@workflow-engine/execution/engine';
+import { createBeatSyncEditorExecutor } from '@workflow-engine/executors/saas/beat-sync-editor-executor';
+import { describe, expect, it, vi } from 'vitest';
+
+const ctx: ExecutionContext = {
+  organizationId: 'o',
+  runId: 'r',
+  userId: 'u',
+  workflowId: 'w',
+};
+
+describe('BeatSyncEditorExecutor', () => {
+  describe('validate', () => {
+    it('valid defaults', () => {
+      expect(
+        createBeatSyncEditorExecutor().validate({
+          config: {},
+          id: '1',
+          inputs: [],
+          label: 'B',
+          type: 'beatSyncEditor',
+        }).valid,
+      ).toBe(true);
+    });
+    it('invalid cutStrategy', () => {
+      expect(
+        createBeatSyncEditorExecutor().validate({
+          config: { cutStrategy: 'random' },
+          id: '1',
+          inputs: [],
+          label: 'B',
+          type: 'beatSyncEditor',
+        }).valid,
+      ).toBe(false);
+    });
+    it('invalid transitionType', () => {
+      expect(
+        createBeatSyncEditorExecutor().validate({
+          config: { transitionType: 'wipe' },
+          id: '1',
+          inputs: [],
+          label: 'B',
+          type: 'beatSyncEditor',
+        }).valid,
+      ).toBe(false);
+    });
+    it('invalid transitionDuration', () => {
+      expect(
+        createBeatSyncEditorExecutor().validate({
+          config: { transitionDuration: 2000 },
+          id: '1',
+          inputs: [],
+          label: 'B',
+          type: 'beatSyncEditor',
+        }).valid,
+      ).toBe(false);
+    });
+    it('invalid beatsPerClip', () => {
+      expect(
+        createBeatSyncEditorExecutor().validate({
+          config: { beatsPerClip: 20 },
+          id: '1',
+          inputs: [],
+          label: 'B',
+          type: 'beatSyncEditor',
+        }).valid,
+      ).toBe(false);
+    });
+  });
+
+  describe('estimateCost', () => {
+    it('base cost + beatsPerClip=1 bonus', () => {
+      expect(
+        createBeatSyncEditorExecutor().estimateCost({
+          config: {
+            beatsPerClip: 1,
+            transitionType: BeatSyncTransitionType.CUT,
+          },
+          id: '1',
+          inputs: [],
+          label: 'B',
+          type: 'beatSyncEditor',
+        }),
+      ).toBe(8);
+    });
+    it('adds transition cost', () => {
+      expect(
+        createBeatSyncEditorExecutor().estimateCost({
+          config: {
+            beatsPerClip: 2,
+            transitionType: BeatSyncTransitionType.CROSSFADE,
+          },
+          id: '1',
+          inputs: [],
+          label: 'B',
+          type: 'beatSyncEditor',
+        }),
+      ).toBe(7);
+    });
+  });
+
+  describe('execute', () => {
+    it('throws without editor', async () => {
+      await expect(
+        createBeatSyncEditorExecutor().execute({
+          context: ctx,
+          inputs: new Map<string, unknown>([
+            ['videoFiles', ['v.mp4']],
+            ['beatTimestamps', [0.5]],
+            ['musicUrl', 'http://m'],
+          ]),
+          node: {
+            config: {},
+            id: '1',
+            inputs: [],
+            label: 'B',
+            type: 'beatSyncEditor',
+          },
+        }),
+      ).rejects.toThrow('editor');
+    });
+
+    it('processes video', async () => {
+      const editor = vi.fn().mockResolvedValue({
+        jobId: 'j-1',
+        outputVideoUrl: 'http://out.mp4',
+        totalClips: 5,
+        totalDuration: 30,
+      });
+      const exec = createBeatSyncEditorExecutor(editor);
+      const result = await exec.execute({
+        context: ctx,
+        inputs: new Map<string, unknown>([
+          ['videoFiles', ['v.mp4']],
+          ['beatTimestamps', [0.5, 1.0]],
+          ['musicUrl', 'http://m'],
+        ]),
+        node: {
+          config: {},
+          id: '1',
+          inputs: [],
+          label: 'B',
+          type: 'beatSyncEditor',
+        },
+      });
+      expect(result.data).toBe('http://out.mp4');
+      expect(result.metadata?.totalClips).toBe(5);
+    });
+
+    it('handles single string videoFiles', async () => {
+      const editor = vi.fn().mockResolvedValue({
+        jobId: 'j',
+        outputVideoUrl: 'o',
+        totalClips: 1,
+        totalDuration: 10,
+      });
+      const exec = createBeatSyncEditorExecutor(editor);
+      await exec.execute({
+        context: ctx,
+        inputs: new Map<string, unknown>([
+          ['videoFiles', 'v.mp4'],
+          ['beatTimestamps', [0.5]],
+          ['musicUrl', 'http://m'],
+        ]),
+        node: {
+          config: {},
+          id: '1',
+          inputs: [],
+          label: 'B',
+          type: 'beatSyncEditor',
+        },
+      });
+      expect(editor).toHaveBeenCalledWith(
+        expect.objectContaining({ videoFiles: ['v.mp4'] }),
+      );
+    });
+
+    it('handles beat data as object', async () => {
+      const editor = vi.fn().mockResolvedValue({
+        jobId: 'j',
+        outputVideoUrl: 'o',
+        totalClips: 1,
+        totalDuration: 10,
+      });
+      const exec = createBeatSyncEditorExecutor(editor);
+      await exec.execute({
+        context: ctx,
+        inputs: new Map<string, unknown>([
+          ['videoFiles', ['v.mp4']],
+          ['beatTimestamps', { beatTimestamps: [0.5] }],
+          ['musicUrl', 'http://m'],
+        ]),
+        node: {
+          config: {},
+          id: '1',
+          inputs: [],
+          label: 'B',
+          type: 'beatSyncEditor',
+        },
+      });
+      expect(editor).toHaveBeenCalledWith(
+        expect.objectContaining({ beatTimestamps: [0.5] }),
+      );
+    });
+
+    it('throws on missing videoFiles', async () => {
+      const editor = vi.fn();
+      const exec = createBeatSyncEditorExecutor(editor);
+      await expect(
+        exec.execute({
+          context: ctx,
+          inputs: new Map<string, unknown>([
+            ['beatTimestamps', [0.5]],
+            ['musicUrl', 'http://m'],
+          ]),
+          node: {
+            config: {},
+            id: '1',
+            inputs: [],
+            label: 'B',
+            type: 'beatSyncEditor',
+          },
+        }),
+      ).rejects.toThrow('videoFiles');
+    });
+
+    it('throws on empty beatTimestamps', async () => {
+      const editor = vi.fn();
+      const exec = createBeatSyncEditorExecutor(editor);
+      await expect(
+        exec.execute({
+          context: ctx,
+          inputs: new Map<string, unknown>([
+            ['videoFiles', ['v.mp4']],
+            ['beatTimestamps', []],
+            ['musicUrl', 'http://m'],
+          ]),
+          node: {
+            config: {},
+            id: '1',
+            inputs: [],
+            label: 'B',
+            type: 'beatSyncEditor',
+          },
+        }),
+      ).rejects.toThrow('beat timestamp');
+    });
+  });
+});