@genfeedai/workflow-saas 0.2.0

package/src/nodes/social-publish.ts

@@ -0,0 +1,66 @@
+/**
+ * Social Publish Node Types
+ *
+ * This node enables direct publishing to social media platforms.
+ * Requires OAuth integrations with each platform.
+ */
+
+export type SocialPlatform =
+  | 'youtube'
+  | 'tiktok'
+  | 'instagram'
+  | 'twitter'
+  | 'linkedin'
+  | 'facebook'
+  | 'threads';
+
+export type SocialVisibility = 'public' | 'private' | 'unlisted';
+
+export interface SocialPublishNodeData {
+  label: string;
+  status: 'idle' | 'pending' | 'processing' | 'complete' | 'error';
+  error?: string;
+
+  // Input from connections
+  inputVideo: string | null;
+
+  // Publish config
+  platform: SocialPlatform;
+  title: string;
+  description: string;
+  tags: string[];
+  visibility: SocialVisibility;
+  scheduledTime: string | null;
+
+  // Output
+  publishedUrl: string | null;
+
+  // Job state
+  jobId: string | null;
+}
+
+export const defaultSocialPublishData: Partial<SocialPublishNodeData> = {
+  description: '',
+  inputVideo: null,
+  jobId: null,
+  label: 'Social Publish',
+  platform: 'youtube',
+  publishedUrl: null,
+  scheduledTime: null,
+  status: 'idle',
+  tags: [],
+  title: '',
+  visibility: 'public',
+};
+
+export const socialPublishNodeDefinition = {
+  category: 'output',
+  defaultData: defaultSocialPublishData,
+  description:
+    'Publish video to YouTube, TikTok, Instagram, LinkedIn, Facebook, or Threads',
+  icon: 'Share2',
+  inputs: [{ id: 'video', label: 'Video', required: true, type: 'video' }],
+  label: 'Social Publish',
+  outputs: [],
+  type: 'socialPublish',
+};

package/src/nodes/sound-overlay.spec.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from 'vitest';
+import {
+  DEFAULT_SOUND_OVERLAY_DATA,
+  soundOverlayNodeDefinition,
+} from './sound-overlay';
+
+describe('sound-overlay node', () => {
+  describe('DEFAULT_SOUND_OVERLAY_DATA', () => {
+    it('should have label set to Sound Overlay', () => {
+      expect(DEFAULT_SOUND_OVERLAY_DATA.label).toBe('Sound Overlay');
+    });
+
+    it('should default to idle status', () => {
+      expect(DEFAULT_SOUND_OVERLAY_DATA.status).toBe('idle');
+    });
+
+    it('should default mixMode to replace', () => {
+      expect(DEFAULT_SOUND_OVERLAY_DATA.mixMode).toBe('replace');
+    });
+
+    it('should default audioVolume to 100 and videoVolume to 0', () => {
+      expect(DEFAULT_SOUND_OVERLAY_DATA.audioVolume).toBe(100);
+      expect(DEFAULT_SOUND_OVERLAY_DATA.videoVolume).toBe(0);
+    });
+
+    it('should default fadeIn and fadeOut to 0', () => {
+      expect(DEFAULT_SOUND_OVERLAY_DATA.fadeIn).toBe(0);
+      expect(DEFAULT_SOUND_OVERLAY_DATA.fadeOut).toBe(0);
+    });
+
+    it('should default input URLs to null', () => {
+      expect(DEFAULT_SOUND_OVERLAY_DATA.videoUrl).toBeNull();
+      expect(DEFAULT_SOUND_OVERLAY_DATA.soundUrl).toBeNull();
+    });
+
+    it('should default output and processing fields to null', () => {
+      expect(DEFAULT_SOUND_OVERLAY_DATA.outputVideoUrl).toBeNull();
+      expect(DEFAULT_SOUND_OVERLAY_DATA.jobId).toBeNull();
+      expect(DEFAULT_SOUND_OVERLAY_DATA.processingProgress).toBeNull();
+    });
+  });
+
+  describe('soundOverlayNodeDefinition', () => {
+    it('should have type soundOverlay', () => {
+      expect(soundOverlayNodeDefinition.type).toBe('soundOverlay');
+    });
+
+    it('should be in processing category', () => {
+      expect(soundOverlayNodeDefinition.category).toBe('processing');
+    });
+
+    it('should have label Sound Overlay', () => {
+      expect(soundOverlayNodeDefinition.label).toBe('Sound Overlay');
+    });
+
+    it('should require videoUrl and soundUrl inputs', () => {
+      expect(soundOverlayNodeDefinition.inputs).toHaveLength(2);
+      const videoInput = soundOverlayNodeDefinition.inputs.find(
+        (i) => i.id === 'videoUrl',
+      );
+      const soundInput = soundOverlayNodeDefinition.inputs.find(
+        (i) => i.id === 'soundUrl',
+      );
+      expect(videoInput?.required).toBe(true);
+      expect(soundInput?.required).toBe(true);
+    });
+
+    it('should output a single videoUrl', () => {
+      expect(soundOverlayNodeDefinition.outputs).toHaveLength(1);
+      expect(soundOverlayNodeDefinition.outputs[0].id).toBe('videoUrl');
+    });
+
+    it('should reference default data', () => {
+      expect(soundOverlayNodeDefinition.defaultData).toBe(
+        DEFAULT_SOUND_OVERLAY_DATA,
+      );
+    });
+  });
+});

