@genfeedai/workflow-saas 0.2.0

package/src/nodes/beat-sync-editor.spec.ts

@@ -0,0 +1,90 @@
+import { BeatSyncCutStrategy, BeatSyncTransitionType } from '@genfeedai/enums';
+import { describe, expect, it } from 'vitest';
+import {
+  beatSyncEditorNodeDefinition,
+  DEFAULT_BEAT_SYNC_EDITOR_DATA,
+} from './beat-sync-editor';
+
+describe('beat-sync-editor node', () => {
+  describe('DEFAULT_BEAT_SYNC_EDITOR_DATA', () => {
+    it('should have label set to Beat Sync Editor', () => {
+      expect(DEFAULT_BEAT_SYNC_EDITOR_DATA.label).toBe('Beat Sync Editor');
+    });
+
+    it('should default to idle status', () => {
+      expect(DEFAULT_BEAT_SYNC_EDITOR_DATA.status).toBe('idle');
+    });
+
+    it('should default cutStrategy to EVERY_BEAT', () => {
+      expect(DEFAULT_BEAT_SYNC_EDITOR_DATA.cutStrategy).toBe(
+        BeatSyncCutStrategy.EVERY_BEAT,
+      );
+    });
+
+    it('should default transitionType to CUT', () => {
+      expect(DEFAULT_BEAT_SYNC_EDITOR_DATA.transitionType).toBe(
+        BeatSyncTransitionType.CUT,
+      );
+    });
+
+    it('should default transitionDuration to 50', () => {
+      expect(DEFAULT_BEAT_SYNC_EDITOR_DATA.transitionDuration).toBe(50);
+    });
+
+    it('should default loopVideos to true and shuffleOrder to false', () => {
+      expect(DEFAULT_BEAT_SYNC_EDITOR_DATA.loopVideos).toBe(true);
+      expect(DEFAULT_BEAT_SYNC_EDITOR_DATA.shuffleOrder).toBe(false);
+    });
+
+    it('should default beatsPerClip to 1', () => {
+      expect(DEFAULT_BEAT_SYNC_EDITOR_DATA.beatsPerClip).toBe(1);
+    });
+
+    it('should default input arrays to empty', () => {
+      expect(DEFAULT_BEAT_SYNC_EDITOR_DATA.videoFiles).toEqual([]);
+      expect(DEFAULT_BEAT_SYNC_EDITOR_DATA.beatTimestamps).toEqual([]);
+      expect(DEFAULT_BEAT_SYNC_EDITOR_DATA.customPattern).toEqual([]);
+    });
+
+    it('should default output and processing fields to null', () => {
+      expect(DEFAULT_BEAT_SYNC_EDITOR_DATA.outputVideoUrl).toBeNull();
+      expect(DEFAULT_BEAT_SYNC_EDITOR_DATA.totalClips).toBeNull();
+      expect(DEFAULT_BEAT_SYNC_EDITOR_DATA.totalDuration).toBeNull();
+      expect(DEFAULT_BEAT_SYNC_EDITOR_DATA.jobId).toBeNull();
+      expect(DEFAULT_BEAT_SYNC_EDITOR_DATA.processingProgress).toBeNull();
+    });
+  });
+
+  describe('beatSyncEditorNodeDefinition', () => {
+    it('should have type beatSyncEditor', () => {
+      expect(beatSyncEditorNodeDefinition.type).toBe('beatSyncEditor');
+    });
+
+    it('should be in processing category', () => {
+      expect(beatSyncEditorNodeDefinition.category).toBe('processing');
+    });
+
+    it('should have label Beat Sync Editor', () => {
+      expect(beatSyncEditorNodeDefinition.label).toBe('Beat Sync Editor');
+    });
+
+    it('should require videoFiles, beatTimestamps, and musicUrl inputs', () => {
+      const inputIds = beatSyncEditorNodeDefinition.inputs.map((i) => i.id);
+      expect(inputIds).toEqual(['videoFiles', 'beatTimestamps', 'musicUrl']);
+      for (const input of beatSyncEditorNodeDefinition.inputs) {
+        expect(input.required).toBe(true);
+      }
+    });
+
+    it('should output videoUrl, totalClips, and totalDuration', () => {
+      const outputIds = beatSyncEditorNodeDefinition.outputs.map((o) => o.id);
+      expect(outputIds).toEqual(['videoUrl', 'totalClips', 'totalDuration']);
+    });
+
+    it('should reference default data', () => {
+      expect(beatSyncEditorNodeDefinition.defaultData).toBe(
+        DEFAULT_BEAT_SYNC_EDITOR_DATA,
+      );
+    });
+  });
+});

