fix(slack): propagate legacy webhook dispatch failures

Author: TheodoreSpeaks

apps/sim/app/api/webhooks/trigger/[path]/route.test.ts

@@ -529,7 +529,13 @@ describe('Webhook Trigger API Route', () => {
         : null
     })
     verifySlackCustomBotCredentialRequestMock.mockResolvedValue(null)
-    dispatchSlackCustomBotCredentialMock.mockResolvedValue(1)
+    dispatchSlackCustomBotCredentialMock.mockResolvedValue([
+      {
+        outcome: 'queued',
+        reason: 'queued',
+        response: new NextResponse(null, { status: 200 }),
+      },
+    ])
 
     // Set up default workflow for tests
     testData.workflows.push({
@@ -760,6 +766,36 @@ describe('Webhook Trigger API Route', () => {
       expect(dispatchSlackCustomBotCredentialMock).not.toHaveBeenCalled()
       expect(dispatchResolvedWebhookTargetMock).not.toHaveBeenCalled()
     })
+
+    it('propagates a legacy fan-out failure when no target queues successfully', async () => {
+      testData.webhooks.push({
+        id: 'legacy-slack-webhook',
+        provider: 'slack',
+        path: 'legacy-slack-path',
+        routingKey: 'credential-1',
+        isActive: true,
+        providerConfig: {
+          triggerId: 'slack_webhook',
+          credentialId: 'credential-1',
+          ingressMode: 'legacy_custom_bot',
+        },
+        workflowId: 'test-workflow-id',
+      })
+      dispatchSlackCustomBotCredentialMock.mockResolvedValueOnce([
+        {
+          outcome: 'failed',
+          reason: 'preprocessing',
+          response: NextResponse.json({ error: 'Preprocessing failed' }, { status: 500 }),
+        },
+      ])
+
+      const response = await POST(createMockRequest('POST', { type: 'event_callback' }), {
+        params: Promise.resolve({ path: 'legacy-slack-path' }),
+      })
+
+      expect(response.status).toBe(500)
+      expect(dispatchResolvedWebhookTargetMock).not.toHaveBeenCalled()
+    })
   })
 
   describe('Reservation-free filtering', () => {

apps/sim/app/api/webhooks/trigger/[path]/route.ts

@@ -13,6 +13,7 @@ import {
   handleProviderReachabilityTest,
   parseWebhookBody,
   verifyProviderAuth,
+  type WebhookDispatchResult,
 } from '@/lib/webhooks/processor'
 import { acceptsPathWebhookDelivery } from '@/lib/webhooks/providers'
 import {
@@ -142,8 +143,9 @@ async function handleWebhookPost(
     )
   }
 
-  let dispatchedLegacySlackAlias = false
+  let authenticatedLegacySlackAlias = false
   let firstLegacySlackAuthError: NextResponse | null = null
+  const legacySlackDispatchResults: WebhookDispatchResult[] = []
   for (const credentialId of legacySlackCredentialIds) {
     const authError = await verifySlackCustomBotCredentialRequest({
       credentialId,
@@ -157,17 +159,18 @@ async function handleWebhookPost(
       continue
     }
 
-    await dispatchSlackCustomBotCredential({
+    const dispatchResults = await dispatchSlackCustomBotCredential({
       credentialId,
       body,
       request,
       requestId,
       receivedAt,
     })
-    dispatchedLegacySlackAlias = true
+    authenticatedLegacySlackAlias = true
+    legacySlackDispatchResults.push(...dispatchResults)
   }
 
-  if (legacySlackCredentialIds.size > 0 && !dispatchedLegacySlackAlias) {
+  if (legacySlackCredentialIds.size > 0 && !authenticatedLegacySlackAlias) {
     return (
       firstLegacySlackAuthError ??
       new NextResponse('Unauthorized - Invalid Slack signature', { status: 401 })
@@ -178,11 +181,17 @@ async function handleWebhookPost(
    * Process each unmarked webhook matched on this path. Marked Slack rows were
    * already included in the routing-key fan-out and must not run twice.
    */
-  const responses: NextResponse[] = dispatchedLegacySlackAlias
-    ? [new NextResponse(null, { status: 200 })]
-    : []
+  const responses: NextResponse[] = []
   const failures: NextResponse[] = []
-  const dispatchTargetCount = directWebhooksForPath.length + (dispatchedLegacySlackAlias ? 1 : 0)
+  for (const dispatchResult of legacySlackDispatchResults) {
+    if (dispatchResult.reason === 'filtered') continue
+    if (dispatchResult.outcome === 'failed' || dispatchResult.reason === 'block-missing') {
+      failures.push(dispatchResult.response)
+      continue
+    }
+    responses.push(dispatchResult.response)
+  }
+  const dispatchTargetCount = directWebhooksForPath.length + legacySlackDispatchResults.length
 
   for (const { webhook: foundWebhook, workflow: foundWorkflow } of directWebhooksForPath) {
     const provider = foundWebhook.provider

apps/sim/lib/webhooks/slack-custom-ingress.ts

@@ -2,7 +2,7 @@ import { createLogger } from '@sim/logger'
 import type { NextRequest } from 'next/server'
 import { NextResponse } from 'next/server'
 import { getSlackBotCredential } from '@/lib/oauth/credential-service'
-import { findWebhooksByRoutingKey } from '@/lib/webhooks/processor'
+import { findWebhooksByRoutingKey, type WebhookDispatchResult } from '@/lib/webhooks/processor'
 import { verifySlackRequestSignature } from '@/lib/webhooks/providers/slack'
 import { LEGACY_SLACK_CUSTOM_BOT_INGRESS_MODE } from '@/lib/webhooks/slack-custom-ingress-constants'
 import { dispatchSlackWebhooks } from '@/lib/webhooks/slack-dispatch'
@@ -99,15 +99,14 @@ export async function dispatchSlackCustomBotCredential({
   request,
   requestId,
   receivedAt,
-}: DispatchSlackCustomBotOptions): Promise<number> {
+}: DispatchSlackCustomBotOptions): Promise<WebhookDispatchResult[]> {
   const webhooks = await findWebhooksByRoutingKey(credentialId, requestId, 'slack')
   if (webhooks.length === 0) {
     logger.info(
       `[${requestId}] No active trigger for bot credential ${credentialId}; nothing to run`
     )
-    return 0
+    return []
   }
 
-  await dispatchSlackWebhooks(webhooks, { body, request, requestId, receivedAt })
-  return webhooks.length
+  return dispatchSlackWebhooks(webhooks, { body, request, requestId, receivedAt })
 }

apps/sim/lib/webhooks/slack-dispatch.ts

@@ -3,6 +3,7 @@ import type { NextRequest } from 'next/server'
 import {
   dispatchResolvedWebhookTarget,
   type findWebhooksByRoutingKey,
+  type WebhookDispatchResult,
 } from '@/lib/webhooks/processor'
 import { resolveSlackEventKey } from '@/lib/webhooks/providers/slack'
 
@@ -25,11 +26,12 @@ interface DispatchSlackWebhooksOptions {
 export async function dispatchSlackWebhooks(
   webhooks: Awaited<ReturnType<typeof findWebhooksByRoutingKey>>,
   { body, request, requestId, receivedAt }: DispatchSlackWebhooksOptions
-): Promise<void> {
+): Promise<WebhookDispatchResult[]> {
   const payload = body as Record<string, unknown>
   const slackRequestTimestamp = request.headers.get('x-slack-request-timestamp')
   const parsedTimestampMs = slackRequestTimestamp ? Number(slackRequestTimestamp) * 1000 : undefined
   const triggerTimestampMs = Number.isFinite(parsedTimestampMs) ? parsedTimestampMs : undefined
+  const results: WebhookDispatchResult[] = []
 
   for (const { webhook: foundWebhook, workflow: foundWorkflow } of webhooks) {
     const result = await dispatchResolvedWebhookTarget(foundWebhook, foundWorkflow, body, request, {
@@ -52,5 +54,8 @@ export async function dispatchSlackWebhooks(
         botId: rawEvent?.bot_id,
       })
     }
+    results.push(result)
   }
+
+  return results
 }