fix(tables): finish the typed-error migration in the table service

The bulk column-add path kept throwing plain `Error` after the single-column
path was migrated, so an invalid column type or the column cap fell past the
import route's substring list and surfaced as a 500 with the message swallowed
("Failed to import CSV") — the caller never learned their header was invalid.

All 13 remaining throws in the table service are now typed: a missing table is
404, everything else 400. The import route and both table-create routes check
the type before their substring lists, which stay only for messages raised by
the CSV parser, which is not table-aware.

Extracts `buildAddedColumns` so the batch validation is testable without a
transaction, mirroring `buildAddedColumn`, and pins the typing rather than the
message — this is the third error-status gap found on this PR, and each came
from a list that had to be remembered. Also pins that message text and
`instanceof Error` are unchanged, since the runners, the copilot tool and
sibling routes still match on text.

Author: waleedlatif1

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

@@ -37,6 +37,7 @@ 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'
@@ -425,6 +426,15 @@ export const POST = withRouteHandler(async (request: NextRequest, { params }: Ro
     const message = toError(error).message
     logger.error(`[${requestId}] CSV import into existing table failed:`, error)
 
+    // The table service says whether a failure is the caller's and what status
+    // it deserves. The substring list below still covers the CSV parser, which
+    // 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 isClientError =
       message.includes('CSV file has no') ||
       message.includes('already exists') ||

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

@@ -15,6 +15,7 @@ import {
   type TableSchema,
   type TableScope,
 } from '@/lib/table'
+import { TableRequestError } from '@/lib/table/errors'
 import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
 import { normalizeColumn } from '@/app/api/table/utils'
 
@@ -154,6 +155,11 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
     })
   } catch (error) {
     if (error instanceof Error) {
+      // One typed check: the service says whether a failure is the caller's
+      // and what status it deserves.
+      if (error instanceof TableRequestError) {
+        return NextResponse.json({ error: error.message }, { status: error.status })
+      }
       if (error.message.includes('maximum table limit')) {
         return NextResponse.json({ error: error.message }, { status: 403 })
       }

apps/sim/app/api/v1/tables/route.ts

@@ -6,6 +6,7 @@ import { parseRequest } from '@/lib/api/server'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import { createTable, getWorkspaceTableLimits, listTables, type TableSchema } from '@/lib/table'
+import { TableRequestError } from '@/lib/table/errors'
 import { normalizeColumn } from '@/app/api/table/utils'
 import {
   checkRateLimit,
@@ -172,6 +173,11 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
     if (validationResponse) return validationResponse
 
     if (error instanceof Error) {
+      // One typed check: the service says whether a failure is the caller's
+      // and what status it deserves.
+      if (error instanceof TableRequestError) {
+        return NextResponse.json({ error: error.message }, { status: error.status })
+      }
       if (error.message.includes('maximum table limit')) {
         return NextResponse.json({ error: error.message }, { status: 403 })
       }

apps/sim/lib/table/__tests__/backward-compatibility.test.ts

@@ -17,7 +17,10 @@
  */
 import { describe, expect, it } from 'vitest'
 import { COLUMN_TYPE_REGISTRY } from '@/lib/table/column-types'
+import { TABLE_LIMITS } from '@/lib/table/constants'
+import { TableRequestError, tableNotFound } from '@/lib/table/errors'
 import { coerceValue, inferColumnType } from '@/lib/table/import'
+import { buildAddedColumns } from '@/lib/table/service'
 import { buildFilterClause, buildSortClause } from '@/lib/table/sql'
 import type { ColumnDefinition, Filter, JsonValue, Sort } from '@/lib/table/types'
 import { validateColumnDefinition } from '@/lib/table/validation'
@@ -257,3 +260,45 @@ describe('export is unchanged for pre-existing types', () => {
     expect(COLUMN_TYPE_REGISTRY.select.formatForDisplay('o1', LEGACY_COLUMNS[6])).toBe('One')
   })
 })
+
+describe('caller-fixable failures are typed, not string-matched', () => {
+  const table = { schema: { columns: [{ id: 'a', name: 'a', type: 'string' as const }] } }
+
+  it.each([
+    ['invalid name', { name: '1bad', type: 'string' }],
+    ['name too long', { name: 'a'.repeat(200), type: 'string' }],
+    ['invalid type', { name: 'ok', type: 'nonsense' }],
+    ['duplicate name', { name: 'a', type: 'string' }],
+  ])('raises TableRequestError(400) for %s', (_label, column) => {
+    // The bulk path kept throwing plain `Error` after the single-column path was
+    // migrated, so an invalid type or the column cap fell past the import
+    // route's substring list and became a 500 with the message swallowed.
+    // Asserting the TYPE is what stops the two drifting again.
+    let thrown: unknown
+    try {
+      buildAddedColumns(table as never, [column as never])
+    } catch (error) {
+      thrown = error
+    }
+    expect(thrown).toBeInstanceOf(TableRequestError)
+    expect((thrown as TableRequestError).status).toBe(400)
+  })
+
+  it('raises TableRequestError(400) when the column cap is exceeded', () => {
+    const many = Array.from({ length: TABLE_LIMITS.MAX_COLUMNS_PER_TABLE + 1 }, (_, i) => ({
+      name: `c${i}`,
+      type: 'string',
+    }))
+    expect(() => buildAddedColumns(table as never, many as never)).toThrow(TableRequestError)
+  })
+
+  it('keeps message text and Error-ness, so existing string matchers still work', () => {
+    // The migration changed the CLASS, never the message — other consumers
+    // (runners, the copilot tool, sibling routes) still match on text.
+    const notFound = tableNotFound('Table not found')
+    expect(notFound).toBeInstanceOf(Error)
+    expect(notFound.message).toBe('Table not found')
+    expect(notFound.status).toBe(404)
+    expect(new TableRequestError('anything').status).toBe(400)
+  })
+})

apps/sim/lib/table/service.ts

@@ -27,7 +27,7 @@ import {
   pickMetadata,
 } from '@/lib/table/column-types'
 import { COLUMN_TYPES, NAME_PATTERN, TABLE_LIMITS } from '@/lib/table/constants'
-import { tableNotFound } from '@/lib/table/errors'
+import { TableRequestError, tableNotFound } from '@/lib/table/errors'
 import { appendTableEvent } from '@/lib/table/events'
 import { EMPTY_JOB_FIELDS, latestJobForTable, latestJobsForTables } from '@/lib/table/jobs/service'
 import { assertSchemaMutable, TableLockedError } from '@/lib/table/mutation-locks'
@@ -294,13 +294,13 @@ export async function createTable(
   // Validate table name
   const nameValidation = validateTableName(data.name)
   if (!nameValidation.valid) {
-    throw new Error(`Invalid table name: ${nameValidation.errors.join(', ')}`)
+    throw new TableRequestError(`Invalid table name: ${nameValidation.errors.join(', ')}`)
   }
 
   // Validate schema
   const schemaValidation = validateTableSchema(data.schema)
   if (!schemaValidation.valid) {
-    throw new Error(`Invalid schema: ${schemaValidation.errors.join(', ')}`)
+    throw new TableRequestError(`Invalid schema: ${schemaValidation.errors.join(', ')}`)
   }
 
   const tableId = `tbl_${generateId().replace(/-/g, '')}`
@@ -364,7 +364,7 @@ export async function createTable(
         )
 
       if (Number(existingCount) >= maxTables) {
-        throw new Error(`Workspace has reached maximum table limit (${maxTables})`)
+        throw new TableRequestError(`Workspace has reached maximum table limit (${maxTables})`)
       }
 
       const duplicateName = await trx
@@ -510,59 +510,82 @@ export function buildAddedColumn(
   }
 }
 
-export async function addTableColumnsWithTx(
-  trx: DbTransaction,
-  table: TableDefinition,
+/**
+ * Validates a batch of new columns and returns what to persist.
+ *
+ * Extracted and exported so the validation is testable without a transaction —
+ * the same reason `buildAddedColumn` is. Every failure here is caller-fixable,
+ * so each raises `TableRequestError` rather than a plain `Error`: the single
+ * -column path was migrated first, and while this one lagged, an invalid type
+ * or the column cap fell past the import route's substring list and surfaced as
+ * a 500 with the message swallowed.
+ */
+export function buildAddedColumns(
+  table: Pick<TableDefinition, 'schema'>,
   columns: (ColumnTypeMetadata & {
     id?: string
     name: string
     type: string
     required?: boolean
     unique?: boolean
-  })[],
-  requestId: string
-): Promise<TableDefinition> {
-  if (columns.length === 0) return table
-
-  // Runs outside `withLockedTable` (reachable from CSV import with new
-  // headers), so it must assert directly.
-  assertSchemaMutable(table)
-
+  })[]
+): TableSchema['columns'] {
   const usedNames = new Set(table.schema.columns.map((c) => c.name.toLowerCase()))
   const additions: TableSchema['columns'] = []
 
   for (const column of columns) {
     if (!NAME_PATTERN.test(column.name)) {
-      throw new Error(
+      throw new TableRequestError(
         `Invalid column name "${column.name}". Must start with a letter or underscore and contain only alphanumeric characters and underscores.`
       )
     }
     if (column.name.length > TABLE_LIMITS.MAX_COLUMN_NAME_LENGTH) {
-      throw new Error(
+      throw new TableRequestError(
         `Column name exceeds maximum length (${TABLE_LIMITS.MAX_COLUMN_NAME_LENGTH} characters)`
       )
     }
     if (!COLUMN_TYPES.includes(column.type as (typeof COLUMN_TYPES)[number])) {
-      throw new Error(
+      throw new TableRequestError(
         `Invalid column type "${column.type}". Must be one of: ${COLUMN_TYPES.join(', ')}`
       )
     }
     const lower = column.name.toLowerCase()
     if (usedNames.has(lower)) {
-      throw new Error(`Column "${column.name}" already exists`)
+      throw new TableRequestError(`Column "${column.name}" already exists`)
     }
     usedNames.add(lower)
     // Honor a caller-assigned id (the CSV append path pre-assigns so coercion
     // and persistence agree); otherwise mint one.
-    const id = column.id ?? generateColumnId()
-    additions.push(buildAddedColumn(column, id))
+    additions.push(buildAddedColumn(column, column.id ?? generateColumnId()))
   }
 
   if (table.schema.columns.length + additions.length > TABLE_LIMITS.MAX_COLUMNS_PER_TABLE) {
-    throw new Error(
+    throw new TableRequestError(
       `Adding ${additions.length} column(s) would exceed maximum column limit (${TABLE_LIMITS.MAX_COLUMNS_PER_TABLE})`
     )
   }
+  return additions
+}
+
+export async function addTableColumnsWithTx(
+  trx: DbTransaction,
+  table: TableDefinition,
+  columns: (ColumnTypeMetadata & {
+    id?: string
+    name: string
+    type: string
+    required?: boolean
+    unique?: boolean
+  })[],
+  requestId: string
+): Promise<TableDefinition> {
+  if (columns.length === 0) return table
+
+  // Runs outside `withLockedTable` (reachable from CSV import with new
+  // headers), so it must assert directly.
+  assertSchemaMutable(table)
+
+  const additions = buildAddedColumns(table, columns)
 
   // Spread `table.schema` first so workflow groups (and any future top-level
   // schema fields) survive a CSV import that only adds plain columns.
@@ -630,7 +653,7 @@ export async function renameTable(
 ): Promise<{ id: string; name: string }> {
   const nameValidation = validateTableName(newName)
   if (!nameValidation.valid) {
-    throw new Error(nameValidation.errors.join(', '))
+    throw new TableRequestError(nameValidation.errors.join(', '))
   }
 
   const now = new Date()
@@ -646,7 +669,7 @@ export async function renameTable(
       })
 
     if (result.length === 0) {
-      throw new Error(`Table ${tableId} not found`)
+      throw tableNotFound(`Table ${tableId} not found`)
     }
 
     const { createdBy, workspaceId } = result[0]
@@ -723,7 +746,7 @@ export async function moveTableToFolder(
     })
 
   if (result.length === 0) {
-    throw new Error(`Table ${tableId} not found`)
+    throw tableNotFound(`Table ${tableId} not found`)
   }
 
   const { name, createdBy } = result[0]
@@ -977,14 +1000,14 @@ export async function restoreTable(
   }
 
   if (!table.archivedAt) {
-    throw new Error('Table is not archived')
+    throw new TableRequestError('Table is not archived')
   }
 
   if (table.workspaceId) {
     const { getWorkspaceWithOwner } = await import('@/lib/workspaces/permissions/utils')
     const ws = await getWorkspaceWithOwner(table.workspaceId)
     if (!ws || ws.archivedAt) {
-      throw new Error('Cannot restore table into an archived workspace')
+      throw new TableRequestError('Cannot restore table into an archived workspace')
     }
   }