refactor(knowledge): declare v2 body lifecycle

Author: TheodoreSpeaks

apps/sim/app/api/v2/knowledge/[id]/documents/route.test.ts

@@ -15,6 +15,7 @@ const {
   mockUploadWorkspaceFile,
   mockPlatformUploaded,
   mockCapture,
+  mockIsPayloadSizeLimitError,
 } = vi.hoisted(() => ({
   mockAuthenticate: vi.fn(),
   mockCheckPreAuth: vi.fn(),
@@ -26,6 +27,7 @@ const {
   mockUploadWorkspaceFile: vi.fn(),
   mockPlatformUploaded: vi.fn(),
   mockCapture: vi.fn(),
+  mockIsPayloadSizeLimitError: vi.fn(),
 }))
 
 vi.mock('@/lib/api/server/routes/v2-api-key-auth', () => ({
@@ -64,7 +66,8 @@ vi.mock('@/lib/knowledge/application/documents', () => ({
 }))
 
 vi.mock('@/lib/core/utils/stream-limits', () => ({
-  isPayloadSizeLimitError: () => false,
+  MAX_MULTIPART_OVERHEAD_BYTES: 1024 * 1024,
+  isPayloadSizeLimitError: mockIsPayloadSizeLimitError,
   readFormDataWithLimit: mockReadFormData,
   readFileToBufferWithLimit: mockReadFile,
 }))
@@ -79,7 +82,10 @@ vi.mock('@/lib/core/telemetry', () => ({
 
 vi.mock('@/lib/posthog/server', () => ({ captureServerEvent: mockCapture }))
 
+import { OrchestrationError } from '@/lib/core/orchestration/types'
 import { KnowledgeUsageLimitExceededError } from '@/lib/knowledge/application/billing'
+import { MAX_KNOWLEDGE_DOCUMENT_FILE_SIZE } from '@/lib/uploads/shared/types'
+import { validateFileType } from '@/lib/uploads/utils/validation'
 import { POST } from '@/app/api/v2/knowledge/[id]/documents/route'
 
 const WORKSPACE_ID = 'workspace-1'
@@ -103,6 +109,7 @@ describe('POST /api/v2/knowledge/[id]/documents', () => {
     vi.clearAllMocks()
     mockCheckPreAuth.mockResolvedValue(RATE_LIMIT_OK)
     mockCheckRateLimit.mockResolvedValue(RATE_LIMIT_OK)
+    mockIsPayloadSizeLimitError.mockReturnValue(false)
     mockAuthenticate.mockResolvedValue({
       principal: PRINCIPAL,
       rolloutUserId: 'user-1',
@@ -184,6 +191,16 @@ describe('POST /api/v2/knowledge/[id]/documents', () => {
       expect.objectContaining({ knowledge_base_id: 'kb-1' }),
       expect.any(Object)
     )
+    expect(mockReadFormData).toHaveBeenCalledWith(request, {
+      maxBytes: MAX_KNOWLEDGE_DOCUMENT_FILE_SIZE + 1024 * 1024,
+      label: 'knowledge document upload body',
+    })
+    expect(mockReadFile).toHaveBeenCalledWith(expect.any(File), {
+      maxBytes: MAX_KNOWLEDGE_DOCUMENT_FILE_SIZE,
+      label: 'knowledge document file',
+    })
+    expect(response.headers.get('cache-control')).toBe('private, no-store')
+    expect(response.headers.get('x-ratelimit-limit')).toBe('100')
   })
 
   it('maps usage admission to the v2 error before multipart buffering', async () => {
@@ -215,4 +232,109 @@ describe('POST /api/v2/knowledge/[id]/documents', () => {
     expect(mockPlatformUploaded).toHaveBeenCalledOnce()
     expect(mockCapture).not.toHaveBeenCalled()
   })
+
+  it('preserves the malformed multipart envelope without transferring storage', async () => {
+    mockReadFormData.mockRejectedValueOnce(new Error('multipart boundary missing'))
+
+    const response = await POST(buildRequest(), { params: Promise.resolve({ id: 'kb-1' }) })
+
+    expect(response.status).toBe(400)
+    expect(await response.json()).toEqual({
+      error: { code: 'BAD_REQUEST', message: 'Request body must be valid multipart form data' },
+    })
+    expect(mockUploadWorkspaceFile).not.toHaveBeenCalled()
+    expect(mockUploadDocument).not.toHaveBeenCalled()
+    expect(mockPlatformUploaded).not.toHaveBeenCalled()
+  })
+
+  it('preserves bounded multipart rejection and stops before storage transfer', async () => {
+    const error = new Error('knowledge document upload body exceeds maximum size')
+    mockReadFormData.mockRejectedValueOnce(error)
+    mockIsPayloadSizeLimitError.mockImplementation((candidate: unknown) => candidate === error)
+
+    const response = await POST(buildRequest(), { params: Promise.resolve({ id: 'kb-1' }) })
+
+    expect(response.status).toBe(413)
+    expect(await response.json()).toEqual({
+      error: { code: 'PAYLOAD_TOO_LARGE', message: error.message },
+    })
+    expect(mockUploadWorkspaceFile).not.toHaveBeenCalled()
+    expect(mockUploadDocument).not.toHaveBeenCalled()
+  })
+
+  it('requires a file form field before storage transfer', async () => {
+    mockReadFormData.mockResolvedValueOnce(new FormData())
+
+    const response = await POST(buildRequest(), { params: Promise.resolve({ id: 'kb-1' }) })
+
+    expect(response.status).toBe(400)
+    expect(await response.json()).toEqual({
+      error: { code: 'BAD_REQUEST', message: 'file form field is required' },
+    })
+    expect(mockUploadWorkspaceFile).not.toHaveBeenCalled()
+  })
+
+  it('preserves the exact file-size rejection before reading file bytes', async () => {
+    const formData = new FormData()
+    const file = new File(['x'], 'large.txt', { type: 'text/plain' })
+    Object.defineProperty(file, 'size', { value: MAX_KNOWLEDGE_DOCUMENT_FILE_SIZE + 1 })
+    formData.set('file', file)
+    mockReadFormData.mockResolvedValueOnce(formData)
+
+    const response = await POST(buildRequest(), { params: Promise.resolve({ id: 'kb-1' }) })
+
+    expect(response.status).toBe(413)
+    expect(await response.json()).toEqual({
+      error: { code: 'PAYLOAD_TOO_LARGE', message: 'File size exceeds 100MB limit (100.00MB)' },
+    })
+    expect(mockReadFile).not.toHaveBeenCalled()
+    expect(mockUploadWorkspaceFile).not.toHaveBeenCalled()
+  })
+
+  it('preserves unsupported file-type validation before reading file bytes', async () => {
+    const formData = new FormData()
+    formData.set('file', new File(['x'], 'malware.exe', { type: 'application/octet-stream' }))
+    mockReadFormData.mockResolvedValueOnce(formData)
+    const expectedMessage = validateFileType('malware.exe', 'application/octet-stream')?.message
+    if (!expectedMessage) throw new Error('Expected unsupported file type validation to fail')
+
+    const response = await POST(buildRequest(), { params: Promise.resolve({ id: 'kb-1' }) })
+
+    expect(response.status).toBe(415)
+    expect(await response.json()).toEqual({
+      error: { code: 'UNSUPPORTED_MEDIA_TYPE', message: expectedMessage },
+    })
+    expect(mockReadFile).not.toHaveBeenCalled()
+    expect(mockUploadWorkspaceFile).not.toHaveBeenCalled()
+  })
+
+  it('does not register or emit effects when storage transfer fails', async () => {
+    mockUploadWorkspaceFile.mockRejectedValueOnce(new Error('storage unavailable'))
+
+    const response = await POST(buildRequest(), { params: Promise.resolve({ id: 'kb-1' }) })
+
+    expect(response.status).toBe(500)
+    expect(await response.json()).toEqual({
+      error: { code: 'INTERNAL_ERROR', message: 'Internal server error' },
+    })
+    expect(mockUploadDocument).not.toHaveBeenCalled()
+    expect(mockPlatformUploaded).not.toHaveBeenCalled()
+    expect(mockCapture).not.toHaveBeenCalled()
+  })
+
+  it('preserves application authorization errors after storage transfer', async () => {
+    mockUploadDocument.mockRejectedValueOnce(
+      new OrchestrationError('forbidden', 'Insufficient workspace permissions')
+    )
+
+    const response = await POST(buildRequest(), { params: Promise.resolve({ id: 'kb-1' }) })
+
+    expect(response.status).toBe(403)
+    expect(await response.json()).toEqual({
+      error: { code: 'FORBIDDEN', message: 'Insufficient workspace permissions' },
+    })
+    expect(mockUploadWorkspaceFile).toHaveBeenCalledOnce()
+    expect(mockPlatformUploaded).not.toHaveBeenCalled()
+    expect(mockCapture).not.toHaveBeenCalled()
+  })
 })