@genfeedai/workflow-engine 0.2.0

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

@@ -0,0 +1,199 @@
+import {
+  createConditionExecutor,
+  evaluateCondition,
+} from '@workflow-engine/executors/saas/condition-executor';
+import { beforeEach, describe, expect, it } from 'vitest';
+
+function makeInput(config, inputData) {
+  const node = {
+    config,
+    id: 'cond-1',
+    inputs: [],
+    label: 'Condition',
+    type: 'condition',
+  };
+  const inputs = new Map();
+  if (inputData !== undefined) {
+    inputs.set('value', inputData);
+  }
+  const context = {
+    organizationId: 'org-1',
+    runId: 'run-1',
+    userId: 'user-1',
+    workflowId: 'wf-1',
+  };
+  return { context, inputs, node };
+}
+describe('evaluateCondition', () => {
+  it('equals', () => {
+    expect(evaluateCondition('equals', 'foo', 'foo')).toBe(true);
+    expect(evaluateCondition('equals', 'foo', 'bar')).toBe(false);
+    expect(evaluateCondition('equals', 5, '5')).toBe(false); // strict equality after security fix
+  });
+  it('notEquals', () => {
+    expect(evaluateCondition('notEquals', 'foo', 'bar')).toBe(true);
+    expect(evaluateCondition('notEquals', 'foo', 'foo')).toBe(false);
+  });
+  it('greaterThan', () => {
+    expect(evaluateCondition('greaterThan', 10, 5)).toBe(true);
+    expect(evaluateCondition('greaterThan', 5, 10)).toBe(false);
+  });
+  it('lessThan', () => {
+    expect(evaluateCondition('lessThan', 5, 10)).toBe(true);
+    expect(evaluateCondition('lessThan', 10, 5)).toBe(false);
+  });
+  it('greaterThanOrEquals', () => {
+    expect(evaluateCondition('greaterThanOrEquals', 10, 10)).toBe(true);
+    expect(evaluateCondition('greaterThanOrEquals', 11, 10)).toBe(true);
+    expect(evaluateCondition('greaterThanOrEquals', 9, 10)).toBe(false);
+  });
+  it('lessThanOrEquals', () => {
+    expect(evaluateCondition('lessThanOrEquals', 10, 10)).toBe(true);
+    expect(evaluateCondition('lessThanOrEquals', 9, 10)).toBe(true);
+  });
+  it('contains', () => {
+    expect(evaluateCondition('contains', 'hello world', 'world')).toBe(true);
+    expect(evaluateCondition('contains', 'hello', 'world')).toBe(false);
+  });
+  it('notContains', () => {
+    expect(evaluateCondition('notContains', 'hello', 'world')).toBe(true);
+  });
+  it('startsWith', () => {
+    expect(evaluateCondition('startsWith', 'hello world', 'hello')).toBe(true);
+    expect(evaluateCondition('startsWith', 'hello world', 'world')).toBe(false);
+  });
+  it('endsWith', () => {
+    expect(evaluateCondition('endsWith', 'hello world', 'world')).toBe(true);
+  });
+  it('matches regex', () => {
+    expect(evaluateCondition('matches', 'hello123', '\\d+')).toBe(true);
+    expect(evaluateCondition('matches', 'hello', '\\d+')).toBe(false);
+  });
+  it('isTrue / isFalse', () => {
+    expect(evaluateCondition('isTrue', true, undefined)).toBe(true);
+    expect(evaluateCondition('isTrue', 1, undefined)).toBe(true);
+    expect(evaluateCondition('isFalse', false, undefined)).toBe(true);
+    expect(evaluateCondition('isFalse', 0, undefined)).toBe(true);
+  });
+  it('isEmpty / isNotEmpty', () => {
+    expect(evaluateCondition('isEmpty', null, undefined)).toBe(true);
+    expect(evaluateCondition('isEmpty', '', undefined)).toBe(true);
+    expect(evaluateCondition('isEmpty', [], undefined)).toBe(true);
+    expect(evaluateCondition('isNotEmpty', 'foo', undefined)).toBe(true);
+    expect(evaluateCondition('isNotEmpty', [1], undefined)).toBe(true);
+  });
+  it('expression', () => {
+    expect(evaluateCondition('expression', 15, undefined, 'value > 10')).toBe(
+      true,
+    );
+    expect(evaluateCondition('expression', 5, undefined, 'value > 10')).toBe(
+      false,
+    );
+  });
+  it('expression throws on missing string', () => {
+    expect(() => evaluateCondition('expression', 5, undefined)).toThrow();
+  });
+});
+describe('ConditionExecutor', () => {
+  let executor;
+  beforeEach(() => {
+    executor = createConditionExecutor();
+  });
+  it('evaluates engagementRate greaterThan', async () => {
+    const input = makeInput(
+      { field: 'engagementRate', operator: 'greaterThan', value: 5 },
+      { engagementRate: 8.5 },
+    );
+    const result = await executor.execute(input);
+    expect(result.metadata?.result).toBe(true);
+    expect(result.metadata?.branch).toBe('true');
+  });
+  it('evaluates engagementRate lessThan (false branch)', async () => {
+    const input = makeInput(
+      { field: 'engagementRate', operator: 'greaterThan', value: 10 },
+      { engagementRate: 3.2 },
+    );
+    const result = await executor.execute(input);
+    expect(result.metadata?.result).toBe(false);
+    expect(result.metadata?.branch).toBe('false');
+  });
+  it('evaluates custom field with dot notation', async () => {
+    const input = makeInput(
+      {
+        customField: 'data.status',
+        field: 'custom',
+        operator: 'equals',
+        value: 'published',
+      },
+      { data: { status: 'published' } },
+    );
+    const result = await executor.execute(input);
+    expect(result.metadata?.result).toBe(true);
+  });
+  it('evaluates platform field', async () => {
+    const input = makeInput(
+      { field: 'platform', operator: 'equals', value: 'instagram' },
+      { platform: 'instagram' },
+    );
+    const result = await executor.execute(input);
+    expect(result.metadata?.result).toBe(true);
+  });
+  it('passes through input data', async () => {
+    const inputData = { foo: 'bar' };
+    const input = makeInput(
+      { customField: 'foo', field: 'custom', operator: 'equals', value: 'bar' },
+      inputData,
+    );
+    const result = await executor.execute(input);
+    expect(result.data.data).toEqual(inputData);
+  });
+  describe('validate', () => {
+    it('valid config', () => {
+      const node = {
+        config: { field: 'engagementRate', operator: 'greaterThan', value: 5 },
+        id: '1',
+        inputs: [],
+        label: 'Condition',
+        type: 'condition',
+      };
+      expect(executor.validate(node).valid).toBe(true);
+    });
+    it('missing field', () => {
+      const node = {
+        config: { operator: 'equals', value: 'x' },
+        id: '1',
+        inputs: [],
+        label: 'Condition',
+        type: 'condition',
+      };
+      const result = executor.validate(node);
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('Condition field is required');
+    });
+    it('missing value for comparison operator', () => {
+      const node = {
+        config: { field: 'engagementRate', operator: 'greaterThan' },
+        id: '1',
+        inputs: [],
+        label: 'Condition',
+        type: 'condition',
+      };
+      const result = executor.validate(node);
+      expect(result.valid).toBe(false);
+    });
+    it('missing customField for custom field type', () => {
+      const node = {
+        config: { field: 'custom', operator: 'equals', value: 'x' },
+        id: '1',
+        inputs: [],
+        label: 'Condition',
+        type: 'condition',
+      };
+      const result = executor.validate(node);
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain(
+        'customField is required when field is "custom"',
+      );
+    });
+  });
+});

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