package/src/nodes/sound-overlay.ts

@@ -0,0 +1,57 @@
+/**
+ * Sound Overlay Node Types
+ *
+ * This node adds an audio track to a generated video using FFmpeg.
+ * Supports replace, mix, and background modes with volume controls.
+ */
+
+import type { BaseTrendNodeData, MixMode } from './trend-shared';
+
+export interface SoundOverlayNodeData extends BaseTrendNodeData {
+  // Inputs
+  videoUrl: string | null;
+  soundUrl: string | null;
+
+  // Configuration
+  mixMode: MixMode;
+  audioVolume: number;
+  videoVolume: number;
+  fadeIn: number;
+  fadeOut: number;
+
+  // Output
+  outputVideoUrl: string | null;
+
+  // Processing info (for display)
+  jobId: string | null;
+  processingProgress: number | null;
+}
+
+export const DEFAULT_SOUND_OVERLAY_DATA: Partial<SoundOverlayNodeData> = {
+  audioVolume: 100,
+  fadeIn: 0,
+  fadeOut: 0,
+  jobId: null,
+  label: 'Sound Overlay',
+  mixMode: 'replace',
+  outputVideoUrl: null,
+  processingProgress: null,
+  soundUrl: null,
+  status: 'idle',
+  videoUrl: null,
+  videoVolume: 0,
+};
+
+export const soundOverlayNodeDefinition = {
+  category: 'processing' as const,
+  defaultData: DEFAULT_SOUND_OVERLAY_DATA,
+  description: 'Add audio track to video via FFmpeg',
+  icon: 'Volume2',
+  inputs: [
+    { id: 'videoUrl', label: 'Video URL', required: true, type: 'text' },
+    { id: 'soundUrl', label: 'Sound URL', required: true, type: 'text' },
+  ],
+  label: 'Sound Overlay',
+  outputs: [{ id: 'videoUrl', label: 'Output Video', type: 'text' }],
+  type: 'soundOverlay',
+};

