@genfeedai/workflow-saas 0.2.0

package/src/nodes/publish.ts

@@ -0,0 +1,113 @@
+/**
+ * Publish Node
+ *
+ * OUTPUT category node that publishes content to social platforms.
+ * Requires brand input connection for credentials.
+ * Creates Post entities that are trackable in the Publisher app.
+ */
+
+import type { BaseNodeData } from '@workflow-saas/types';
+
+/**
+ * Supported social platforms
+ */
+export type PublishPlatform = 'twitter' | 'instagram' | 'tiktok' | 'linkedin';
+
+/**
+ * Platform configuration
+ */
+export interface PlatformConfig {
+  enabled: boolean;
+  accountId?: string; // Optional specific account if brand has multiple
+}
+
+/**
+ * Schedule configuration
+ */
+export interface PublishSchedule {
+  type: 'immediate' | 'scheduled';
+  datetime?: string; // ISO 8601 datetime for scheduled posts
+  timezone?: string; // Timezone for the scheduled time
+}
+
+/**
+ * Publish Node Data
+ *
+ * Inputs:
+ * - brand (brand): Brand context from Brand node (required)
+ * - media (any): Media to publish - image, video, etc. (required)
+ * - caption (text): Optional caption text
+ *
+ * Creates Post entities in the database.
+ */
+export interface PublishNodeData extends BaseNodeData {
+  type: 'publish';
+
+  // Input references (populated by edges)
+  inputBrandId: string | null;
+  inputMediaId: string | null;
+  inputCaption: string | null;
+
+  // Platform configuration
+  platforms: {
+    twitter: boolean;
+    instagram: boolean;
+    tiktok: boolean;
+    linkedin: boolean;
+  };
+
+  // Schedule configuration
+  schedule: PublishSchedule;
+
+  // Caption configuration
+  caption: string;
+  hashtags: string[];
+
+  // Output - created post IDs
+  createdPostIds: string[];
+  publishedUrls: string[];
+}
+
+/**
+ * Default data for a new Publish node
+ */
+export const DEFAULT_PUBLISH_DATA: Partial<PublishNodeData> = {
+  caption: '',
+  createdPostIds: [],
+  hashtags: [],
+  inputBrandId: null,
+  inputCaption: null,
+  inputMediaId: null,
+  label: 'Publish',
+  platforms: {
+    instagram: false,
+    linkedin: false,
+    tiktok: false,
+    twitter: false,
+  },
+  publishedUrls: [],
+  schedule: {
+    type: 'immediate',
+  },
+  status: 'idle',
+  type: 'publish',
+};
+
+/**
+ * Publish node definition for registry
+ */
+export const publishNodeDefinition = {
+  category: 'output' as const,
+  defaultData: DEFAULT_PUBLISH_DATA,
+  description:
+    'Publish content to Twitter, Instagram, TikTok, or LinkedIn with scheduling support',
+  icon: 'Share2',
+  inputs: [
+    { id: 'brand', label: 'Brand', required: true, type: 'brand' },
+    { id: 'media', label: 'Media', required: true, type: 'any' },
+    { id: 'caption', label: 'Caption', required: false, type: 'text' },
+  ],
+  label: 'Publish',
+  outputs: [],
+  type: 'publish',
+};

package/src/nodes/rss-input.spec.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'vitest';
+import { defaultRssInputData, rssInputNodeDefinition } from './rss-input';
+
+describe('rss-input node', () => {
+  describe('defaultRssInputData', () => {
+    it('should have label set to RSS Input', () => {
+      expect(defaultRssInputData.label).toBe('RSS Input');
+    });
+
+    it('should default to idle status', () => {
+      expect(defaultRssInputData.status).toBe('idle');
+    });
+
+    it('should default inputMode to url', () => {
+      expect(defaultRssInputData.inputMode).toBe('url');
+    });
+
+    it('should default feedUrl and rawXml to empty string', () => {
+      expect(defaultRssInputData.feedUrl).toBe('');
+      expect(defaultRssInputData.rawXml).toBe('');
+    });
+
+    it('should default selectedItemIndex to 0', () => {
+      expect(defaultRssInputData.selectedItemIndex).toBe(0);
+    });
+
+    it('should default feedTitle and feedItems to null', () => {
+      expect(defaultRssInputData.feedTitle).toBeNull();
+      expect(defaultRssInputData.feedItems).toBeNull();
+    });
+  });
+
+  describe('rssInputNodeDefinition', () => {
+    it('should have type rssInput', () => {
+      expect(rssInputNodeDefinition.type).toBe('rssInput');
+    });
+
+    it('should be in input category', () => {
+      expect(rssInputNodeDefinition.category).toBe('input');
+    });
+
+    it('should have label RSS Input', () => {
+      expect(rssInputNodeDefinition.label).toBe('RSS Input');
+    });
+
+    it('should have no inputs', () => {
+      expect(rssInputNodeDefinition.inputs).toEqual([]);
+    });
+
+    it('should output title, description, and link', () => {
+      const outputIds = rssInputNodeDefinition.outputs.map((o) => o.id);
+      expect(outputIds).toEqual(['title', 'description', 'link']);
+    });
+
+    it('should reference default data', () => {
+      expect(rssInputNodeDefinition.defaultData).toBe(defaultRssInputData);
+    });
+  });
+});

