cleanup triggers

Author: icecrasher321

apps/sim/app/api/workflows/[id]/execute/route.ts

@@ -14,7 +14,7 @@ import { LoggingSession } from '@/lib/logs/execution/logging-session'
 import { buildTraceSpans } from '@/lib/logs/execution/trace-spans/trace-spans'
 import { decryptSecret, generateRequestId } from '@/lib/utils'
 import { loadDeployedWorkflowState } from '@/lib/workflows/db-helpers'
-import { TriggerUtils } from '@/lib/workflows/triggers'
+import { StartBlockPath, TriggerUtils } from '@/lib/workflows/triggers'
 import {
   createHttpResponseFromBlock,
   updateWorkflowRunCounts,
@@ -313,10 +313,9 @@ export async function executeWorkflow(
       throw new Error(errorMsg)
     }
 
-    const startBlockId = startBlock.blockId
-    const triggerBlock = startBlock.block
+    const { blockId: startBlockId, block: triggerBlock, path: startPath } = startBlock
 
-    if (triggerBlock.type !== 'starter') {
+    if (startPath !== StartBlockPath.LEGACY_STARTER) {
       const outgoingConnections = serializedWorkflow.connections.filter(
         (conn) => conn.source === startBlockId
       )

apps/sim/app/api/workspaces/route.ts

@@ -4,6 +4,8 @@ import { and, desc, eq, isNull } from 'drizzle-orm'
 import { NextResponse } from 'next/server'
 import { getSession } from '@/lib/auth'
 import { createLogger } from '@/lib/logs/console/logger'
+import { saveWorkflowToNormalizedTables } from '@/lib/workflows/db-helpers'
+import { buildDefaultWorkflowArtifacts } from '@/lib/workflows/defaults'
 
 const logger = createLogger('Workspaces')
 
@@ -137,6 +139,13 @@ async function createWorkspace(userId: string, name: string) {
         `Created workspace ${workspaceId} with initial workflow ${workflowId} for user ${userId}`
       )
     })
+
+    const { workflowState } = buildDefaultWorkflowArtifacts()
+    const seedResult = await saveWorkflowToNormalizedTables(workflowId, workflowState)
+
+    if (!seedResult.success) {
+      throw new Error(seedResult.error || 'Failed to seed default workflow state')
+    }
   } catch (error) {
     logger.error(`Failed to create workspace ${workspaceId} with initial workflow:`, error)
     throw error

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/control-bar/components/deploy-modal/deploy-modal.tsx

@@ -17,6 +17,7 @@ import { getEnv } from '@/lib/env'
 import { createLogger } from '@/lib/logs/console/logger'
 import { cn } from '@/lib/utils'
 import type { WorkflowDeploymentVersionResponse } from '@/lib/workflows/db-helpers'
+import { resolveStartCandidates, StartBlockPath } from '@/lib/workflows/triggers'
 import {
   DeployForm,
   DeploymentInfo,
@@ -120,13 +121,17 @@ export function DeployModal({
     let inputFormatExample = ''
     try {
       const blocks = Object.values(useWorkflowStore.getState().blocks)
+      const candidates = resolveStartCandidates(useWorkflowStore.getState().blocks, {
+        execution: 'api',
+      })
 
-      // Check for start_trigger first, then API trigger, then legacy starter
-      const startTriggerBlock = blocks.find((block) => block.type === 'start_trigger')
-      const apiTriggerBlock = blocks.find((block) => block.type === 'api_trigger')
-      const starterBlock = blocks.find((block) => block.type === 'starter')
+      const targetCandidate =
+        candidates.find((candidate) => candidate.path === StartBlockPath.UNIFIED) ||
+        candidates.find((candidate) => candidate.path === StartBlockPath.SPLIT_API) ||
+        candidates.find((candidate) => candidate.path === StartBlockPath.SPLIT_INPUT) ||
+        candidates.find((candidate) => candidate.path === StartBlockPath.LEGACY_STARTER)
 
-      const targetBlock = startTriggerBlock || apiTriggerBlock || starterBlock
+      const targetBlock = targetCandidate?.block
 
       if (targetBlock) {
         const inputFormat = useSubBlockStore.getState().getValue(targetBlock.id, 'inputFormat')

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-workflow-execution.ts

@@ -3,7 +3,7 @@ import { v4 as uuidv4 } from 'uuid'
 import { createLogger } from '@/lib/logs/console/logger'
 import { buildTraceSpans } from '@/lib/logs/execution/trace-spans/trace-spans'
 import { processStreamingBlockLogs } from '@/lib/tokenization'
-import { TriggerUtils } from '@/lib/workflows/triggers'
+import { resolveStartCandidates, StartBlockPath, TriggerUtils } from '@/lib/workflows/triggers'
 import type { BlockOutput } from '@/blocks/types'
 import { Executor } from '@/executor'
 import type { BlockLog, ExecutionResult, StreamingExecution } from '@/executor/types'
@@ -824,132 +824,76 @@ export function useWorkflowExecution() {
 
       startBlockId = startBlock.blockId
     } else {
-      // For manual editor runs: look for Manual trigger OR API trigger
-      const entries = Object.entries(filteredStates)
-
-      // Find manual triggers and API triggers
-      const manualTriggers = TriggerUtils.findTriggersByType(filteredStates, 'manual')
-      const apiTriggers = TriggerUtils.findTriggersByType(filteredStates, 'api')
-
-      logger.info('Manual run trigger check:', {
-        manualTriggersCount: manualTriggers.length,
-        apiTriggersCount: apiTriggers.length,
-        manualTriggers: manualTriggers.map((t) => ({
-          type: t.type,
-          name: t.name,
-          isLegacy: t.type === 'starter',
-        })),
-        apiTriggers: apiTriggers.map((t) => ({
-          type: t.type,
-          name: t.name,
-          isLegacy: t.type === 'starter',
+      const candidates = resolveStartCandidates(filteredStates, {
+        execution: 'manual',
+      })
+
+      logger.info('Manual run start candidates:', {
+        count: candidates.length,
+        paths: candidates.map((candidate) => ({
+          path: candidate.path,
+          type: candidate.block.type,
+          name: candidate.block.name,
         })),
       })
 
-      let selectedTrigger: any = null
-      let selectedBlockId: string | null = null
-
-      // Check for API triggers first (they take precedence over manual triggers)
-      if (apiTriggers.length === 1) {
-        selectedTrigger = apiTriggers[0]
-        const blockEntry = entries.find(([, block]) => block === selectedTrigger)
-        if (blockEntry) {
-          selectedBlockId = blockEntry[0]
-
-          // Extract test values from the API trigger's inputFormat
-          if (
-            selectedTrigger.type === 'api_trigger' ||
-            selectedTrigger.type === 'start_trigger' ||
-            selectedTrigger.type === 'starter'
-          ) {
-            const inputFormatValue = selectedTrigger.subBlocks?.inputFormat?.value
-            const testInput = extractTestValuesFromInputFormat(inputFormatValue)
-
-            // Use the test input as workflow input
-            if (Object.keys(testInput).length > 0) {
-              finalWorkflowInput = testInput
-              logger.info('Using trigger test values for manual run:', testInput)
-            }
-          }
-        }
-      } else if (apiTriggers.length > 1) {
+      const apiCandidates = candidates.filter(
+        (candidate) => candidate.path === StartBlockPath.SPLIT_API
+      )
+      if (apiCandidates.length > 1) {
         const error = new Error('Multiple API Trigger blocks found. Keep only one.')
         logger.error('Multiple API triggers found')
         setIsExecuting(false)
         throw error
-      } else if (manualTriggers.length >= 1) {
-        // No API trigger, check for manual triggers
-        // Prefer manual_trigger over input_trigger for simple runs
-        const manualTrigger = manualTriggers.find((t) => t.type === 'manual_trigger')
-        const inputTrigger = manualTriggers.find((t) => t.type === 'input_trigger')
-
-        selectedTrigger = manualTrigger || inputTrigger || manualTriggers[0]
-        const blockEntry = entries.find(([, block]) => block === selectedTrigger)
-        if (blockEntry) {
-          selectedBlockId = blockEntry[0]
-
-          // Extract test values from input trigger's inputFormat if it's an input_trigger or start_trigger
-          if (
-            selectedTrigger.type === 'input_trigger' ||
-            selectedTrigger.type === 'start_trigger'
-          ) {
-            const inputFormatValue = selectedTrigger.subBlocks?.inputFormat?.value
-            const testInput = extractTestValuesFromInputFormat(inputFormatValue)
-
-            // Use the test input as workflow input
-            if (Object.keys(testInput).length > 0) {
-              finalWorkflowInput = testInput
-              logger.info('Using trigger test values for manual run:', testInput)
-            }
-          }
-        }
-      } else {
-        // Fallback: Check for legacy starter block
-        const starterBlock = Object.values(filteredStates).find((block) => block.type === 'starter')
-        if (starterBlock) {
-          // Found a legacy starter block, use it as a manual trigger
-          const blockEntry = Object.entries(filteredStates).find(
-            ([, block]) => block === starterBlock
-          )
-          if (blockEntry) {
-            selectedBlockId = blockEntry[0]
-            selectedTrigger = starterBlock
-            logger.info('Using legacy starter block for manual run')
-          }
-        }
+      }
 
-        if (!selectedBlockId || !selectedTrigger) {
-          const error = new Error('Manual run requires a Manual, Input Form, or API Trigger block')
-          logger.error('No manual/input or API triggers found for manual run')
+      const selectedCandidate = apiCandidates[0] ?? candidates[0]
+
+      if (!selectedCandidate) {
+        const error = new Error('Manual run requires a Manual, Input Form, or API Trigger block')
+        logger.error('No manual/input or API triggers found for manual run')
+        setIsExecuting(false)
+        throw error
+      }
+
+      startBlockId = selectedCandidate.blockId
+      const selectedTrigger = selectedCandidate.block
+
+      if (selectedCandidate.path !== StartBlockPath.LEGACY_STARTER) {
+        const outgoingConnections = workflowEdges.filter((edge) => edge.source === startBlockId)
+        if (outgoingConnections.length === 0) {
+          const triggerName = selectedTrigger.name || selectedTrigger.type
+          const error = new Error(`${triggerName} must be connected to other blocks to execute`)
+          logger.error('Trigger has no outgoing connections', { triggerName, startBlockId })
           setIsExecuting(false)
           throw error
         }
       }
 
-      if (selectedBlockId && selectedTrigger) {
-        startBlockId = selectedBlockId
-
-        // Check if the trigger has any outgoing connections (except for legacy starter blocks)
-        // Legacy starter blocks have their own validation in the executor
-        if (selectedTrigger.type !== 'starter') {
-          const outgoingConnections = workflowEdges.filter((edge) => edge.source === startBlockId)
-          if (outgoingConnections.length === 0) {
-            const triggerName = selectedTrigger.name || selectedTrigger.type
-            const error = new Error(`${triggerName} must be connected to other blocks to execute`)
-            logger.error('Trigger has no outgoing connections', { triggerName, startBlockId })
-            setIsExecuting(false)
-            throw error
-          }
+      if (
+        selectedCandidate.path === StartBlockPath.SPLIT_API ||
+        selectedCandidate.path === StartBlockPath.SPLIT_INPUT ||
+        selectedCandidate.path === StartBlockPath.UNIFIED
+      ) {
+        const inputFormatValue = selectedTrigger.subBlocks?.inputFormat?.value
+        const testInput = extractTestValuesFromInputFormat(inputFormatValue)
+
+        if (Object.keys(testInput).length > 0) {
+          finalWorkflowInput = testInput
+          logger.info('Using trigger test values for manual run:', {
+            startBlockId,
+            testFields: Object.keys(testInput),
+            path: selectedCandidate.path,
+          })
         }
-
-        logger.info('Trigger found for manual run:', {
-          startBlockId,
-          triggerType: selectedTrigger.type,
-          triggerName: selectedTrigger.name,
-          isLegacyStarter: selectedTrigger.type === 'starter',
-          usingTestValues: selectedTrigger.type === 'api_trigger',
-        })
       }
+
+      logger.info('Trigger found for manual run:', {
+        startBlockId,
+        triggerType: selectedTrigger.type,
+        triggerName: selectedTrigger.name,
+        startPath: selectedCandidate.path,
+      })
     }
 
     // If we don't have a valid startBlockId at this point, throw an error