package/src/nodes/trend-hashtag-inspiration.spec.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it } from 'vitest';
+import {
+  DEFAULT_TREND_HASHTAG_INSPIRATION_DATA,
+  trendHashtagInspirationNodeDefinition,
+} from './trend-hashtag-inspiration';
+
+describe('trend-hashtag-inspiration node', () => {
+  describe('DEFAULT_TREND_HASHTAG_INSPIRATION_DATA', () => {
+    it('should have label set to Trend Hashtag Inspiration', () => {
+      expect(DEFAULT_TREND_HASHTAG_INSPIRATION_DATA.label).toBe(
+        'Trend Hashtag Inspiration',
+      );
+    });
+
+    it('should default to idle status', () => {
+      expect(DEFAULT_TREND_HASHTAG_INSPIRATION_DATA.status).toBe('idle');
+    });
+
+    it('should default platform to tiktok', () => {
+      expect(DEFAULT_TREND_HASHTAG_INSPIRATION_DATA.platform).toBe('tiktok');
+    });
+
+    it('should default auto to true', () => {
+      expect(DEFAULT_TREND_HASHTAG_INSPIRATION_DATA.auto).toBe(true);
+    });
+
+    it('should default contentPreference to video', () => {
+      expect(DEFAULT_TREND_HASHTAG_INSPIRATION_DATA.contentPreference).toBe(
+        'video',
+      );
+    });
+
+    it('should default output fields to null or empty', () => {
+      expect(DEFAULT_TREND_HASHTAG_INSPIRATION_DATA.prompt).toBeNull();
+      expect(DEFAULT_TREND_HASHTAG_INSPIRATION_DATA.hashtags).toEqual([]);
+      expect(DEFAULT_TREND_HASHTAG_INSPIRATION_DATA.contentType).toBeNull();
+      expect(
+        DEFAULT_TREND_HASHTAG_INSPIRATION_DATA.recommendedPlatform,
+      ).toBeNull();
+    });
+
+    it('should default source info to null', () => {
+      expect(DEFAULT_TREND_HASHTAG_INSPIRATION_DATA.hashtag).toBeNull();
+      expect(DEFAULT_TREND_HASHTAG_INSPIRATION_DATA.sourceHashtag).toBeNull();
+      expect(
+        DEFAULT_TREND_HASHTAG_INSPIRATION_DATA.hashtagPostCount,
+      ).toBeNull();
+    });
+  });
+
+  describe('trendHashtagInspirationNodeDefinition', () => {
+    it('should have type trendHashtagInspiration', () => {
+      expect(trendHashtagInspirationNodeDefinition.type).toBe(
+        'trendHashtagInspiration',
+      );
+    });
+
+    it('should be in ai category', () => {
+      expect(trendHashtagInspirationNodeDefinition.category).toBe('ai');
+    });
+
+    it('should have label Trend Hashtag Inspiration', () => {
+      expect(trendHashtagInspirationNodeDefinition.label).toBe(
+        'Trend Hashtag Inspiration',
+      );
+    });
+
+    it('should have optional hashtag input', () => {
+      expect(trendHashtagInspirationNodeDefinition.inputs).toHaveLength(1);
+      expect(trendHashtagInspirationNodeDefinition.inputs[0].id).toBe(
+        'hashtag',
+      );
+      expect(trendHashtagInspirationNodeDefinition.inputs[0].optional).toBe(
+        true,
+      );
+    });
+
+    it('should output prompt, hashtags, contentType, and platform', () => {
+      const outputIds = trendHashtagInspirationNodeDefinition.outputs.map(
+        (o) => o.id,
+      );
+      expect(outputIds).toEqual([
+        'prompt',
+        'hashtags',
+        'contentType',
+        'platform',
+      ]);
+    });
+
+    it('should reference default data', () => {
+      expect(trendHashtagInspirationNodeDefinition.defaultData).toBe(
+        DEFAULT_TREND_HASHTAG_INSPIRATION_DATA,
+      );
+    });
+  });
+});

package/src/nodes/trend-hashtag-inspiration.ts