package/src/nodes/rss-input.ts

@@ -0,0 +1,55 @@
+/**
+ * RSS Input Node Types
+ *
+ * This node fetches and parses RSS feeds from URL or raw XML.
+ * Used for content aggregation workflows.
+ */
+
+export interface RssFeedItem {
+  title: string;
+  description: string;
+  link: string;
+  pubDate: string | null;
+}
+
+export interface RssInputNodeData {
+  label: string;
+  status: 'idle' | 'pending' | 'processing' | 'complete' | 'error';
+  error?: string;
+
+  // Input mode
+  inputMode: 'url' | 'text';
+  feedUrl: string;
+  rawXml: string;
+
+  // Parsed data
+  feedTitle: string | null;
+  feedItems: RssFeedItem[] | null;
+  selectedItemIndex: number;
+}
+
+export const defaultRssInputData: Partial<RssInputNodeData> = {
+  feedItems: null,
+  feedTitle: null,
+  feedUrl: '',
+  inputMode: 'url',
+  label: 'RSS Input',
+  rawXml: '',
+  selectedItemIndex: 0,
+  status: 'idle',
+};
+
+export const rssInputNodeDefinition = {
+  category: 'input',
+  defaultData: defaultRssInputData,
+  description: 'Fetch and parse RSS feeds from URL or XML',
+  icon: 'Rss',
+  inputs: [],
+  label: 'RSS Input',
+  outputs: [
+    { id: 'title', label: 'Item Title', type: 'text' },
+    { id: 'description', label: 'Item Description', type: 'text' },
+    { id: 'link', label: 'Item Link', type: 'text' },
+  ],
+  type: 'rssInput',
+};

package/src/nodes/send-dm.spec.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+import { DEFAULT_SEND_DM_DATA } from './send-dm';
+
+describe('send-dm node', () => {
+  describe('DEFAULT_SEND_DM_DATA', () => {
+    it('should have label set to Send DM', () => {
+      expect(DEFAULT_SEND_DM_DATA.label).toBe('Send DM');
+    });
+
+    it('should default to idle status', () => {
+      expect(DEFAULT_SEND_DM_DATA.status).toBe('idle');
+    });
+
+    it('should have type set to sendDm', () => {
+      expect(DEFAULT_SEND_DM_DATA.type).toBe('sendDm');
+    });
+
+    it('should default platform to twitter', () => {
+      expect(DEFAULT_SEND_DM_DATA.platform).toBe('twitter');
+    });
+
+    it('should default recipientId and text to empty string', () => {
+      expect(DEFAULT_SEND_DM_DATA.recipientId).toBe('');
+      expect(DEFAULT_SEND_DM_DATA.text).toBe('');
+    });
+
+    it('should default mediaUrl to empty string', () => {
+      expect(DEFAULT_SEND_DM_DATA.mediaUrl).toBe('');
+    });
+
+    it('should default messageId to null', () => {
+      expect(DEFAULT_SEND_DM_DATA.messageId).toBeNull();
+    });
+  });
+});

package/src/nodes/send-dm.ts

