fix(tables): map typed service errors in the import routes' own catches

The append branch returns instead of rethrowing, so nothing the outer catch
does applies to it. addTableColumnsWithTx runs inside importAppendRows, so
the column cap and an invalid column name surfaced there as a generic 500
with the real reason replaced by 'Failed to import CSV'.

Extract tableRequestErrorResponse alongside the existing rowWriteErrorResponse
funnel and call it from all three catches (both import routes), so a new
service validation message is classified the day it is added rather than when
someone remembers to extend a substring list.

Author: waleedlatif1

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

@@ -5,6 +5,7 @@ import { hybridAuthMockFns } from '@sim/testing'
 import { NextRequest } from 'next/server'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import type { TableDefinition } from '@/lib/table'
+import { TableRequestError } from '@/lib/table/errors'
 
 const {
   mockCheckAccess,
@@ -32,6 +33,7 @@ vi.mock('@sim/utils/id', () => ({
 vi.mock('@/app/api/table/utils', async () => {
   const { NextResponse } = await import('next/server')
   const { TableLockedError } = await import('@/lib/table/mutation-locks')
+  const { TableRequestError } = await import('@/lib/table/errors')
   return {
     checkAccess: mockCheckAccess,
     accessError: (result: { status: number }) => {
@@ -43,6 +45,10 @@ vi.mock('@/app/api/table/utils', async () => {
       error instanceof TableLockedError
         ? NextResponse.json({ error: error.message, lock: error.lock }, { status: 423 })
         : null,
+    tableRequestErrorResponse: (error: unknown) =>
+      error instanceof TableRequestError
+        ? NextResponse.json({ error: error.message }, { status: error.status })
+        : null,
     multipartErrorResponse: (error: { code: string; message: string }) =>
       NextResponse.json(
         { error: error.message },
@@ -316,6 +322,43 @@ describe('POST /api/table/[tableId]/import', () => {
     expect(mockImportAppendRows).not.toHaveBeenCalled()
   })
 
+  /**
+   * `addTableColumnsWithTx` runs INSIDE `importAppendRows`, so the service's own
+   * typed failures surface in the append catch — which returns instead of
+   * rethrowing, so nothing the outer catch does applies. Without the explicit
+   * mapping there, the column cap and an invalid column type both come back as
+   * a 500 whose real reason has been replaced by 'Failed to import CSV'.
+   */
+  it.each([
+    ['the column cap', 'Adding 2 column(s) would exceed maximum column limit (100)'],
+    ['an invalid column type', 'Invalid column type "sometype". Must be one of: string, number'],
+  ])('surfaces %s from an append as the service status', async (_label, message) => {
+    mockImportAppendRows.mockRejectedValueOnce(new TableRequestError(message))
+    const response = await callPost(
+      createFormData(createCsvFile('name,age\nAlice,30'), { mode: 'append' })
+    )
+    expect(response.status).toBe(400)
+    expect((await response.json()).error).toBe(message)
+  })
+
+  it('keeps a 404 from an append a 404 rather than flattening it to 400', async () => {
+    mockImportAppendRows.mockRejectedValueOnce(new TableRequestError('Table not found', 404))
+    const response = await callPost(
+      createFormData(createCsvFile('name,age\nAlice,30'), { mode: 'append' })
+    )
+    expect(response.status).toBe(404)
+    expect((await response.json()).error).toBe('Table not found')
+  })
+
+  it('still returns a generic 500 for an append failure the service did not type', async () => {
+    mockImportAppendRows.mockRejectedValueOnce(new Error('connection terminated unexpectedly'))
+    const response = await callPost(
+      createFormData(createCsvFile('name,age\nAlice,30'), { mode: 'append' })
+    )
+    expect(response.status).toBe(500)
+    expect((await response.json()).error).toBe('Failed to import CSV')
+  })
+
   it('replaces rows via importReplaceRows', async () => {
     mockImportReplaceRows.mockResolvedValueOnce({ deletedCount: 5, insertedCount: 2 })
     const response = await callPost(

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

@@ -37,7 +37,6 @@ import {
   wouldExceedRowLimit,
 } from '@/lib/table'
 import { sniffCsvDelimiterFromStream } from '@/lib/table/csv-delimiter-stream'
-import { TableRequestError } from '@/lib/table/errors'
 import { signalTableSchemaChanged } from '@/lib/table/events'
 import { importAppendRows, importReplaceRows } from '@/lib/table/import-data'
 import { getUserSettings } from '@/lib/users/queries'
@@ -47,6 +46,7 @@ import {
   csvProxyBodyCapResponse,
   multipartErrorResponse,
   tableLockErrorResponse,
+  tableRequestErrorResponse,
 } from '@/app/api/table/utils'
 
 const logger = createLogger('TableImportCSVExisting')
@@ -346,11 +346,17 @@ export const POST = withRouteHandler(async (request: NextRequest, { params }: Ro
           },
         })
       } catch (err) {
-        // This branch returns rather than rethrowing, so the outer catch's
-        // mapper is unreachable from here — map the lock error first or a 423
-        // degrades into a generic 500 (replace mode rethrows and maps fine).
+        // This branch returns rather than rethrowing, so NOTHING in the outer
+        // catch runs for an append failure — every mapper it applies has to be
+        // repeated here (replace mode rethrows and maps fine). A 423 lock
+        // violation and the service's own typed failures both degrade into a
+        // generic 500 without these two lines: `addTableColumnsWithTx` runs
+        // INSIDE `importAppendRows`, so an invalid column name or the column
+        // cap surfaces here, not out there.
         const lockError = tableLockErrorResponse(err)
         if (lockError) return lockError
+        const requestError = tableRequestErrorResponse(err)
+        if (requestError) return requestError
 
         const message = toError(err).message
         logger.warn(`[${requestId}] Append failed for table ${tableId}`, {
@@ -437,9 +443,8 @@ export const POST = withRouteHandler(async (request: NextRequest, { params }: Ro
     // is not table-aware — but the service's own validation (an invalid column
     // type, the column cap) matched none of those strings and was reported as a
     // 500 with the message swallowed.
-    if (error instanceof TableRequestError) {
-      return NextResponse.json({ error: error.message }, { status: error.status })
-    }
+    const requestError = tableRequestErrorResponse(error)
+    if (requestError) return requestError
 
     const isClientError =
       message.includes('CSV file has no') ||

apps/sim/app/api/table/import-csv/route.test.ts

@@ -32,6 +32,7 @@ vi.mock('@/lib/table/rows/service', () => ({
 vi.mock('@/lib/table/billing', () => ({ getWorkspaceTableLimits: mockGetLimits }))
 vi.mock('@/app/api/table/utils', async () => {
   const { NextResponse } = await import('next/server')
+  const { TableRequestError } = await import('@/lib/table/errors')
   return {
     normalizeColumn: (column: unknown) => column,
     csvProxyBodyCapResponse: () => null,
@@ -40,6 +41,10 @@ vi.mock('@/app/api/table/utils', async () => {
         { error: error.message },
         { status: error.code === 'FILE_TOO_LARGE' ? 413 : 400 }
       ),
+    tableRequestErrorResponse: (error: unknown) =>
+      error instanceof TableRequestError
+        ? NextResponse.json({ error: error.message }, { status: error.status })
+        : null,
     rowWriteErrorResponse: (error: unknown) => {
       const message = getErrorMessage(error)
       return message.includes('row limit')
@@ -50,6 +55,7 @@ vi.mock('@/app/api/table/utils', async () => {
 })
 vi.mock('@/lib/workspaces/permissions/utils', () => permissionsMock)
 
+import { TableRequestError } from '@/lib/table/errors'
 import { POST } from '@/app/api/table/import-csv/route'
 
 type Part =
@@ -193,6 +199,20 @@ describe('POST /api/table/import-csv', () => {
     expect(data.error).toMatch(/row limit/)
   })
 
+  /**
+   * `createTable` validates the name, the schema, the per-column rules, and both
+   * plan caps. The substring list in this route's catch named only some of those
+   * messages, so the rest reached the client as a generic 500.
+   */
+  it('surfaces a typed createTable failure the substring list never named', async () => {
+    const message = 'Column name exceeds maximum length (64 characters)'
+    mockCreateTable.mockRejectedValueOnce(new TableRequestError(message))
+    const response = await POST(makeRequest(uploadParts(csvWithRows(5))))
+
+    expect(response.status).toBe(400)
+    expect((await response.json()).error).toBe(message)
+  })
+
   it('rolls back the created table when a batch insert fails mid-stream', async () => {
     mockBatchInsertRows
       .mockResolvedValueOnce(Array.from({ length: 100 }, () => ({ id: 'row' })))

apps/sim/app/api/table/import-csv/route.ts

@@ -35,6 +35,7 @@ import {
   multipartErrorResponse,
   normalizeColumn,
   rowWriteErrorResponse,
+  tableRequestErrorResponse,
 } from '@/app/api/table/utils'
 
 const logger = createLogger('TableImportCSV')
@@ -254,6 +255,11 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
     const rowWriteError = rowWriteErrorResponse(error)
     if (rowWriteError) return rowWriteError
 
+    // `createTable` validates the name, the schema, the per-column rules, and
+    // both plan caps — most of which the substring list below never named.
+    const requestError = tableRequestErrorResponse(error)
+    if (requestError) return requestError
+
     const message = toError(error).message
     const isClientError =
       message.includes('maximum table limit') ||

apps/sim/app/api/table/utils.test.ts

@@ -3,8 +3,14 @@
  */
 import { describe, expect, it } from 'vitest'
 import { TableRowLimitError } from '@/lib/table/billing'
+import { TableRequestError } from '@/lib/table/errors'
 import type { ColumnDefinition } from '@/lib/table/types'
-import { rootErrorMessage, rowWriteErrorResponse, tableFilterError } from '@/app/api/table/utils'
+import {
+  rootErrorMessage,
+  rowWriteErrorResponse,
+  tableFilterError,
+  tableRequestErrorResponse,
+} from '@/app/api/table/utils'
 
 /** Mimics drizzle's DrizzleQueryError: message is the failed SQL, real error on `cause`. */
 function wrapLikeDrizzle(cause: Error): Error {
@@ -55,6 +61,34 @@ describe('rowWriteErrorResponse', () => {
   })
 })
 
+/**
+ * The service classifies its own failures, so callers must not re-derive the
+ * verdict from message text. These cases are exactly the ones no substring list
+ * named — which is how they reached clients as a generic 500.
+ */
+describe('tableRequestErrorResponse', () => {
+  it('carries the service message at the status the service chose', async () => {
+    const response = tableRequestErrorResponse(
+      new TableRequestError('Adding 2 column(s) would exceed maximum column limit (100)')
+    )
+    expect(response?.status).toBe(400)
+    const body = await response?.json()
+    expect(body.error).toBe('Adding 2 column(s) would exceed maximum column limit (100)')
+  })
+
+  it('preserves a 404 rather than flattening every typed failure to 400', () => {
+    expect(tableRequestErrorResponse(new TableRequestError('Table not found', 404))?.status).toBe(
+      404
+    )
+  })
+
+  it('returns null for anything the service did not type', () => {
+    expect(tableRequestErrorResponse(new Error('connection refused'))).toBeNull()
+    expect(tableRequestErrorResponse(new TableRowLimitError(10000))).toBeNull()
+    expect(tableRequestErrorResponse('not an error')).toBeNull()
+  })
+})
+
 /**
  * The async destructive routes (delete-async, cancel-runs, columns/run)
  * validate the WIRE filter here. The predicate branch must reject unknown

apps/sim/app/api/table/utils.ts

@@ -13,6 +13,7 @@ import type { ColumnDefinition, Filter, TableDefinition, TablePredicate } from '
 import { buildFilterClause, getTableById, TableQueryValidationError } from '@/lib/table'
 import { typeMetadataOf } from '@/lib/table/column-types'
 import { USER_TABLE_ROWS_SQL_NAME } from '@/lib/table/constants'
+import { TableRequestError } from '@/lib/table/errors'
 import { TableLockedError } from '@/lib/table/mutation-locks'
 import { isTablePredicate } from '@/lib/table/query-builder/converters'
 import { validateStoragePredicate } from '@/lib/table/query-builder/validate'
@@ -105,6 +106,22 @@ export function rootErrorMessage(error: unknown): string {
   return toError(current).message
 }
 
+/**
+ * Maps the table service's own typed failures to the status they declare, or
+ * `null` when the error came from somewhere else.
+ *
+ * Prefer this over matching message substrings: the service says whose fault a
+ * failure is, so a new validation message is classified correctly the day it is
+ * added. The substring lists still cover the layers that are not table-aware
+ * (the CSV parser, drizzle), which is why callers run both — this one first,
+ * since a typed error carries an explicit status that a substring match would
+ * flatten to 400.
+ */
+export function tableRequestErrorResponse(error: unknown): NextResponse | null {
+  if (!(error instanceof TableRequestError)) return null
+  return NextResponse.json({ error: error.message }, { status: error.status })
+}
+
 /**
  * Known user-facing row-write failures (service validation + the best-effort
  * plan row-limit check). Anything outside this list stays a generic 500 —