@@ -0,0 +1,65 @@
+/**
+ * Trend Hashtag Inspiration Node Types
+ *
+ * This node generates content ideas from trending hashtags.
+ * Uses AI to analyze hashtag context and create suitable content prompts.
+ */
+
+import type {
+  BaseTrendNodeData,
+  ContentPreference,
+  ContentType,
+  TrendPlatform,
+} from './trend-shared';
+
+export interface TrendHashtagInspirationNodeData extends BaseTrendNodeData {
+  // Inputs (can be connected or auto-selected)
+  hashtag: string | null;
+  auto: boolean;
+
+  // Configuration
+  platform: TrendPlatform;
+  contentPreference: ContentPreference;
+
+  // Outputs
+  prompt: string | null;
+  hashtags: string[];
+  contentType: ContentType | null;
+  recommendedPlatform: TrendPlatform | null;
+
+  // Source hashtag info (for display)
+  sourceHashtag: string | null;
+  hashtagPostCount: number | null;
+}
+
+export const DEFAULT_TREND_HASHTAG_INSPIRATION_DATA: Partial<TrendHashtagInspirationNodeData> =
+  {
+    auto: true,
+    contentPreference: 'video',
+    contentType: null,
+    hashtag: null,
+    hashtagPostCount: null,
+    hashtags: [],
+    label: 'Trend Hashtag Inspiration',
+    platform: 'tiktok',
+    prompt: null,
+    recommendedPlatform: null,
+    sourceHashtag: null,
+    status: 'idle',
+  };
+
+export const trendHashtagInspirationNodeDefinition = {
+  category: 'ai' as const,
+  defaultData: DEFAULT_TREND_HASHTAG_INSPIRATION_DATA,
+  description: 'Generate content idea from trending hashtag',
+  icon: 'Hash',
+  inputs: [{ id: 'hashtag', label: 'Hashtag', optional: true, type: 'text' }],
+  label: 'Trend Hashtag Inspiration',
+  outputs: [
+    { id: 'prompt', label: 'Prompt', type: 'text' },
+    { id: 'hashtags', label: 'Hashtags', type: 'text[]' },
+    { id: 'contentType', label: 'Content Type', type: 'text' },
+    { id: 'platform', label: 'Best Platform', type: 'text' },
+  ],
+  type: 'trendHashtagInspiration',
+};

package/src/nodes/trend-shared.spec.ts

@@ -0,0 +1,99 @@
+import { describe, expect, it } from 'vitest';
+import type {
+  AspectRatio,
+  BaseTrendNodeData,
+  CheckFrequency,
+  ContentPreference,
+  ContentStyle,
+  ContentType,
+  InspirationStyle,
+  MixMode,
+  TrendPlatform,
+  TrendType,
+} from './trend-shared';
+
+describe('trend-shared types', () => {
+  it('should allow valid TrendPlatform values', () => {
+    const platforms: TrendPlatform[] = [
+      'tiktok',
+      'instagram',
+      'twitter',
+      'youtube',
+      'reddit',
+    ];
+    expect(platforms).toHaveLength(5);
+  });
+
+  it('should allow valid TrendType values', () => {
+    const types: TrendType[] = ['video', 'hashtag', 'sound', 'topic'];
+    expect(types).toHaveLength(4);
+  });
+
+  it('should allow valid AspectRatio values', () => {
+    const ratios: AspectRatio[] = ['16:9', '9:16', '1:1'];
+    expect(ratios).toHaveLength(3);
+  });
+
+  it('should allow valid InspirationStyle values', () => {
+    const styles: InspirationStyle[] = [
+      'match_closely',
+      'inspired_by',
+      'remix_concept',
+    ];
+    expect(styles).toHaveLength(3);
+  });
+
+  it('should allow valid ContentStyle values', () => {
+    const styles: ContentStyle[] = [
+      'cinematic',
+      'vlog',
+      'tutorial',
+      'comedy',
+      'aesthetic',
+      'educational',
+      'storytelling',
+      'trend_dance',
+      'product',
+      'other',
+    ];
+    expect(styles).toHaveLength(10);
+  });
+
+  it('should allow valid ContentType values', () => {
+    const types: ContentType[] = ['video', 'image', 'carousel', 'thread'];
+    expect(types).toHaveLength(4);
+  });
+
+  it('should allow valid ContentPreference values', () => {
+    const prefs: ContentPreference[] = ['video', 'image', 'any'];
+    expect(prefs).toHaveLength(3);
+  });
+
+  it('should allow valid CheckFrequency values', () => {
+    const freqs: CheckFrequency[] = ['15min', '30min', '1hr', '4hr', 'daily'];
+    expect(freqs).toHaveLength(5);
+  });
+
+  it('should allow valid MixMode values', () => {
+    const modes: MixMode[] = ['replace', 'mix', 'background'];
+    expect(modes).toHaveLength(3);
+  });
+
+  it('should allow BaseTrendNodeData with required fields', () => {
+    const data: BaseTrendNodeData = {
+      label: 'Test',
+      status: 'idle',
+    };
+    expect(data.status).toBe('idle');
+    expect(data.label).toBe('Test');
+  });
+
+  it('should allow BaseTrendNodeData with optional error', () => {
+    const data: BaseTrendNodeData = {
+      error: 'something went wrong',
+      label: 'Test',
+      status: 'error',
+    };
+    expect(data.error).toBe('something went wrong');
+  });
+});