@@ -0,0 +1,60 @@
+import { BaseExecutor, type ExecutorInput, type ExecutorOutput } from '@workflow-engine/executors/base-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+export type DelayMode = 'fixed' | 'until' | 'optimal';
+export type DelayUnit = 'milliseconds' | 'seconds' | 'minutes' | 'hours' | 'days';
+export interface DelayConfig {
+    /** Delay mode: fixed duration, until specific time, or optimal posting time */
+    mode: DelayMode;
+    /** Duration value (used with 'fixed' mode) */
+    duration?: number;
+    /** Duration unit (used with 'fixed' mode) */
+    unit?: DelayUnit;
+    /** ISO 8601 timestamp to wait until (used with 'until' mode) */
+    untilTime?: string;
+    /** Platform for optimal posting time lookup (used with 'optimal' mode) */
+    platform?: string;
+    /** Timezone for optimal time calculation */
+    timezone?: string;
+}
+export interface DelayState {
+    /** When the delay was initiated */
+    startedAt: string;
+    /** When the delay should resume */
+    resumeAt: string;
+    /** Original delay config for auditability */
+    config: DelayConfig;
+    /** Whether this delay has been completed */
+    completed: boolean;
+}
+export interface DelayResult {
+    /** The computed delay in milliseconds */
+    delayMs: number;
+    /** ISO timestamp when execution should resume */
+    resumeAt: string;
+    /** The serialized state for persistence */
+    state: DelayState;
+    /** Pass-through data from input */
+    data: unknown;
+}
+/**
+ * Resolver interface for optimal posting time lookups.
+ * Injected at runtime by the NestJS service layer.
+ */
+export interface OptimalTimeResolver {
+    getOptimalPostingTime(organizationId: string, platform: string, timezone?: string): Promise<Date>;
+}
+export declare function durationToMs(duration: number, unit: DelayUnit): number;
+export declare class DelayExecutor extends BaseExecutor {
+    readonly nodeType = "delay";
+    private optimalTimeResolver?;
+    setOptimalTimeResolver(resolver: OptimalTimeResolver): void;
+    execute(input: ExecutorInput): Promise<ExecutorOutput>;
+    validate(node: ExecutableNode): {
+        valid: boolean;
+        errors: string[];
+    };
+    estimateCost(_node: ExecutableNode): number;
+    private resolveConfig;
+}
+export declare function createDelayExecutor(): DelayExecutor;
+//# sourceMappingURL=delay-executor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delay-executor.d.ts","sourceRoot":"","sources":["../../../../../src/executors/saas/delay-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,SAAS,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,CAAC;AAEtD,MAAM,MAAM,SAAS,GACjB,cAAc,GACd,SAAS,GACT,SAAS,GACT,OAAO,GACP,MAAM,CAAC;AAEX,MAAM,WAAW,WAAW;IAC1B,+EAA+E;IAC/E,IAAI,EAAE,SAAS,CAAC;IAChB,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6CAA6C;IAC7C,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,gEAAgE;IAChE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,UAAU;IACzB,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,mCAAmC;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,6CAA6C;IAC7C,MAAM,EAAE,WAAW,CAAC;IACpB,4CAA4C;IAC5C,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,yCAAyC;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,iDAAiD;IACjD,QAAQ,EAAE,MAAM,CAAC;IACjB,2CAA2C;IAC3C,KAAK,EAAE,UAAU,CAAC;IAClB,mCAAmC;IACnC,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,qBAAqB,CACnB,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,MAAM,EAChB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAAC;CAClB;AAcD,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,MAAM,CAMtE;AAMD,qBAAa,aAAc,SAAQ,YAAY;IAC7C,QAAQ,CAAC,QAAQ,WAAW;IAE5B,OAAO,CAAC,mBAAmB,CAAC,CAAsB;IAElD,sBAAsB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,IAAI;IAIrD,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;IAmF5D,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE;IA6BpE,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM;IAI3C,OAAO,CAAC,aAAa;CAUtB;AAED,wBAAgB,mBAAmB,IAAI,aAAa,CAEnD"}

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