@@ -0,0 +1,51 @@
+/**
+ * Send DM Node
+ *
+ * ACTION category node that sends a direct message on a social platform.
+ * Requires brand input for credentials resolution.
+ */
+
+import type { BaseNodeData } from '@workflow-saas/types';
+
+export type SendDmPlatform = 'twitter' | 'instagram';
+
+/**
+ * Send DM Node Data
+ *
+ * Inputs:
+ * - brand (brand): Brand context (required)
+ * - recipientId (text): Recipient user ID (required)
+ * - text (text): Message text (required)
+ *
+ * Outputs:
+ * - messageId (text): The ID of the sent message
+ */
+export interface SendDmNodeData extends BaseNodeData {
+  type: 'sendDm';
+
+  /** Platform to send DM on */
+  platform: SendDmPlatform;
+  /** Recipient user ID or username */
+  recipientId: string;
+  /** DM text */
+  text: string;
+  /** Optional media URL to attach */
+  mediaUrl: string;
+
+  /** Output - sent message ID */
+  messageId: string | null;
+}
+
+/**
+ * Default data for a new Send DM node
+ */
+export const DEFAULT_SEND_DM_DATA: Partial<SendDmNodeData> = {
+  label: 'Send DM',
+  mediaUrl: '',
+  messageId: null,
+  platform: 'twitter',
+  recipientId: '',
+  status: 'idle',
+  text: '',
+  type: 'sendDm',
+};

package/src/nodes/slideshow-image-batch.spec.ts

@@ -0,0 +1,142 @@
+import { describe, expect, it } from 'vitest';
+import {
+  DEFAULT_SLIDESHOW_IMAGE_BATCH_DATA,
+  DEFAULT_STYLE_MODIFIERS,
+  SLIDESHOW_DIMENSIONS,
+  slideshowImageBatchNodeDefinition,
+} from './slideshow-image-batch';
+
+describe('slideshow-image-batch node', () => {
+  describe('SLIDESHOW_DIMENSIONS', () => {
+    it('should define tiktok_portrait as 1080x1350', () => {
+      expect(SLIDESHOW_DIMENSIONS.tiktok_portrait).toEqual({
+        height: 1350,
+        width: 1080,
+      });
+    });
+
+    it('should define tiktok_square as 1080x1080', () => {
+      expect(SLIDESHOW_DIMENSIONS.tiktok_square).toEqual({
+        height: 1080,
+        width: 1080,
+      });
+    });
+
+    it('should define custom as 1080x1080', () => {
+      expect(SLIDESHOW_DIMENSIONS.custom).toEqual({
+        height: 1080,
+        width: 1080,
+      });
+    });
+  });
+
+  describe('DEFAULT_STYLE_MODIFIERS', () => {
+    it('should have 6 style modifiers for a 6-slide slideshow', () => {
+      expect(DEFAULT_STYLE_MODIFIERS).toHaveLength(6);
+    });
+
+    it('should have non-empty modifier strings', () => {
+      for (const modifier of DEFAULT_STYLE_MODIFIERS) {
+        expect(modifier).toBeTruthy();
+        expect(typeof modifier).toBe('string');
+      }
+    });
+  });
+
+  describe('DEFAULT_SLIDESHOW_IMAGE_BATCH_DATA', () => {
+    it('should have label set to Slideshow Image Batch', () => {
+      expect(DEFAULT_SLIDESHOW_IMAGE_BATCH_DATA.label).toBe(
+        'Slideshow Image Batch',
+      );
+    });
+
+    it('should default to idle status', () => {
+      expect(DEFAULT_SLIDESHOW_IMAGE_BATCH_DATA.status).toBe('idle');
+    });
+
+    it('should have type set to slideshowImageBatch', () => {
+      expect(DEFAULT_SLIDESHOW_IMAGE_BATCH_DATA.type).toBe(
+        'slideshowImageBatch',
+      );
+    });
+
+    it('should default slideCount to 6', () => {
+      expect(DEFAULT_SLIDESHOW_IMAGE_BATCH_DATA.slideCount).toBe(6);
+    });
+
+    it('should default aspectRatio to tiktok_portrait', () => {
+      expect(DEFAULT_SLIDESHOW_IMAGE_BATCH_DATA.aspectRatio).toBe(
+        'tiktok_portrait',
+      );
+    });
+
+    it('should include default style modifiers', () => {
+      expect(DEFAULT_SLIDESHOW_IMAGE_BATCH_DATA.styleModifiers).toEqual(
+        DEFAULT_STYLE_MODIFIERS,
+      );
+    });
+
+    it('should not share the same array reference as DEFAULT_STYLE_MODIFIERS', () => {
+      expect(DEFAULT_SLIDESHOW_IMAGE_BATCH_DATA.styleModifiers).not.toBe(
+        DEFAULT_STYLE_MODIFIERS,
+      );
+    });
+
+    it('should default nullable config fields to null', () => {
+      expect(DEFAULT_SLIDESHOW_IMAGE_BATCH_DATA.basePrompt).toBeNull();
+      expect(DEFAULT_SLIDESHOW_IMAGE_BATCH_DATA.model).toBeNull();
+      expect(DEFAULT_SLIDESHOW_IMAGE_BATCH_DATA.seed).toBeNull();
+    });
+
+    it('should default input connections to null', () => {
+      expect(DEFAULT_SLIDESHOW_IMAGE_BATCH_DATA.inputSlidePrompts).toBeNull();
+      expect(DEFAULT_SLIDESHOW_IMAGE_BATCH_DATA.inputBasePrompt).toBeNull();
+    });
+
+    it('should default output arrays to empty', () => {
+      expect(DEFAULT_SLIDESHOW_IMAGE_BATCH_DATA.outputImageUrls).toEqual([]);
+      expect(DEFAULT_SLIDESHOW_IMAGE_BATCH_DATA.outputJobIds).toEqual([]);
+    });
+  });
+
+  describe('slideshowImageBatchNodeDefinition', () => {
+    it('should have type slideshowImageBatch', () => {
+      expect(slideshowImageBatchNodeDefinition.type).toBe(
+        'slideshowImageBatch',
+      );
+    });
+
+    it('should be in saas category', () => {
+      expect(slideshowImageBatchNodeDefinition.category).toBe('saas');
+    });
+
+    it('should have label Slideshow Image Batch', () => {
+      expect(slideshowImageBatchNodeDefinition.label).toBe(
+        'Slideshow Image Batch',
+      );
+    });
+
+    it('should have optional slidePrompts and basePrompt inputs', () => {
+      const slidePromptsInput = slideshowImageBatchNodeDefinition.inputs.find(
+        (i) => i.id === 'slidePrompts',
+      );
+      const basePromptInput = slideshowImageBatchNodeDefinition.inputs.find(
+        (i) => i.id === 'basePrompt',
+      );
+      expect(slidePromptsInput?.required).toBe(false);
+      expect(basePromptInput?.required).toBe(false);
+    });
+
+    it('should output multiple images', () => {
+      expect(slideshowImageBatchNodeDefinition.outputs).toHaveLength(1);
+      expect(slideshowImageBatchNodeDefinition.outputs[0].id).toBe('images');
+      expect(slideshowImageBatchNodeDefinition.outputs[0].multiple).toBe(true);
+    });
+
+    it('should reference default data', () => {
+      expect(slideshowImageBatchNodeDefinition.defaultData).toBe(
+        DEFAULT_SLIDESHOW_IMAGE_BATCH_DATA,
+      );
+    });
+  });
+});