package/src/nodes/trend-shared.ts

@@ -0,0 +1,79 @@
+/**
+ * Shared Types for Trend Automation Nodes
+ *
+ * Common types and interfaces used across trend-related workflow nodes.
+ */
+
+import type { BaseNodeData } from '@workflow-saas/types';
+
+/**
+ * Supported social platforms for trend monitoring
+ */
+export type TrendPlatform =
+  | 'tiktok'
+  | 'instagram'
+  | 'twitter'
+  | 'youtube'
+  | 'reddit';
+
+/**
+ * Content type categories
+ */
+export type TrendType = 'video' | 'hashtag' | 'sound' | 'topic';
+
+/**
+ * Video aspect ratios
+ */
+export type AspectRatio = '16:9' | '9:16' | '1:1';
+
+/**
+ * How closely to match the original trend
+ */
+export type InspirationStyle =
+  | 'match_closely'
+  | 'inspired_by'
+  | 'remix_concept';
+
+/**
+ * Content style categories
+ */
+export type ContentStyle =
+  | 'cinematic'
+  | 'vlog'
+  | 'tutorial'
+  | 'comedy'
+  | 'aesthetic'
+  | 'educational'
+  | 'storytelling'
+  | 'trend_dance'
+  | 'product'
+  | 'other';
+
+/**
+ * Content type output
+ */
+export type ContentType = 'video' | 'image' | 'carousel' | 'thread';
+
+/**
+ * Content format preference
+ */
+export type ContentPreference = 'video' | 'image' | 'any';
+
+/**
+ * Trend check frequency intervals
+ */
+export type CheckFrequency = '15min' | '30min' | '1hr' | '4hr' | 'daily';
+
+/**
+ * Audio mixing modes for sound overlay
+ */
+export type MixMode = 'replace' | 'mix' | 'background';
+
+/**
+ * Base interface for trend-related node data
+ * Extends BaseNodeData with common trend node fields
+ */
+export interface BaseTrendNodeData extends BaseNodeData {
+  status: 'idle' | 'pending' | 'processing' | 'complete' | 'error';
+  error?: string;
+}