@@ -0,0 +1,136 @@
+import { BaseExecutor, } from '@workflow-engine/executors/base-executor';
+// =============================================================================
+// UNIT CONVERSION
+// =============================================================================
+const UNIT_TO_MS = {
+    days: 86_400_000,
+    hours: 3_600_000,
+    milliseconds: 1,
+    minutes: 60_000,
+    seconds: 1_000,
+};
+export function durationToMs(duration, unit) {
+    const multiplier = UNIT_TO_MS[unit];
+    if (!multiplier) {
+        throw new Error(`Unknown delay unit: ${unit}`);
+    }
+    return Math.max(0, Math.round(duration * multiplier));
+}
+// =============================================================================
+// EXECUTOR
+// =============================================================================
+export class DelayExecutor extends BaseExecutor {
+    nodeType = 'delay';
+    optimalTimeResolver;
+    setOptimalTimeResolver(resolver) {
+        this.optimalTimeResolver = resolver;
+    }
+    async execute(input) {
+        const { node, inputs, context } = input;
+        const config = this.resolveConfig(node);
+        const now = new Date();
+        let resumeAt;
+        switch (config.mode) {
+            case 'fixed': {
+                const duration = config.duration ?? 0;
+                const unit = config.unit ?? 'minutes';
+                const ms = durationToMs(duration, unit);
+                resumeAt = new Date(now.getTime() + ms);
+                break;
+            }
+            case 'until': {
+                if (!config.untilTime) {
+                    throw new Error('Delay mode "until" requires untilTime config');
+                }
+                resumeAt = new Date(config.untilTime);
+                if (Number.isNaN(resumeAt.getTime())) {
+                    throw new Error(`Invalid untilTime: ${config.untilTime}`);
+                }
+                // If the time is in the past, resume immediately
+                if (resumeAt.getTime() <= now.getTime()) {
+                    resumeAt = now;
+                }
+                break;
+            }
+            case 'optimal': {
+                if (!this.optimalTimeResolver) {
+                    throw new Error('Optimal time resolver not configured. Register an OptimalTimeResolver.');
+                }
+                const platform = config.platform ?? 'instagram';
+                resumeAt = await this.optimalTimeResolver.getOptimalPostingTime(context.organizationId, platform, config.timezone);
+                // If optimal time is in the past, push to next day
+                if (resumeAt.getTime() <= now.getTime()) {
+                    resumeAt = new Date(resumeAt.getTime() + 86_400_000);
+                }
+                break;
+            }
+            default:
+                throw new Error(`Unknown delay mode: ${config.mode}`);
+        }
+        const delayMs = Math.max(0, resumeAt.getTime() - now.getTime());
+        const state = {
+            completed: false,
+            config,
+            resumeAt: resumeAt.toISOString(),
+            startedAt: now.toISOString(),
+        };
+        // Pass through the first input value
+        const passthrough = inputs.values().next().value ?? null;
+        const result = {
+            data: passthrough,
+            delayMs,
+            resumeAt: resumeAt.toISOString(),
+            state,
+        };
+        return {
+            data: result,
+            metadata: {
+                delayMs,
+                mode: config.mode,
+                requiresDelayedJob: delayMs > 0,
+                resumeAt: resumeAt.toISOString(),
+            },
+        };
+    }
+    validate(node) {
+        const errors = [];
+        const config = node.config;
+        if (!config.mode) {
+            errors.push('Delay mode is required');
+        }
+        else if (!['fixed', 'until', 'optimal'].includes(config.mode)) {
+            errors.push(`Invalid delay mode: ${config.mode}`);
+        }
+        if (config.mode === 'fixed') {
+            if (config.duration === undefined || config.duration === null) {
+                errors.push('Duration is required for fixed delay mode');
+            }
+            else if (typeof config.duration !== 'number' || config.duration < 0) {
+                errors.push('Duration must be a non-negative number');
+            }
+        }
+        if (config.mode === 'until' && !config.untilTime) {
+            errors.push('untilTime is required for "until" delay mode');
+        }
+        if (config.mode === 'optimal' && !config.platform) {
+            errors.push('platform is required for "optimal" delay mode');
+        }
+        return { errors, valid: errors.length === 0 };
+    }
+    estimateCost(_node) {
+        return 0;
+    }
+    resolveConfig(node) {
+        return {
+            duration: node.config.duration,
+            mode: node.config.mode ?? 'fixed',
+            platform: node.config.platform,
+            timezone: node.config.timezone,
+            unit: node.config.unit ?? 'minutes',
+            untilTime: node.config.untilTime,
+        };
+    }
+}
+export function createDelayExecutor() {
+    return new DelayExecutor();
+}

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

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

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

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

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

