edited airtable payload and webhook deletion

Author: Adam Gough

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

@@ -1,8 +1,10 @@
 import { eq } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { getSession } from '@/lib/auth'
+import { env } from '@/lib/env'
 import { createLogger } from '@/lib/logs/console/logger'
 import { getUserEntityPermissions } from '@/lib/permissions/utils'
+import { getOAuthToken } from '@/app/api/auth/oauth/utils'
 import { db } from '@/db'
 import { webhook, workflow } from '@/db/schema'
 
@@ -242,6 +244,167 @@ 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 requestOrigin = new URL(request.url).origin
+            const effectiveOrigin = requestOrigin.includes('localhost')
+              ? env.NEXT_PUBLIC_APP_URL || requestOrigin
+              : requestOrigin
+            const expectedNotificationUrl = `${effectiveOrigin}/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 }
+        )
+      }
+    }
+
     // If it's a Telegram webhook, delete it from Telegram first
     if (foundWebhook.provider === 'telegram') {
       try {

apps/sim/executor/handlers/trigger/trigger-handler.ts

@@ -63,7 +63,12 @@ export class TriggerBlockHandler implements BlockHandler {
             }
           }
 
-          // Extract the flattened properties that should be at root level (non-GitHub)
+          // Provider-specific early return for Airtable: preserve raw shape entirely
+          if (provider === 'airtable') {
+            return starterOutput
+          }
+
+          // Extract the flattened properties that should be at root level (non-GitHub/Airtable)
           const result: any = {
             // Always keep the input at root level
             input: starterOutput.input,

apps/sim/lib/webhooks/utils.ts

@@ -825,6 +825,8 @@ export async function fetchAndProcessAirtablePayloads(
   let apiCallCount = 0
   // Use a Map to consolidate changes per record ID
   const consolidatedChangesMap = new Map<string, AirtableChange>()
+  // Capture raw payloads from Airtable for exposure to workflows
+  const allPayloads: any[] = []
   const localProviderConfig = {
     ...((webhookData.providerConfig as Record<string, any>) || {}),
   } // Local copy
@@ -1021,6 +1023,10 @@ export async function fetchAndProcessAirtablePayloads(
         // --- Process and Consolidate Changes ---
         if (receivedPayloads.length > 0) {
           payloadsFetched += receivedPayloads.length
+          // Keep the raw payloads for later exposure to the workflow
+          for (const p of receivedPayloads) {
+            allPayloads.push(p)
+          }
           let changeCount = 0
           for (const payload of receivedPayloads) {
             if (payload.changedTablesById) {
@@ -1186,10 +1192,25 @@ export async function fetchAndProcessAirtablePayloads(
     )
 
     // --- Execute Workflow if we have changes (simplified - no lock check) ---
-    if (finalConsolidatedChanges.length > 0) {
+    if (finalConsolidatedChanges.length > 0 || allPayloads.length > 0) {
       try {
-        // Format the input for the executor using the consolidated changes
-        const input = { airtableChanges: finalConsolidatedChanges } // Use the consolidated array
+        // Build input exposing raw payloads and consolidated changes
+        const latestPayload = allPayloads.length > 0 ? allPayloads[allPayloads.length - 1] : null
+        const input: any = {
+          // Raw Airtable payloads as received from the API
+          payloads: allPayloads,
+          latestPayload,
+          // Consolidated, simplified changes for convenience
+          airtableChanges: finalConsolidatedChanges,
+          // Include webhook metadata for resolver fallbacks
+          webhook: {
+            data: {
+              provider: 'airtable',
+              providerConfig: webhookData.providerConfig,
+              payload: latestPayload,
+            },
+          },
+        }
 
         // CRITICAL EXECUTION TRACE POINT
         logger.info(
@@ -1206,6 +1227,7 @@ export async function fetchAndProcessAirtablePayloads(
         logger.info(`[${requestId}] CRITICAL_TRACE: Airtable changes processed, returning input`, {
           workflowId: workflowData.id,
           recordCount: finalConsolidatedChanges.length,
+          rawPayloadCount: allPayloads.length,
           timestamp: new Date().toISOString(),
         })
 

apps/sim/triggers/airtable/webhook.ts

@@ -38,6 +38,40 @@ export const airtableWebhookTrigger: TriggerConfig = {
   },
 
   outputs: {
+    payloads: {
+      type: 'array',
+      description: 'The payloads of the Airtable changes',
+    },
+    latestPayload: {
+      timestamp: {
+        type: 'string',
+        description: 'The timestamp of the Airtable change',
+      },
+      payloadFormat: {
+        type: 'object',
+        description: 'The format of the Airtable change',
+      },
+      actionMetadata: {
+        source: {
+          type: 'string',
+          description: 'The source of the Airtable change',
+        },
+        sourceMetadata: {
+          pageId: {
+            type: 'string',
+            description: 'The ID of the page that triggered the Airtable change',
+          },
+        },
+        changedTablesById: {
+          type: 'object',
+          description: 'The tables that were changed',
+        },
+        baseTransactionNumber: {
+          type: 'number',
+          description: 'The transaction number of the Airtable change',
+        },
+      },
+    },
     airtableChanges: {
       type: 'array',
       description: 'Changes made to the Airtable table',