chore: import upstream snapshot with attribution

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

@@ -0,0 +1,195 @@
+import { useCallback, useEffect, useMemo, useRef } from 'react'
+import { createLogger } from '@sim/logger'
+import { useParams } from 'next/navigation'
+import { getBaseUrl } from '@/lib/core/utils/urls'
+import { getBlock } from '@/blocks'
+import { useWebhookQuery } from '@/hooks/queries/webhooks'
+import { populateTriggerFieldsFromConfig } from '@/hooks/use-trigger-config-aggregation'
+import { useSubBlockStore } from '@/stores/workflows/subblock/store'
+import { useWorkflowStore } from '@/stores/workflows/workflow/store'
+import { isTriggerValid } from '@/triggers'
+
+const logger = createLogger('useWebhookManagement')
+
+interface UseWebhookManagementProps {
+  blockId: string
+  triggerId?: string
+  isPreview?: boolean
+  useWebhookUrl?: boolean
+}
+
+interface WebhookManagementState {
+  webhookUrl: string
+  webhookPath: string
+  webhookId: string | null
+  isLoading: boolean
+}
+
+/**
+ * Resolves the effective triggerId from various sources in order of priority
+ */
+function resolveEffectiveTriggerId(
+  blockId: string,
+  triggerId: string | undefined,
+  webhook?: { providerConfig?: { triggerId?: string } }
+): string | undefined {
+  if (triggerId && isTriggerValid(triggerId)) {
+    return triggerId
+  }
+
+  const selectedTriggerId = useSubBlockStore.getState().getValue(blockId, 'selectedTriggerId')
+  if (typeof selectedTriggerId === 'string' && isTriggerValid(selectedTriggerId)) {
+    return selectedTriggerId
+  }
+
+  const storedTriggerId = useSubBlockStore.getState().getValue(blockId, 'triggerId')
+  if (typeof storedTriggerId === 'string' && isTriggerValid(storedTriggerId)) {
+    return storedTriggerId
+  }
+
+  if (webhook?.providerConfig?.triggerId && typeof webhook.providerConfig.triggerId === 'string') {
+    return webhook.providerConfig.triggerId
+  }
+
+  const workflowState = useWorkflowStore.getState()
+  const block = workflowState.blocks?.[blockId]
+  if (block) {
+    const blockConfig = getBlock(block.type)
+    if (blockConfig) {
+      if (blockConfig.category === 'triggers') {
+        return block.type
+      }
+      if (block.triggerMode && blockConfig.triggers?.enabled) {
+        const selectedTriggerIdValue = block.subBlocks?.selectedTriggerId?.value
+        const triggerIdValue = block.subBlocks?.triggerId?.value
+        return (
+          (typeof selectedTriggerIdValue === 'string' && isTriggerValid(selectedTriggerIdValue)
+            ? selectedTriggerIdValue
+            : undefined) ||
+          (typeof triggerIdValue === 'string' && isTriggerValid(triggerIdValue)
+            ? triggerIdValue
+            : undefined) ||
+          blockConfig.triggers?.available?.[0]
+        )
+      }
+    }
+  }
+
+  return undefined
+}
+
+/**
+ * Hook to load webhook info for trigger blocks.
+ * Uses React Query for data fetching and syncs results to the sub-block store.
+ * Webhook creation/updates are handled by the deploy flow.
+ */
+export function useWebhookManagement({
+  blockId,
+  triggerId,
+  isPreview = false,
+  useWebhookUrl = false,
+}: UseWebhookManagementProps): WebhookManagementState {
+  const params = useParams()
+  const workflowId = params.workflowId as string
+  const syncedRef = useRef(false)
+
+  const webhookId = useSubBlockStore(
+    useCallback((state) => state.getValue(blockId, 'webhookId') as string | null, [blockId])
+  )
+  const webhookPath = useSubBlockStore(
+    useCallback((state) => state.getValue(blockId, 'triggerPath') as string | null, [blockId])
+  )
+
+  const webhookUrl = useMemo(() => {
+    const baseUrl = getBaseUrl()
+    if (!webhookPath) {
+      return `${baseUrl}/api/webhooks/trigger/${blockId}`
+    }
+    return `${baseUrl}/api/webhooks/trigger/${webhookPath}`
+  }, [webhookPath, blockId])
+
+  useEffect(() => {
+    if (triggerId && !isPreview) {
+      const storedTriggerId = useSubBlockStore.getState().getValue(blockId, 'triggerId')
+      if (storedTriggerId !== triggerId) {
+        useSubBlockStore.getState().setValue(blockId, 'triggerId', triggerId)
+      }
+    }
+  }, [triggerId, blockId, isPreview])
+
+  const queryEnabled = useWebhookUrl && !isPreview && Boolean(workflowId && blockId)
+
+  // Reset sync flag when blockId changes or query becomes disabled (render-phase guard)
+  const prevBlockIdRef = useRef(blockId)
+  if (blockId !== prevBlockIdRef.current) {
+    prevBlockIdRef.current = blockId
+    syncedRef.current = false
+  }
+  if (!queryEnabled) {
+    syncedRef.current = false
+  }
+
+  const { data: webhook, isLoading: queryLoading } = useWebhookQuery(
+    workflowId,
+    blockId,
+    queryEnabled
+  )
+
+  useEffect(() => {
+    if (!queryEnabled || syncedRef.current) return
+    if (webhook === undefined) return
+
+    if (webhook) {
+      syncedRef.current = true
+      useSubBlockStore.getState().setValue(blockId, 'webhookId', webhook.id)
+      logger.info('Webhook loaded from API', {
+        blockId,
+        webhookId: webhook.id,
+        hasProviderConfig: !!webhook.providerConfig,
+      })
+
+      if (webhook.path) {
+        useSubBlockStore.getState().setValue(blockId, 'triggerPath', webhook.path)
+      }
+
+      if (webhook.providerConfig) {
+        const effectiveTriggerId = resolveEffectiveTriggerId(blockId, triggerId, webhook)
+
+        const {
+          credentialId: _credId,
+          userId: _userId,
+          historyId: _historyId,
+          lastCheckedTimestamp: _lastChecked,
+          setupCompleted: _setupCompleted,
+          externalId: _externalId,
+          triggerId: _triggerId,
+          blockId: _blockId,
+          ...userConfigurableFields
+        } = webhook.providerConfig as Record<string, unknown>
+
+        useSubBlockStore.getState().setValue(blockId, 'triggerConfig', userConfigurableFields)
+
+        if (effectiveTriggerId) {
+          populateTriggerFieldsFromConfig(blockId, webhook.providerConfig, effectiveTriggerId)
+        } else {
+          logger.warn('Cannot migrate - triggerId not available', {
+            blockId,
+            propTriggerId: triggerId,
+            providerConfigTriggerId: webhook.providerConfig.triggerId,
+          })
+        }
+      }
+    } else {
+      // Deliberately leave syncedRef.current = false here: when no webhook exists yet
+      // (e.g., before deploy), a later refetch may return a real webhook that must be synced.
+      useSubBlockStore.getState().setValue(blockId, 'webhookId', null)
+    }
+  }, [webhook, queryEnabled, blockId, triggerId])
+
+  return {
+    webhookUrl,
+    webhookPath: webhookPath || blockId,
+    webhookId,
+    isLoading: queryLoading,
+  }
+}