chore: import upstream snapshot with attribution

apps/sim/hooks/use-table-undo.test.ts

@@ -0,0 +1,231 @@
+/**
+ * @vitest-environment node
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+// Passthrough React hooks so the hook can run outside a React root.
+vi.mock('react', () => ({
+  useCallback: (fn: unknown) => fn,
+  useEffect: (fn: () => void) => fn(),
+  useRef: (init: unknown) => ({ current: init }),
+}))
+
+const mockMutate = vi.fn()
+const mockMutateAsync = vi.fn()
+
+vi.mock('@/hooks/queries/tables', () => ({
+  useUpdateTableRow: vi.fn(() => ({ mutate: mockMutate })),
+  useCreateTableRow: vi.fn(() => ({ mutate: mockMutate })),
+  useBatchCreateTableRows: vi.fn(() => ({ mutate: mockMutate, mutateAsync: mockMutateAsync })),
+  useBatchUpdateTableRows: vi.fn(() => ({ mutate: mockMutate, mutateAsync: mockMutateAsync })),
+  useDeleteTableRow: vi.fn(() => ({ mutate: mockMutate })),
+  useDeleteTableRows: vi.fn(() => ({ mutate: mockMutate })),
+  useAddTableColumn: vi.fn(() => ({ mutate: mockMutate })),
+  useUpdateColumn: vi.fn(() => ({ mutate: mockMutate })),
+  useDeleteColumn: vi.fn(() => ({ mutate: mockMutate })),
+  useRenameTable: vi.fn(() => ({ mutate: mockMutate })),
+  useUpdateTableMetadata: vi.fn(() => ({ mutate: mockMutate })),
+}))
+
+vi.mock('@/lib/table/constants', () => ({
+  TABLE_LIMITS: { MAX_BULK_OPERATION_SIZE: 3 }, // small limit so tests don't need 1000 items
+}))
+
+const mockPopUndo = vi.fn()
+const mockPopRedo = vi.fn()
+const mockPush = vi.fn()
+const mockPatchRedoRowId = vi.fn()
+const mockPatchUndoRowId = vi.fn()
+const mockClear = vi.fn()
+
+const storeState = {
+  stacks: {},
+  push: mockPush,
+  popUndo: mockPopUndo,
+  popRedo: mockPopRedo,
+  patchRedoRowId: mockPatchRedoRowId,
+  patchUndoRowId: mockPatchUndoRowId,
+  clear: mockClear,
+}
+
+vi.mock('@/stores/table/store', () => ({
+  useTableUndoStore: vi.fn((selector: (s: typeof storeState) => unknown) => selector(storeState)),
+  runWithoutRecording: (fn: () => unknown) => Promise.resolve(fn()),
+}))
+
+import { useTableUndo } from '@/hooks/use-table-undo'
+import type { TableUndoAction } from '@/stores/table/types'
+
+const WORKSPACE_ID = 'ws-1'
+const TABLE_ID = 'tbl-1'
+
+function TestHook() {
+  return useTableUndo({ workspaceId: WORKSPACE_ID, tableId: TABLE_ID })
+}
+
+function makeEntry(action: TableUndoAction) {
+  return { id: 'e1', action, timestamp: Date.now() }
+}
+
+function makeCellsForClear(count: number) {
+  return Array.from({ length: count }, (_, i) => ({
+    rowId: `row-${i}`,
+    data: { col: `val-${i}` },
+  }))
+}
+
+/** Drain the microtask queue so all async chunks in executeAction finish. */
+async function flush() {
+  await new Promise((r) => setTimeout(r, 0))
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  mockMutateAsync.mockResolvedValue({})
+})
+
+describe('useTableUndo – clear-cells chunking (via undo)', () => {
+  it('sends a single mutateAsync call when cells fit in one chunk', async () => {
+    const cells = makeCellsForClear(2)
+    mockPopUndo.mockReturnValueOnce(makeEntry({ type: 'clear-cells', cells }))
+    const { undo } = TestHook()
+    ;(undo as () => void)()
+    await flush()
+    expect(mockMutateAsync).toHaveBeenCalledTimes(1)
+    expect(mockMutateAsync.mock.calls[0][0].updates).toHaveLength(2)
+  })
+
+  it('splits into multiple chunks when cells exceed the limit', async () => {
+    const cells = makeCellsForClear(7) // limit=3 → [3,3,1]
+    mockPopUndo.mockReturnValueOnce(makeEntry({ type: 'clear-cells', cells }))
+    const { undo } = TestHook()
+    ;(undo as () => void)()
+    await flush()
+    expect(mockMutateAsync).toHaveBeenCalledTimes(3)
+    expect(mockMutateAsync.mock.calls[0][0].updates).toHaveLength(3)
+    expect(mockMutateAsync.mock.calls[1][0].updates).toHaveLength(3)
+    expect(mockMutateAsync.mock.calls[2][0].updates).toHaveLength(1)
+  })
+
+  it('sends original data values for undo direction', async () => {
+    const cells = makeCellsForClear(1)
+    mockPopUndo.mockReturnValueOnce(makeEntry({ type: 'clear-cells', cells }))
+    const { undo } = TestHook()
+    ;(undo as () => void)()
+    await flush()
+    expect(mockMutateAsync.mock.calls[0][0].updates[0].data.col).toBe('val-0')
+  })
+
+  it('sends null values for redo direction', async () => {
+    const cells = makeCellsForClear(1)
+    mockPopRedo.mockReturnValueOnce(makeEntry({ type: 'clear-cells', cells }))
+    const { redo } = TestHook()
+    ;(redo as () => void)()
+    await flush()
+    expect(mockMutateAsync.mock.calls[0][0].updates[0].data.col).toBeNull()
+  })
+
+  it('does not call mutateAsync when cells is empty', async () => {
+    mockPopUndo.mockReturnValueOnce(makeEntry({ type: 'clear-cells', cells: [] }))
+    const { undo } = TestHook()
+    ;(undo as () => void)()
+    await flush()
+    expect(mockMutateAsync).not.toHaveBeenCalled()
+  })
+
+  it('stops processing after the first failing chunk', async () => {
+    mockMutateAsync.mockRejectedValueOnce(new Error('Network error'))
+    const cells = makeCellsForClear(5) // limit=3 → would be [3,2] but stops at chunk 1
+    mockPopUndo.mockReturnValueOnce(makeEntry({ type: 'clear-cells', cells }))
+    const { undo } = TestHook()
+    // executeAction catches the error internally via logger — undo itself doesn't re-throw.
+    ;(undo as () => void)()
+    await flush()
+    expect(mockMutateAsync).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('useTableUndo – update-cells chunking (via undo)', () => {
+  function makeCellsForUpdate(count: number) {
+    return Array.from({ length: count }, (_, i) => ({
+      rowId: `row-${i}`,
+      oldData: { col: `old-${i}` },
+      newData: { col: `new-${i}` },
+    }))
+  }
+
+  it('sends a single call when cells fit within limit', async () => {
+    const cells = makeCellsForUpdate(2)
+    mockPopUndo.mockReturnValueOnce(makeEntry({ type: 'update-cells', cells }))
+    const { undo } = TestHook()
+    ;(undo as () => void)()
+    await flush()
+    expect(mockMutateAsync).toHaveBeenCalledTimes(1)
+    expect(mockMutateAsync.mock.calls[0][0].updates[0].data.col).toBe('old-0')
+  })
+
+  it('chunks across multiple calls and picks the correct direction data', async () => {
+    const cells = makeCellsForUpdate(8) // limit=3 → [3,3,2]
+    mockPopRedo.mockReturnValueOnce(makeEntry({ type: 'update-cells', cells }))
+    const { redo } = TestHook()
+    ;(redo as () => void)()
+    await flush()
+    expect(mockMutateAsync).toHaveBeenCalledTimes(3)
+    const lastChunk = mockMutateAsync.mock.calls[2][0].updates
+    expect(lastChunk).toHaveLength(2)
+    // redo direction → newData
+    expect(lastChunk[0].data.col).toBe('new-6')
+  })
+})
+
+describe('useTableUndo – delete-column undo cell restore chunking', () => {
+  const baseAction: TableUndoAction = {
+    type: 'delete-column',
+    columnName: 'col',
+    columnType: 'string' as const,
+    columnPosition: 0,
+    columnUnique: false,
+    columnRequired: false,
+    cellData: [],
+    previousOrder: null,
+    previousWidth: null,
+    previousPinnedColumns: null,
+  }
+
+  it('does not call mutateAsync when cellData is empty', async () => {
+    mockPopUndo.mockReturnValueOnce(makeEntry(baseAction))
+    const { undo } = TestHook()
+    ;(undo as () => void)()
+    await flush()
+    // addColumnMutation.mutate fires but the cell-restore block should not.
+    expect(mockMutateAsync).not.toHaveBeenCalled()
+  })
+
+  it('fires chunked mutateAsync calls via the onSuccess IIFE when cellData exceeds limit', async () => {
+    const cellData = Array.from({ length: 5 }, (_, i) => ({ rowId: `row-${i}`, value: i }))
+    const action: TableUndoAction = { ...baseAction, cellData }
+    mockPopUndo.mockReturnValueOnce(makeEntry(action))
+
+    // addColumnMutation.mutate is the first mockMutate call.
+    // Capture its onSuccess and invoke it to simulate column creation completing.
+    let capturedOnSuccess: (() => void) | undefined
+    mockMutate.mockImplementationOnce((_: unknown, opts: { onSuccess?: () => void }) => {
+      capturedOnSuccess = opts?.onSuccess
+    })
+
+    const { undo } = TestHook()
+    ;(undo as () => void)()
+    await flush()
+
+    // At this point executeAction has returned, but the restore happens in the
+    // addColumn onSuccess callback — fire it now.
+    capturedOnSuccess?.()
+    // Allow the void IIFE's microtasks to drain.
+    await new Promise((r) => setTimeout(r, 0))
+
+    // limit=3 → [3, 2]
+    expect(mockMutateAsync).toHaveBeenCalledTimes(2)
+    expect(mockMutateAsync.mock.calls[0][0].updates).toHaveLength(3)
+    expect(mockMutateAsync.mock.calls[1][0].updates).toHaveLength(2)
+  })
+})