fix(tables): don't drop a rename when the write it rides on no-ops

Found by Cursor Bugbot — a bug I introduced folding the rename in.
`updateColumnCurrency` returns early when the code is unchanged, and that
return sat ahead of the rename, so PATCH {name, currencyCode} with the column's
current code answered 200 with the rename silently discarded.

Both early returns now treat a pending rename as work: the currency path only
no-ops when the code is unchanged AND no rename is riding along, and the retype
path applies a rename-only write when the type is unchanged. `applyPendingRename`
signals "nothing to do" by returning the same reference, which is what lets
both detect it cleanly.

Also extracts `persistColumns` — five sites were repeating the same
schema-write-and-return.

Author: waleedlatif1

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

@@ -113,6 +113,29 @@ describe('PATCH /api/table/[tableId]/columns — pre-flight guards', () => {
     expect(mockRenameColumn).not.toHaveBeenCalled()
   })
 
+  it('still applies a rename when the currency it rides on is unchanged', async () => {
+    // `updateColumnCurrency` no-ops on an unchanged code. The rename folded into
+    // the same request must not be dropped with it.
+    mockCheckAccess.mockResolvedValue({
+      ok: true,
+      table: {
+        workspaceId: WORKSPACE_ID,
+        schema: {
+          columns: [{ id: 'col_a', name: 'amount', type: 'currency', currencyCode: 'USD' }],
+        },
+      },
+    })
+    mockUpdateColumnCurrency.mockResolvedValue({ schema: { columns: [] } })
+
+    const response = await patch({ name: 'renamed', currencyCode: 'USD' })
+
+    expect(response.status).toBe(200)
+    expect(mockUpdateColumnCurrency).toHaveBeenCalledWith(
+      expect.objectContaining({ currencyCode: 'USD', newName: 'renamed' }),
+      expect.any(String)
+    )
+  })
+
   it('renames standalone when there is no other write to ride on', async () => {
     mockRenameColumn.mockResolvedValue({ schema: { columns: [] } })
 

apps/sim/lib/table/__tests__/column-conversion.test.ts

@@ -182,6 +182,15 @@ describe('rename folded into another write', () => {
     expect(() => applyPendingRename(columns, 0, 'TAKEN')).toThrow(/already exists/)
   })
 
+  it('signals a no-op by identity, which is how callers detect nothing to write', () => {
+    // The early returns in `updateColumnType` / `updateColumnCurrency` rely on
+    // this: same reference means there is genuinely nothing to persist.
+    const columns: ColumnDefinition[] = [{ id: 'col_a', name: 'amount', type: 'currency' }]
+    expect(applyPendingRename(columns, 0, undefined)).toBe(columns[0])
+    expect(applyPendingRename(columns, 0, 'amount')).toBe(columns[0])
+    expect(applyPendingRename(columns, 0, 'renamed')).not.toBe(columns[0])
+  })
+
   it('applies a valid rename and is a no-op without one', () => {
     const columns: ColumnDefinition[] = [{ id: 'col_a', name: 'amount', type: 'currency' }]
     expect(applyPendingRename(columns, 0, 'total').name).toBe('total')

apps/sim/lib/table/columns/service.ts

@@ -485,6 +485,21 @@ export async function deleteColumns(
   return def
 }
 
+/** Persists a column list as the table's schema and returns the updated definition. */
+async function persistColumns(
+  trx: DbTransaction,
+  table: TableDefinition,
+  columns: ColumnDefinition[]
+): Promise<TableDefinition> {
+  const updatedSchema: TableSchema = { ...table.schema, columns }
+  const now = new Date()
+  await trx
+    .update(userTableDefinitions)
+    .set({ schema: updatedSchema, updatedAt: now })
+    .where(eq(userTableDefinitions.id, table.id))
+  return { ...table, schema: updatedSchema, updatedAt: now }
+}
+
 /**
  * Whether any two rows share a stored value in this column.
  *
@@ -627,7 +642,15 @@ export async function updateColumnType(
 
     const column = schema.columns[columnIndex]
     if (column.type === data.newType) {
-      return table
+      // The type is unchanged, but a rename folded into this same request still
+      // has to land — returning here unconditionally would drop it silently.
+      const renamed = applyPendingRename(schema.columns, columnIndex, data.newName)
+      if (renamed === column) return table
+      return persistColumns(
+        trx,
+        table,
+        schema.columns.map((c, i) => (i === columnIndex ? renamed : c))
+      )
     }
     const columnKey = getColumnId(column)
 
@@ -1097,7 +1120,9 @@ export async function updateColumnCurrency(
       throw new Error(`Invalid column: ${columnValidation.errors.join('; ')}`)
     }
 
-    if (updatedColumn.currencyCode === column.currencyCode) {
+    // Only a no-op when the currency is unchanged AND no rename is riding along.
+    const renamePending = data.newName !== undefined && data.newName !== column.name
+    if (updatedColumn.currencyCode === column.currencyCode && !renamePending) {
       return table
     }