chore: import upstream snapshot with attribution

apps/sim/app/api/webhooks/poll/[provider]/route.test.ts

@@ -0,0 +1,108 @@
+/**
+ * Tests for the webhook polling cron route.
+ *
+ * @vitest-environment node
+ */
+import { createMockRequest, redisConfigMock, redisConfigMockFns } from '@sim/testing'
+import { sleep } from '@sim/utils/helpers'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { mockVerifyCronAuth, mockPollProvider } = vi.hoisted(() => ({
+  mockVerifyCronAuth: vi.fn().mockReturnValue(null),
+  mockPollProvider: vi.fn().mockResolvedValue({ processed: 0 }),
+}))
+
+vi.mock('@/lib/auth/internal', () => ({
+  verifyCronAuth: mockVerifyCronAuth,
+}))
+
+vi.mock('@/lib/core/config/redis', () => redisConfigMock)
+
+vi.mock('@/lib/webhooks/polling', () => ({
+  pollProvider: mockPollProvider,
+  VALID_POLLING_PROVIDERS: new Set(['gmail', 'outlook', 'rss']),
+}))
+
+import { GET } from './route'
+
+function createRequest() {
+  return createMockRequest('GET', undefined, {}, 'http://localhost:3000/api/webhooks/poll/gmail')
+}
+
+function createContext(provider: string) {
+  return { params: Promise.resolve({ provider }) }
+}
+
+const flushMicrotasks = () => sleep(0)
+
+describe('webhook polling route (fire-and-forget)', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    redisConfigMockFns.mockAcquireLock.mockResolvedValue(true)
+    redisConfigMockFns.mockReleaseLock.mockResolvedValue(true)
+    mockVerifyCronAuth.mockReturnValue(null)
+    mockPollProvider.mockResolvedValue({ processed: 0 })
+  })
+
+  it('returns the auth error when cron auth fails', async () => {
+    mockVerifyCronAuth.mockReturnValueOnce(
+      new Response(null, { status: 401 }) as unknown as Response
+    )
+
+    const response = await GET(createRequest(), createContext('gmail'))
+
+    expect(response.status).toBe(401)
+    expect(mockPollProvider).not.toHaveBeenCalled()
+  })
+
+  it('returns 404 for an unknown provider', async () => {
+    const response = await GET(createRequest(), createContext('unknown'))
+
+    expect(response.status).toBe(404)
+    expect(redisConfigMockFns.mockAcquireLock).not.toHaveBeenCalled()
+  })
+
+  it('acknowledges with 202 and polls in the background after acquiring the lock', async () => {
+    const response = await GET(createRequest(), createContext('gmail'))
+
+    expect(response.status).toBe(202)
+    const data = await response.json()
+    expect(data).toMatchObject({ status: 'started' })
+    expect(redisConfigMockFns.mockAcquireLock).toHaveBeenCalledWith(
+      'gmail-polling-lock',
+      expect.any(String),
+      expect.any(Number)
+    )
+
+    await flushMicrotasks()
+    expect(mockPollProvider).toHaveBeenCalledWith('gmail')
+    expect(redisConfigMockFns.mockReleaseLock).toHaveBeenCalledWith(
+      'gmail-polling-lock',
+      expect.any(String)
+    )
+  })
+
+  it('skips with 202 when the lock is already held', async () => {
+    redisConfigMockFns.mockAcquireLock.mockResolvedValueOnce(false)
+
+    const response = await GET(createRequest(), createContext('gmail'))
+
+    expect(response.status).toBe(202)
+    const data = await response.json()
+    expect(data).toMatchObject({ status: 'skip' })
+    expect(mockPollProvider).not.toHaveBeenCalled()
+  })
+
+  it('releases the lock even when polling throws', async () => {
+    mockPollProvider.mockRejectedValueOnce(new Error('poll failed'))
+
+    const response = await GET(createRequest(), createContext('gmail'))
+
+    expect(response.status).toBe(202)
+    await flushMicrotasks()
+    expect(redisConfigMockFns.mockReleaseLock).toHaveBeenCalledWith(
+      'gmail-polling-lock',
+      expect.any(String)
+    )
+  })
+})

apps/sim/app/api/webhooks/poll/[provider]/route.ts

@@ -0,0 +1,88 @@
+import { createLogger } from '@sim/logger'
+import { getErrorMessage } from '@sim/utils/errors'
+import { generateShortId } from '@sim/utils/id'
+import { type NextRequest, NextResponse } from 'next/server'
+import { webhookPollingContract } from '@/lib/api/contracts/webhooks'
+import { parseRequest } from '@/lib/api/server'
+import { verifyCronAuth } from '@/lib/auth/internal'
+import { acquireLock, releaseLock } from '@/lib/core/config/redis'
+import { runDetached } from '@/lib/core/utils/background'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { pollProvider, VALID_POLLING_PROVIDERS } from '@/lib/webhooks/polling'
+
+const logger = createLogger('PollingAPI')
+
+/** Lock TTL in seconds — must match maxDuration so the lock auto-expires if the function times out. */
+const LOCK_TTL_SECONDS = 180
+
+export const dynamic = 'force-dynamic'
+export const maxDuration = 180
+
+export const GET = withRouteHandler(
+  async (request: NextRequest, context: { params: Promise<{ provider: string }> }) => {
+    const requestId = generateShortId()
+    let provider: string | undefined
+
+    try {
+      const authError = verifyCronAuth(request, 'webhook polling')
+      if (authError) return authError
+
+      const parsed = await parseRequest(webhookPollingContract, request, context)
+      if (!parsed.success) return parsed.response
+      provider = parsed.data.params.provider
+
+      if (!VALID_POLLING_PROVIDERS.has(provider)) {
+        return NextResponse.json(
+          { error: `Unknown polling provider: ${provider}` },
+          { status: 404 }
+        )
+      }
+
+      const LOCK_KEY = `${provider}-polling-lock`
+      const lockValue = requestId
+      const locked = await acquireLock(LOCK_KEY, lockValue, LOCK_TTL_SECONDS)
+      if (!locked) {
+        return NextResponse.json(
+          {
+            success: true,
+            message: 'Polling already in progress – skipped',
+            requestId,
+            status: 'skip',
+          },
+          { status: 202 }
+        )
+      }
+
+      const pollingProvider = provider
+      runDetached(`${pollingProvider}-polling`, async () => {
+        try {
+          await pollProvider(pollingProvider)
+        } finally {
+          await releaseLock(LOCK_KEY, lockValue).catch(() => {})
+        }
+      })
+
+      return NextResponse.json(
+        {
+          success: true,
+          message: `${provider} polling started`,
+          requestId,
+          status: 'started',
+        },
+        { status: 202 }
+      )
+    } catch (error) {
+      const providerLabel = provider ?? 'webhook'
+      logger.error(`Error during ${providerLabel} polling (${requestId}):`, error)
+      return NextResponse.json(
+        {
+          success: false,
+          message: `${providerLabel} polling failed`,
+          error: getErrorMessage(error, 'Unknown error'),
+          requestId,
+        },
+        { status: 500 }
+      )
+    }
+  }
+)