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

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.ts

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

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

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

@@ -619,7 +619,7 @@ export function TableGrid({
 
   const hasWorkflowColumns = columns.some((c) => !!c.workflowGroupId)
   const { colWidth: checkboxColWidth, numRegionWidth } = checkboxColLayout(
-    tableData?.maxRows ?? 0,
+    tableData?.rowCount ?? 0,
     hasWorkflowColumns
   )