@genfeedai/workflow-engine 0.2.0

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

@@ -0,0 +1,65 @@
+import { BaseExecutor, type ExecutorInput, type ExecutorOutput } from '@workflow-engine/executors/base-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+export type ReplyPlatform = 'twitter' | 'instagram' | 'threads' | 'facebook';
+export interface PostReplyConfig {
+    /** Platform to reply on */
+    platform: ReplyPlatform;
+    /** The post/tweet ID to reply to (can come from input) */
+    postId?: string;
+    /** Reply text (can come from input) */
+    text?: string;
+    /** Optional media URL to attach */
+    mediaUrl?: string;
+}
+export interface PostReplyResult {
+    /** Whether the reply was posted successfully */
+    success: boolean;
+    /** The ID of the reply post */
+    replyId?: string;
+    /** URL of the reply post */
+    replyUrl?: string;
+    /** Platform the reply was posted on */
+    platform: ReplyPlatform;
+    /** The original post ID that was replied to */
+    originalPostId: string;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Function signature for the injected reply publisher.
+ * The NestJS service layer injects the actual implementation at runtime.
+ */
+export type ReplyPublisher = (params: {
+    organizationId: string;
+    userId: string;
+    /** The brand ID associated with this action. Use this instead of userId for brand-scoped operations. */
+    brandId?: string;
+    platform: ReplyPlatform;
+    postId: string;
+    text: string;
+    mediaUrl?: string;
+}) => Promise<{
+    replyId: string;
+    replyUrl: string;
+}>;
+/**
+ * Post Reply Executor
+ *
+ * Replies to a social media post on the specified platform.
+ * Requires a ReplyPublisher to be injected at runtime.
+ *
+ * Node Type: postReply
+ */
+export declare class PostReplyExecutor extends BaseExecutor {
+    readonly nodeType = "postReply";
+    private publisher;
+    setPublisher(publisher: ReplyPublisher): void;
+    validate(node: ExecutableNode): {
+        valid: boolean;
+        errors: string[];
+    };
+    execute(input: ExecutorInput): Promise<ExecutorOutput>;
+    estimateCost(_node: ExecutableNode): number;
+}
+export declare function createPostReplyExecutor(): PostReplyExecutor;
+//# sourceMappingURL=post-reply-executor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"post-reply-executor.d.ts","sourceRoot":"","sources":["../../../../../src/executors/saas/post-reply-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,aAAa,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,GAAG,UAAU,CAAC;AAE7E,MAAM,WAAW,eAAe;IAC9B,2BAA2B;IAC3B,QAAQ,EAAE,aAAa,CAAC;IACxB,0DAA0D;IAC1D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,mCAAmC;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,gDAAgD;IAChD,OAAO,EAAE,OAAO,CAAC;IACjB,+BAA+B;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4BAA4B;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,uCAAuC;IACvC,QAAQ,EAAE,aAAa,CAAC;IACxB,+CAA+C;IAC/C,cAAc,EAAE,MAAM,CAAC;IACvB,8BAA8B;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE;IACpC,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,wGAAwG;IACxG,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,aAAa,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,KAAK,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAMrD;;;;;;;GAOG;AACH,qBAAa,iBAAkB,SAAQ,YAAY;IACjD,QAAQ,CAAC,QAAQ,eAAe;IAChC,OAAO,CAAC,SAAS,CAA+B;IAEhD,YAAY,CAAC,SAAS,EAAE,cAAc,GAAG,IAAI;IAI7C,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE;IAoB9D,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;IA2D5D,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM;CAG5C;AAED,wBAAgB,uBAAuB,IAAI,iBAAiB,CAE3D"}

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

@@ -0,0 +1,84 @@
+import { BaseExecutor, } from '@workflow-engine/executors/base-executor';
+// =============================================================================
+// EXECUTOR
+// =============================================================================
+/**
+ * Post Reply Executor
+ *
+ * Replies to a social media post on the specified platform.
+ * Requires a ReplyPublisher to be injected at runtime.
+ *
+ * Node Type: postReply
+ */
+export class PostReplyExecutor extends BaseExecutor {
+    nodeType = 'postReply';
+    publisher = null;
+    setPublisher(publisher) {
+        this.publisher = publisher;
+    }
+    validate(node) {
+        const baseValidation = super.validate(node);
+        const errors = [...baseValidation.errors];
+        const platform = node.config.platform;
+        const validPlatforms = [
+            'twitter',
+            'instagram',
+            'threads',
+            'facebook',
+        ];
+        if (!platform || !validPlatforms.includes(platform)) {
+            errors.push(`Invalid platform. Must be one of: ${validPlatforms.join(', ')}`);
+        }
+        return { errors, valid: errors.length === 0 };
+    }
+    async execute(input) {
+        const { node, inputs, context } = input;
+        if (!this.publisher) {
+            throw new Error('Reply publisher not configured');
+        }
+        const platform = this.getRequiredConfig(node.config, 'platform');
+        // postId and text can come from config or from connected inputs
+        const postId = node.config.postId ??
+            inputs.get('postId');
+        const text = node.config.text ??
+            inputs.get('text');
+        if (!postId) {
+            throw new Error('Post ID is required (via config or input)');
+        }
+        if (!text) {
+            throw new Error('Reply text is required (via config or input)');
+        }
+        const mediaUrl = node.config.mediaUrl ??
+            inputs.get('mediaUrl');
+        const result = await this.publisher({
+            brandId: node.config.brandId,
+            mediaUrl,
+            organizationId: context.organizationId,
+            platform,
+            postId,
+            text,
+            userId: context.userId,
+        });
+        const replyResult = {
+            originalPostId: postId,
+            platform,
+            replyId: result.replyId,
+            replyUrl: result.replyUrl,
+            success: true,
+        };
+        return {
+            data: replyResult,
+            metadata: {
+                platform,
+                replyId: result.replyId,
+                replyUrl: result.replyUrl,
+            },
+        };
+    }
+    estimateCost(_node) {
+        return 1;
+    }
+}
+export function createPostReplyExecutor() {
+    return new PostReplyExecutor();
+}

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

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

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

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

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

@@ -0,0 +1,117 @@
+import { createPostReplyExecutor } from '@workflow-engine/executors/saas/post-reply-executor';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+function makeInput(config, inputData) {
+  const node = {
+    config,
+    id: 'reply-1',
+    inputs: [],
+    label: 'Post Reply',
+    type: 'postReply',
+  };
+  const inputs = new Map();
+  if (inputData) {
+    for (const [k, v] of Object.entries(inputData)) {
+      inputs.set(k, v);
+    }
+  }
+  const context = {
+    organizationId: 'org-1',
+    runId: 'run-1',
+    userId: 'user-1',
+    workflowId: 'wf-1',
+  };
+  return { context, inputs, node };
+}
+describe('PostReplyExecutor', () => {
+  let executor;
+  let mockPublisher;
+  beforeEach(() => {
+    executor = createPostReplyExecutor();
+    mockPublisher = vi.fn().mockResolvedValue({
+      replyId: 'reply-123',
+      replyUrl: 'https://x.com/user/status/reply-123',
+    });
+    executor.setPublisher(mockPublisher);
+  });
+  it('creates via factory', () => {
+    expect(executor.nodeType).toBe('postReply');
+  });
+  it('throws if publisher not configured', async () => {
+    const fresh = createPostReplyExecutor();
+    const input = makeInput({ platform: 'twitter', postId: '123', text: 'hi' });
+    await expect(fresh.execute(input)).rejects.toThrow(
+      'Reply publisher not configured',
+    );
+  });
+  it('executes reply with config values', async () => {
+    const input = makeInput({
+      platform: 'twitter',
+      postId: 'tweet-456',
+      text: 'Great post!',
+    });
+    const result = await executor.execute(input);
+    expect(mockPublisher).toHaveBeenCalledWith(
+      expect.objectContaining({
+        organizationId: 'org-1',
+        platform: 'twitter',
+        postId: 'tweet-456',
+        text: 'Great post!',
+      }),
+    );
+    expect(result.data).toMatchObject({
+      originalPostId: 'tweet-456',
+      platform: 'twitter',
+      replyId: 'reply-123',
+      success: true,
+    });
+  });
+  it('uses input values when config is missing', async () => {
+    const input = makeInput(
+      { platform: 'twitter' },
+      {
+        postId: 'tweet-789',
+        text: 'From input!',
+      },
+    );
+    const result = await executor.execute(input);
+    expect(result.data).toMatchObject({ success: true });
+  });
+  it('throws if postId missing', async () => {
+    const input = makeInput({ platform: 'twitter', text: 'hello' });
+    await expect(executor.execute(input)).rejects.toThrow(
+      'Post ID is required',
+    );
+  });
+  it('throws if text missing', async () => {
+    const input = makeInput({ platform: 'twitter', postId: '123' });
+    await expect(executor.execute(input)).rejects.toThrow(
+      'Reply text is required',
+    );
+  });
+  it('validates platform', () => {
+    const node = {
+      config: { platform: 'invalid' },
+      id: 'r1',
+      inputs: [],
+      label: 'Reply',
+      type: 'postReply',
+    };
+    const result = executor.validate(node);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes('Invalid platform'))).toBe(
+      true,
+    );
+  });
+  it('validates valid platform', () => {
+    const node = {
+      config: { platform: 'twitter' },
+      id: 'r1',
+      inputs: [],
+      label: 'Reply',
+      type: 'postReply',
+    };
+    const result = executor.validate(node);
+    expect(result.valid).toBe(true);
+  });
+});

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