package/src/nodes/slideshow-image-batch.ts

@@ -0,0 +1,121 @@
+/**
+ * Slideshow Image Batch Node
+ *
+ * SAAS category node that orchestrates generating a batch of consistent
+ * images for a TikTok slideshow. Uses a shared base prompt with per-slide
+ * style modifiers and a shared seed to maintain visual consistency across slides.
+ */
+
+import type { BaseNodeData } from '@workflow-saas/types';
+
+/**
+ * Aspect ratio presets for TikTok slideshows
+ */
+export type SlideshowAspectRatio =
+  | 'tiktok_portrait'
+  | 'tiktok_square'
+  | 'custom';
+
+/**
+ * Dimension mapping for each aspect ratio preset
+ */
+export const SLIDESHOW_DIMENSIONS: Record<
+  SlideshowAspectRatio,
+  { width: number; height: number }
+> = {
+  custom: { height: 1080, width: 1080 },
+  tiktok_portrait: { height: 1350, width: 1080 },
+  tiktok_square: { height: 1080, width: 1080 },
+};
+
+/**
+ * Default per-slide style modifiers for a 6-slide TikTok slideshow
+ */
+export const DEFAULT_STYLE_MODIFIERS: string[] = [
+  'dramatic front-facing hero shot, bold lighting',
+  'candid side angle, natural environment',
+  'close-up detail shot, shallow depth of field',
+  'wide establishing shot, environmental context',
+  'dynamic action pose, motion blur background',
+  'warm golden hour, aspirational lifestyle',
+];
+
+/**
+ * Slideshow Image Batch Node Data
+ *
+ * Inputs:
+ * - slidePrompts (text[]): Per-slide prompts from HookGenerator
+ * - basePrompt (text): Optional shared base prompt override
+ *
+ * Outputs:
+ * - images (image[]): Generated image URLs (one per slide)
+ */
+export interface SlideshowImageBatchNodeData extends BaseNodeData {
+  type: 'slideshowImageBatch';
+
+  // Configuration
+  slideCount: number;
+  basePrompt: string | null;
+  styleModifiers: string[];
+  aspectRatio: SlideshowAspectRatio;
+  model: string | null;
+  seed: number | null;
+
+  // Input from connections
+  inputSlidePrompts: string[] | null;
+  inputBasePrompt: string | null;
+
+  // Output
+  outputImageUrls: string[];
+  outputJobIds: string[];
+}
+
+/**
+ * Default data for a new Slideshow Image Batch node
+ */
+export const DEFAULT_SLIDESHOW_IMAGE_BATCH_DATA: Partial<SlideshowImageBatchNodeData> =
+  {
+    aspectRatio: 'tiktok_portrait',
+    basePrompt: null,
+    inputBasePrompt: null,
+    inputSlidePrompts: null,
+    label: 'Slideshow Image Batch',
+    model: null,
+    outputImageUrls: [],
+    outputJobIds: [],
+    seed: null,
+    slideCount: 6,
+    status: 'idle',
+    styleModifiers: [...DEFAULT_STYLE_MODIFIERS],
+    type: 'slideshowImageBatch',
+  };
+
+/**
+ * Slideshow Image Batch node definition for registry
+ */
+export const slideshowImageBatchNodeDefinition = {
+  category: 'saas' as const,
+  defaultData: DEFAULT_SLIDESHOW_IMAGE_BATCH_DATA,
+  description:
+    'Generate a batch of consistent images for TikTok slideshow posts',
+  icon: 'Images',
+  inputs: [
+    {
+      id: 'slidePrompts',
+      label: 'Slide Prompts',
+      required: false,
+      type: 'text[]',
+    },
+    {
+      id: 'basePrompt',
+      label: 'Base Prompt',
+      required: false,
+      type: 'text',
+    },
+  ],
+  label: 'Slideshow Image Batch',
+  outputs: [
+    { id: 'images', label: 'Slide Images', multiple: true, type: 'image' },
+  ],
+  type: 'slideshowImageBatch',
+};

