@genfeedai/workflow-engine 0.2.0

package/dist/workflow-engine/src/executors/saas/color-grade-executor.spec.js

@@ -0,0 +1,199 @@
+import {
+  buildFfmpegFilterChain,
+  COLOR_GRADE_PRESETS,
+  createColorGradeExecutor,
+} from '@workflow-engine/executors/saas/color-grade-executor';
+import { describe, expect, it, vi } from 'vitest';
+
+const ctx = {
+  organizationId: 'o',
+  runId: 'r',
+  userId: 'u',
+  workflowId: 'w',
+};
+describe('buildFfmpegFilterChain', () => {
+  it('builds basic eq filter', () => {
+    const chain = buildFfmpegFilterChain({
+      contrast: 50,
+      grain: 0,
+      saturation: 50,
+      sharpness: 0,
+      vignette: 0,
+      warmth: 50,
+    });
+    expect(chain).toContain('eq=');
+  });
+  it('includes vignette when > 0', () => {
+    expect(
+      buildFfmpegFilterChain({
+        contrast: 50,
+        grain: 0,
+        saturation: 50,
+        sharpness: 0,
+        vignette: 50,
+        warmth: 50,
+      }),
+    ).toContain('vignette');
+  });
+  it('includes grain when > 0', () => {
+    expect(
+      buildFfmpegFilterChain({
+        contrast: 50,
+        grain: 50,
+        saturation: 50,
+        sharpness: 0,
+        vignette: 0,
+        warmth: 50,
+      }),
+    ).toContain('noise');
+  });
+  it('includes sharpness when > 0', () => {
+    expect(
+      buildFfmpegFilterChain({
+        contrast: 50,
+        grain: 0,
+        saturation: 50,
+        sharpness: 50,
+        vignette: 0,
+        warmth: 50,
+      }),
+    ).toContain('unsharp');
+  });
+  it('includes colorbalance for warm warmth', () => {
+    expect(
+      buildFfmpegFilterChain({
+        contrast: 50,
+        grain: 0,
+        saturation: 50,
+        sharpness: 0,
+        vignette: 0,
+        warmth: 80,
+      }),
+    ).toContain('colorbalance');
+  });
+});
+describe('COLOR_GRADE_PRESETS', () => {
+  it('has all presets', () => {
+    expect(Object.keys(COLOR_GRADE_PRESETS)).toContain('instagram-warm');
+    expect(Object.keys(COLOR_GRADE_PRESETS)).toContain('custom');
+  });
+});
+describe('ColorGradeExecutor', () => {
+  describe('validate', () => {
+    it('valid defaults', () => {
+      expect(
+        createColorGradeExecutor().validate({
+          config: {},
+          id: '1',
+          inputs: [],
+          label: 'CG',
+          type: 'colorGrade',
+        }).valid,
+      ).toBe(true);
+    });
+    it('invalid mode', () => {
+      expect(
+        createColorGradeExecutor().validate({
+          config: { mode: 'magic' },
+          id: '1',
+          inputs: [],
+          label: 'CG',
+          type: 'colorGrade',
+        }).valid,
+      ).toBe(false);
+    });
+    it('invalid preset', () => {
+      expect(
+        createColorGradeExecutor().validate({
+          config: { preset: 'fantasy' },
+          id: '1',
+          inputs: [],
+          label: 'CG',
+          type: 'colorGrade',
+        }).valid,
+      ).toBe(false);
+    });
+    it('invalid numeric field', () => {
+      expect(
+        createColorGradeExecutor().validate({
+          config: { warmth: 150 },
+          id: '1',
+          inputs: [],
+          label: 'CG',
+          type: 'colorGrade',
+        }).valid,
+      ).toBe(false);
+    });
+    it('requires style ref for ai-style', () => {
+      expect(
+        createColorGradeExecutor().validate({
+          config: { mode: 'ai-style' },
+          id: '1',
+          inputs: [],
+          label: 'CG',
+          type: 'colorGrade',
+        }).valid,
+      ).toBe(false);
+    });
+  });
+  describe('estimateCost', () => {
+    it('5 for ai-style', () => {
+      expect(
+        createColorGradeExecutor().estimateCost({
+          config: { mode: 'ai-style' },
+          id: '1',
+          inputs: [],
+          label: 'CG',
+          type: 'colorGrade',
+        }),
+      ).toBe(5);
+    });
+    it('0 for preset', () => {
+      expect(
+        createColorGradeExecutor().estimateCost({
+          config: { mode: 'preset' },
+          id: '1',
+          inputs: [],
+          label: 'CG',
+          type: 'colorGrade',
+        }),
+      ).toBe(0);
+    });
+  });
+  describe('execute', () => {
+    it('throws without processor', async () => {
+      await expect(
+        createColorGradeExecutor().execute({
+          context: ctx,
+          inputs: new Map([['imageUrl', 'http://i.png']]),
+          node: {
+            config: {},
+            id: '1',
+            inputs: [],
+            label: 'CG',
+            type: 'colorGrade',
+          },
+        }),
+      ).rejects.toThrow('processor');
+    });
+    it('processes image', async () => {
+      const processor = vi
+        .fn()
+        .mockResolvedValue({ jobId: 'j', outputImageUrl: 'http://out.png' });
+      const exec = createColorGradeExecutor(processor);
+      const result = await exec.execute({
+        context: ctx,
+        inputs: new Map([['imageUrl', 'http://i.png']]),
+        node: {
+          config: {},
+          id: '1',
+          inputs: [],
+          label: 'CG',
+          type: 'colorGrade',
+        },
+      });
+      expect(result.data).toBe('http://out.png');
+      expect(result.metadata?.mode).toBe('preset');
+    });
+  });
+});

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