@@ -0,0 +1,151 @@
+import {
+  createDelayExecutor,
+  durationToMs,
+} from '@workflow-engine/executors/saas/delay-executor';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+function makeInput(config, inputData) {
+  const node = {
+    config,
+    id: 'delay-1',
+    inputs: [],
+    label: 'Delay',
+    type: 'delay',
+  };
+  const inputs = new Map();
+  if (inputData !== undefined) {
+    inputs.set('trigger', inputData);
+  }
+  const context = {
+    organizationId: 'org-1',
+    runId: 'run-1',
+    userId: 'user-1',
+    workflowId: 'wf-1',
+  };
+  return { context, inputs, node };
+}
+describe('durationToMs', () => {
+  it('converts minutes to ms', () => {
+    expect(durationToMs(5, 'minutes')).toBe(300_000);
+  });
+  it('converts hours to ms', () => {
+    expect(durationToMs(2, 'hours')).toBe(7_200_000);
+  });
+  it('converts days to ms', () => {
+    expect(durationToMs(1, 'days')).toBe(86_400_000);
+  });
+  it('returns 0 for negative duration', () => {
+    expect(durationToMs(-5, 'minutes')).toBe(0);
+  });
+});
+describe('DelayExecutor', () => {
+  let executor;
+  beforeEach(() => {
+    executor = createDelayExecutor();
+  });
+  describe('fixed mode', () => {
+    it('calculates delay in milliseconds', async () => {
+      const input = makeInput({ duration: 10, mode: 'fixed', unit: 'minutes' });
+      const result = await executor.execute(input);
+      expect(result.metadata?.mode).toBe('fixed');
+      expect(result.metadata?.requiresDelayedJob).toBe(true);
+      expect(result.data.delayMs).toBeGreaterThan(0);
+      expect(result.data.state.config.mode).toBe('fixed');
+    });
+    it('passes through input data', async () => {
+      const input = makeInput(
+        { duration: 1, mode: 'fixed', unit: 'seconds' },
+        { foo: 'bar' },
+      );
+      const result = await executor.execute(input);
+      expect(result.data.data).toEqual({ foo: 'bar' });
+    });
+  });
+  describe('until mode', () => {
+    it('calculates delay until future time', async () => {
+      const futureTime = new Date(Date.now() + 60_000).toISOString();
+      const input = makeInput({ mode: 'until', untilTime: futureTime });
+      const result = await executor.execute(input);
+      expect(result.data.delayMs).toBeGreaterThan(0);
+      expect(result.metadata?.resumeAt).toBe(futureTime);
+    });
+    it('resumes immediately for past time', async () => {
+      const pastTime = new Date(Date.now() - 60_000).toISOString();
+      const input = makeInput({ mode: 'until', untilTime: pastTime });
+      const result = await executor.execute(input);
+      expect(result.data.delayMs).toBe(0);
+    });
+    it('throws on missing untilTime', async () => {
+      const input = makeInput({ mode: 'until' });
+      await expect(executor.execute(input)).rejects.toThrow('untilTime');
+    });
+  });
+  describe('optimal mode', () => {
+    it('throws without resolver', async () => {
+      const input = makeInput({ mode: 'optimal', platform: 'instagram' });
+      await expect(executor.execute(input)).rejects.toThrow('resolver');
+    });
+    it('uses resolver when configured', async () => {
+      const futureDate = new Date(Date.now() + 3_600_000);
+      const resolver = {
+        getOptimalPostingTime: vi.fn().mockResolvedValue(futureDate),
+      };
+      executor.setOptimalTimeResolver(resolver);
+      const input = makeInput({ mode: 'optimal', platform: 'instagram' });
+      const result = await executor.execute(input);
+      expect(resolver.getOptimalPostingTime).toHaveBeenCalledWith(
+        'org-1',
+        'instagram',
+        undefined,
+      );
+      expect(result.data.delayMs).toBeGreaterThan(0);
+    });
+  });
+  describe('validate', () => {
+    it('returns valid for correct fixed config', () => {
+      const node = {
+        config: { duration: 5, mode: 'fixed', unit: 'minutes' },
+        id: '1',
+        inputs: [],
+        label: 'Delay',
+        type: 'delay',
+      };
+      expect(executor.validate(node).valid).toBe(true);
+    });
+    it('returns errors for missing mode', () => {
+      const node = {
+        config: {},
+        id: '1',
+        inputs: [],
+        label: 'Delay',
+        type: 'delay',
+      };
+      const result = executor.validate(node);
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('Delay mode is required');
+    });
+    it('returns errors for missing duration in fixed mode', () => {
+      const node = {
+        config: { mode: 'fixed' },
+        id: '1',
+        inputs: [],
+        label: 'Delay',
+        type: 'delay',
+      };
+      const result = executor.validate(node);
+      expect(result.valid).toBe(false);
+    });
+  });
+  describe('estimateCost', () => {
+    it('returns 0', () => {
+      const node = {
+        config: {},
+        id: '1',
+        inputs: [],
+        label: 'Delay',
+        type: 'delay',
+      };
+      expect(executor.estimateCost(node)).toBe(0);
+    });
+  });
+});

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

