feat(triggers): modify triggers to use existing subblock system, webhook order of operations improvements (#1774)

* feat(triggers): make triggers use existing subblock system, need to still fix webhook URL on multiselect and add script in text subblock for google form

* minimize added subblocks, cleanup code, make triggers first-class subblock users

* remove multi select dropdown and add props to existing dropdown instead

* cleanup dropdown

* add socket op to delete external webhook connections on block delete

* establish external webhook before creating webhook DB record, surface better errors for ones that require external connections

* fix copy button in short-input

* revert environment.ts, cleanup

* add triggers registry, update copilot tool to reflect new trigger setup

* update trigger-save subblock

* clean

* cleanup

* remove unused subblock store op, update search modal to reflect list of triggers

* add init from workflow to subblock store to populate new subblock format from old triggers

* fix mapping of old names to new ones

* added debug logging

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

* fix trigger config for triggers w/ multiple triggers

* edge cases for effectiveTriggerId

* cleaned up

* fix dropdown multiselect

* fix multiselect

* updated short-input copy button

* duplicate blocks in trigger mode

* ack PR comments

Author: waleedlatif1

apps/sim/app/api/webhooks/[id]/route.ts

@@ -5,9 +5,7 @@ import { type NextRequest, NextResponse } from 'next/server'
 import { getSession } from '@/lib/auth'
 import { createLogger } from '@/lib/logs/console/logger'
 import { getUserEntityPermissions } from '@/lib/permissions/utils'
-import { getBaseUrl } from '@/lib/urls/utils'
 import { generateRequestId } from '@/lib/utils'
-import { getOAuthToken } from '@/app/api/auth/oauth/utils'
 
 const logger = createLogger('WebhookAPI')
 
@@ -245,219 +243,9 @@ export async function DELETE(
 
     const foundWebhook = webhookData.webhook
 
-    // If it's an Airtable webhook, delete it from Airtable first
-    if (foundWebhook.provider === 'airtable') {
-      try {
-        const { baseId, externalId } = (foundWebhook.providerConfig || {}) as {
-          baseId?: string
-          externalId?: string
-        }
-
-        if (!baseId) {
-          logger.warn(`[${requestId}] Missing baseId for Airtable webhook deletion.`, {
-            webhookId: id,
-          })
-          return NextResponse.json(
-            { error: 'Missing baseId for Airtable webhook deletion' },
-            { status: 400 }
-          )
-        }
-
-        // Get access token for the workflow owner
-        const userIdForToken = webhookData.workflow.userId
-        const accessToken = await getOAuthToken(userIdForToken, 'airtable')
-        if (!accessToken) {
-          logger.warn(
-            `[${requestId}] Could not retrieve Airtable access token for user ${userIdForToken}. Cannot delete webhook in Airtable.`,
-            { webhookId: id }
-          )
-          return NextResponse.json(
-            { error: 'Airtable access token not found for webhook deletion' },
-            { status: 401 }
-          )
-        }
-
-        // Resolve externalId if missing by listing webhooks and matching our notificationUrl
-        let resolvedExternalId: string | undefined = externalId
-
-        if (!resolvedExternalId) {
-          try {
-            const expectedNotificationUrl = `${getBaseUrl()}/api/webhooks/trigger/${foundWebhook.path}`
-
-            const listUrl = `https://api.airtable.com/v0/bases/${baseId}/webhooks`
-            const listResp = await fetch(listUrl, {
-              headers: {
-                Authorization: `Bearer ${accessToken}`,
-              },
-            })
-            const listBody = await listResp.json().catch(() => null)
-
-            if (listResp.ok && listBody && Array.isArray(listBody.webhooks)) {
-              const match = listBody.webhooks.find((w: any) => {
-                const url: string | undefined = w?.notificationUrl
-                if (!url) return false
-                // Prefer exact match; fallback to suffix match to handle origin/host remaps
-                return (
-                  url === expectedNotificationUrl ||
-                  url.endsWith(`/api/webhooks/trigger/${foundWebhook.path}`)
-                )
-              })
-              if (match?.id) {
-                resolvedExternalId = match.id as string
-                // Persist resolved externalId for future operations
-                try {
-                  await db
-                    .update(webhook)
-                    .set({
-                      providerConfig: {
-                        ...(foundWebhook.providerConfig || {}),
-                        externalId: resolvedExternalId,
-                      },
-                      updatedAt: new Date(),
-                    })
-                    .where(eq(webhook.id, id))
-                } catch {
-                  // non-fatal persistence error
-                }
-                logger.info(`[${requestId}] Resolved Airtable externalId by listing webhooks`, {
-                  baseId,
-                  externalId: resolvedExternalId,
-                })
-              } else {
-                logger.warn(`[${requestId}] Could not resolve Airtable externalId from list`, {
-                  baseId,
-                  expectedNotificationUrl,
-                })
-              }
-            } else {
-              logger.warn(`[${requestId}] Failed to list Airtable webhooks to resolve externalId`, {
-                baseId,
-                status: listResp.status,
-                body: listBody,
-              })
-            }
-          } catch (e: any) {
-            logger.warn(`[${requestId}] Error attempting to resolve Airtable externalId`, {
-              error: e?.message,
-            })
-          }
-        }
-
-        // If still not resolvable, skip remote deletion but proceed with local delete
-        if (!resolvedExternalId) {
-          logger.info(
-            `[${requestId}] Airtable externalId not found; skipping remote deletion and proceeding to remove local record`,
-            { baseId }
-          )
-        }
-
-        if (resolvedExternalId) {
-          const airtableDeleteUrl = `https://api.airtable.com/v0/bases/${baseId}/webhooks/${resolvedExternalId}`
-          const airtableResponse = await fetch(airtableDeleteUrl, {
-            method: 'DELETE',
-            headers: {
-              Authorization: `Bearer ${accessToken}`,
-            },
-          })
-
-          // Attempt to parse error body for better diagnostics
-          if (!airtableResponse.ok) {
-            let responseBody: any = null
-            try {
-              responseBody = await airtableResponse.json()
-            } catch {
-              // ignore parse errors
-            }
-
-            logger.error(
-              `[${requestId}] Failed to delete Airtable webhook in Airtable. Status: ${airtableResponse.status}`,
-              { baseId, externalId: resolvedExternalId, response: responseBody }
-            )
-            return NextResponse.json(
-              {
-                error: 'Failed to delete webhook from Airtable',
-                details:
-                  (responseBody && (responseBody.error?.message || responseBody.error)) ||
-                  `Status ${airtableResponse.status}`,
-              },
-              { status: 500 }
-            )
-          }
-
-          logger.info(`[${requestId}] Successfully deleted Airtable webhook in Airtable`, {
-            baseId,
-            externalId: resolvedExternalId,
-          })
-        }
-      } catch (error: any) {
-        logger.error(`[${requestId}] Error deleting Airtable webhook`, {
-          webhookId: id,
-          error: error.message,
-          stack: error.stack,
-        })
-        return NextResponse.json(
-          { error: 'Failed to delete webhook from Airtable', details: error.message },
-          { status: 500 }
-        )
-      }
-    }
-
-    // Delete Microsoft Teams subscription if applicable
-    if (foundWebhook.provider === 'microsoftteams') {
-      const { deleteTeamsSubscription } = await import('@/lib/webhooks/webhook-helpers')
-      logger.info(`[${requestId}] Deleting Teams subscription for webhook ${id}`)
-      await deleteTeamsSubscription(foundWebhook, webhookData.workflow, requestId)
-      // Don't fail webhook deletion if subscription cleanup fails
-    }
-
-    // Delete Telegram webhook if applicable
-    if (foundWebhook.provider === 'telegram') {
-      try {
-        const { botToken } = (foundWebhook.providerConfig || {}) as { botToken?: string }
-
-        if (!botToken) {
-          logger.warn(`[${requestId}] Missing botToken for Telegram webhook deletion.`, {
-            webhookId: id,
-          })
-          return NextResponse.json(
-            { error: 'Missing botToken for Telegram webhook deletion' },
-            { status: 400 }
-          )
-        }
-
-        const telegramApiUrl = `https://api.telegram.org/bot${botToken}/deleteWebhook`
-        const telegramResponse = await fetch(telegramApiUrl, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-        })
-
-        const responseBody = await telegramResponse.json()
-        if (!telegramResponse.ok || !responseBody.ok) {
-          const errorMessage =
-            responseBody.description ||
-            `Failed to delete Telegram webhook. Status: ${telegramResponse.status}`
-          logger.error(`[${requestId}] ${errorMessage}`, { response: responseBody })
-          return NextResponse.json(
-            { error: 'Failed to delete webhook from Telegram', details: errorMessage },
-            { status: 500 }
-          )
-        }
-
-        logger.info(`[${requestId}] Successfully deleted Telegram webhook for webhook ${id}`)
-      } catch (error: any) {
-        logger.error(`[${requestId}] Error deleting Telegram webhook`, {
-          webhookId: id,
-          error: error.message,
-          stack: error.stack,
-        })
-        return NextResponse.json(
-          { error: 'Failed to delete webhook from Telegram', details: error.message },
-          { status: 500 }
-        )
-      }
-    }
+    const { cleanupExternalWebhook } = await import('@/lib/webhooks/webhook-helpers')
+    await cleanupExternalWebhook(foundWebhook, webhookData.workflow, requestId)
 
-    // Delete the webhook from the database
     await db.delete(webhook).where(eq(webhook.id, id))
 
     logger.info(`[${requestId}] Successfully deleted webhook: ${id}`)