@@ -0,0 +1,28 @@
+import { BaseExecutor, type ExecutorInput, type ExecutorOutput } from '@workflow-engine/executors/base-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+export interface PromptConstructorConfig {
+    /** The template string with {{variable}} placeholders */
+    template: string;
+    /** Key-value pairs to substitute into the template */
+    variables: Record<string, string>;
+}
+export interface PromptConstructorResult {
+    /** The fully resolved prompt text */
+    prompt: string;
+    /** Variables that were successfully substituted */
+    resolvedVariables: string[];
+    /** Placeholders that had no matching variable */
+    unresolvedPlaceholders: string[];
+}
+export declare class PromptConstructorExecutor extends BaseExecutor {
+    readonly nodeType = "promptConstructor";
+    execute(input: ExecutorInput): Promise<ExecutorOutput>;
+    validate(node: ExecutableNode): {
+        valid: boolean;
+        errors: string[];
+    };
+    estimateCost(_node: ExecutableNode): number;
+    private resolveConfig;
+}
+export declare function createPromptConstructorExecutor(): PromptConstructorExecutor;
+//# sourceMappingURL=prompt-constructor-executor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-constructor-executor.d.ts","sourceRoot":"","sources":["../../../../../src/executors/saas/prompt-constructor-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,WAAW,uBAAuB;IACtC,yDAAyD;IACzD,QAAQ,EAAE,MAAM,CAAC;IACjB,sDAAsD;IACtD,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,uBAAuB;IACtC,qCAAqC;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,mDAAmD;IACnD,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,iDAAiD;IACjD,sBAAsB,EAAE,MAAM,EAAE,CAAC;CAClC;AAoCD,qBAAa,yBAA0B,SAAQ,YAAY;IACzD,QAAQ,CAAC,QAAQ,uBAAuB;IAElC,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;IAe5D,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE;IAmBpE,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM;IAI3C,OAAO,CAAC,aAAa;CA4BtB;AAED,wBAAgB,+BAA+B,IAAI,yBAAyB,CAE3E"}

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