@@ -0,0 +1,49 @@
+import { BaseExecutor, type ExecutorInput, type ExecutorOutput } from '@workflow-engine/executors/base-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+export type EngagementTriggerPlatform = 'twitter' | 'instagram' | 'threads';
+export type EngagementMetricType = 'likes' | 'comments' | 'shares' | 'views';
+export interface EngagementTriggerOutput {
+    /** The post/tweet ID that hit the threshold */
+    postId: string;
+    /** URL of the post */
+    postUrl: string;
+    /** The metric type that triggered */
+    metricType: EngagementMetricType;
+    /** Current value of the metric */
+    currentValue: number;
+    /** Threshold that was exceeded */
+    threshold: number;
+    /** Platform */
+    platform: EngagementTriggerPlatform;
+    /** Timestamp of the trigger event */
+    triggeredAt: string;
+}
+export type EngagementChecker = (params: {
+    organizationId: string;
+    platform: EngagementTriggerPlatform;
+    postIds: string[];
+    metricType: EngagementMetricType;
+    threshold: number;
+    lastCheckedPostId: string | null;
+}) => Promise<EngagementTriggerOutput | null>;
+/**
+ * Engagement Trigger Executor
+ *
+ * Starts a workflow when engagement metrics (likes, comments, shares, views)
+ * on monitored posts hit a configured threshold.
+ *
+ * Node Type: engagementTrigger
+ */
+export declare class EngagementTriggerExecutor extends BaseExecutor {
+    readonly nodeType = "engagementTrigger";
+    private checker;
+    setChecker(checker: EngagementChecker): void;
+    validate(node: ExecutableNode): {
+        valid: boolean;
+        errors: string[];
+    };
+    execute(input: ExecutorInput): Promise<ExecutorOutput>;
+    estimateCost(_node: ExecutableNode): number;
+}
+export declare function createEngagementTriggerExecutor(): EngagementTriggerExecutor;
+//# sourceMappingURL=engagement-trigger-executor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"engagement-trigger-executor.d.ts","sourceRoot":"","sources":["../../../../../src/executors/saas/engagement-trigger-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,yBAAyB,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,CAAC;AAE5E,MAAM,MAAM,oBAAoB,GAAG,OAAO,GAAG,UAAU,GAAG,QAAQ,GAAG,OAAO,CAAC;AAE7E,MAAM,WAAW,uBAAuB;IACtC,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,sBAAsB;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,qCAAqC;IACrC,UAAU,EAAE,oBAAoB,CAAC;IACjC,kCAAkC;IAClC,YAAY,EAAE,MAAM,CAAC;IACrB,kCAAkC;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe;IACf,QAAQ,EAAE,yBAAyB,CAAC;IACpC,qCAAqC;IACrC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,MAAM,iBAAiB,GAAG,CAAC,MAAM,EAAE;IACvC,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,yBAAyB,CAAC;IACpC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,UAAU,EAAE,oBAAoB,CAAC;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC,KAAK,OAAO,CAAC,uBAAuB,GAAG,IAAI,CAAC,CAAC;AAM9C;;;;;;;GAOG;AACH,qBAAa,yBAA0B,SAAQ,YAAY;IACzD,QAAQ,CAAC,QAAQ,uBAAuB;IACxC,OAAO,CAAC,OAAO,CAAkC;IAEjD,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAI5C,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE;IA+C9D,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;IAwD5D,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM;CAG5C;AAED,wBAAgB,+BAA+B,IAAI,yBAAyB,CAE3E"}