chore: import upstream snapshot with attribution

apps/sim/app/api/table/[tableId]/export-async/route.test.ts

@@ -0,0 +1,128 @@
+/**
+ * @vitest-environment node
+ */
+import { hybridAuthMockFns } from '@sim/testing'
+import { NextRequest } from 'next/server'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { TableDefinition } from '@/lib/table'
+
+const { mockCheckAccess, mockMarkTableJobRunning, mockRunTableExport } = vi.hoisted(() => ({
+  mockCheckAccess: vi.fn(),
+  mockMarkTableJobRunning: vi.fn(),
+  mockRunTableExport: vi.fn(),
+}))
+
+vi.mock('@sim/utils/id', () => ({
+  generateId: vi.fn().mockReturnValue('job-id-xyz'),
+  generateShortId: vi.fn().mockReturnValue('short-id'),
+}))
+vi.mock('@/lib/table/jobs/service', () => ({ markTableJobRunning: mockMarkTableJobRunning }))
+vi.mock('@/lib/table/export-runner', () => ({ runTableExport: mockRunTableExport }))
+vi.mock('@/lib/core/utils/background', () => ({
+  runDetached: (_label: string, work: () => Promise<unknown>) => {
+    void work()
+  },
+}))
+vi.mock('@/app/api/table/utils', async () => {
+  const { NextResponse } = await import('next/server')
+  return {
+    checkAccess: mockCheckAccess,
+    accessError: (result: { status: number }) =>
+      NextResponse.json({ error: 'denied' }, { status: result.status }),
+  }
+})
+
+import { POST } from '@/app/api/table/[tableId]/export-async/route'
+
+function buildTable(overrides: Partial<TableDefinition> = {}): TableDefinition {
+  return {
+    id: 'tbl_1',
+    name: 'People',
+    description: null,
+    schema: { columns: [{ name: 'name', type: 'string' }] },
+    metadata: null,
+    rowCount: 50000,
+    maxRows: 1_000_000,
+    workspaceId: 'workspace-1',
+    createdBy: 'user-1',
+    archivedAt: null,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    ...overrides,
+  }
+}
+
+function makeRequest(body: unknown, tableId = 'tbl_1') {
+  const req = new NextRequest(`http://localhost:3000/api/table/${tableId}/export-async`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  })
+  return POST(req, { params: Promise.resolve({ tableId }) })
+}
+
+const validBody = { workspaceId: 'workspace-1', format: 'csv' }
+
+describe('POST /api/table/[tableId]/export-async', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    hybridAuthMockFns.mockCheckSessionOrInternalAuth.mockResolvedValue({
+      success: true,
+      userId: 'user-1',
+      authType: 'session',
+    })
+    mockCheckAccess.mockResolvedValue({ ok: true, table: buildTable() })
+    mockMarkTableJobRunning.mockResolvedValue(true)
+    mockRunTableExport.mockResolvedValue(undefined)
+  })
+
+  it('claims an export job and kicks off the worker', async () => {
+    const response = await makeRequest(validBody)
+    const data = await response.json()
+
+    expect(response.status).toBe(200)
+    expect(data.data).toEqual({ tableId: 'tbl_1', jobId: 'job-id-xyz' })
+    expect(mockMarkTableJobRunning).toHaveBeenCalledWith('tbl_1', 'job-id-xyz', 'export', {
+      format: 'csv',
+    })
+    expect(mockRunTableExport).toHaveBeenCalledWith({
+      jobId: 'job-id-xyz',
+      tableId: 'tbl_1',
+      workspaceId: 'workspace-1',
+      format: 'csv',
+    })
+  })
+
+  it('defaults the format to csv', async () => {
+    const response = await makeRequest({ workspaceId: 'workspace-1' })
+    expect(response.status).toBe(200)
+    expect(mockRunTableExport).toHaveBeenCalledWith(expect.objectContaining({ format: 'csv' }))
+  })
+
+  it('returns 409 when the claim fails', async () => {
+    mockMarkTableJobRunning.mockResolvedValue(false)
+    const response = await makeRequest(validBody)
+    expect(response.status).toBe(409)
+    expect(mockRunTableExport).not.toHaveBeenCalled()
+  })
+
+  it('returns 401 when unauthenticated', async () => {
+    hybridAuthMockFns.mockCheckSessionOrInternalAuth.mockResolvedValue({ success: false })
+    const response = await makeRequest(validBody)
+    expect(response.status).toBe(401)
+    expect(mockMarkTableJobRunning).not.toHaveBeenCalled()
+  })
+
+  it('returns the access error status when access is denied', async () => {
+    mockCheckAccess.mockResolvedValue({ ok: false, status: 403 })
+    const response = await makeRequest(validBody)
+    expect(response.status).toBe(403)
+    expect(mockRunTableExport).not.toHaveBeenCalled()
+  })
+
+  it('returns 400 on workspace mismatch', async () => {
+    const response = await makeRequest({ ...validBody, workspaceId: 'other-ws' })
+    expect(response.status).toBe(400)
+    expect(mockMarkTableJobRunning).not.toHaveBeenCalled()
+  })
+})