package/src/nodes/beat-sync-editor.ts

@@ -0,0 +1,85 @@
+/**
+ * Beat Sync Editor Node Types
+ *
+ * This node cuts and assembles videos to match beat timestamps.
+ * Supports multiple cut strategies and transition types.
+ */
+
+import { BeatSyncCutStrategy, BeatSyncTransitionType } from '@genfeedai/enums';
+import type { BaseTrendNodeData } from './trend-shared';
+
+export interface BeatSyncEditorNodeData extends BaseTrendNodeData {
+  // Inputs
+  videoFiles: string[];
+  beatTimestamps: number[];
+  musicUrl: string | null;
+
+  // Configuration
+  cutStrategy: BeatSyncCutStrategy;
+  transitionType: BeatSyncTransitionType;
+  transitionDuration: number;
+  loopVideos: boolean;
+  shuffleOrder: boolean;
+  beatsPerClip: number;
+  customPattern: number[];
+
+  // Outputs
+  outputVideoUrl: string | null;
+
+  // Processing info
+  totalClips: number | null;
+  totalDuration: number | null;
+  jobId: string | null;
+  processingProgress: number | null;
+}
+
+export const DEFAULT_BEAT_SYNC_EDITOR_DATA: Partial<BeatSyncEditorNodeData> = {
+  beatsPerClip: 1,
+  beatTimestamps: [],
+  customPattern: [],
+  cutStrategy: BeatSyncCutStrategy.EVERY_BEAT,
+  jobId: null,
+  label: 'Beat Sync Editor',
+  loopVideos: true,
+  musicUrl: null,
+  outputVideoUrl: null,
+  processingProgress: null,
+  shuffleOrder: false,
+  status: 'idle',
+  totalClips: null,
+  totalDuration: null,
+  transitionDuration: 50,
+  transitionType: BeatSyncTransitionType.CUT,
+  videoFiles: [],
+};
+
+export const beatSyncEditorNodeDefinition = {
+  category: 'processing' as const,
+  defaultData: DEFAULT_BEAT_SYNC_EDITOR_DATA,
+  description: 'Cut videos to match beat timestamps',
+  icon: 'Scissors',
+  inputs: [
+    {
+      id: 'videoFiles',
+      label: 'Video Files',
+      multiple: true,
+      required: true,
+      type: 'text',
+    },
+    {
+      id: 'beatTimestamps',
+      label: 'Beat Timestamps',
+      multiple: true,
+      required: true,
+      type: 'number',
+    },
+    { id: 'musicUrl', label: 'Music URL', required: true, type: 'text' },
+  ],
+  label: 'Beat Sync Editor',
+  outputs: [
+    { id: 'videoUrl', label: 'Output Video', type: 'text' },
+    { id: 'totalClips', label: 'Total Clips', type: 'number' },
+    { id: 'totalDuration', label: 'Total Duration (s)', type: 'number' },
+  ],
+  type: 'beatSyncEditor',
+};

