fix(tables): guard import batches in-transaction and split paste by verb

- Re-assert the insert lock inside each import batch's insert transaction,
  under the same advisory lock updateTableLocks takes. Reversing the earlier
  "let the file finish" call: an admin can lift the lock to clean up a partial
  import, so honouring it beats letting the rest of the file land
- Gate paste per verb. Overwriting existing rows is an update and extending
  past the last row is a full-row insert, so a paste-append still works on an
  append-only table while an overwrite explains itself. Refuses the whole
  paste rather than applying half of it
- Space opens the same row editor as double-click, so it now follows the
  update lock instead of filling in a form that 423s on save

Author: TheodoreSpeaks

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

@@ -572,6 +572,8 @@ export function TableGrid({
   canEditCellRef.current = canEditCell
   const canManualAddRowRef = useRef(canManualAddRow)
   canManualAddRowRef.current = canManualAddRow
+  const canInsertFullRowRef = useRef(canInsertFullRow)
+  canInsertFullRowRef.current = canInsertFullRow
   // Read by the closure-free double-click handler to tell "locked" apart from
   // "no write permission" — only the former gets the explanation modal.
   const updateLockedRef = useRef(locks?.updateLocked)
@@ -2346,6 +2348,12 @@ export function TableGrid({
       if (e.key === ' ' && !e.shiftKey) {
         if (!canEditRef.current) return
         e.preventDefault()
+        // Space opens the same row editor as double-click, so it follows the
+        // update lock too — otherwise the form fills in and only 423s on save.
+        if (updateLockedRef.current) {
+          onBlockedActionRef.current('edit-cell')
+          return
+        }
         const row = currentRows[anchor.rowIndex]
         if (row) {
           onOpenRowModalRef.current(row)
@@ -2840,10 +2848,7 @@ export function TableGrid({
     const handlePaste = (e: ClipboardEvent) => {
       const tag = (e.target as HTMLElement).tagName
       if (tag === 'INPUT' || tag === 'TEXTAREA') return
-      // Paste overwrites the selected cells (an edit). Under an update lock we
-      // block it wholesale — the append-into-new-rows variant is a rarer path
-      // the user can still reach via the Add row button.
-      if (!canEditCellRef.current) return
+      if (!canEditRef.current) return
 
       const currentAnchor = selectionAnchorRef.current
       if (!currentAnchor || editingCellRef.current) return
@@ -2899,6 +2904,20 @@ export function TableGrid({
         }
       }
 
+      // A paste can do two different things at once: overwrite existing rows
+      // (an update) and extend past the last row (a full-row insert). Gate each
+      // against its own lock, and refuse the whole paste rather than applying
+      // half of it — so a full-row paste-append still works on an append-only
+      // table, while an overwrite on that same table explains itself.
+      if (updateBatch.length > 0 && !canEditCellRef.current) {
+        onBlockedActionRef.current('edit-cell')
+        return
+      }
+      if (createBatchRows.length > 0 && !canInsertFullRowRef.current) {
+        onBlockedActionRef.current('add-row')
+        return
+      }
+
       if (updateBatch.length > 0) {
         batchUpdateRef.current({ updates: updateBatch })
         pushUndoRef.current({

apps/sim/lib/table/import-data.ts

@@ -13,7 +13,11 @@ import { assertRowCapacity, notifyTableRowUsage } from '@/lib/table/billing'
 import { CSV_MAX_BATCH_SIZE } from '@/lib/table/import'
 import { assertRowDelete, assertRowInsert, assertSchemaMutable } from '@/lib/table/mutation-locks'
 import { nKeysBetween } from '@/lib/table/order-key'
-import { acquireRowOrderLock } from '@/lib/table/rows/ordering'
+import {
+  acquireRowOrderLock,
+  guardBatch,
+  type MutationRevalidator,
+} from '@/lib/table/rows/ordering'
 import { batchInsertRowsWithTx, replaceTableRowsWithTx } from '@/lib/table/rows/service'
 import { addTableColumnsWithTx, auditTableColumnsAdded } from '@/lib/table/service'
 import type {
@@ -61,7 +65,9 @@ export interface BulkImportBatch {
 export async function bulkInsertImportBatch(
   data: BulkImportBatch,
   table: TableDefinition,
-  requestId: string
+  requestId: string,
+  /** Re-asserts the insert lock inside the write transaction. See {@link guardBatch}. */
+  revalidate?: MutationRevalidator
 ): Promise<{ inserted: number; lastOrderKey: string | null }> {
   assertRowInsert(table)
 
@@ -107,7 +113,10 @@ export async function bulkInsertImportBatch(
     ...(data.userId ? { createdBy: data.userId } : {}),
   }))
 
-  await db.insert(userTableRows).values(rowsToInsert)
+  await db.transaction(async (trx) => {
+    await guardBatch(trx, data.tableId, revalidate)
+    await trx.insert(userTableRows).values(rowsToInsert)
+  })
   logger.info(`[${requestId}] Bulk-imported ${rowsToInsert.length} rows into table ${data.tableId}`)
   return {
     inserted: rowsToInsert.length,

apps/sim/lib/table/import-runner.ts

@@ -29,6 +29,7 @@ import {
 } from '@/lib/table/import-data'
 import { markJobFailed, markJobReady, updateJobProgress } from '@/lib/table/jobs/service'
 import { assertRowDelete, assertRowInsert } from '@/lib/table/mutation-locks'
+import type { DbTransaction } from '@/lib/table/planner'
 import { nextImportStartOrderKey, nextImportStartPosition } from '@/lib/table/rows/ordering'
 import { getTableById } from '@/lib/table/service'
 import { deleteFile, downloadFileStream, headObject } from '@/lib/uploads/core/storage-service'
@@ -103,12 +104,18 @@ export async function runTableImport(payload: TableImportPayload): Promise<void>
     // fails up front instead of after `deleteAllTableRows` has already wiped it.
     // (The sync replace path gets this for free from `replaceTableRowsWithTx`,
     // which asserts both in one place; this path deletes and inserts separately.)
-    // Checked once, unlike the delete/update runners which re-check per page: a
-    // lock landing mid-import should let the file finish, since a half-imported
-    // table has to be cleaned up with the very deletes the lock now forbids.
     assertRowInsert(table)
     if (mode === 'replace') assertRowDelete(table)
 
+    // Re-asserted inside every batch's insert transaction, under the same
+    // advisory lock `updateTableLocks` writes with, so enabling the insert lock
+    // mid-import stops it at the next batch instead of letting the rest of the
+    // file through. Rows already committed stay — as with an explicit cancel.
+    const revalidateInsert = async (trx: DbTransaction) => {
+      const fresh = await getTableById(tableId, { tx: trx, includeArchived: true })
+      if (fresh) assertRowInsert(fresh)
+    }
+
     // Total byte size for the progress estimate — a cheap HEAD, no download. May be null on
     // the local dev provider, in which case the bar stays indeterminate (rows still show).
     const totalBytes = (await headObject(fileKey, 'workspace'))?.size ?? 0
@@ -244,7 +251,8 @@ export async function runTableImport(payload: TableImportPayload): Promise<void>
           afterOrderKey: lastOrderKey,
         },
         { ...table, schema },
-        requestId
+        requestId,
+        revalidateInsert
       )
       notifyTableRowUsage({
         workspaceId,

apps/sim/lib/table/rows/ordering.ts

@@ -409,7 +409,7 @@ export type MutationRevalidator = (trx: DbTransaction) => Promise<void>
  * waits for this batch to finish. Without it, the caller's proof would only
  * describe the lock state at some earlier point in the run.
  */
-async function guardBatch(
+export async function guardBatch(
   trx: DbTransaction,
   tableId: string,
   revalidate: MutationRevalidator | undefined