apps/sim/app/api/table/[tableId]/export-async/route.ts

@@ -0,0 +1,113 @@
+import { AuditAction, AuditResourceType, recordAudit } from '@sim/audit'
+import { createLogger } from '@sim/logger'
+import { generateId } from '@sim/utils/id'
+import { type NextRequest, NextResponse } from 'next/server'
+import { exportTableAsyncContract } from '@/lib/api/contracts/tables'
+import { parseRequest } from '@/lib/api/server'
+import { checkSessionOrInternalAuth } from '@/lib/auth/hybrid'
+import { isTriggerDevEnabled } from '@/lib/core/config/env-flags'
+import { runDetached } from '@/lib/core/utils/background'
+import { generateRequestId } from '@/lib/core/utils/request'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { captureServerEvent } from '@/lib/posthog/server'
+import { runTableExport, type TableExportPayload } from '@/lib/table/export-runner'
+import { markTableJobRunning, releaseJobClaim } from '@/lib/table/jobs/service'
+import type { TableExportJobPayload } from '@/lib/table/types'
+import { accessError, checkAccess } from '@/app/api/table/utils'
+
+const logger = createLogger('TableExportAsync')
+
+export const runtime = 'nodejs'
+export const dynamic = 'force-dynamic'
+
+interface RouteParams {
+  params: Promise<{ tableId: string }>
+}
+
+/**
+ * POST /api/table/[tableId]/export-async
+ *
+ * Kicks off a background export for large tables (small ones stream synchronously via `/export`).
+ * Export jobs are read-only, so they bypass the one-running-job-per-table gate (the partial-unique
+ * index excludes `type = 'export'`) — an export can run alongside an import or delete, and the
+ * delete-mask keeps a mid-delete export consistent with the delete's outcome.
+ */
+export const POST = withRouteHandler(async (request: NextRequest, { params }: RouteParams) => {
+  const requestId = generateRequestId()
+
+  const authResult = await checkSessionOrInternalAuth(request, { requireWorkflowId: false })
+  if (!authResult.success || !authResult.userId) {
+    return NextResponse.json({ error: 'Authentication required' }, { status: 401 })
+  }
+
+  const parsed = await parseRequest(exportTableAsyncContract, request, { params })
+  if (!parsed.success) return parsed.response
+  const { tableId } = parsed.data.params
+  const { workspaceId, format } = parsed.data.body
+
+  const access = await checkAccess(tableId, authResult.userId, 'read')
+  if (!access.ok) return accessError(access, requestId, tableId)
+  if (access.table.workspaceId !== workspaceId) {
+    return NextResponse.json({ error: 'Invalid workspace ID' }, { status: 400 })
+  }
+
+  const jobId = generateId()
+  const jobPayload: TableExportJobPayload = { format }
+  const claimed = await markTableJobRunning(tableId, jobId, 'export', jobPayload)
+  if (!claimed) {
+    // Only possible against another running *export*-typed insert race losing on the pkey, or a
+    // missing table — the active-job index excludes exports.
+    return NextResponse.json({ error: 'Failed to start export' }, { status: 409 })
+  }
+
+  const payload: TableExportPayload = {
+    jobId,
+    tableId,
+    workspaceId,
+    format,
+  }
+  if (isTriggerDevEnabled) {
+    try {
+      const [{ tableExportTask }, { tasks }, { resolveTriggerRegion }] = await Promise.all([
+        import('@/background/table-export'),
+        import('@trigger.dev/sdk'),
+        import('@/lib/core/async-jobs/region'),
+      ])
+      await tasks.trigger<typeof tableExportTask>('table-export', payload, {
+        tags: [`tableId:${tableId}`, `jobId:${jobId}`],
+        region: await resolveTriggerRegion(),
+      })
+    } catch (error) {
+      // A failed dispatch must not leave a ghost `running` job holding the
+      // table's one-write-job slot until the stale-job janitor fires.
+      await releaseJobClaim(tableId, jobId).catch(() => {})
+      throw error
+    }
+  } else {
+    runDetached('table-export', () => runTableExport(payload))
+  }
+
+  // Audit at authorization (like the sync route) so a failed/abandoned job still records the export.
+  recordAudit({
+    workspaceId,
+    actorId: authResult.userId,
+    action: AuditAction.TABLE_EXPORTED,
+    resourceType: AuditResourceType.TABLE,
+    resourceId: tableId,
+    resourceName: access.table.name,
+    description: `Exported table "${access.table.name}" as ${format.toUpperCase()}`,
+    metadata: { format, rowCount: access.table.rowCount, async: true },
+    request,
+  })
+  if (access.table.workspaceId) {
+    captureServerEvent(
+      authResult.userId,
+      'table_exported',
+      { table_id: tableId, workspace_id: workspaceId },
+      { groups: { workspace: workspaceId } }
+    )
+  }
+
+  logger.info(`[${requestId}] Async export started`, { tableId, jobId, format })
+  return NextResponse.json({ success: true, data: { tableId, jobId } })
+})