package/src/nodes/brand-asset.spec.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from 'vitest';
+import { DEFAULT_BRAND_ASSET_DATA } from './brand-asset';
+
+describe('brand-asset node', () => {
+  describe('DEFAULT_BRAND_ASSET_DATA', () => {
+    it('should have label set to Brand Asset', () => {
+      expect(DEFAULT_BRAND_ASSET_DATA.label).toBe('Brand Asset');
+    });
+
+    it('should default to idle status', () => {
+      expect(DEFAULT_BRAND_ASSET_DATA.status).toBe('idle');
+    });
+
+    it('should default assetType to logo', () => {
+      expect(DEFAULT_BRAND_ASSET_DATA.assetType).toBe('logo');
+    });
+
+    it('should default brandId to null', () => {
+      expect(DEFAULT_BRAND_ASSET_DATA.brandId).toBeNull();
+    });
+
+    it('should default resolvedUrl to null', () => {
+      expect(DEFAULT_BRAND_ASSET_DATA.resolvedUrl).toBeNull();
+    });
+
+    it('should default resolvedUrls to empty array', () => {
+      expect(DEFAULT_BRAND_ASSET_DATA.resolvedUrls).toEqual([]);
+    });
+
+    it('should default dimensions and mimeType to null', () => {
+      expect(DEFAULT_BRAND_ASSET_DATA.dimensions).toBeNull();
+      expect(DEFAULT_BRAND_ASSET_DATA.mimeType).toBeNull();
+    });
+
+    it('should default brandLabel to null', () => {
+      expect(DEFAULT_BRAND_ASSET_DATA.brandLabel).toBeNull();
+    });
+  });
+});

package/src/nodes/brand-asset.ts

@@ -0,0 +1,56 @@
+import type { BaseNodeData } from '@workflow-saas/types';
+
+/**
+ * Type of brand asset to resolve
+ */
+export type BrandAssetType = 'logo' | 'banner' | 'references';
+
+/**
+ * Asset dimensions
+ */
+export interface AssetDimensions {
+  width: number;
+  height: number;
+}
+
+/**
+ * Brand Asset Node Data
+ *
+ * Resolves brand-specific assets (logos, banners, reference images)
+ * for use in downstream workflow nodes.
+ *
+ * Outputs:
+ * - image (image): Single resolved asset URL (for logo/banner)
+ * - images (image, multiple): Multiple reference images
+ */
+export interface BrandAssetNodeData extends BaseNodeData {
+  // Configuration (user selects brand and asset type in UI)
+  brandId: string | null;
+  assetType: BrandAssetType;
+
+  // Resolved at execution time (populated from Asset collection)
+  resolvedUrl: string | null;
+  resolvedUrls: string[];
+
+  // Asset metadata
+  dimensions: AssetDimensions | null;
+  mimeType: string | null;
+
+  // Brand metadata for display
+  brandLabel: string | null;
+}
+
+/**
+ * Default data for a new Brand Asset node
+ */
+export const DEFAULT_BRAND_ASSET_DATA: Partial<BrandAssetNodeData> = {
+  assetType: 'logo',
+  brandId: null,
+  brandLabel: null,
+  dimensions: null,
+  label: 'Brand Asset',
+  mimeType: null,
+  resolvedUrl: null,
+  resolvedUrls: [],
+  status: 'idle',
+};

package/src/nodes/brand-context.spec.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { DEFAULT_BRAND_CONTEXT_DATA } from './brand-context';
+
+describe('brand-context node', () => {
+  describe('DEFAULT_BRAND_CONTEXT_DATA', () => {
+    it('should have label set to Brand Context', () => {
+      expect(DEFAULT_BRAND_CONTEXT_DATA.label).toBe('Brand Context');
+    });
+
+    it('should default to idle status', () => {
+      expect(DEFAULT_BRAND_CONTEXT_DATA.status).toBe('idle');
+    });
+
+    it('should default brandId to null', () => {
+      expect(DEFAULT_BRAND_CONTEXT_DATA.brandId).toBeNull();
+    });
+
+    it('should default all resolved fields to null', () => {
+      expect(DEFAULT_BRAND_CONTEXT_DATA.resolvedVoice).toBeNull();
+      expect(DEFAULT_BRAND_CONTEXT_DATA.resolvedColors).toBeNull();
+      expect(DEFAULT_BRAND_CONTEXT_DATA.resolvedFonts).toBeNull();
+      expect(DEFAULT_BRAND_CONTEXT_DATA.resolvedModels).toBeNull();
+    });
+
+    it('should default brand metadata to null', () => {
+      expect(DEFAULT_BRAND_CONTEXT_DATA.brandLabel).toBeNull();
+      expect(DEFAULT_BRAND_CONTEXT_DATA.brandHandle).toBeNull();
+    });
+  });
+});

package/src/nodes/brand-context.ts