@@ -0,0 +1,43 @@
+import { BaseExecutor, type ExecutorInput, type ExecutorOutput } from '@workflow-engine/executors/base-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+export type ConditionOperator = 'equals' | 'notEquals' | 'greaterThan' | 'lessThan' | 'greaterThanOrEquals' | 'lessThanOrEquals' | 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'matches' | 'isTrue' | 'isFalse' | 'isEmpty' | 'isNotEmpty' | 'expression';
+export type ConditionField = 'engagementRate' | 'followerCount' | 'contentType' | 'platform' | 'timeOfDay' | 'dayOfWeek' | 'custom';
+export interface ConditionConfig {
+    /** The field to evaluate */
+    field: ConditionField;
+    /** The comparison operator */
+    operator: ConditionOperator;
+    /** The value to compare against */
+    value?: unknown;
+    /** Custom field path (dot-notation) when field is 'custom' */
+    customField?: string;
+    /** Raw expression string for 'expression' operator */
+    expression?: string;
+    /** Timezone for time-based conditions */
+    timezone?: string;
+}
+export interface ConditionResult {
+    /** Whether the condition evaluated to true */
+    result: boolean;
+    /** The actual value that was evaluated */
+    actualValue: unknown;
+    /** The expected/comparison value */
+    expectedValue: unknown;
+    /** The operator used */
+    operator: ConditionOperator;
+    /** Pass-through data from input */
+    data: unknown;
+}
+export declare function evaluateCondition(operator: ConditionOperator, actual: unknown, expected: unknown, expression?: string): boolean;
+export declare class ConditionExecutor extends BaseExecutor {
+    readonly nodeType = "condition";
+    execute(input: ExecutorInput): Promise<ExecutorOutput>;
+    validate(node: ExecutableNode): {
+        valid: boolean;
+        errors: string[];
+    };
+    estimateCost(_node: ExecutableNode): number;
+    private resolveConfig;
+}
+export declare function createConditionExecutor(): ConditionExecutor;
+//# sourceMappingURL=condition-executor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"condition-executor.d.ts","sourceRoot":"","sources":["../../../../../src/executors/saas/condition-executor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,KAAK,aAAa,EAClB,KAAK,cAAc,EACpB,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAM7D,MAAM,MAAM,iBAAiB,GACzB,QAAQ,GACR,WAAW,GACX,aAAa,GACb,UAAU,GACV,qBAAqB,GACrB,kBAAkB,GAClB,UAAU,GACV,aAAa,GACb,YAAY,GACZ,UAAU,GACV,SAAS,GACT,QAAQ,GACR,SAAS,GACT,SAAS,GACT,YAAY,GACZ,YAAY,CAAC;AAEjB,MAAM,MAAM,cAAc,GACtB,gBAAgB,GAChB,eAAe,GACf,aAAa,GACb,UAAU,GACV,WAAW,GACX,WAAW,GACX,QAAQ,CAAC;AAEb,MAAM,WAAW,eAAe;IAC9B,4BAA4B;IAC5B,KAAK,EAAE,cAAc,CAAC;IACtB,8BAA8B;IAC9B,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,mCAAmC;IACnC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,8DAA8D;IAC9D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sDAAsD;IACtD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,yCAAyC;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,8CAA8C;IAC9C,MAAM,EAAE,OAAO,CAAC;IAChB,0CAA0C;IAC1C,WAAW,EAAE,OAAO,CAAC;IACrB,oCAAoC;IACpC,aAAa,EAAE,OAAO,CAAC;IACvB,wBAAwB;IACxB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,mCAAmC;IACnC,IAAI,EAAE,OAAO,CAAC;CACf;AAiHD,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,iBAAiB,EAC3B,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,OAAO,EACjB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAyET;AAsED,qBAAa,iBAAkB,SAAQ,YAAY;IACjD,QAAQ,CAAC,QAAQ,eAAe;IAE1B,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;IAgC5D,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE;IA6CpE,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM;IAI3C,OAAO,CAAC,aAAa;CAUtB;AAED,wBAAgB,uBAAuB,IAAI,iBAAiB,CAE3D"}

