chore: import upstream snapshot with attribution

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

@@ -0,0 +1,236 @@
+import { AuditAction, AuditResourceType, recordAudit } from '@sim/audit'
+import { type NextRequest, NextResponse } from 'next/server'
+import {
+  v1ListKnowledgeDocumentsContract,
+  v1UploadKnowledgeDocumentContract,
+} from '@/lib/api/contracts/v1/knowledge'
+import { parseRequest } from '@/lib/api/server'
+import { checkActorUsageLimits } from '@/lib/billing/calculations/usage-monitor'
+import {
+  isPayloadSizeLimitError,
+  MAX_MULTIPART_OVERHEAD_BYTES,
+  readFormDataWithLimit,
+} from '@/lib/core/utils/stream-limits'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import {
+  createSingleDocument,
+  type DocumentData,
+  getDocuments,
+  processDocumentsWithQueue,
+} from '@/lib/knowledge/documents/service'
+import type { DocumentSortField, SortOrder } from '@/lib/knowledge/documents/types'
+import { uploadWorkspaceFile } from '@/lib/uploads/contexts/workspace'
+import { validateFileType } from '@/lib/uploads/utils/validation'
+import { handleError, resolveKnowledgeBase, serializeDate } from '@/app/api/v1/knowledge/utils'
+import { authenticateRequest } from '@/app/api/v1/middleware'
+
+export const dynamic = 'force-dynamic'
+export const revalidate = 0
+
+const MAX_FILE_SIZE = 100 * 1024 * 1024 // 100MB
+
+interface DocumentsRouteParams {
+  params: Promise<{ id: string }>
+}
+
+/** GET /api/v1/knowledge/[id]/documents — List documents in a knowledge base. */
+export const GET = withRouteHandler(async (request: NextRequest, context: DocumentsRouteParams) => {
+  const auth = await authenticateRequest(request, 'knowledge-detail')
+  if (auth instanceof NextResponse) return auth
+  const { requestId, userId, rateLimit } = auth
+
+  try {
+    const parsed = await parseRequest(v1ListKnowledgeDocumentsContract, request, context)
+    if (!parsed.success) return parsed.response
+
+    const { workspaceId, limit, offset, search, enabledFilter, sortBy, sortOrder } =
+      parsed.data.query
+    const { id: knowledgeBaseId } = parsed.data.params
+
+    const result = await resolveKnowledgeBase(knowledgeBaseId, workspaceId, userId, rateLimit)
+    if (result instanceof NextResponse) return result
+
+    const documentsResult = await getDocuments(
+      knowledgeBaseId,
+      {
+        enabledFilter: enabledFilter === 'all' ? undefined : enabledFilter,
+        search,
+        limit,
+        offset,
+        sortBy: sortBy as DocumentSortField,
+        sortOrder: sortOrder as SortOrder,
+      },
+      requestId
+    )
+
+    return NextResponse.json({
+      success: true,
+      data: {
+        documents: documentsResult.documents.map((doc) => ({
+          id: doc.id,
+          knowledgeBaseId,
+          filename: doc.filename,
+          fileSize: doc.fileSize,
+          mimeType: doc.mimeType,
+          processingStatus: doc.processingStatus,
+          chunkCount: doc.chunkCount,
+          tokenCount: doc.tokenCount,
+          characterCount: doc.characterCount,
+          enabled: doc.enabled,
+          createdAt: serializeDate(doc.uploadedAt),
+        })),
+        pagination: documentsResult.pagination,
+      },
+    })
+  } catch (error) {
+    return handleError(requestId, error, 'Failed to list documents')
+  }
+})
+
+/** POST /api/v1/knowledge/[id]/documents — Upload a document to a knowledge base. */
+export const POST = withRouteHandler(
+  async (request: NextRequest, context: DocumentsRouteParams) => {
+    const auth = await authenticateRequest(request, 'knowledge-detail')
+    if (auth instanceof NextResponse) return auth
+    const { requestId, userId, rateLimit } = auth
+
+    try {
+      const parsed = await parseRequest(v1UploadKnowledgeDocumentContract, request, context)
+      if (!parsed.success) return parsed.response
+      const { id: knowledgeBaseId } = parsed.data.params
+
+      let formData: FormData
+      try {
+        formData = await readFormDataWithLimit(request, {
+          maxBytes: MAX_FILE_SIZE + MAX_MULTIPART_OVERHEAD_BYTES,
+          label: 'knowledge document upload body',
+        })
+      } catch (error) {
+        if (isPayloadSizeLimitError(error)) {
+          return NextResponse.json({ error: error.message }, { status: 413 })
+        }
+        return NextResponse.json(
+          { error: 'Request body must be valid multipart form data' },
+          { status: 400 }
+        )
+      }
+
+      const rawFile = formData.get('file')
+      const file = rawFile instanceof File ? rawFile : null
+      const rawWorkspaceId = formData.get('workspaceId')
+      const workspaceId = typeof rawWorkspaceId === 'string' ? rawWorkspaceId : null
+
+      if (!workspaceId) {
+        return NextResponse.json({ error: 'workspaceId form field is required' }, { status: 400 })
+      }
+
+      if (!file) {
+        return NextResponse.json({ error: 'file form field is required' }, { status: 400 })
+      }
+
+      if (file.size > MAX_FILE_SIZE) {
+        return NextResponse.json(
+          {
+            error: `File size exceeds 100MB limit (${(file.size / (1024 * 1024)).toFixed(2)}MB)`,
+          },
+          { status: 413 }
+        )
+      }
+
+      const fileTypeError = validateFileType(file.name, file.type || '')
+      if (fileTypeError) {
+        return NextResponse.json({ error: fileTypeError.message }, { status: 415 })
+      }
+
+      const result = await resolveKnowledgeBase(
+        knowledgeBaseId,
+        workspaceId,
+        userId,
+        rateLimit,
+        'write'
+      )
+      if (result instanceof NextResponse) return result
+
+      // Fast usage gate before the storage write + indexing (the async backstop
+      // in processDocumentAsync still covers non-HTTP paths).
+      const usage = await checkActorUsageLimits(userId, workspaceId)
+      if (usage.isExceeded) {
+        return NextResponse.json(
+          {
+            error: usage.message || 'Usage limit exceeded. Please upgrade your plan to continue.',
+          },
+          { status: 402 }
+        )
+      }
+
+      const buffer = Buffer.from(await file.arrayBuffer())
+      const contentType = file.type || 'application/octet-stream'
+
+      const uploadedFile = await uploadWorkspaceFile(
+        workspaceId,
+        userId,
+        buffer,
+        file.name,
+        contentType
+      )
+
+      const newDocument = await createSingleDocument(
+        {
+          filename: file.name,
+          fileUrl: uploadedFile.url,
+          fileSize: file.size,
+          mimeType: contentType,
+        },
+        knowledgeBaseId,
+        requestId,
+        userId
+      )
+
+      const documentData: DocumentData = {
+        documentId: newDocument.id,
+        filename: file.name,
+        fileUrl: uploadedFile.url,
+        fileSize: file.size,
+        mimeType: contentType,
+      }
+
+      processDocumentsWithQueue([documentData], knowledgeBaseId, {}, requestId).catch(() => {
+        // Processing errors are logged internally
+      })
+
+      recordAudit({
+        workspaceId,
+        actorId: userId,
+        action: AuditAction.DOCUMENT_UPLOADED,
+        resourceType: AuditResourceType.DOCUMENT,
+        resourceId: newDocument.id,
+        resourceName: file.name,
+        description: `Uploaded document "${file.name}" to knowledge base via API`,
+        metadata: { knowledgeBaseId, fileSize: file.size, mimeType: contentType },
+        request,
+      })
+
+      return NextResponse.json({
+        success: true,
+        data: {
+          document: {
+            id: newDocument.id,
+            knowledgeBaseId,
+            filename: newDocument.filename,
+            fileSize: newDocument.fileSize,
+            mimeType: newDocument.mimeType,
+            processingStatus: 'pending',
+            chunkCount: 0,
+            tokenCount: 0,
+            characterCount: 0,
+            enabled: newDocument.enabled,
+            createdAt: serializeDate(newDocument.uploadedAt),
+          },
+          message: 'Document uploaded successfully. Processing will begin shortly.',
+        },
+      })
+    } catch (error) {
+      return handleError(requestId, error, 'Failed to upload document')
+    }
+  }
+)