@@ -0,0 +1,62 @@
+import type { BaseNodeData } from '@workflow-saas/types';
+
+/**
+ * Brand color palette resolved from the Brand entity
+ */
+export interface BrandColors {
+  primary: string;
+  secondary: string;
+  background: string;
+}
+
+/**
+ * Default AI models configured for the brand
+ */
+export interface BrandModels {
+  video: string | null;
+  image: string | null;
+  imageToVideo: string | null;
+  music: string | null;
+}
+
+/**
+ * Brand Context Node Data
+ *
+ * Injects brand styling context (voice, colors, fonts, default models)
+ * into downstream workflow nodes.
+ *
+ * Outputs:
+ * - voice (text): Brand voice/tone description
+ * - colors (text): JSON color palette
+ * - fonts (text): Font family name
+ * - models (text): Default model preferences
+ */
+export interface BrandContextNodeData extends BaseNodeData {
+  // Configuration (user selects brand in UI)
+  brandId: string | null;
+
+  // Resolved at execution time (populated from Brand + Ingredient collections)
+  resolvedVoice: string | null;
+  resolvedColors: BrandColors | null;
+  resolvedFonts: string | null;
+  resolvedModels: BrandModels | null;
+
+  // Brand metadata for display
+  brandLabel: string | null;
+  brandHandle: string | null;
+}
+
+/**
+ * Default data for a new Brand Context node
+ */
+export const DEFAULT_BRAND_CONTEXT_DATA: Partial<BrandContextNodeData> = {
+  brandHandle: null,
+  brandId: null,
+  brandLabel: null,
+  label: 'Brand Context',
+  resolvedColors: null,
+  resolvedFonts: null,
+  resolvedModels: null,
+  resolvedVoice: null,
+  status: 'idle',
+};

package/src/nodes/brand.spec.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from 'vitest';
+import { brandNodeDefinition, DEFAULT_BRAND_DATA } from './brand';
+
+describe('brand node', () => {
+  describe('DEFAULT_BRAND_DATA', () => {
+    it('should have label set to Brand', () => {
+      expect(DEFAULT_BRAND_DATA.label).toBe('Brand');
+    });
+
+    it('should default to idle status', () => {
+      expect(DEFAULT_BRAND_DATA.status).toBe('idle');
+    });
+
+    it('should have type set to brand', () => {
+      expect(DEFAULT_BRAND_DATA.type).toBe('brand');
+    });
+
+    it('should default brandId to null', () => {
+      expect(DEFAULT_BRAND_DATA.brandId).toBeNull();
+    });
+
+    it('should default all resolved fields to null', () => {
+      expect(DEFAULT_BRAND_DATA.resolvedBrandId).toBeNull();
+      expect(DEFAULT_BRAND_DATA.resolvedLabel).toBeNull();
+      expect(DEFAULT_BRAND_DATA.resolvedHandle).toBeNull();
+      expect(DEFAULT_BRAND_DATA.resolvedVoice).toBeNull();
+      expect(DEFAULT_BRAND_DATA.resolvedColors).toBeNull();
+      expect(DEFAULT_BRAND_DATA.resolvedFonts).toBeNull();
+      expect(DEFAULT_BRAND_DATA.resolvedModels).toBeNull();
+      expect(DEFAULT_BRAND_DATA.resolvedLogoUrl).toBeNull();
+    });
+  });
+
+  describe('brandNodeDefinition', () => {
+    it('should have type brand', () => {
+      expect(brandNodeDefinition.type).toBe('brand');
+    });
+
+    it('should be in input category', () => {
+      expect(brandNodeDefinition.category).toBe('input');
+    });
+
+    it('should have label Brand', () => {
+      expect(brandNodeDefinition.label).toBe('Brand');
+    });
+
+    it('should have no inputs (user selects brand in UI)', () => {
+      expect(brandNodeDefinition.inputs).toEqual([]);
+    });
+
+    it('should output brand, voice, colors, and fonts', () => {
+      const outputIds = brandNodeDefinition.outputs.map((o) => o.id);
+      expect(outputIds).toEqual(['brand', 'voice', 'colors', 'fonts']);
+    });
+
+    it('should reference default data', () => {
+      expect(brandNodeDefinition.defaultData).toBe(DEFAULT_BRAND_DATA);
+    });
+  });
+});