@@ -0,0 +1,79 @@
+import { BaseExecutor, } from '@workflow-engine/executors/base-executor';
+// =============================================================================
+// HELPERS
+// =============================================================================
+const PLACEHOLDER_REGEX = /\{\{(\w+)\}\}/g;
+/**
+ * Replaces {{variable}} placeholders in a template with values from the
+ * variables map. Returns the resolved string plus metadata about which
+ * placeholders were/were not resolved.
+ */
+function resolveTemplate(template, variables) {
+    const resolvedVariables = [];
+    const unresolvedPlaceholders = [];
+    const prompt = template.replace(PLACEHOLDER_REGEX, (match, key) => {
+        if (key in variables) {
+            resolvedVariables.push(key);
+            return variables[key];
+        }
+        unresolvedPlaceholders.push(key);
+        return match;
+    });
+    return { prompt, resolvedVariables, unresolvedPlaceholders };
+}
+// =============================================================================
+// EXECUTOR
+// =============================================================================
+export class PromptConstructorExecutor extends BaseExecutor {
+    nodeType = 'promptConstructor';
+    async execute(input) {
+        const { inputs, node } = input;
+        const config = this.resolveConfig(node, inputs);
+        const result = resolveTemplate(config.template, config.variables);
+        return {
+            data: result.prompt,
+            metadata: {
+                resolvedCount: result.resolvedVariables.length,
+                unresolvedCount: result.unresolvedPlaceholders.length,
+            },
+        };
+    }
+    validate(node) {
+        const errors = [];
+        const config = node.config;
+        if (!config.template || typeof config.template !== 'string') {
+            errors.push('Template is required and must be a string');
+        }
+        if (config.template &&
+            typeof config.template === 'string' &&
+            config.template.trim().length === 0) {
+            errors.push('Template must not be empty');
+        }
+        return { errors, valid: errors.length === 0 };
+    }
+    estimateCost(_node) {
+        return 0;
+    }
+    resolveConfig(node, inputs) {
+        const rawVariables = node.config.variables;
+        const variables = {};
+        if (rawVariables && typeof rawVariables === 'object') {
+            for (const [key, value] of Object.entries(rawVariables)) {
+                variables[key] = String(value);
+            }
+        }
+        for (const [key, value] of inputs.entries()) {
+            if (value === undefined || value === null) {
+                continue;
+            }
+            variables[key] = String(value);
+        }
+        return {
+            template: node.config.template ?? '',
+            variables,
+        };
+    }
+}
+export function createPromptConstructorExecutor() {
+    return new PromptConstructorExecutor();
+}

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

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

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

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

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

