fix(tables): enforce row limits against the current plan, not a frozen per-table cap (#5120)

* fix(tables): enforce row limits against the current plan, not a frozen per-table cap

* fix(tables): gate multi-batch CSV create + initial rows against the plan, harden limits cache bound

* fix(tables): thread running row count through copilot batchInsertAll capacity check

* chore(tables): align tx-variant capacity docstrings

* fix(tables): map row-limit errors to 400 in create-from-CSV import

* feat(tables): add Upgrade action to the row-limit toast

* fix(tables): keep CreateTableData.maxRows so staging callers type-check after merge

* improvement(tables): route row-limit Upgrade action to the explore-plans page

Author: TheodoreSpeaks

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

@@ -13,13 +13,15 @@ const {
   mockDispatchAfterBatchInsert,
   mockMarkTableImporting,
   mockReleaseImportClaim,
+  mockGetMaxRowsPerTable,
 } = vi.hoisted(() => ({
   mockCheckAccess: vi.fn(),
   mockImportAppendRows: vi.fn(),
   mockImportReplaceRows: vi.fn(),
   mockDispatchAfterBatchInsert: vi.fn(),
   mockMarkTableImporting: vi.fn(),
   mockReleaseImportClaim: vi.fn(),
+  mockGetMaxRowsPerTable: vi.fn(),
 }))
 
 vi.mock('@sim/utils/id', () => ({
@@ -65,6 +67,13 @@ vi.mock('@/lib/table/rows/service', () => ({
   dispatchAfterBatchInsert: mockDispatchAfterBatchInsert,
 }))
 
+/** The append pre-check reads the workspace's current plan row limit, not the frozen `table.maxRows`. */
+vi.mock('@/lib/table/billing', () => ({
+  getMaxRowsPerTable: mockGetMaxRowsPerTable,
+  wouldExceedRowLimit: (limit: number, current: number, added: number) =>
+    limit >= 0 && current + added > limit,
+}))
+
 import { POST } from '@/app/api/table/[tableId]/import/route'
 
 function createCsvFile(contents: string, name = 'data.csv', type = 'text/csv'): File {
@@ -167,6 +176,7 @@ describe('POST /api/table/[tableId]/import', () => {
     mockImportReplaceRows.mockResolvedValue({ deletedCount: 0, insertedCount: 0 })
     mockMarkTableImporting.mockResolvedValue(true)
     mockReleaseImportClaim.mockResolvedValue(undefined)
+    mockGetMaxRowsPerTable.mockResolvedValue(1_000_000)
   })
 
   it('returns 401 when the user is not authenticated', async () => {
@@ -288,11 +298,9 @@ describe('POST /api/table/[tableId]/import', () => {
     expect(mockImportAppendRows).toHaveBeenCalledTimes(1)
   })
 
-  it('rejects append when it would exceed maxRows', async () => {
-    mockCheckAccess.mockResolvedValueOnce({
-      ok: true,
-      table: buildTable({ rowCount: 99, maxRows: 100 }),
-    })
+  it('rejects append when it would exceed the current plan row limit', async () => {
+    mockCheckAccess.mockResolvedValueOnce({ ok: true, table: buildTable({ rowCount: 99 }) })
+    mockGetMaxRowsPerTable.mockResolvedValueOnce(100)
     const response = await callPost(
       createFormData(createCsvFile('name,age\nAlice,30\nBob,40'), { mode: 'append' })
     )

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

@@ -25,13 +25,15 @@ import {
   createCsvParser,
   dispatchAfterBatchInsert,
   generateColumnId,
+  getMaxRowsPerTable,
   inferColumnType,
   markTableJobRunning,
   releaseJobClaim,
   sanitizeName,
   type TableDefinition,
   type TableSchema,
   validateMapping,
+  wouldExceedRowLimit,
 } from '@/lib/table'
 import { importAppendRows, importReplaceRows } from '@/lib/table/import-data'
 import {
@@ -264,11 +266,12 @@ export const POST = withRouteHandler(async (request: NextRequest, { params }: Ro
     claimedImportId = syncImportId
 
     if (mode === 'append') {
-      if (prospectiveTable.rowCount + coerced.length > prospectiveTable.maxRows) {
-        const deficit = prospectiveTable.rowCount + coerced.length - prospectiveTable.maxRows
+      const maxRows = await getMaxRowsPerTable(workspaceId)
+      if (wouldExceedRowLimit(maxRows, prospectiveTable.rowCount, coerced.length)) {
+        const deficit = prospectiveTable.rowCount + coerced.length - maxRows
         return NextResponse.json(
           {
-            error: `Append would exceed table row limit (${prospectiveTable.maxRows}). Currently ${prospectiveTable.rowCount} rows, ${coerced.length} new rows, ${deficit} over.`,
+            error: `Append would exceed table row limit (${maxRows}). Currently ${prospectiveTable.rowCount} rows, ${coerced.length} new rows, ${deficit} over.`,
           },
           { status: 400 }
         )

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

@@ -84,7 +84,6 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
         schema: { columns: [{ name: 'column_1', type: 'string' }] },
         workspaceId,
         userId,
-        maxRows: planLimits.maxRowsPerTable,
         maxTables: planLimits.maxTables,
         jobStatus: 'running',
         jobType: 'import',

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

@@ -39,6 +39,12 @@ vi.mock('@/app/api/table/utils', async () => {
         { error: error.message },
         { status: error.code === 'FILE_TOO_LARGE' ? 413 : 400 }
       ),
+    rowWriteErrorResponse: (error: unknown) => {
+      const message = error instanceof Error ? error.message : String(error)
+      return message.includes('row limit')
+        ? NextResponse.json({ error: message }, { status: 400 })
+        : null
+    },
   }
 })
 vi.mock('@/lib/workspaces/permissions/utils', () => permissionsMock)
@@ -175,6 +181,17 @@ describe('POST /api/table/import-csv', () => {
     expect(mockCreateTable).not.toHaveBeenCalled()
   })
 
+  it('returns 400 with the reason when an insert exceeds the plan row limit', async () => {
+    mockBatchInsertRows.mockRejectedValueOnce(
+      new Error('This table has reached its row limit (1,000 rows) on your current plan.')
+    )
+    const response = await POST(makeRequest(uploadParts(csvWithRows(250))))
+    const data = await response.json()
+
+    expect(response.status).toBe(400)
+    expect(data.error).toMatch(/row limit/)
+  })
+
   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

@@ -30,6 +30,7 @@ import {
   csvProxyBodyCapResponse,
   multipartErrorResponse,
   normalizeColumn,
+  rowWriteErrorResponse,
 } from '@/app/api/table/utils'
 
 const logger = createLogger('TableImportCSV')
@@ -105,12 +106,18 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
       headerToColumn: Map<string, string>
     }
 
-    const insertRows = async (rows: Record<string, unknown>[], state: ImportState) => {
+    const insertRows = async (
+      rows: Record<string, unknown>[],
+      state: ImportState,
+      currentRowCount: number
+    ) => {
       if (rows.length === 0) return 0
       const coerced = coerceRowsForTable(rows, state.schema, state.headerToColumn)
       const result = await batchInsertRows(
         { tableId: state.table.id, rows: coerced, workspaceId, userId },
-        state.table,
+        // The created table's rowCount is frozen at 0; pass the running total so the
+        // per-batch capacity check sees cumulative rows, not an always-empty table.
+        { ...state.table, rowCount: currentRowCount },
         generateId().slice(0, 8)
       )
       return result.length
@@ -132,7 +139,6 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
           schema,
           workspaceId,
           userId,
-          maxRows: planLimits.maxRowsPerTable,
           maxTables: planLimits.maxTables,
         },
         requestId
@@ -153,13 +159,13 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
           sample.push(record)
           if (sample.length >= CSV_SCHEMA_SAMPLE_SIZE) {
             state = await buildTable(sample)
-            inserted += await insertRows(sample, state)
+            inserted += await insertRows(sample, state, inserted)
           }
           continue
         }
         batch.push(record)
         if (batch.length >= CSV_MAX_BATCH_SIZE) {
-          inserted += await insertRows(batch, state)
+          inserted += await insertRows(batch, state, inserted)
           batch = []
         }
       }
@@ -169,9 +175,9 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
           return NextResponse.json({ error: 'CSV file has no data rows' }, { status: 400 })
         }
         state = await buildTable(sample)
-        inserted += await insertRows(sample, state)
+        inserted += await insertRows(sample, state, inserted)
       } else {
-        inserted += await insertRows(batch, state)
+        inserted += await insertRows(batch, state, inserted)
       }
     } catch (streamError) {
       if (state) await deleteTable(state.table.id, requestId).catch(() => {})
@@ -200,9 +206,13 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
   } catch (error) {
     if (isMultipartError(error)) return multipartErrorResponse(error)
 
-    const message = toError(error).message
     logger.error(`[${requestId}] CSV import failed:`, error)
 
+    // Row-write failures (e.g. the plan row-limit check) map to a 400 with the real reason.
+    const rowWriteError = rowWriteErrorResponse(error)
+    if (rowWriteError) return rowWriteError
+
+    const message = toError(error).message
     const isClientError =
       message.includes('maximum table limit') ||
       message.includes('CSV file has no') ||

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

@@ -82,7 +82,6 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
         schema: normalizedSchema,
         workspaceId: params.workspaceId,
         userId: authResult.userId,
-        maxRows: planLimits.maxRowsPerTable,
         maxTables: planLimits.maxTables,
         initialRowCount: params.initialRowCount,
       },

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

@@ -2,6 +2,7 @@
  * @vitest-environment node
  */
 import { describe, expect, it } from 'vitest'
+import { TableRowLimitError } from '@/lib/table/billing'
 import { rootErrorMessage, rowWriteErrorResponse } from '@/app/api/table/utils'
 
 /** Mimics drizzle's DrizzleQueryError: message is the failed SQL, real error on `cause`. */
@@ -17,7 +18,7 @@ describe('rootErrorMessage', () => {
   })
 
   it('unwraps the cause chain to the deepest error', () => {
-    const root = new Error('Maximum row limit (10000) reached for table tbl_abc')
+    const root = new Error('Value for column "email" must be unique')
     expect(rootErrorMessage(wrapLikeDrizzle(root))).toBe(root.message)
   })
 
@@ -27,14 +28,13 @@ describe('rootErrorMessage', () => {
 })
 
 describe('rowWriteErrorResponse', () => {
-  it('rewrites the DB row-limit trigger error into a friendly 400', async () => {
-    const error = wrapLikeDrizzle(
-      new Error('Maximum row limit (10000) reached for table tbl_2b15ec29647040e7b8eb5d2949f556cf')
-    )
-    const response = rowWriteErrorResponse(error)
+  it('passes the plan row-limit error through as a 400', async () => {
+    const response = rowWriteErrorResponse(new TableRowLimitError(10000))
     expect(response?.status).toBe(400)
     const body = await response?.json()
-    expect(body.error).toBe('Row limit exceeded — this table is capped at 10,000 rows')
+    expect(body.error).toBe(
+      'This table has reached its row limit (10,000 rows) on your current plan.'
+    )
   })
 
   it('passes known validation messages through as 400', async () => {

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

@@ -36,9 +36,9 @@ export function tableFilterError(
 const logger = createLogger('TableUtils')
 
 /**
- * Deepest `Error` message in the cause chain. Drizzle wraps DB errors (e.g. the
- * row-limit trigger's RAISE) in a `DrizzleQueryError` whose own message is just
- * the failed SQL — substring classification must look at the root cause.
+ * Deepest `Error` message in the cause chain. Drizzle wraps DB errors in a
+ * `DrizzleQueryError` whose own message is just the failed SQL — substring
+ * classification must look at the root cause.
  */
 export function rootErrorMessage(error: unknown): string {
   let current: unknown = error
@@ -49,9 +49,9 @@ export function rootErrorMessage(error: unknown): string {
 }
 
 /**
- * Known user-facing row-write failures (service validation + the DB row-limit
- * trigger). Anything outside this list stays a generic 500 — unknown errors can
- * carry SQL/internals that don't belong in a toast.
+ * Known user-facing row-write failures (service validation + the best-effort
+ * plan row-limit check). Anything outside this list stays a generic 500 —
+ * unknown errors can carry SQL/internals that don't belong in a toast.
  */
 const ROW_WRITE_ERROR_PATTERNS = [
   'row limit',
@@ -79,18 +79,6 @@ const ROW_WRITE_ERROR_PATTERNS = [
 export function rowWriteErrorResponse(error: unknown): NextResponse | null {
   const message = rootErrorMessage(error)
 
-  // Trigger message reads `Maximum row limit (N) reached for table tbl_...` —
-  // rewrite it for the toast instead of leaking the internal table id.
-  const limitMatch = message.match(/Maximum row limit \((\d+)\) reached/)
-  if (limitMatch) {
-    return NextResponse.json(
-      {
-        error: `Row limit exceeded — this table is capped at ${Number(limitMatch[1]).toLocaleString('en-US')} rows`,
-      },
-      { status: 400 }
-    )
-  }
-
   if (ROW_WRITE_ERROR_PATTERNS.some((p) => message.includes(p)) || /^Row .+?:/.test(message)) {
     return NextResponse.json({ error: message }, { status: 400 })
   }

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

@@ -108,7 +108,6 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
         schema: normalizedSchema,
         workspaceId: params.workspaceId,
         userId,
-        maxRows: planLimits.maxRowsPerTable,
         maxTables: planLimits.maxTables,
       },
       requestId

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/data-row.tsx

@@ -50,7 +50,7 @@ export interface DataRowProps {
   runningCount: number
   /** Whether the table has at least one workflow column — controls whether a run/stop icon is rendered. */
   hasWorkflowColumns: boolean
-  /** Width of the centered row-number/checkbox region in px, derived from the table's maxRows digit count. */
+  /** Width of the centered row-number/checkbox region in px, derived from the table's row-count digit count. */
   numRegionWidth: number
   onStopRow: (rowId: string) => void
   onRunRow: (rowId: string) => void