package/src/nodes/brand.ts

@@ -0,0 +1,108 @@
+/**
+ * Brand Node
+ *
+ * INPUT category node that selects a brand from the organization.
+ * Outputs brand context including voice, colors, fonts, and default models.
+ * Credentials are included implicitly and resolved server-side.
+ *
+ * Multiple brand nodes in a workflow = multi-brand workflow.
+ */
+
+import type { BaseNodeData } from '@workflow-saas/types';
+
+/**
+ * Brand color palette
+ */
+export interface BrandColorPalette {
+  primary: string;
+  secondary: string;
+  accent: string;
+  background: string;
+  text: string;
+}
+
+/**
+ * Brand font configuration
+ */
+export interface BrandFontConfig {
+  heading: string;
+  body: string;
+}
+
+/**
+ * Default AI models configured for the brand
+ */
+export interface BrandDefaultModels {
+  video: string | null;
+  image: string | null;
+  imageToVideo: string | null;
+  music: string | null;
+  text: string | null;
+}
+
+/**
+ * Brand Node Data
+ *
+ * Outputs:
+ * - brand (brand): Full brand context object for downstream nodes
+ * - voice (text): Brand voice/tone description
+ * - colors (object): Color palette
+ * - fonts (object): Font configuration
+ */
+export interface BrandNodeData extends BaseNodeData {
+  type: 'brand';
+
+  // Configuration - user selects brand in UI
+  brandId: string | null;
+
+  // Resolved at execution time from Brand + Ingredient collections
+  resolvedBrandId: string | null;
+  resolvedLabel: string | null;
+  resolvedHandle: string | null;
+  resolvedVoice: string | null;
+  resolvedColors: BrandColorPalette | null;
+  resolvedFonts: BrandFontConfig | null;
+  resolvedModels: BrandDefaultModels | null;
+  resolvedLogoUrl: string | null;
+
+  // Credentials are resolved server-side, never exposed to client
+  // credentialsResolved: boolean (internal flag, not in data)
+}
+
+/**
+ * Default data for a new Brand node
+ */
+export const DEFAULT_BRAND_DATA: Partial<BrandNodeData> = {
+  brandId: null,
+  label: 'Brand',
+  resolvedBrandId: null,
+  resolvedColors: null,
+  resolvedFonts: null,
+  resolvedHandle: null,
+  resolvedLabel: null,
+  resolvedLogoUrl: null,
+  resolvedModels: null,
+  resolvedVoice: null,
+  status: 'idle',
+  type: 'brand',
+};
+
+/**
+ * Brand node definition for registry
+ */
+export const brandNodeDefinition = {
+  category: 'input' as const,
+  defaultData: DEFAULT_BRAND_DATA,
+  description:
+    'Select a brand from your organization to inject brand context into the workflow',
+  icon: 'Store',
+  inputs: [],
+  label: 'Brand',
+  outputs: [
+    { id: 'brand', label: 'Brand Context', type: 'brand' },
+    { id: 'voice', label: 'Voice', type: 'text' },
+    { id: 'colors', label: 'Colors', type: 'object' },
+    { id: 'fonts', label: 'Fonts', type: 'object' },
+  ],
+  type: 'brand',
+};

package/src/nodes/condition.spec.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from 'vitest';
+import { DEFAULT_CONDITION_DATA } from './condition';
+
+describe('condition node', () => {
+  describe('DEFAULT_CONDITION_DATA', () => {
+    it('should have label set to Condition', () => {
+      expect(DEFAULT_CONDITION_DATA.label).toBe('Condition');
+    });
+
+    it('should default to idle status', () => {
+      expect(DEFAULT_CONDITION_DATA.status).toBe('idle');
+    });
+
+    it('should have type set to condition', () => {
+      expect(DEFAULT_CONDITION_DATA.type).toBe('condition');
+    });
+
+    it('should default field to custom', () => {
+      expect(DEFAULT_CONDITION_DATA.field).toBe('custom');
+    });
+
+    it('should default operator to equals', () => {
+      expect(DEFAULT_CONDITION_DATA.operator).toBe('equals');
+    });
+
+    it('should default value to empty string', () => {
+      expect(DEFAULT_CONDITION_DATA.value).toBe('');
+    });
+
+    it('should default customField to empty string', () => {
+      expect(DEFAULT_CONDITION_DATA.customField).toBe('');
+    });
+
+    it('should default expression to empty string', () => {
+      expect(DEFAULT_CONDITION_DATA.expression).toBe('');
+    });
+
+    it('should default timezone to UTC', () => {
+      expect(DEFAULT_CONDITION_DATA.timezone).toBe('UTC');
+    });
+  });
+});

