regen migrations

Author: icecrasher321

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

@@ -74,7 +74,7 @@ vi.mock('@/serializer', () => ({
  */
 interface TestWebhook {
   id: string
-  provider: string
+  provider: string | null
   path: string
   isActive: boolean
   providerConfig?: Record<string, unknown>
@@ -542,6 +542,24 @@ describe('Webhook Trigger API Route', () => {
     expect(text).toMatch(/not found/i)
   })
 
+  it('returns 500 without dispatching when a persisted webhook has no provider', async () => {
+    testData.webhooks.push({
+      id: 'missing-provider-webhook',
+      provider: null,
+      path: 'missing-provider-path',
+      isActive: true,
+      workflowId: 'test-workflow-id',
+    })
+
+    const response = await POST(createMockRequest('POST', { event: 'test' }), {
+      params: Promise.resolve({ path: 'missing-provider-path' }),
+    })
+
+    expect(response.status).toBe(500)
+    await expect(response.json()).resolves.toEqual({ error: 'Webhook provider is missing' })
+    expect(dispatchResolvedWebhookTargetMock).not.toHaveBeenCalled()
+  })
+
   it('returns a stable retryable response when the webhook admission gate is full', async () => {
     tryAdmitMock.mockReturnValueOnce(null)
 

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

@@ -137,12 +137,27 @@ async function handleWebhookPost(
   let billingBlocked = false
 
   for (const { webhook: foundWebhook, workflow: foundWorkflow } of webhooksForPath) {
+    const provider = foundWebhook.provider
+    if (!provider) {
+      const missingProviderResponse = NextResponse.json(
+        { error: 'Webhook provider is missing' },
+        { status: 500 }
+      )
+      if (webhooksForPath.length > 1) {
+        logger.error(
+          `[${requestId}] Webhook ${foundWebhook.id} has no provider, continuing to next`
+        )
+        continue
+      }
+      return missingProviderResponse
+    }
+
     // Generic ("custom") webhooks are an unauthenticated programmatic execution
     // surface, so they fall under the same paid-plan gate as the API. Provider
     // webhooks (slack, github, ...) are unaffected.
     if (
-      foundWebhook.provider === 'generic' &&
-      !(await isWorkspaceApiExecutionEntitled(foundWorkflow.workspaceId))
+      provider === 'generic' &&
+      !(await isWorkspaceApiExecutionEntitled(foundWorkflow.workspaceId ?? undefined))
     ) {
       logger.warn(`[${requestId}] Generic webhook blocked: workspace on free plan`)
       billingBlocked = true
@@ -165,7 +180,7 @@ async function handleWebhookPost(
       return authError
     }
 
-    const reachabilityResponse = handleProviderReachabilityTest(foundWebhook, body, requestId)
+    const reachabilityResponse = handleProviderReachabilityTest({ provider }, body, requestId)
     if (reachabilityResponse) {
       return reachabilityResponse
     }

apps/sim/lib/knowledge/documents/service.ts

@@ -972,14 +972,18 @@ type DocumentStorageBilling =
   | {
       readonly context: StorageBillingContext
       readonly bytes: number
-      readonly updatedUsage?: number
     }
   | {
       readonly userId: string
       readonly bytes: number
       readonly sub: HighestPrioritySubscription | null
     }
 
+interface DocumentStorageNotification {
+  readonly context: StorageBillingContext
+  readonly updatedUsage: number
+}
+
 /**
  * Resolves and checks one document-write storage payer. Workspace documents
  * use only the workspace-selected payer; workspace-less legacy documents retain
@@ -1043,12 +1047,12 @@ export async function createDocumentRecords(
   requestId: string,
   uploadedBy: string | null = null
 ): Promise<DocumentData[]> {
-  let storageBilling: DocumentStorageBilling | null = null
-
   const totalBytes = documents.reduce((sum, docData) => sum + (docData.fileSize || 0), 0)
   const sub = totalBytes > 0 ? await resolveQuotaSubscription(knowledgeBaseId, uploadedBy) : null
 
-  const returnData = await db.transaction(async (tx) => {
+  const { returnData, storageNotification } = await db.transaction(async (tx) => {
+    let storageNotification: DocumentStorageNotification | null = null
+
     await tx.execute(sql`SELECT 1 FROM knowledge_base WHERE id = ${knowledgeBaseId} FOR UPDATE`)
 
     const kb = await tx
@@ -1083,13 +1087,13 @@ export async function createDocumentRecords(
         sub
       )
       if ('context' in preparedBilling) {
-        storageBilling = {
-          ...preparedBilling,
-          updatedUsage: await incrementStorageUsageForBillingContextInTx(
-            tx,
-            preparedBilling.context,
-            preparedBilling.bytes
-          ),
+        const updatedUsage = await incrementStorageUsageForBillingContextInTx(
+          tx,
+          preparedBilling.context,
+          preparedBilling.bytes
+        )
+        if (updatedUsage !== undefined) {
+          storageNotification = { context: preparedBilling.context, updatedUsage }
         }
       } else {
         const quotaCheck = await checkAndIncrementStorageUsageInTx(
@@ -1101,7 +1105,6 @@ export async function createDocumentRecords(
         if (!quotaCheck.allowed) {
           throw new Error(quotaCheck.error || 'Storage limit exceeded')
         }
-        storageBilling = preparedBilling
       }
     }
 
@@ -1191,13 +1194,13 @@ export async function createDocumentRecords(
         .where(eq(knowledgeBase.id, knowledgeBaseId))
     }
 
-    return returnData
+    return { returnData, storageNotification }
   })
 
-  if (storageBilling && 'context' in storageBilling && storageBilling.updatedUsage !== undefined) {
+  if (storageNotification) {
     void maybeNotifyStorageLimitForBillingContext(
-      storageBilling.context,
-      storageBilling.updatedUsage
+      storageNotification.context,
+      storageNotification.updatedUsage
     )
   }
 
@@ -1520,12 +1523,12 @@ export async function createSingleDocument(
     ...processedTags,
   }
 
-  let storageBilling: DocumentStorageBilling | null = null
-
   const sub =
     documentData.fileSize > 0 ? await resolveQuotaSubscription(knowledgeBaseId, uploadedBy) : null
 
-  await db.transaction(async (tx) => {
+  const storageNotification = await db.transaction(async (tx) => {
+    let storageNotification: DocumentStorageNotification | null = null
+
     await tx.execute(sql`SELECT 1 FROM knowledge_base WHERE id = ${knowledgeBaseId} FOR UPDATE`)
 
     const kb = await tx
@@ -1559,13 +1562,13 @@ export async function createSingleDocument(
         sub
       )
       if ('context' in preparedBilling) {
-        storageBilling = {
-          ...preparedBilling,
-          updatedUsage: await incrementStorageUsageForBillingContextInTx(
-            tx,
-            preparedBilling.context,
-            preparedBilling.bytes
-          ),
+        const updatedUsage = await incrementStorageUsageForBillingContextInTx(
+          tx,
+          preparedBilling.context,
+          preparedBilling.bytes
+        )
+        if (updatedUsage !== undefined) {
+          storageNotification = { context: preparedBilling.context, updatedUsage }
         }
       } else {
         const quotaCheck = await checkAndIncrementStorageUsageInTx(
@@ -1577,7 +1580,6 @@ export async function createSingleDocument(
         if (!quotaCheck.allowed) {
           throw new Error(quotaCheck.error || 'Storage limit exceeded')
         }
-        storageBilling = preparedBilling
       }
     }
 
@@ -1587,12 +1589,14 @@ export async function createSingleDocument(
       .update(knowledgeBase)
       .set({ updatedAt: now })
       .where(eq(knowledgeBase.id, knowledgeBaseId))
+
+    return storageNotification
   })
 
-  if (storageBilling && 'context' in storageBilling && storageBilling.updatedUsage !== undefined) {
+  if (storageNotification) {
     void maybeNotifyStorageLimitForBillingContext(
-      storageBilling.context,
-      storageBilling.updatedUsage
+      storageNotification.context,
+      storageNotification.updatedUsage
     )
   }
 

apps/sim/lib/knowledge/documents/storage-billing.test.ts

@@ -11,6 +11,7 @@ const {
   mockDecrementStorageUsageInTx,
   mockIncrementStorageUsage,
   mockIncrementStorageUsageForBillingContextInTx,
+  mockMaybeNotifyStorageLimitForBillingContext,
   mockResolveStorageBillingContext,
 } = vi.hoisted(() => ({
   mockCheckStorageQuota: vi.fn(),
@@ -19,6 +20,7 @@ const {
   mockDecrementStorageUsageInTx: vi.fn(),
   mockIncrementStorageUsage: vi.fn(),
   mockIncrementStorageUsageForBillingContextInTx: vi.fn(),
+  mockMaybeNotifyStorageLimitForBillingContext: vi.fn(),
   mockResolveStorageBillingContext: vi.fn(),
 }))
 
@@ -31,10 +33,11 @@ vi.mock('@/lib/billing/storage', () => ({
   decrementStorageUsageInTx: mockDecrementStorageUsageInTx,
   incrementStorageUsage: mockIncrementStorageUsage,
   incrementStorageUsageForBillingContextInTx: mockIncrementStorageUsageForBillingContextInTx,
+  maybeNotifyStorageLimitForBillingContext: mockMaybeNotifyStorageLimitForBillingContext,
   resolveStorageBillingContext: mockResolveStorageBillingContext,
 }))
 
-import { createDocumentRecords } from '@/lib/knowledge/documents/service'
+import { createDocumentRecords, createSingleDocument } from '@/lib/knowledge/documents/service'
 
 const STORAGE_CONTEXT = {
   workspaceId: 'workspace-1',
@@ -57,7 +60,8 @@ describe('knowledge document storage attribution', () => {
     ])
     mockResolveStorageBillingContext.mockResolvedValue(STORAGE_CONTEXT)
     mockCheckStorageQuotaForBillingContext.mockResolvedValue({ allowed: true })
-    mockIncrementStorageUsageForBillingContextInTx.mockResolvedValue(undefined)
+    mockIncrementStorageUsageForBillingContextInTx.mockResolvedValue(5)
+    mockMaybeNotifyStorageLimitForBillingContext.mockResolvedValue(undefined)
   })
 
   it.each(['external-collaborator', 'personal-api-key-user'])(
@@ -84,11 +88,45 @@ describe('knowledge document storage attribution', () => {
         STORAGE_CONTEXT,
         5
       )
+      expect(mockMaybeNotifyStorageLimitForBillingContext).toHaveBeenCalledWith(STORAGE_CONTEXT, 5)
       expect(mockCheckStorageQuota).not.toHaveBeenCalled()
       expect(mockIncrementStorageUsage).not.toHaveBeenCalled()
       expect(dbChainMockFns.values).toHaveBeenCalledWith([
         expect.objectContaining({ uploadedBy: actorUserId }),
       ])
     }
   )
+
+  it('notifies the workspace payer after a single document transaction commits', async () => {
+    let transactionCommitted = false
+    dbChainMockFns.transaction.mockImplementationOnce(
+      async (callback: (tx: typeof dbChainMock.db) => unknown) => {
+        const result = await callback(dbChainMock.db)
+        transactionCommitted = true
+        return result
+      }
+    )
+    mockMaybeNotifyStorageLimitForBillingContext.mockImplementationOnce(() => {
+      expect(transactionCommitted).toBe(true)
+    })
+
+    await createSingleDocument(
+      {
+        filename: 'note.txt',
+        fileUrl: 'data:text/plain;base64,SGVsbG8=',
+        fileSize: 5,
+        mimeType: 'text/plain',
+      },
+      'knowledge-base-1',
+      'request-1',
+      'external-collaborator'
+    )
+
+    expect(mockIncrementStorageUsageForBillingContextInTx).toHaveBeenCalledWith(
+      expect.anything(),
+      STORAGE_CONTEXT,
+      5
+    )
+    expect(mockMaybeNotifyStorageLimitForBillingContext).toHaveBeenCalledWith(STORAGE_CONTEXT, 5)
+  })
 })

apps/sim/lib/webhooks/processor.test.ts

@@ -398,6 +398,28 @@ describe('webhook processor execution identity', () => {
     workflowsPersistenceUtilsMockFns.mockBlockExistsInDeployment.mockResolvedValue(true)
   })
 
+  it('normalizes nullable persisted metadata in preprocessing correlation', async () => {
+    const result = await checkWebhookPreprocessing(
+      makeWorkflowRecord({ workspaceId: null }),
+      makeWebhookRecord({ path: null, provider: null }),
+      'request-1'
+    )
+
+    expect(mockPreprocessExecution).toHaveBeenCalledWith(
+      expect.objectContaining({
+        workspaceId: undefined,
+        triggerData: {
+          correlation: expect.objectContaining({
+            path: undefined,
+            provider: undefined,
+          }),
+        },
+      })
+    )
+    expect(result.correlation?.path).toBeUndefined()
+    expect(result.correlation?.provider).toBeUndefined()
+  })
+
   it('reuses preprocessing execution identity when queueing a polling webhook', async () => {
     const expectedCorrelation = {
       executionId: 'generated-execution-id',

apps/sim/lib/webhooks/processor.ts

@@ -560,7 +560,7 @@ export async function verifyProviderAuth(
     try {
       decryptedEnvVars = await getEffectiveDecryptedEnv(
         foundWorkflow.userId,
-        foundWorkflow.workspaceId
+        foundWorkflow.workspaceId ?? undefined
       )
     } catch (error) {
       logger.error(`[${requestId}] Failed to fetch environment variables`, {
@@ -602,8 +602,8 @@ export async function checkWebhookPreprocessing(
       source: 'webhook' as const,
       workflowId: foundWorkflow.id,
       webhookId: foundWebhook.id,
-      path: foundWebhook.path,
-      provider: foundWebhook.provider,
+      path: foundWebhook.path ?? undefined,
+      provider: foundWebhook.provider ?? undefined,
       triggerType: 'webhook',
     }
 
@@ -616,7 +616,7 @@ export async function checkWebhookPreprocessing(
       triggerData: { correlation },
       checkRateLimit: true,
       checkDeployment: true,
-      workspaceId: foundWorkflow.workspaceId,
+      workspaceId: foundWorkflow.workspaceId ?? undefined,
       workflowRecord: foundWorkflow,
     })
 
@@ -1045,7 +1045,7 @@ export async function processPolledWebhookEvent(
         source: 'webhook' as const,
         workflowId: foundWorkflow.id,
         webhookId: foundWebhook.id,
-        path: foundWebhook.path ?? '',
+        path: foundWebhook.path ?? undefined,
         provider,
         triggerType: 'webhook',
       } satisfies AsyncExecutionCorrelation)