remove all extraneous debug logging and added mapping for triggerConfig field names that were changed

Author: waleed

apps/sim/hooks/use-trigger-config-aggregation.ts

@@ -92,57 +92,29 @@ export function populateTriggerFieldsFromConfig(
   triggerId: string | undefined
 ) {
   if (!triggerConfig || !triggerId || !blockId) {
-    logger.debug('populateTriggerFieldsFromConfig: Skipping - missing params', {
-      blockId,
-      triggerId,
-      hasTriggerConfig: !!triggerConfig,
-    })
     return
   }
 
   if (!isTriggerValid(triggerId)) {
-    logger.debug('populateTriggerFieldsFromConfig: Skipping - invalid trigger', {
-      blockId,
-      triggerId,
-    })
     return
   }
 
-  logger.debug('populateTriggerFieldsFromConfig: Starting migration', {
-    blockId,
-    triggerId,
-    triggerConfigKeys: Object.keys(triggerConfig),
-    triggerConfig,
-  })
-
   const triggerDef = getTrigger(triggerId)
 
   const subBlockStore = useSubBlockStore.getState()
 
-  let migratedCount = 0
   triggerDef.subBlocks
     .filter((sb) => sb.mode === 'trigger' && !SYSTEM_SUBBLOCK_IDS.includes(sb.id))
     .forEach((subBlock) => {
       let configValue: any
 
       if (subBlock.id in triggerConfig) {
         configValue = triggerConfig[subBlock.id]
-        logger.debug('populateTriggerFieldsFromConfig: Found new field name', {
-          blockId,
-          subBlockId: subBlock.id,
-          value: configValue,
-        })
       } else {
         for (const [oldFieldName, value] of Object.entries(triggerConfig)) {
           const mappedFieldName = mapOldFieldNameToNewSubBlockId(oldFieldName)
           if (mappedFieldName === subBlock.id) {
             configValue = value
-            logger.debug('populateTriggerFieldsFromConfig: Mapped old field name', {
-              blockId,
-              oldFieldName,
-              newSubBlockId: subBlock.id,
-              value: configValue,
-            })
             break
           }
         }
@@ -157,23 +129,8 @@ export function populateTriggerFieldsFromConfig(
           if (typeof configValue === 'string' && configValue.trim() !== '') {
             try {
               normalizedValue = JSON.parse(configValue)
-              logger.debug('populateTriggerFieldsFromConfig: Parsed string to array', {
-                blockId,
-                subBlockId: subBlock.id,
-                originalValue: configValue,
-                normalizedValue,
-              })
             } catch {
               normalizedValue = [configValue]
-              logger.debug(
-                'populateTriggerFieldsFromConfig: Converted string to single-item array',
-                {
-                  blockId,
-                  subBlockId: subBlock.id,
-                  originalValue: configValue,
-                  normalizedValue,
-                }
-              )
             }
           } else if (
             !Array.isArray(configValue) &&
@@ -182,39 +139,13 @@ export function populateTriggerFieldsFromConfig(
           ) {
             // If it's not already an array and not null/undefined, wrap it
             normalizedValue = [configValue]
-            logger.debug('populateTriggerFieldsFromConfig: Wrapped non-array value in array', {
-              blockId,
-              subBlockId: subBlock.id,
-              originalValue: configValue,
-              normalizedValue,
-            })
           }
           // If it's already an array or null/undefined, use as-is
         }
 
         if (currentValue === null || currentValue === undefined || currentValue === '') {
           subBlockStore.setValue(blockId, subBlock.id, normalizedValue)
-          migratedCount++
-          logger.debug('populateTriggerFieldsFromConfig: Set value', {
-            blockId,
-            subBlockId: subBlock.id,
-            value: normalizedValue,
-            currentValue,
-          })
-        } else {
-          logger.debug('populateTriggerFieldsFromConfig: Skipped - value already exists', {
-            blockId,
-            subBlockId: subBlock.id,
-            currentValue,
-            wouldSet: normalizedValue,
-          })
         }
       }
     })
-
-  logger.debug('populateTriggerFieldsFromConfig: Migration complete', {
-    blockId,
-    triggerId,
-    migratedCount,
-  })
 }

apps/sim/hooks/use-webhook-management.ts

@@ -2,7 +2,9 @@ import { useCallback, useEffect, useMemo, useState } from 'react'
 import { useParams } from 'next/navigation'
 import { createLogger } from '@/lib/logs/console/logger'
 import { getBaseUrl } from '@/lib/urls/utils'
+import { getBlock } from '@/blocks'
 import { useSubBlockStore } from '@/stores/workflows/subblock/store'
+import { useWorkflowStore } from '@/stores/workflows/workflow/store'
 import { getTrigger, isTriggerValid } from '@/triggers'
 import { populateTriggerFieldsFromConfig } from './use-trigger-config-aggregation'
 
@@ -78,15 +80,26 @@ export function useWebhookManagement({
     const store = useSubBlockStore.getState()
     const currentlyLoading = store.loadingWebhooks.has(blockId)
     const alreadyChecked = store.checkedWebhooks.has(blockId)
+    const currentWebhookId = store.getValue(blockId, 'webhookId')
 
     if (currentlyLoading) {
       return
     }
 
-    if (alreadyChecked) {
+    // If already checked and webhookId exists, skip fetching
+    if (alreadyChecked && currentWebhookId) {
       return
     }
 
+    // If already checked but webhookId is null, allow re-checking (handles timing issues)
+    if (alreadyChecked && !currentWebhookId) {
+      useSubBlockStore.setState((state) => {
+        const newSet = new Set(state.checkedWebhooks)
+        newSet.delete(blockId)
+        return { checkedWebhooks: newSet }
+      })
+    }
+
     let isMounted = true
 
     const loadWebhookOrGenerateUrl = async () => {
@@ -101,11 +114,23 @@ export function useWebhookManagement({
 
       try {
         const response = await fetch(`/api/webhooks?workflowId=${workflowId}&blockId=${blockId}`)
-        if (response.ok && isMounted) {
+        const stillMounted = isMounted // Capture mount state at response time
+
+        // Process response even if component unmounted, since we're using Zustand (global store)
+        // The webhookId should be set in the store regardless of component lifecycle
+        if (response.ok) {
           const data = await response.json()
+
           if (data.webhooks && data.webhooks.length > 0) {
             const webhook = data.webhooks[0].webhook
+
             useSubBlockStore.getState().setValue(blockId, 'webhookId', webhook.id)
+            logger.info('Webhook loaded from API', {
+              blockId,
+              webhookId: webhook.id,
+              hasProviderConfig: !!webhook.providerConfig,
+              wasMounted: stillMounted,
+            })
 
             if (webhook.path) {
               const currentPath = useSubBlockStore.getState().getValue(blockId, 'triggerPath')
@@ -115,27 +140,78 @@ export function useWebhookManagement({
             }
 
             if (webhook.providerConfig) {
+              // Determine triggerId from multiple sources
+              let effectiveTriggerId: string | undefined = triggerId
+              if (!effectiveTriggerId) {
+                // Try to get from stored value
+                const storedTriggerId = useSubBlockStore.getState().getValue(blockId, 'triggerId')
+                effectiveTriggerId =
+                  (typeof storedTriggerId === 'string' ? storedTriggerId : undefined) || undefined
+              }
+              if (!effectiveTriggerId && webhook.providerConfig.triggerId) {
+                effectiveTriggerId =
+                  typeof webhook.providerConfig.triggerId === 'string'
+                    ? webhook.providerConfig.triggerId
+                    : undefined
+              }
+              if (!effectiveTriggerId) {
+                // Try to determine from block config
+                const workflowState = useWorkflowStore.getState()
+                const block = workflowState.blocks?.[blockId]
+                if (block) {
+                  const blockConfig = getBlock(block.type)
+                  if (blockConfig) {
+                    if (blockConfig.category === 'triggers') {
+                      effectiveTriggerId = block.type
+                    } else if (block.triggerMode && blockConfig.triggers?.enabled) {
+                      const triggerIdValue = block.subBlocks?.triggerId?.value
+                      effectiveTriggerId =
+                        (typeof triggerIdValue === 'string' ? triggerIdValue : undefined) ||
+                        blockConfig.triggers?.available?.[0]
+                    }
+                  }
+                }
+              }
+
               const currentConfig = useSubBlockStore.getState().getValue(blockId, 'triggerConfig')
               if (JSON.stringify(webhook.providerConfig) !== JSON.stringify(currentConfig)) {
                 useSubBlockStore
                   .getState()
                   .setValue(blockId, 'triggerConfig', webhook.providerConfig)
 
-                populateTriggerFieldsFromConfig(blockId, webhook.providerConfig, triggerId)
+                if (effectiveTriggerId) {
+                  populateTriggerFieldsFromConfig(
+                    blockId,
+                    webhook.providerConfig,
+                    effectiveTriggerId
+                  )
+                } else {
+                  logger.warn('Cannot migrate - triggerId not available', {
+                    blockId,
+                    propTriggerId: triggerId,
+                    providerConfigTriggerId: webhook.providerConfig.triggerId,
+                  })
+                }
               }
             }
-          } else if (isMounted) {
+          } else {
             useSubBlockStore.getState().setValue(blockId, 'webhookId', null)
           }
 
-          if (isMounted) {
-            useSubBlockStore.setState((state) => ({
-              checkedWebhooks: new Set([...state.checkedWebhooks, blockId]),
-            }))
-          }
+          // Mark as checked even if component unmounted, since Zustand state persists
+          useSubBlockStore.setState((state) => ({
+            checkedWebhooks: new Set([...state.checkedWebhooks, blockId]),
+          }))
+        } else {
+          logger.warn('API response not OK', {
+            blockId,
+            workflowId,
+            status: response.status,
+            statusText: response.statusText,
+          })
         }
       } catch (error) {
-        logger.error('Error loading webhook:', { error })
+        logger.error('Error loading webhook:', { error, blockId, workflowId })
       } finally {
         useSubBlockStore.setState((state) => {
           const newSet = new Set(state.loadingWebhooks)
@@ -150,6 +226,8 @@ export function useWebhookManagement({
     return () => {
       isMounted = false
     }
+    // Note: Intentionally not including webhookId in dependencies to avoid re-running when it changes
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [isPreview, triggerId, workflowId, blockId])
 
   const saveConfig = async (): Promise<boolean> => {

apps/sim/stores/workflows/subblock/store.ts

@@ -133,32 +133,21 @@ export const useSubBlockStore = create<SubBlockStore>()(
         }
 
         if (!triggerId || !isTriggerValid(triggerId)) {
-          console.log('[initializeFromWorkflow] Skipping - invalid triggerId', {
-            blockId,
-            blockType: block.type,
-            triggerId,
-            isTriggerValid: triggerId ? isTriggerValid(triggerId) : false,
-          })
           return
         }
 
         const triggerConfigSubBlock = block.subBlocks?.triggerConfig
         if (triggerConfigSubBlock?.value && typeof triggerConfigSubBlock.value === 'object') {
-          console.log('[initializeFromWorkflow] Found triggerConfig, migrating', {
-            blockId,
-            triggerId,
-            triggerConfigKeys: Object.keys(triggerConfigSubBlock.value),
-            triggerConfig: triggerConfigSubBlock.value,
-          })
           populateTriggerFieldsFromConfig(blockId, triggerConfigSubBlock.value, triggerId)
-        } else {
-          console.log('[initializeFromWorkflow] No triggerConfig subblock found', {
-            blockId,
-            triggerId,
-            hasTriggerConfigSubBlock: !!triggerConfigSubBlock,
-            triggerConfigValue: triggerConfigSubBlock?.value,
-            allSubBlockIds: Object.keys(block.subBlocks || {}),
-          })
+
+          const currentChecked = get().checkedWebhooks
+          if (currentChecked.has(blockId)) {
+            set((state) => {
+              const newSet = new Set(state.checkedWebhooks)
+              newSet.delete(blockId)
+              return { checkedWebhooks: newSet }
+            })
+          }
         }
       })