package/src/nodes/condition.ts

@@ -0,0 +1,77 @@
+/**
+ * Condition Node
+ *
+ * LOGIC category node that branches workflow based on conditions.
+ * Evaluates a field against an operator/value and routes to true/false branches.
+ */
+
+import type { BaseNodeData } from '@workflow-saas/types';
+
+export type ConditionOperator =
+  | 'equals'
+  | 'notEquals'
+  | 'greaterThan'
+  | 'lessThan'
+  | 'greaterThanOrEquals'
+  | 'lessThanOrEquals'
+  | 'contains'
+  | 'notContains'
+  | 'startsWith'
+  | 'endsWith'
+  | 'matches'
+  | 'isTrue'
+  | 'isFalse'
+  | 'isEmpty'
+  | 'isNotEmpty'
+  | 'expression';
+
+export type ConditionField =
+  | 'engagementRate'
+  | 'followerCount'
+  | 'contentType'
+  | 'platform'
+  | 'timeOfDay'
+  | 'dayOfWeek'
+  | 'custom';
+
+/**
+ * Condition Node Data
+ *
+ * Inputs:
+ * - value (any): Value to evaluate
+ *
+ * Outputs:
+ * - true (any): Data passed through when condition is true
+ * - false (any): Data passed through when condition is false
+ */
+export interface ConditionNodeData extends BaseNodeData {
+  type: 'condition';
+
+  /** The field to evaluate */
+  field: ConditionField;
+  /** The comparison operator */
+  operator: ConditionOperator;
+  /** The value to compare against */
+  value: string;
+  /** Custom field path (dot-notation) when field is 'custom' */
+  customField: string;
+  /** Raw expression string for 'expression' operator */
+  expression: string;
+  /** Timezone for time-based conditions */
+  timezone: string;
+}
+
+/**
+ * Default data for a new Condition node
+ */
+export const DEFAULT_CONDITION_DATA: Partial<ConditionNodeData> = {
+  customField: '',
+  expression: '',
+  field: 'custom',
+  label: 'Condition',
+  operator: 'equals',
+  status: 'idle',
+  timezone: 'UTC',
+  type: 'condition',
+  value: '',
+};

package/src/nodes/delay.spec.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from 'vitest';
+import { DEFAULT_DELAY_DATA } from './delay';
+
+describe('delay node', () => {
+  describe('DEFAULT_DELAY_DATA', () => {
+    it('should have label set to Delay', () => {
+      expect(DEFAULT_DELAY_DATA.label).toBe('Delay');
+    });
+
+    it('should default to idle status', () => {
+      expect(DEFAULT_DELAY_DATA.status).toBe('idle');
+    });
+
+    it('should have type set to delay', () => {
+      expect(DEFAULT_DELAY_DATA.type).toBe('delay');
+    });
+
+    it('should default mode to fixed', () => {
+      expect(DEFAULT_DELAY_DATA.mode).toBe('fixed');
+    });
+
+    it('should default duration to 5', () => {
+      expect(DEFAULT_DELAY_DATA.duration).toBe(5);
+    });
+
+    it('should default unit to minutes', () => {
+      expect(DEFAULT_DELAY_DATA.unit).toBe('minutes');
+    });
+
+    it('should default untilTime to empty string', () => {
+      expect(DEFAULT_DELAY_DATA.untilTime).toBe('');
+    });
+
+    it('should default platform to empty string', () => {
+      expect(DEFAULT_DELAY_DATA.platform).toBe('');
+    });
+
+    it('should default timezone to UTC', () => {
+      expect(DEFAULT_DELAY_DATA.timezone).toBe('UTC');
+    });
+  });
+});