fix(tables): toast on delete-column failure, case-insensitive row cleanup, rename row-data keys

Address greptile review:
- useDeleteColumn now toasts on non-validation errors so users see when
  the column "snaps back" after a server/network failure
- Row data cleanup matches keys case-insensitively in both useDeleteColumn
  and useUpdateColumn so a column stored as "Age" is cleaned even when
  the request uses "age"
- useUpdateColumn now migrates row-data keys when updates.name is set,
  preventing blank cells during the server round-trip on a rename

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: waleedlatif1

apps/sim/hooks/queries/tables.test.ts

@@ -204,4 +204,48 @@ describe('useUpdateColumn optimistic update', () => {
 
     expect(getCache(tableKeys.detail(TABLE_ID))).toEqual(original)
   })
+
+  it('renames the corresponding row-data key when updates.name is set', async () => {
+    setCache(tableKeys.detail(TABLE_ID), {
+      id: TABLE_ID,
+      schema: { columns: [{ name: 'age', type: 'number' }] },
+    })
+    setCache(tableKeys.rowsRoot(TABLE_ID), {
+      rows: [
+        { id: 'r1', data: { age: 30 } },
+        { id: 'r2', data: { age: 40 } },
+      ],
+      totalCount: 2,
+    })
+
+    const hook = useUpdateColumn({ workspaceId: WORKSPACE_ID, tableId: TABLE_ID })
+    await hook.onMutate?.({ columnName: 'age', updates: { name: 'years' } })
+
+    const rows = getCache<{ rows: Array<{ data: Record<string, unknown> }> }>(
+      tableKeys.rowsRoot(TABLE_ID)
+    )
+    expect(rows?.rows[0]?.data).toEqual({ years: 30 })
+    expect(rows?.rows[1]?.data).toEqual({ years: 40 })
+  })
+})
+
+describe('useDeleteColumn case-insensitive row cleanup', () => {
+  it('strips the row data key even when stored casing differs from the requested name', async () => {
+    setCache(tableKeys.detail(TABLE_ID), {
+      id: TABLE_ID,
+      schema: { columns: [{ name: 'Age', type: 'number' }] },
+    })
+    setCache(tableKeys.rowsRoot(TABLE_ID), {
+      rows: [{ id: 'r1', data: { Age: 30, name: 'a' } }],
+      totalCount: 1,
+    })
+
+    const hook = useDeleteColumn({ workspaceId: WORKSPACE_ID, tableId: TABLE_ID })
+    await hook.onMutate?.('age')
+
+    const rows = getCache<{ rows: Array<{ data: Record<string, unknown> }> }>(
+      tableKeys.rowsRoot(TABLE_ID)
+    )
+    expect(rows?.rows[0]?.data).toEqual({ name: 'a' })
+  })
 })

apps/sim/hooks/queries/tables.ts

@@ -885,12 +885,30 @@ export function useUpdateColumn({ workspaceId, tableId }: RowMutationContext) {
           schema: { ...previousDetail.schema, columns: nextColumns },
         })
       }
-      return { previousDetail }
+
+      const newName = (updates as { name?: string }).name
+      const rowSnapshots =
+        typeof newName === 'string' && newName.length > 0 && newName !== columnName
+          ? await snapshotAndMutateRows(queryClient, tableId, (row) => {
+              const lower = columnName.toLowerCase()
+              const matchKey = Object.keys(row.data).find((k) => k.toLowerCase() === lower)
+              if (!matchKey) return null
+              const { [matchKey]: value, ...rest } = row.data
+              return { ...row, data: { ...rest, [newName]: value } }
+            })
+          : []
+
+      return { previousDetail, rowSnapshots }
     },
     onError: (error, _vars, context) => {
       if (context?.previousDetail) {
         queryClient.setQueryData(tableKeys.detail(tableId), context.previousDetail)
       }
+      if (context?.rowSnapshots) {
+        for (const [key, data] of context.rowSnapshots) {
+          queryClient.setQueryData(key, data)
+        }
+      }
       // Validation errors are surfaced as inline FieldErrors by the caller.
       if (isValidationError(error)) return
       toast.error(error.message, { duration: 5000 })
@@ -1173,9 +1191,9 @@ export function useDeleteColumn({ workspaceId, tableId }: RowMutationContext) {
     onMutate: async (columnName) => {
       await queryClient.cancelQueries({ queryKey: tableKeys.detail(tableId) })
 
+      const lower = columnName.toLowerCase()
       const previousDetail = queryClient.getQueryData<TableDefinition>(tableKeys.detail(tableId))
       if (previousDetail) {
-        const lower = columnName.toLowerCase()
         const nextColumns = previousDetail.schema.columns.filter(
           (c) => c.name.toLowerCase() !== lower
         )
@@ -1196,14 +1214,15 @@ export function useDeleteColumn({ workspaceId, tableId }: RowMutationContext) {
       }
 
       const rowSnapshots = await snapshotAndMutateRows(queryClient, tableId, (row) => {
-        if (!(columnName in row.data)) return null
-        const { [columnName]: _removed, ...rest } = row.data
+        const matchKey = Object.keys(row.data).find((k) => k.toLowerCase() === lower)
+        if (!matchKey) return null
+        const { [matchKey]: _removed, ...rest } = row.data
         return { ...row, data: rest }
       })
 
       return { previousDetail, rowSnapshots }
     },
-    onError: (_err, _columnName, context) => {
+    onError: (error, _columnName, context) => {
       if (context?.previousDetail) {
         queryClient.setQueryData(tableKeys.detail(tableId), context.previousDetail)
       }
@@ -1212,6 +1231,8 @@ export function useDeleteColumn({ workspaceId, tableId }: RowMutationContext) {
           queryClient.setQueryData(key, data)
         }
       }
+      if (isValidationError(error)) return
+      toast.error(error.message, { duration: 5000 })
     },
     onSettled: () => {
       invalidateTableSchema(queryClient, tableId)