chore: import upstream snapshot with attribution

apps/sim/app/api/table/[tableId]/job/cancel/route.test.ts

@@ -0,0 +1,113 @@
+/**
+ * @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, mockMarkJobCanceled, mockGetTableJob, mockAppendTableEvent } = vi.hoisted(
+  () => ({
+    mockCheckAccess: vi.fn(),
+    mockMarkJobCanceled: vi.fn(),
+    mockGetTableJob: vi.fn(),
+    mockAppendTableEvent: vi.fn(),
+  })
+)
+
+vi.mock('@/lib/table/jobs/service', () => ({
+  markJobCanceled: mockMarkJobCanceled,
+  getTableJob: mockGetTableJob,
+}))
+vi.mock('@/lib/table/events', () => ({ appendTableEvent: mockAppendTableEvent }))
+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]/job/cancel/route'
+
+function buildTable(overrides: Partial<TableDefinition> = {}): TableDefinition {
+  return {
+    id: 'tbl_1',
+    name: 'People',
+    description: null,
+    schema: { columns: [] },
+    metadata: null,
+    rowCount: 0,
+    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}/job/cancel`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  })
+  return POST(req, { params: Promise.resolve({ tableId }) })
+}
+
+const validBody = { workspaceId: 'workspace-1', jobId: 'job_1' }
+
+describe('POST /api/table/[tableId]/job/cancel', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    hybridAuthMockFns.mockCheckSessionOrInternalAuth.mockResolvedValue({
+      success: true,
+      userId: 'user-1',
+      authType: 'session',
+    })
+    mockCheckAccess.mockResolvedValue({ ok: true, table: buildTable() })
+    mockMarkJobCanceled.mockResolvedValue(true)
+    mockGetTableJob.mockResolvedValue({
+      id: 'job_1',
+      type: 'delete',
+      status: 'running',
+      payload: null,
+    })
+  })
+
+  it('cancels the job and emits a typed cancel event', async () => {
+    const response = await makeRequest(validBody)
+    const data = await response.json()
+
+    expect(response.status).toBe(200)
+    expect(data.data).toEqual({ canceled: true })
+    expect(mockMarkJobCanceled).toHaveBeenCalledWith('tbl_1', 'job_1')
+    expect(mockAppendTableEvent).toHaveBeenCalledWith(
+      expect.objectContaining({ kind: 'job', type: 'delete', status: 'canceled', jobId: 'job_1' })
+    )
+  })
+
+  it('does not emit an event when nothing was running', async () => {
+    mockMarkJobCanceled.mockResolvedValue(false)
+    const response = await makeRequest(validBody)
+    const data = await response.json()
+    expect(data.data).toEqual({ canceled: false })
+    expect(mockAppendTableEvent).not.toHaveBeenCalled()
+  })
+
+  it('returns 401 when unauthenticated', async () => {
+    hybridAuthMockFns.mockCheckSessionOrInternalAuth.mockResolvedValue({ success: false })
+    const response = await makeRequest(validBody)
+    expect(response.status).toBe(401)
+    expect(mockMarkJobCanceled).not.toHaveBeenCalled()
+  })
+
+  it('returns 400 on workspace mismatch', async () => {
+    const response = await makeRequest({ ...validBody, workspaceId: 'other' })
+    expect(response.status).toBe(400)
+    expect(mockMarkJobCanceled).not.toHaveBeenCalled()
+  })
+})

apps/sim/app/api/table/[tableId]/job/cancel/route.ts

@@ -0,0 +1,60 @@
+import { createLogger } from '@sim/logger'
+import { type NextRequest, NextResponse } from 'next/server'
+import { cancelTableJobContract } from '@/lib/api/contracts/tables'
+import { parseRequest } from '@/lib/api/server'
+import { checkSessionOrInternalAuth } from '@/lib/auth/hybrid'
+import { generateRequestId } from '@/lib/core/utils/request'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { appendTableEvent } from '@/lib/table/events'
+import { getTableJob, markJobCanceled } from '@/lib/table/jobs/service'
+import type { TableJobType } from '@/lib/table/types'
+import { accessError, checkAccess } from '@/app/api/table/utils'
+
+const logger = createLogger('TableJobCancelAPI')
+
+export const runtime = 'nodejs'
+export const dynamic = 'force-dynamic'
+
+interface RouteParams {
+  params: Promise<{ tableId: string }>
+}
+
+/**
+ * POST /api/table/[tableId]/job/cancel
+ *
+ * Cancels an in-flight async table job (import or delete). Flips the table's job status to
+ * `canceled`, which makes the detached worker's next ownership check fail so it stops. Committed
+ * work (inserted/deleted rows) is left in place (no rollback). No-op if the job already finished.
+ */
+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(cancelTableJobContract, request, { params })
+  if (!parsed.success) return parsed.response
+  const { tableId } = parsed.data.params
+  const { workspaceId, jobId } = parsed.data.body
+
+  const access = await checkAccess(tableId, authResult.userId, 'write')
+  if (!access.ok) return accessError(access, requestId, tableId)
+  if (access.table.workspaceId !== workspaceId) {
+    return NextResponse.json({ error: 'Invalid workspace ID' }, { status: 400 })
+  }
+
+  // Resolve the job's actual type (from its own row — the table-level derivation excludes
+  // exports) so the cancel event carries the right `type`.
+  const job = await getTableJob(tableId, jobId)
+  const type = (job?.type ?? 'import') as TableJobType
+
+  const canceled = await markJobCanceled(tableId, jobId)
+  if (canceled) {
+    void appendTableEvent({ kind: 'job', type, tableId, jobId, status: 'canceled' })
+  }
+  logger.info(`[${requestId}] Job cancel requested`, { tableId, jobId, type, canceled })
+
+  return NextResponse.json({ success: true, data: { canceled } })
+})