package/dist/workflow-engine/src/executors/saas/condition-executor.js

@@ -0,0 +1,281 @@
+import { BaseExecutor, } from '@workflow-engine/executors/base-executor';
+// =============================================================================
+// FIELD RESOLVERS
+// =============================================================================
+function resolveFieldValue(field, inputs, config) {
+    const inputData = inputs.values().next().value;
+    switch (field) {
+        case 'engagementRate':
+            return (resolveNestedValue(inputData, 'engagementRate') ??
+                resolveNestedValue(inputData, 'analytics.engagementRate') ??
+                resolveNestedValue(inputData, 'data.engagementRate'));
+        case 'followerCount':
+            return (resolveNestedValue(inputData, 'followerCount') ??
+                resolveNestedValue(inputData, 'analytics.followerCount') ??
+                resolveNestedValue(inputData, 'data.followerCount'));
+        case 'contentType':
+            return (resolveNestedValue(inputData, 'contentType') ??
+                resolveNestedValue(inputData, 'type') ??
+                resolveNestedValue(inputData, 'data.contentType'));
+        case 'platform':
+            return (resolveNestedValue(inputData, 'platform') ??
+                resolveNestedValue(inputData, 'data.platform'));
+        case 'timeOfDay': {
+            const tz = config.timezone ?? 'UTC';
+            try {
+                const now = new Date();
+                const formatter = new Intl.DateTimeFormat('en-US', {
+                    hour: 'numeric',
+                    hour12: false,
+                    timeZone: tz,
+                });
+                return parseInt(formatter.format(now), 10);
+            }
+            catch {
+                return new Date().getUTCHours();
+            }
+        }
+        case 'dayOfWeek': {
+            const tz = config.timezone ?? 'UTC';
+            try {
+                const now = new Date();
+                const formatter = new Intl.DateTimeFormat('en-US', {
+                    timeZone: tz,
+                    weekday: 'long',
+                });
+                return formatter.format(now).toLowerCase();
+            }
+            catch {
+                const days = [
+                    'sunday',
+                    'monday',
+                    'tuesday',
+                    'wednesday',
+                    'thursday',
+                    'friday',
+                    'saturday',
+                ];
+                return days[new Date().getUTCDay()];
+            }
+        }
+        case 'custom': {
+            const customPath = config.customField;
+            if (!customPath) {
+                throw new Error('customField is required when field is "custom"');
+            }
+            return resolveNestedValue(inputData, customPath);
+        }
+        default:
+            throw new Error(`Unknown condition field: ${field}`);
+    }
+}
+function resolveNestedValue(obj, path) {
+    if (obj == null || typeof obj !== 'object') {
+        return undefined;
+    }
+    const parts = path.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current == null || typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+// =============================================================================
+// OPERATOR EVALUATION
+// =============================================================================
+export function evaluateCondition(operator, actual, expected, expression) {
+    switch (operator) {
+        case 'equals':
+            return actual === expected; // eslint-disable-line eqeqeq
+        case 'notEquals':
+            return actual !== expected; // eslint-disable-line eqeqeq
+        case 'greaterThan':
+            return Number(actual) > Number(expected);
+        case 'lessThan':
+            return Number(actual) < Number(expected);
+        case 'greaterThanOrEquals':
+            return Number(actual) >= Number(expected);
+        case 'lessThanOrEquals':
+            return Number(actual) <= Number(expected);
+        case 'contains':
+            return String(actual).includes(String(expected));
+        case 'notContains':
+            return !String(actual).includes(String(expected));
+        case 'startsWith':
+            return String(actual).startsWith(String(expected));
+        case 'endsWith':
+            return String(actual).endsWith(String(expected));
+        case 'matches': {
+            try {
+                const regex = new RegExp(String(expected));
+                return regex.test(String(actual));
+            }
+            catch {
+                return false;
+            }
+        }
+        case 'isTrue':
+            return Boolean(actual) === true;
+        case 'isFalse':
+            return Boolean(actual) === false;
+        case 'isEmpty':
+            return (actual == null ||
+                actual === '' ||
+                (Array.isArray(actual) && actual.length === 0));
+        case 'isNotEmpty':
+            return (actual != null &&
+                actual !== '' &&
+                !(Array.isArray(actual) && actual.length === 0));
+        case 'expression': {
+            if (!expression) {
+                throw new Error('Expression string is required for "expression" operator');
+            }
+            return evaluateExpression(expression, actual);
+        }
+        default:
+            throw new Error(`Unknown operator: ${operator}`);
+    }
+}
+/**
+ * Evaluates a simple expression string against a value.
+ * Supports: `value > 10`, `value === "foo"`, `value !== "bar"`, etc.
+ * Uses a safe AST-free comparison parser — no code execution.
+ */
+function evaluateExpression(expression, value) {
+    const sanitized = expression.trim();
+    // Match pattern: value <operator> <literal>
+    const match = sanitized.match(/^value\s*(===|!==|==|!=|>=|<=|>|<)\s*(.+)$/);
+    if (!match) {
+        throw new Error('Expression must be in the form: value <operator> <literal>');
+    }
+    const operator = match[1];
+    const rawRight = match[2].trim();
+    // Parse the right-hand literal safely (string, number, boolean, null)
+    let right;
+    if ((rawRight.startsWith('"') && rawRight.endsWith('"')) ||
+        (rawRight.startsWith("'") && rawRight.endsWith("'"))) {
+        right = rawRight.slice(1, -1);
+    }
+    else if (rawRight === 'true') {
+        right = true;
+    }
+    else if (rawRight === 'false') {
+        right = false;
+    }
+    else if (rawRight === 'null') {
+        right = null;
+    }
+    else if (rawRight === 'undefined') {
+        right = undefined;
+    }
+    else if (!Number.isNaN(Number(rawRight))) {
+        right = Number(rawRight);
+    }
+    else {
+        throw new Error(`Unsupported literal in expression: ${rawRight}`);
+    }
+    switch (operator) {
+        case '===':
+            return value === right;
+        case '!==':
+            return value !== right;
+        case '==':
+            // biome-ignore lint/suspicious/noDoubleEquals: intentional loose equality for user expressions
+            return value == right;
+        case '!=':
+            // biome-ignore lint/suspicious/noDoubleEquals: intentional loose inequality for user expressions
+            return value != right;
+        case '>':
+            return value > right;
+        case '<':
+            return value < right;
+        case '>=':
+            return value >= right;
+        case '<=':
+            return value <= right;
+        default:
+            throw new Error(`Unsupported operator: ${operator}`);
+    }
+}
+// =============================================================================
+// EXECUTOR
+// =============================================================================
+export class ConditionExecutor extends BaseExecutor {
+    nodeType = 'condition';
+    async execute(input) {
+        const { node, inputs } = input;
+        const config = this.resolveConfig(node);
+        const actualValue = resolveFieldValue(config.field, inputs, config);
+        const result = evaluateCondition(config.operator, actualValue, config.value, config.expression);
+        const passthrough = inputs.values().next().value ?? null;
+        const conditionResult = {
+            actualValue,
+            data: passthrough,
+            expectedValue: config.value,
+            operator: config.operator,
+            result,
+        };
+        return {
+            data: conditionResult,
+            metadata: {
+                /** The branch that should be followed: 'true' or 'false' */
+                branch: result ? 'true' : 'false',
+                result,
+            },
+        };
+    }
+    validate(node) {
+        const errors = [];
+        const config = node.config;
+        if (!config.field) {
+            errors.push('Condition field is required');
+        }
+        if (!config.operator) {
+            errors.push('Condition operator is required');
+        }
+        const needsValue = [
+            'equals',
+            'notEquals',
+            'greaterThan',
+            'lessThan',
+            'greaterThanOrEquals',
+            'lessThanOrEquals',
+            'contains',
+            'notContains',
+            'startsWith',
+            'endsWith',
+            'matches',
+        ];
+        if (config.operator &&
+            needsValue.includes(config.operator) &&
+            config.value === undefined) {
+            errors.push(`Value is required for operator "${config.operator}"`);
+        }
+        if (config.field === 'custom' && !config.customField) {
+            errors.push('customField is required when field is "custom"');
+        }
+        if (config.operator === 'expression' && !config.expression) {
+            errors.push('expression is required for "expression" operator');
+        }
+        return { errors, valid: errors.length === 0 };
+    }
+    estimateCost(_node) {
+        return 0;
+    }
+    resolveConfig(node) {
+        return {
+            customField: node.config.customField,
+            expression: node.config.expression,
+            field: node.config.field ?? 'custom',
+            operator: node.config.operator ?? 'equals',
+            timezone: node.config.timezone,
+            value: node.config.value,
+        };
+    }
+}
+export function createConditionExecutor() {
+    return new ConditionExecutor();
+}

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

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

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

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