package/src/nodes/social-publish.spec.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from 'vitest';
+import {
+  defaultSocialPublishData,
+  socialPublishNodeDefinition,
+} from './social-publish';
+
+describe('social-publish node', () => {
+  describe('defaultSocialPublishData', () => {
+    it('should have label set to Social Publish', () => {
+      expect(defaultSocialPublishData.label).toBe('Social Publish');
+    });
+
+    it('should default to idle status', () => {
+      expect(defaultSocialPublishData.status).toBe('idle');
+    });
+
+    it('should default platform to youtube', () => {
+      expect(defaultSocialPublishData.platform).toBe('youtube');
+    });
+
+    it('should default visibility to public', () => {
+      expect(defaultSocialPublishData.visibility).toBe('public');
+    });
+
+    it('should default tags to empty array', () => {
+      expect(defaultSocialPublishData.tags).toEqual([]);
+    });
+
+    it('should default input and output references to null', () => {
+      expect(defaultSocialPublishData.inputVideo).toBeNull();
+      expect(defaultSocialPublishData.publishedUrl).toBeNull();
+      expect(defaultSocialPublishData.jobId).toBeNull();
+      expect(defaultSocialPublishData.scheduledTime).toBeNull();
+    });
+
+    it('should default title and description to empty string', () => {
+      expect(defaultSocialPublishData.title).toBe('');
+      expect(defaultSocialPublishData.description).toBe('');
+    });
+  });
+
+  describe('socialPublishNodeDefinition', () => {
+    it('should have type socialPublish', () => {
+      expect(socialPublishNodeDefinition.type).toBe('socialPublish');
+    });
+
+    it('should be in output category', () => {
+      expect(socialPublishNodeDefinition.category).toBe('output');
+    });
+
+    it('should have label Social Publish', () => {
+      expect(socialPublishNodeDefinition.label).toBe('Social Publish');
+    });
+
+    it('should have a description mentioning supported platforms', () => {
+      expect(socialPublishNodeDefinition.description).toContain('YouTube');
+    });
+
+    it('should require video input', () => {
+      expect(socialPublishNodeDefinition.inputs).toHaveLength(1);
+      const videoInput = socialPublishNodeDefinition.inputs[0];
+      expect(videoInput.id).toBe('video');
+      expect(videoInput.required).toBe(true);
+      expect(videoInput.type).toBe('video');
+    });
+
+    it('should have no outputs', () => {
+      expect(socialPublishNodeDefinition.outputs).toEqual([]);
+    });
+
+    it('should reference default data', () => {
+      expect(socialPublishNodeDefinition.defaultData).toBe(
+        defaultSocialPublishData,
+      );
+    });
+  });
+});