@runtypelabs/react-flow 0.1.0

package/src/hooks/useFlowValidation.ts

@@ -0,0 +1,424 @@
+import { useMemo, useCallback } from 'react'
+import type {
+  FlowStep,
+  RuntypeNode,
+  FlowValidationResult,
+  ValidationError,
+  ValidationWarning,
+  PromptStepConfig,
+  FetchUrlStepConfig,
+  TransformDataStepConfig,
+  ConditionalStepConfig,
+  SendEmailStepConfig,
+} from '../types'
+
+// ============================================================================
+// Validation Rules
+// ============================================================================
+
+interface ValidationRule {
+  validate: (step: FlowStep, allSteps: FlowStep[]) => ValidationError[]
+}
+
+interface WarningRule {
+  check: (step: FlowStep, allSteps: FlowStep[]) => ValidationWarning[]
+}
+
+// ============================================================================
+// Prompt Step Validation
+// ============================================================================
+
+const promptValidation: ValidationRule = {
+  validate: (step) => {
+    const errors: ValidationError[] = []
+    const config = step.config as PromptStepConfig
+
+    if (!config.model) {
+      errors.push({
+        stepId: step.id,
+        field: 'model',
+        message: 'Model is required',
+      })
+    }
+
+    if (!config.userPrompt?.trim()) {
+      errors.push({
+        stepId: step.id,
+        field: 'userPrompt',
+        message: 'User prompt is required',
+      })
+    }
+
+    if (!config.outputVariable?.trim()) {
+      errors.push({
+        stepId: step.id,
+        field: 'outputVariable',
+        message: 'Output variable is required',
+      })
+    }
+
+    return errors
+  },
+}
+
+// ============================================================================
+// Fetch URL Step Validation
+// ============================================================================
+
+const fetchUrlValidation: ValidationRule = {
+  validate: (step) => {
+    const errors: ValidationError[] = []
+    const config = step.config as FetchUrlStepConfig
+
+    if (!config.http?.url?.trim()) {
+      errors.push({
+        stepId: step.id,
+        field: 'http.url',
+        message: 'URL is required',
+      })
+    } else {
+      // Validate URL format (allow template variables)
+      const url = config.http.url
+      if (!url.startsWith('http://') && !url.startsWith('https://') && !url.includes('{{')) {
+        errors.push({
+          stepId: step.id,
+          field: 'http.url',
+          message: 'URL must start with http:// or https://',
+        })
+      }
+    }
+
+    if (!config.outputVariable?.trim()) {
+      errors.push({
+        stepId: step.id,
+        field: 'outputVariable',
+        message: 'Output variable is required',
+      })
+    }
+
+    return errors
+  },
+}
+
+// ============================================================================
+// Transform Data Step Validation
+// ============================================================================
+
+const transformDataValidation: ValidationRule = {
+  validate: (step) => {
+    const errors: ValidationError[] = []
+    const config = step.config as TransformDataStepConfig
+
+    if (!config.script?.trim()) {
+      errors.push({
+        stepId: step.id,
+        field: 'script',
+        message: 'Script is required',
+      })
+    }
+
+    if (!config.outputVariable?.trim()) {
+      errors.push({
+        stepId: step.id,
+        field: 'outputVariable',
+        message: 'Output variable is required',
+      })
+    }
+
+    return errors
+  },
+}
+
+// ============================================================================
+// Conditional Step Validation
+// ============================================================================
+
+const conditionalValidation: ValidationRule = {
+  validate: (step, allSteps) => {
+    const errors: ValidationError[] = []
+    const config = step.config as ConditionalStepConfig
+
+    if (!config.condition?.trim()) {
+      errors.push({
+        stepId: step.id,
+        field: 'condition',
+        message: 'Condition is required',
+      })
+    }
+
+    // Validate nested steps
+    if (config.trueSteps && config.trueSteps.length > 0) {
+      for (const nestedStep of config.trueSteps) {
+        const nestedErrors = validateStep(nestedStep, allSteps)
+        errors.push(
+          ...nestedErrors.map((e) => ({
+            ...e,
+            message: `True branch: ${e.message}`,
+          }))
+        )
+      }
+    }
+
+    if (config.falseSteps && config.falseSteps.length > 0) {
+      for (const nestedStep of config.falseSteps) {
+        const nestedErrors = validateStep(nestedStep, allSteps)
+        errors.push(
+          ...nestedErrors.map((e) => ({
+            ...e,
+            message: `False branch: ${e.message}`,
+          }))
+        )
+      }
+    }
+
+    return errors
+  },
+}
+
+// ============================================================================
+// Send Email Step Validation
+// ============================================================================
+
+const sendEmailValidation: ValidationRule = {
+  validate: (step) => {
+    const errors: ValidationError[] = []
+    const config = step.config as SendEmailStepConfig
+
+    if (!config.to?.trim()) {
+      errors.push({
+        stepId: step.id,
+        field: 'to',
+        message: 'Recipient (To) is required',
+      })
+    } else {
+      // Validate email format (allow template variables)
+      const to = config.to
+      if (!to.includes('@') && !to.includes('{{')) {
+        errors.push({
+          stepId: step.id,
+          field: 'to',
+          message: 'Invalid email address',
+        })
+      }
+    }
+
+    if (!config.subject?.trim()) {
+      errors.push({
+        stepId: step.id,
+        field: 'subject',
+        message: 'Subject is required',
+      })
+    }
+
+    if (!config.html?.trim() && !config.text?.trim()) {
+      errors.push({
+        stepId: step.id,
+        field: 'html',
+        message: 'Email content (HTML or text) is required',
+      })
+    }
+
+    if (!config.outputVariable?.trim()) {
+      errors.push({
+        stepId: step.id,
+        field: 'outputVariable',
+        message: 'Output variable is required',
+      })
+    }
+
+    return errors
+  },
+}
+
+// ============================================================================
+// Warning Rules
+// ============================================================================
+
+const outputVariableWarning: WarningRule = {
+  check: (step, allSteps) => {
+    const warnings: ValidationWarning[] = []
+    const config = step.config as { outputVariable?: string }
+
+    if (config.outputVariable) {
+      // Check for duplicate output variables
+      const duplicates = allSteps.filter(
+        (s) =>
+          s.id !== step.id &&
+          (s.config as { outputVariable?: string }).outputVariable === config.outputVariable
+      )
+
+      if (duplicates.length > 0) {
+        warnings.push({
+          stepId: step.id,
+          field: 'outputVariable',
+          message: `Output variable "${config.outputVariable}" is also used by another step`,
+        })
+      }
+    }
+
+    return warnings
+  },
+}
+
+const emptyBranchWarning: WarningRule = {
+  check: (step) => {
+    const warnings: ValidationWarning[] = []
+
+    if (step.type === 'conditional') {
+      const config = step.config as ConditionalStepConfig
+
+      if (!config.trueSteps || config.trueSteps.length === 0) {
+        warnings.push({
+          stepId: step.id,
+          field: 'trueSteps',
+          message: 'True branch has no steps',
+        })
+      }
+
+      if (!config.falseSteps || config.falseSteps.length === 0) {
+        warnings.push({
+          stepId: step.id,
+          field: 'falseSteps',
+          message: 'False branch has no steps',
+        })
+      }
+    }
+
+    return warnings
+  },
+}
+
+// ============================================================================
+// Validation Logic
+// ============================================================================
+
+const validationRules: Record<string, ValidationRule> = {
+  prompt: promptValidation,
+  'fetch-url': fetchUrlValidation,
+  'transform-data': transformDataValidation,
+  conditional: conditionalValidation,
+  'send-email': sendEmailValidation,
+}
+
+const warningRules: WarningRule[] = [outputVariableWarning, emptyBranchWarning]
+
+function validateStep(step: FlowStep, allSteps: FlowStep[]): ValidationError[] {
+  const errors: ValidationError[] = []
+
+  // Common validation
+  if (!step.name?.trim()) {
+    errors.push({
+      stepId: step.id,
+      field: 'name',
+      message: 'Step name is required',
+    })
+  }
+
+  // Type-specific validation
+  const rule = validationRules[step.type]
+  if (rule) {
+    errors.push(...rule.validate(step, allSteps))
+  }
+
+  return errors
+}
+
+function checkWarnings(step: FlowStep, allSteps: FlowStep[]): ValidationWarning[] {
+  const warnings: ValidationWarning[] = []
+
+  for (const rule of warningRules) {
+    warnings.push(...rule.check(step, allSteps))
+  }
+
+  return warnings
+}
+
+// ============================================================================
+// Hook
+// ============================================================================
+
+export interface UseFlowValidationOptions {
+  /** Steps to validate */
+  steps?: FlowStep[]
+  /** Nodes to validate (will extract steps from nodes) */
+  nodes?: RuntypeNode[]
+}
+
+export interface UseFlowValidationReturn {
+  /** Validation result */
+  result: FlowValidationResult
+  /** Validate a specific step */
+  validateStep: (step: FlowStep) => ValidationError[]
+  /** Check if a specific step is valid */
+  isStepValid: (stepId: string) => boolean
+  /** Get errors for a specific step */
+  getStepErrors: (stepId: string) => ValidationError[]
+  /** Get warnings for a specific step */
+  getStepWarnings: (stepId: string) => ValidationWarning[]
+}
+
+export function useFlowValidation(options: UseFlowValidationOptions): UseFlowValidationReturn {
+  const { steps: providedSteps, nodes } = options
+
+  // Extract steps from nodes if not provided directly
+  const steps = useMemo(() => {
+    if (providedSteps) return providedSteps
+    if (nodes) return nodes.map((n) => n.data.step)
+    return []
+  }, [providedSteps, nodes])
+
+  // Perform validation
+  const result = useMemo((): FlowValidationResult => {
+    const errors: ValidationError[] = []
+    const warnings: ValidationWarning[] = []
+
+    for (const step of steps) {
+      errors.push(...validateStep(step, steps))
+      warnings.push(...checkWarnings(step, steps))
+    }
+
+    return {
+      isValid: errors.length === 0,
+      errors,
+      warnings,
+    }
+  }, [steps])
+
+  // Helper functions
+  const validateStepFn = useCallback(
+    (step: FlowStep) => validateStep(step, steps),
+    [steps]
+  )
+
+  const isStepValid = useCallback(
+    (stepId: string) => {
+      return !result.errors.some((e) => e.stepId === stepId)
+    },
+    [result.errors]
+  )
+
+  const getStepErrors = useCallback(
+    (stepId: string) => {
+      return result.errors.filter((e) => e.stepId === stepId)
+    },
+    [result.errors]
+  )
+
+  const getStepWarnings = useCallback(
+    (stepId: string) => {
+      return result.warnings.filter((w) => w.stepId === stepId)
+    },
+    [result.warnings]
+  )
+
+  return {
+    result,
+    validateStep: validateStepFn,
+    isStepValid,
+    getStepErrors,
+    getStepWarnings,
+  }
+}
+
+export default useFlowValidation
+