package/src/nodes/trend-sound-inspiration.spec.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it } from 'vitest';
+import {
+  DEFAULT_TREND_SOUND_INSPIRATION_DATA,
+  trendSoundInspirationNodeDefinition,
+} from './trend-sound-inspiration';
+
+describe('trend-sound-inspiration node', () => {
+  describe('DEFAULT_TREND_SOUND_INSPIRATION_DATA', () => {
+    it('should have label set to Trend Sound Inspiration', () => {
+      expect(DEFAULT_TREND_SOUND_INSPIRATION_DATA.label).toBe(
+        'Trend Sound Inspiration',
+      );
+    });
+
+    it('should default to idle status', () => {
+      expect(DEFAULT_TREND_SOUND_INSPIRATION_DATA.status).toBe('idle');
+    });
+
+    it('should default minUsageCount to 10000', () => {
+      expect(DEFAULT_TREND_SOUND_INSPIRATION_DATA.minUsageCount).toBe(10000);
+    });
+
+    it('should default maxDuration to null', () => {
+      expect(DEFAULT_TREND_SOUND_INSPIRATION_DATA.maxDuration).toBeNull();
+    });
+
+    it('should default all output fields to null', () => {
+      expect(DEFAULT_TREND_SOUND_INSPIRATION_DATA.soundId).toBeNull();
+      expect(DEFAULT_TREND_SOUND_INSPIRATION_DATA.soundName).toBeNull();
+      expect(DEFAULT_TREND_SOUND_INSPIRATION_DATA.soundUrl).toBeNull();
+      expect(DEFAULT_TREND_SOUND_INSPIRATION_DATA.duration).toBeNull();
+      expect(DEFAULT_TREND_SOUND_INSPIRATION_DATA.usageCount).toBeNull();
+    });
+
+    it('should default display info fields to null', () => {
+      expect(DEFAULT_TREND_SOUND_INSPIRATION_DATA.authorName).toBeNull();
+      expect(DEFAULT_TREND_SOUND_INSPIRATION_DATA.coverUrl).toBeNull();
+      expect(DEFAULT_TREND_SOUND_INSPIRATION_DATA.growthRate).toBeNull();
+    });
+  });
+
+  describe('trendSoundInspirationNodeDefinition', () => {
+    it('should have type trendSoundInspiration', () => {
+      expect(trendSoundInspirationNodeDefinition.type).toBe(
+        'trendSoundInspiration',
+      );
+    });
+
+    it('should be in inspiration category', () => {
+      expect(trendSoundInspirationNodeDefinition.category).toBe('inspiration');
+    });
+
+    it('should have label Trend Sound Inspiration', () => {
+      expect(trendSoundInspirationNodeDefinition.label).toBe(
+        'Trend Sound Inspiration',
+      );
+    });
+
+    it('should have no inputs', () => {
+      expect(trendSoundInspirationNodeDefinition.inputs).toEqual([]);
+    });
+
+    it('should output soundId, soundName, soundUrl, duration, and usageCount', () => {
+      const outputIds = trendSoundInspirationNodeDefinition.outputs.map(
+        (o) => o.id,
+      );
+      expect(outputIds).toEqual([
+        'soundId',
+        'soundName',
+        'soundUrl',
+        'duration',
+        'usageCount',
+      ]);
+    });
+
+    it('should reference default data', () => {
+      expect(trendSoundInspirationNodeDefinition.defaultData).toBe(
+        DEFAULT_TREND_SOUND_INSPIRATION_DATA,
+      );
+    });
+  });
+});

package/src/nodes/trend-sound-inspiration.ts

@@ -0,0 +1,59 @@
+/**
+ * Trend Sound Inspiration Node Types
+ *
+ * This node gets trending sounds from TikTok for content creation.
+ * Auto-selects top trending sounds based on usage count and growth rate.
+ */
+
+import type { BaseTrendNodeData } from './trend-shared';
+
+export interface TrendSoundInspirationNodeData extends BaseTrendNodeData {
+  // Configuration
+  minUsageCount: number;
+  maxDuration: number | null;
+
+  // Outputs
+  soundId: string | null;
+  soundName: string | null;
+  soundUrl: string | null;
+  duration: number | null;
+  usageCount: number | null;
+
+  // Additional info (for display)
+  authorName: string | null;
+  coverUrl: string | null;
+  growthRate: number | null;
+}
+
+export const DEFAULT_TREND_SOUND_INSPIRATION_DATA: Partial<TrendSoundInspirationNodeData> =
+  {
+    authorName: null,
+    coverUrl: null,
+    duration: null,
+    growthRate: null,
+    label: 'Trend Sound Inspiration',
+    maxDuration: null,
+    minUsageCount: 10000,
+    soundId: null,
+    soundName: null,
+    soundUrl: null,
+    status: 'idle',
+    usageCount: null,
+  };
+
+export const trendSoundInspirationNodeDefinition = {
+  category: 'inspiration' as const,
+  defaultData: DEFAULT_TREND_SOUND_INSPIRATION_DATA,
+  description: 'Get trending TikTok sound for content',
+  icon: 'Music',
+  inputs: [],
+  label: 'Trend Sound Inspiration',
+  outputs: [
+    { id: 'soundId', label: 'Sound ID', type: 'text' },
+    { id: 'soundName', label: 'Sound Name', type: 'text' },
+    { id: 'soundUrl', label: 'Sound URL', type: 'text' },
+    { id: 'duration', label: 'Duration (s)', type: 'number' },
+    { id: 'usageCount', label: 'Usage Count', type: 'number' },
+  ],
+  type: 'trendSoundInspiration',
+};