chore(slack): reconcile staging merge

- nullable webhook.path coalesced at correlation/payload/tiktok boundaries
- slack dispatch delegates to staging's dispatchResolvedWebhookTarget
  (shared preprocess/deployment/filter/enqueue lifecycle), keeping the
  skip-reason diagnostics; route tests reworked around that seam
- api-validation route baseline 924 -> 926

Author: TheodoreSpeaks

apps/sim/app/api/webhooks/slack/custom/[credentialId]/route.test.ts

@@ -6,23 +6,17 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 const {
   mockParseWebhookBody,
   mockFindWebhooksByRoutingKey,
-  mockCheckWebhookPreprocessing,
-  mockQueueWebhookExecution,
-  mockBlockExistsInDeployment,
+  mockDispatchResolvedWebhookTarget,
   mockGetSlackBotCredential,
   mockHandleChallenge,
   mockVerifySignature,
-  mockShouldSkip,
 } = vi.hoisted(() => ({
   mockParseWebhookBody: vi.fn(),
   mockFindWebhooksByRoutingKey: vi.fn(),
-  mockCheckWebhookPreprocessing: vi.fn(),
-  mockQueueWebhookExecution: vi.fn(),
-  mockBlockExistsInDeployment: vi.fn(),
+  mockDispatchResolvedWebhookTarget: vi.fn(),
   mockGetSlackBotCredential: vi.fn(),
   mockHandleChallenge: vi.fn(),
   mockVerifySignature: vi.fn(),
-  mockShouldSkip: vi.fn(),
 }))
 
 vi.mock('@/lib/core/admission/gate', () => ({
@@ -37,21 +31,15 @@ vi.mock('@/app/api/auth/oauth/utils', () => ({
 vi.mock('@/lib/webhooks/processor', () => ({
   parseWebhookBody: mockParseWebhookBody,
   findWebhooksByRoutingKey: mockFindWebhooksByRoutingKey,
-  checkWebhookPreprocessing: mockCheckWebhookPreprocessing,
-  queueWebhookExecution: mockQueueWebhookExecution,
+  dispatchResolvedWebhookTarget: mockDispatchResolvedWebhookTarget,
 }))
 
 vi.mock('@/lib/webhooks/providers/slack', () => ({
   handleSlackChallenge: mockHandleChallenge,
   verifySlackRequestSignature: mockVerifySignature,
-  shouldSkipSlackTriggerEvent: mockShouldSkip,
   resolveSlackEventKey: () => null,
 }))
 
-vi.mock('@/lib/workflows/persistence/utils', () => ({
-  blockExistsInDeployment: mockBlockExistsInDeployment,
-}))
-
 import { POST } from '@/app/api/webhooks/slack/custom/[credentialId]/route'
 
 const CREDENTIAL_ID = 'cred-123'
@@ -80,7 +68,6 @@ describe('Slack custom-bot webhook route', () => {
     vi.clearAllMocks()
     mockHandleChallenge.mockReturnValue(null)
     mockVerifySignature.mockReturnValue(null)
-    mockShouldSkip.mockReturnValue(false)
     mockParseWebhookBody.mockResolvedValue({
       body: messageBody,
       rawBody: JSON.stringify(messageBody),
@@ -91,12 +78,11 @@ describe('Slack custom-bot webhook route', () => {
       teamId: 'T1',
     })
     mockFindWebhooksByRoutingKey.mockResolvedValue([webhook('wh1')])
-    mockCheckWebhookPreprocessing.mockResolvedValue({
-      actorUserId: 'u1',
-      executionId: 'e1',
-      correlation: {},
+    mockDispatchResolvedWebhookTarget.mockResolvedValue({
+      outcome: 'queued',
+      response: new Response(null, { status: 200 }),
+      reason: 'queued',
     })
-    mockBlockExistsInDeployment.mockResolvedValue(true)
   })
 
   it('echoes the url_verification challenge without loading the credential', async () => {
@@ -110,7 +96,7 @@ describe('Slack custom-bot webhook route', () => {
     mockGetSlackBotCredential.mockResolvedValue(null)
     const res = await POST(makeRequest(), context)
     expect(res.status).toBe(404)
-    expect(mockQueueWebhookExecution).not.toHaveBeenCalled()
+    expect(mockDispatchResolvedWebhookTarget).not.toHaveBeenCalled()
   })
 
   it('verifies with the credential signing secret and rejects a bad signature', async () => {
@@ -123,22 +109,28 @@ describe('Slack custom-bot webhook route', () => {
       expect.any(String)
     )
     expect(res.status).toBe(401)
-    expect(mockQueueWebhookExecution).not.toHaveBeenCalled()
+    expect(mockDispatchResolvedWebhookTarget).not.toHaveBeenCalled()
   })
 
-  it('fans out by credential id (provider slack) and queues when not skipped', async () => {
-    await POST(makeRequest(), context)
+  it('fans out by credential id (provider slack) and dispatches each webhook', async () => {
+    const res = await POST(makeRequest(), context)
     expect(mockFindWebhooksByRoutingKey).toHaveBeenCalledWith(
       CREDENTIAL_ID,
       expect.any(String),
       'slack'
     )
-    expect(mockQueueWebhookExecution).toHaveBeenCalledTimes(1)
+    expect(mockDispatchResolvedWebhookTarget).toHaveBeenCalledTimes(1)
+    expect(res.status).toBe(200)
   })
 
-  it('does not queue when the shared filter skips the event', async () => {
-    mockShouldSkip.mockReturnValue(true)
-    await POST(makeRequest(), context)
-    expect(mockQueueWebhookExecution).not.toHaveBeenCalled()
+  it('still returns 200 when the dispatcher filters the event', async () => {
+    mockDispatchResolvedWebhookTarget.mockResolvedValue({
+      outcome: 'ignored',
+      response: new Response(null, { status: 200 }),
+      reason: 'filtered',
+    })
+    const res = await POST(makeRequest(), context)
+    expect(mockDispatchResolvedWebhookTarget).toHaveBeenCalledTimes(1)
+    expect(res.status).toBe(200)
   })
 })

apps/sim/app/api/webhooks/slack/route.test.ts

@@ -3,21 +3,12 @@
  */
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-const {
-  mockParseWebhookBody,
-  mockFindWebhooksByRoutingKey,
-  mockCheckWebhookPreprocessing,
-  mockQueueWebhookExecution,
-  mockBlockExistsInDeployment,
-  mockShouldSkip,
-} = vi.hoisted(() => ({
-  mockParseWebhookBody: vi.fn(),
-  mockFindWebhooksByRoutingKey: vi.fn(),
-  mockCheckWebhookPreprocessing: vi.fn(),
-  mockQueueWebhookExecution: vi.fn(),
-  mockBlockExistsInDeployment: vi.fn(),
-  mockShouldSkip: vi.fn(),
-}))
+const { mockParseWebhookBody, mockFindWebhooksByRoutingKey, mockDispatchResolvedWebhookTarget } =
+  vi.hoisted(() => ({
+    mockParseWebhookBody: vi.fn(),
+    mockFindWebhooksByRoutingKey: vi.fn(),
+    mockDispatchResolvedWebhookTarget: vi.fn(),
+  }))
 
 vi.mock('@/lib/core/admission/gate', () => ({
   tryAdmit: () => ({ release: vi.fn() }),
@@ -31,21 +22,15 @@ vi.mock('@/lib/core/config/env', () => ({
 vi.mock('@/lib/webhooks/processor', () => ({
   parseWebhookBody: mockParseWebhookBody,
   findWebhooksByRoutingKey: mockFindWebhooksByRoutingKey,
-  checkWebhookPreprocessing: mockCheckWebhookPreprocessing,
-  queueWebhookExecution: mockQueueWebhookExecution,
+  dispatchResolvedWebhookTarget: mockDispatchResolvedWebhookTarget,
 }))
 
 vi.mock('@/lib/webhooks/providers/slack', () => ({
   handleSlackChallenge: () => null,
   verifySlackRequestSignature: () => null,
-  shouldSkipSlackTriggerEvent: mockShouldSkip,
   resolveSlackEventKey: () => null,
 }))
 
-vi.mock('@/lib/workflows/persistence/utils', () => ({
-  blockExistsInDeployment: mockBlockExistsInDeployment,
-}))
-
 import { POST } from '@/app/api/webhooks/slack/route'
 
 function makeRequest() {
@@ -61,12 +46,6 @@ function webhook(id: string) {
 
 async function run(body: Record<string, unknown>) {
   mockParseWebhookBody.mockResolvedValue({ body, rawBody: JSON.stringify(body) })
-  mockCheckWebhookPreprocessing.mockResolvedValue({
-    actorUserId: 'u1',
-    executionId: 'e1',
-    correlation: {},
-  })
-  mockBlockExistsInDeployment.mockResolvedValue(true)
   await POST(makeRequest())
 }
 
@@ -80,22 +59,29 @@ describe('Slack app webhook route', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     mockFindWebhooksByRoutingKey.mockResolvedValue([webhook('wh1')])
+    mockDispatchResolvedWebhookTarget.mockResolvedValue({
+      outcome: 'queued',
+      response: new Response(null, { status: 200 }),
+      reason: 'queued',
+    })
   })
 
-  it('queues execution when the shared filter does not skip', async () => {
-    mockShouldSkip.mockReturnValue(false)
+  it('dispatches each webhook resolved for the event team', async () => {
     await run(messageBody)
-    expect(mockQueueWebhookExecution).toHaveBeenCalledTimes(1)
+    expect(mockDispatchResolvedWebhookTarget).toHaveBeenCalledTimes(1)
   })
 
-  it('does not queue when the shared filter skips the event', async () => {
-    mockShouldSkip.mockReturnValue(true)
+  it('continues cleanly when the dispatcher filters the event', async () => {
+    mockDispatchResolvedWebhookTarget.mockResolvedValue({
+      outcome: 'ignored',
+      response: new Response(null, { status: 200 }),
+      reason: 'filtered',
+    })
     await run(messageBody)
-    expect(mockQueueWebhookExecution).not.toHaveBeenCalled()
+    expect(mockDispatchResolvedWebhookTarget).toHaveBeenCalledTimes(1)
   })
 
   it('routes via Slack Connect authorizations and dedups overlapping webhooks', async () => {
-    mockShouldSkip.mockReturnValue(false)
     // Two candidate teams (outer + authorization) that resolve to overlapping webhooks.
     mockFindWebhooksByRoutingKey.mockImplementation(async (teamId: string) =>
       teamId === 'T1' ? [webhook('wh1')] : [webhook('wh1'), webhook('wh2')]
@@ -105,19 +91,17 @@ describe('Slack app webhook route', () => {
       authorizations: [{ team_id: 'T2' }],
     })
     expect(mockFindWebhooksByRoutingKey).toHaveBeenCalledTimes(2)
-    // wh1 (in both) is queued once, wh2 once — dedup by webhook id.
-    expect(mockQueueWebhookExecution).toHaveBeenCalledTimes(2)
+    // wh1 (in both) is dispatched once, wh2 once — dedup by webhook id.
+    expect(mockDispatchResolvedWebhookTarget).toHaveBeenCalledTimes(2)
   })
 
   it('returns 200 with no team_id', async () => {
-    mockShouldSkip.mockReturnValue(false)
     await run({ event: { type: 'message' } })
     expect(mockFindWebhooksByRoutingKey).not.toHaveBeenCalled()
-    expect(mockQueueWebhookExecution).not.toHaveBeenCalled()
+    expect(mockDispatchResolvedWebhookTarget).not.toHaveBeenCalled()
   })
 
   it('routes an interaction payload by payload.team.id', async () => {
-    mockShouldSkip.mockReturnValue(false)
     await run({
       type: 'block_actions',
       api_app_id: 'A1',
@@ -126,18 +110,17 @@ describe('Slack app webhook route', () => {
       actions: [{ action_id: 'approve_btn' }],
     })
     expect(mockFindWebhooksByRoutingKey).toHaveBeenCalledWith('T1', expect.anything())
-    expect(mockQueueWebhookExecution).toHaveBeenCalledTimes(1)
+    expect(mockDispatchResolvedWebhookTarget).toHaveBeenCalledTimes(1)
   })
 
   it('fails closed on an interaction missing payload.team.id (never routes on user.team_id)', async () => {
-    mockShouldSkip.mockReturnValue(false)
     await run({
       type: 'block_actions',
       api_app_id: 'A1',
       user: { id: 'U1', team_id: 'T_OTHER' },
       actions: [{ action_id: 'approve_btn' }],
     })
     expect(mockFindWebhooksByRoutingKey).not.toHaveBeenCalled()
-    expect(mockQueueWebhookExecution).not.toHaveBeenCalled()
+    expect(mockDispatchResolvedWebhookTarget).not.toHaveBeenCalled()
   })
 })

apps/sim/background/tiktok-webhook-ingress.ts

@@ -60,7 +60,7 @@ export async function executeTikTokWebhookIngress(
       request,
       {
         requestId: payload.requestId,
-        path: webhook.path,
+        path: webhook.path ?? undefined,
         receivedAt: payload.receivedAt,
         triggerTimestampMs: payload.envelope.create_time * 1000,
       }

apps/sim/lib/webhooks/processor.ts

@@ -676,7 +676,8 @@ async function queueWebhookExecutionWithResult(
         source: 'webhook' as const,
         workflowId: foundWorkflow.id,
         webhookId: foundWebhook.id,
-        path: options.path || foundWebhook.path,
+        // Routing-key webhooks (e.g. Slack) have no path.
+        path: options.path || foundWebhook.path || undefined,
         provider: foundWebhook.provider,
         triggerType: 'webhook',
       } satisfies AsyncExecutionCorrelation)
@@ -692,7 +693,7 @@ async function queueWebhookExecutionWithResult(
       provider: foundWebhook.provider,
       body,
       headers,
-      path: options.path || foundWebhook.path,
+      path: options.path || foundWebhook.path || '',
       blockId: foundWebhook.blockId ?? undefined,
       workspaceId,
       ...(credentialId ? { credentialId } : {}),

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

@@ -1,12 +1,10 @@
 import { createLogger } from '@sim/logger'
 import type { NextRequest } from 'next/server'
 import {
-  checkWebhookPreprocessing,
+  dispatchResolvedWebhookTarget,
   type findWebhooksByRoutingKey,
-  queueWebhookExecution,
 } from '@/lib/webhooks/processor'
-import { resolveSlackEventKey, shouldSkipSlackTriggerEvent } from '@/lib/webhooks/providers/slack'
-import { blockExistsInDeployment } from '@/lib/workflows/persistence/utils'
+import { resolveSlackEventKey } from '@/lib/webhooks/providers/slack'
 
 const logger = createLogger('SlackWebhookDispatch')
 
@@ -19,10 +17,10 @@ interface DispatchSlackWebhooksOptions {
 
 /**
  * Shared fan-out tail for the Slack ingest routes (native team-id route and the
- * custom-bot credential route): run each candidate webhook through the trigger
- * filter, verify its block is still deployed, preprocess, and enqueue. Keeping
- * this in one place stops the skip/preprocess/queue sequence drifting between
- * the two ingest paths.
+ * custom-bot credential route): run each candidate webhook through the common
+ * post-auth lifecycle (preprocess, deployment check, trigger filter, enqueue)
+ * via {@link dispatchResolvedWebhookTarget}, logging skip diagnostics for
+ * filtered events.
  */
 export async function dispatchSlackWebhooks(
   webhooks: Awaited<ReturnType<typeof findWebhooksByRoutingKey>>,
@@ -34,12 +32,15 @@ export async function dispatchSlackWebhooks(
   const triggerTimestampMs = Number.isFinite(parsedTimestampMs) ? parsedTimestampMs : undefined
 
   for (const { webhook: foundWebhook, workflow: foundWorkflow } of webhooks) {
-    const providerConfig = (foundWebhook.providerConfig as Record<string, unknown>) || {}
+    const result = await dispatchResolvedWebhookTarget(foundWebhook, foundWorkflow, body, request, {
+      requestId,
+      receivedAt,
+      triggerTimestampMs,
+    })
 
-    // Shared trigger filter (event, source, threads, emoji, name, channels,
-    // interaction, self-drop, bot).
-    if (shouldSkipSlackTriggerEvent(payload, providerConfig)) {
+    if (result.outcome === 'ignored' && result.reason === 'filtered') {
       const rawEvent = payload.event as Record<string, unknown> | undefined
+      const providerConfig = (foundWebhook.providerConfig as Record<string, unknown>) || {}
       logger.info(`[${requestId}] Event skipped by trigger filter for webhook ${foundWebhook.id}`, {
         eventKey: resolveSlackEventKey(payload),
         configuredEvent: providerConfig.eventType,
@@ -50,32 +51,6 @@ export async function dispatchSlackWebhooks(
         threadsSetting: providerConfig.threads,
         botId: rawEvent?.bot_id,
       })
-      continue
     }
-
-    if (foundWebhook.blockId) {
-      const blockExists = await blockExistsInDeployment(foundWorkflow.id, foundWebhook.blockId)
-      if (!blockExists) {
-        logger.info(
-          `[${requestId}] Trigger block ${foundWebhook.blockId} not in deployment for ${foundWorkflow.id}`
-        )
-        continue
-      }
-    }
-
-    const preprocessResult = await checkWebhookPreprocessing(foundWorkflow, foundWebhook, requestId)
-    if (preprocessResult.error) {
-      logger.warn(`[${requestId}] Preprocessing failed for webhook ${foundWebhook.id}`)
-      continue
-    }
-
-    await queueWebhookExecution(foundWebhook, foundWorkflow, body, request, {
-      requestId,
-      actorUserId: preprocessResult.actorUserId,
-      executionId: preprocessResult.executionId,
-      correlation: preprocessResult.correlation,
-      receivedAt,
-      triggerTimestampMs,
-    })
   }
 }

scripts/check-api-validation-contracts.ts

@@ -9,8 +9,8 @@ const QUERY_HOOKS_DIR = path.join(ROOT, 'apps/sim/hooks/queries')
 const SELECTOR_HOOKS_DIR = path.join(ROOT, 'apps/sim/hooks/selectors')
 
 const BASELINE = {
-  totalRoutes: 924,
-  zodRoutes: 924,
+  totalRoutes: 926,
+  zodRoutes: 926,
   nonZodRoutes: 0,
 } as const