@@ -0,0 +1,158 @@
+import { createPromptConstructorExecutor } from '@workflow-engine/executors/saas/prompt-constructor-executor';
+import { beforeEach, describe, expect, it } from 'vitest';
+
+function makeNode(configOverrides = {}) {
+  return {
+    config: {
+      template: 'Hello {{name}}, welcome to {{place}}!',
+      variables: { name: 'Alice', place: 'Wonderland' },
+      ...configOverrides,
+    },
+    id: 'prompt-1',
+    inputs: [],
+    label: 'Prompt Constructor',
+    type: 'promptConstructor',
+  };
+}
+function makeContext() {
+  return {
+    organizationId: 'org-1',
+    runId: 'run-1',
+    userId: 'user-1',
+    workflowId: 'wf-1',
+  };
+}
+function makeInput(configOverrides = {}, inputEntries = []) {
+  return {
+    context: makeContext(),
+    inputs: new Map(inputEntries),
+    node: makeNode(configOverrides),
+  };
+}
+describe('PromptConstructorExecutor', () => {
+  let executor;
+  beforeEach(() => {
+    executor = createPromptConstructorExecutor();
+  });
+  describe('validate', () => {
+    it('should pass with valid template', () => {
+      const node = makeNode({ template: 'Generate a {{style}} image' });
+      const result = executor.validate(node);
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+    it('should fail when template is missing', () => {
+      const node = makeNode({});
+      delete node.config.template;
+      const result = executor.validate(node);
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain(
+        'Template is required and must be a string',
+      );
+    });
+    it('should fail when template is not a string', () => {
+      const node = makeNode({ template: 123 });
+      const result = executor.validate(node);
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain(
+        'Template is required and must be a string',
+      );
+    });
+    it('should fail when template is empty whitespace', () => {
+      const node = makeNode({ template: '   ' });
+      const result = executor.validate(node);
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('Template must not be empty');
+    });
+  });
+  describe('estimateCost', () => {
+    it('should return 0 credits', () => {
+      expect(executor.estimateCost(makeNode())).toBe(0);
+    });
+  });
+  describe('execute', () => {
+    it('should resolve all template variables from config', async () => {
+      const input = makeInput({
+        template: 'Hello {{name}}, welcome to {{place}}!',
+        variables: { name: 'Alice', place: 'Wonderland' },
+      });
+      const result = await executor.execute(input);
+      expect(result.data).toBe('Hello Alice, welcome to Wonderland!');
+      expect(result.metadata?.resolvedCount).toBe(2);
+      expect(result.metadata?.unresolvedCount).toBe(0);
+    });
+    it('should leave unresolved placeholders intact', async () => {
+      const input = makeInput({
+        template: 'Hello {{name}}, your {{role}} awaits',
+        variables: { name: 'Bob' },
+      });
+      const result = await executor.execute(input);
+      expect(result.data).toBe('Hello Bob, your {{role}} awaits');
+      expect(result.metadata?.resolvedCount).toBe(1);
+      expect(result.metadata?.unresolvedCount).toBe(1);
+    });
+    it('should resolve variables from inputs overriding config variables', async () => {
+      const input = makeInput(
+        {
+          template: 'Create a {{style}} portrait of {{subject}}',
+          variables: { style: 'realistic', subject: 'a cat' },
+        },
+        [['style', 'cinematic']],
+      );
+      const result = await executor.execute(input);
+      // Input 'style' should override config 'style'
+      expect(result.data).toBe('Create a cinematic portrait of a cat');
+    });
+    it('should handle template with no placeholders', async () => {
+      const input = makeInput({
+        template: 'A static prompt with no variables',
+        variables: {},
+      });
+      const result = await executor.execute(input);
+      expect(result.data).toBe('A static prompt with no variables');
+      expect(result.metadata?.resolvedCount).toBe(0);
+      expect(result.metadata?.unresolvedCount).toBe(0);
+    });
+    it('should handle null/undefined input values gracefully', async () => {
+      const input = makeInput(
+        {
+          template: 'Value is {{key}}',
+          variables: {},
+        },
+        [
+          ['key', null],
+          ['other', undefined],
+        ],
+      );
+      const result = await executor.execute(input);
+      // null and undefined inputs should be skipped, so placeholder remains
+      expect(result.data).toBe('Value is {{key}}');
+    });
+    it('should stringify non-string variable values', async () => {
+      const input = makeInput({
+        template: 'Count: {{count}}, flag: {{flag}}',
+        variables: { count: 42, flag: true },
+      });
+      const result = await executor.execute(input);
+      expect(result.data).toBe('Count: 42, flag: true');
+    });
+    it('should handle empty variables object', async () => {
+      const input = makeInput({
+        template: 'Hello {{name}}',
+      });
+      delete input.node.config.variables;
+      const result = await executor.execute(input);
+      expect(result.data).toBe('Hello {{name}}');
+      expect(result.metadata?.unresolvedCount).toBe(1);
+    });
+    it('should handle duplicate placeholders', async () => {
+      const input = makeInput({
+        template: '{{name}} meets {{name}}',
+        variables: { name: 'Alice' },
+      });
+      const result = await executor.execute(input);
+      expect(result.data).toBe('Alice meets Alice');
+      expect(result.metadata?.resolvedCount).toBe(2);
+    });
+  });
+});

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

@@ -0,0 +1,40 @@
+import { BaseExecutor, type ExecutorInput, type ExecutorOutput } from '@workflow-engine/executors/base-executor';
+import type { ExecutableNode } from '@workflow-engine/types';
+export type SocialPlatform = 'twitter' | 'instagram' | 'tiktok' | 'linkedin' | 'facebook' | 'threads' | 'youtube';
+export type ScheduleType = 'immediate' | 'scheduled';
+export interface PublishConfig {
+    platforms: Record<SocialPlatform, boolean>;
+    schedule: {
+        type: ScheduleType;
+        datetime?: string;
+    };
+    caption?: string;
+    hashtags?: string[];
+}
+export interface PublishOutput {
+    postIds: string[];
+    platforms: SocialPlatform[];
+    scheduledFor: Date | null;
+    status: 'queued' | 'scheduled' | 'published';
+}
+export type PublishResolver = (params: {
+    brandId: string;
+    organizationId: string;
+    userId: string;
+    media: unknown;
+    caption: string;
+    platforms: SocialPlatform[];
+    scheduledFor: Date | null;
+}) => Promise<PublishOutput>;
+export declare class PublishExecutor extends BaseExecutor {
+    readonly nodeType = "publish";
+    private resolver;
+    setResolver(resolver: PublishResolver): void;
+    validate(node: ExecutableNode): {
+        valid: boolean;
+        errors: string[];
+    };
+    execute(input: ExecutorInput): Promise<ExecutorOutput>;
+}
+export declare function createPublishExecutor(resolver?: PublishResolver): PublishExecutor;
+//# sourceMappingURL=publish-executor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"publish-executor.d.ts","sourceRoot":"","sources":["../../../../../src/executors/saas/publish-executor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,KAAK,aAAa,EAClB,KAAK,cAAc,EACpB,MAAM,0CAA0C,CAAC;AAElD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,MAAM,MAAM,cAAc,GACtB,SAAS,GACT,WAAW,GACX,QAAQ,GACR,UAAU,GACV,UAAU,GACV,SAAS,GACT,SAAS,CAAC;AAEd,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,WAAW,CAAC;AAErD,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC;IAC3C,QAAQ,EAAE;QACR,IAAI,EAAE,YAAY,CAAC;QACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,cAAc,EAAE,CAAC;IAC5B,YAAY,EAAE,IAAI,GAAG,IAAI,CAAC;IAC1B,MAAM,EAAE,QAAQ,GAAG,WAAW,GAAG,WAAW,CAAC;CAC9C;AAED,MAAM,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,cAAc,EAAE,CAAC;IAC5B,YAAY,EAAE,IAAI,GAAG,IAAI,CAAC;CAC3B,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;AAE7B,qBAAa,eAAgB,SAAQ,YAAY;IAC/C,QAAQ,CAAC,QAAQ,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAgC;IAEhD,WAAW,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI;IAI5C,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE;IAgC9D,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;CAgE7D;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,CAAC,EAAE,eAAe,GACzB,eAAe,CAMjB"}

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

@@ -0,0 +1,77 @@
+import { BaseExecutor, } from '@workflow-engine/executors/base-executor';
+export class PublishExecutor extends BaseExecutor {
+    nodeType = 'publish';
+    resolver = null;
+    setResolver(resolver) {
+        this.resolver = resolver;
+    }
+    validate(node) {
+        const baseValidation = super.validate(node);
+        const errors = [...baseValidation.errors];
+        const platforms = node.config.platforms;
+        if (!platforms) {
+            errors.push('Platforms configuration is required');
+        }
+        else {
+            const enabledPlatforms = Object.entries(platforms)
+                .filter(([_, enabled]) => enabled)
+                .map(([platform]) => platform);
+            if (enabledPlatforms.length === 0) {
+                errors.push('At least one platform must be enabled');
+            }
+        }
+        const schedule = node.config.schedule;
+        if (schedule?.type === 'scheduled' && !schedule.datetime) {
+            errors.push('Scheduled datetime is required for scheduled posts');
+        }
+        return {
+            errors,
+            valid: errors.length === 0,
+        };
+    }
+    async execute(input) {
+        const { node, inputs, context } = input;
+        if (!this.resolver) {
+            throw new Error('Publish resolver not configured');
+        }
+        const brandContext = this.getRequiredInput(inputs, 'brand');
+        const media = this.getRequiredInput(inputs, 'media');
+        const captionFromInput = this.getOptionalInput(inputs, 'caption', undefined);
+        const captionFromConfig = this.getOptionalConfig(node.config, 'caption', '');
+        const caption = captionFromInput ?? captionFromConfig;
+        const platforms = this.getRequiredConfig(node.config, 'platforms');
+        const enabledPlatforms = Object.entries(platforms)
+            .filter(([_, enabled]) => enabled)
+            .map(([platform]) => platform);
+        const schedule = this.getOptionalConfig(node.config, 'schedule', {
+            type: 'immediate',
+        });
+        const scheduledFor = schedule.type === 'scheduled' && schedule.datetime
+            ? new Date(schedule.datetime)
+            : null;
+        const result = await this.resolver({
+            brandId: brandContext.brandId,
+            caption,
+            media,
+            organizationId: context.organizationId,
+            platforms: enabledPlatforms,
+            scheduledFor,
+            userId: context.userId,
+        });
+        return {
+            data: result,
+            metadata: {
+                platforms: enabledPlatforms,
+                postCount: result.postIds.length,
+                scheduledFor: scheduledFor?.toISOString() ?? null,
+            },
+        };
+    }
+}
+export function createPublishExecutor(resolver) {
+    const executor = new PublishExecutor();
+    if (resolver) {
+        executor.setResolver(resolver);
+    }
+    return executor;
+}