fix(tables): address Bugbot round 1

Retype's stale-work guard hardcoded options/multiple/currencyCode, so a request
carrying `precision` or `includeTime` against an already-correct type hit the
rename-only path and was silently discarded while reporting success — the exact
hand-listed-key bug this PR exists to remove. It reads TYPE_SPECIFIC_COLUMN_KEYS
now.

Filter values are read through the column that owns them. `parseScalar` returns
NaN for `50%`, `1h` and `$1,234.56`, so the value stayed a string, met the
numeric cast, and the range filter was rejected outright. Only cast columns take
this path — a text column keeps parseScalar's existing coercion and a select
keeps its option id verbatim.

CSV import was the one write path that bypassed `applyIncludeTime`, so an import
could put an instant into a column whose schema says it holds calendar days.

Decimal places is now clearable: the update sent nothing when the field was
emptied, so a precision could be set but never unset. `null` on the update
contract removes a key, applied in `updateColumnMetadata` and mirrored in the
optimistic cache. Non-finite input no longer clamps to 0 and saves as "zero
decimal places".

Filter pruning also moved off `type === 'select'` onto storesOpaqueIds /
storesMultipleValues, which the earlier sweep had missed.

Author: waleedlatif1

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

@@ -20,7 +20,12 @@ import {
   updateColumnType,
 } from '@/lib/table'
 import { columnMatchesRef, getColumnId } from '@/lib/table/column-keys'
-import { columnTypeById, metadataKeysIn, pickMetadata } from '@/lib/table/column-types'
+import {
+  columnTypeById,
+  metadataKeysIn,
+  metadataWithoutClears,
+  pickMetadata,
+} from '@/lib/table/column-types'
 import { validateMetadataUpdate } from '@/lib/table/columns/metadata'
 import { signalTableSchemaChanged } from '@/lib/table/events'
 import {
@@ -216,7 +221,9 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Colu
           // Every type-specific key the payload carries, whichever writer would
           // own it standalone: a conversion applies its target's metadata in the
           // same transaction rather than leaving it to a second write.
-          ...pickMetadata(updates, [...genericMetadataKeys, ...dedicatedMetadataKeys]),
+          ...metadataWithoutClears(
+            pickMetadata(updates, [...genericMetadataKeys, ...dedicatedMetadataKeys])
+          ),
           // Forwarded so the conversion validates against the constraint this
           // same request is about to set, not the column's current one.
           ...(updates.required !== undefined ? { required: updates.required } : {}),

apps/sim/app/api/v1/tables/[tableId]/columns/route.ts

@@ -19,7 +19,12 @@ import {
   updateColumnType,
 } from '@/lib/table'
 import { columnMatchesRef, getColumnId } from '@/lib/table/column-keys'
-import { columnTypeById, metadataKeysIn, pickMetadata } from '@/lib/table/column-types'
+import {
+  columnTypeById,
+  metadataKeysIn,
+  metadataWithoutClears,
+  pickMetadata,
+} from '@/lib/table/column-types'
 import { validateMetadataUpdate } from '@/lib/table/columns/metadata'
 import { signalTableSchemaChanged } from '@/lib/table/events'
 import {
@@ -250,7 +255,9 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Colu
           // Every type-specific key the payload carries, whichever writer would
           // own it standalone: a conversion applies its target's metadata in the
           // same transaction rather than leaving it to a second write.
-          ...pickMetadata(updates, [...genericMetadataKeys, ...dedicatedMetadataKeys]),
+          ...metadataWithoutClears(
+            pickMetadata(updates, [...genericMetadataKeys, ...dedicatedMetadataKeys])
+          ),
           // Forwarded so the conversion validates against the constraint this
           // same request is about to set, not the column's current one.
           ...(updates.required !== undefined ? { required: updates.required } : {}),

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/column-config-sidebar/column-config-sidebar.tsx

@@ -159,8 +159,15 @@ function ColumnConfigBody({
   // type that loses it cannot leave a stale control behind.
   const wantsCurrency = typeOwnsMetadataKey(typeInput, 'currencyCode')
   const wantsPrecision = typeOwnsMetadataKey(typeInput, 'precision')
+  // `undefined` means "no precision declared" — the field is legitimately
+  // clearable back to rendering values as stored. A non-empty value that is not
+  // a finite number is treated the same rather than clamping to 0, so garbage
+  // never silently saves as "zero decimal places".
+  const precisionNumber = Number(precisionInput)
   const parsedPrecision =
-    precisionInput.trim() === '' ? undefined : clampPrecision(Number(precisionInput))
+    precisionInput.trim() === '' || !Number.isFinite(precisionNumber)
+      ? undefined
+      : clampPrecision(precisionNumber)
   const wantsIncludeTime = typeOwnsMetadataKey(typeInput, 'includeTime')
   const trimmedOptions = optionsInput.map((o) => ({ ...o, name: o.name.trim() }))
 
@@ -231,7 +238,7 @@ function ColumnConfigBody({
         options?: SelectOption[]
         multiple?: boolean
         currencyCode?: string
-        precision?: number
+        precision?: number | null
         includeTime?: boolean
       } = {
         ...(renamed ? { name: trimmedName } : {}),
@@ -243,8 +250,11 @@ function ColumnConfigBody({
         ...(wantsCurrency && (typeChanged || currencyChanged)
           ? { currencyCode: currencyInput }
           : {}),
-        ...(wantsPrecision && (typeChanged || precisionChanged) && parsedPrecision !== undefined
-          ? { precision: parsedPrecision }
+        // `null` clears the key. Gating on `!== undefined` meant emptying the
+        // field sent nothing at all, so an existing precision could never be
+        // removed once set.
+        ...(wantsPrecision && (typeChanged || precisionChanged)
+          ? { precision: parsedPrecision ?? null }
           : {}),
         ...(wantsIncludeTime && (typeChanged || includeTimeChanged)
           ? { includeTime: includeTimeInput }

apps/sim/hooks/queries/tables.ts

@@ -86,6 +86,7 @@ import {
 } from '@/lib/api/contracts/tables'
 import { buildUpgradeHref } from '@/lib/billing/upgrade-reasons'
 import type {
+  ColumnDefinition,
   CsvHeaderMapping,
   EnrichmentRunDetail,
   RowData,
@@ -1365,7 +1366,15 @@ export function useUpdateColumn({ workspaceId, tableId }: RowMutationContext) {
         const isRename = typeof (updates as { name?: string }).name === 'string'
         const nextColumns = previousDetail.schema.columns.map((c) => {
           if (getColumnId(c) !== columnName && c.name.toLowerCase() !== lower) return c
-          const next = { ...c, ...updates }
+          // A `null` in the payload CLEARS its key server-side, so the
+          // optimistic column must drop it too — spreading the null straight
+          // in would leave the grid rendering against a shape the server will
+          // never return.
+          const next: ColumnDefinition = { ...c }
+          for (const [key, value] of Object.entries(updates)) {
+            if (value === null) delete next[key as keyof ColumnDefinition]
+            else Object.assign(next, { [key]: value })
+          }
           if (isRename && next.id === undefined) next.id = getColumnId(c)
           return next
         })

apps/sim/lib/api/contracts/tables.ts

@@ -38,7 +38,7 @@ import {
   TABLE_LIMITS,
 } from '@/lib/table/constants'
 import { CSV_MAX_FILE_SIZE_BYTES } from '@/lib/table/import'
-import type { ColumnTypeMetadata } from '@/lib/table/types'
+import type { ColumnMetadataPatch } from '@/lib/table/types'
 import { SELECT_OPTION_COLORS } from '@/lib/table/types'
 
 export const domainObjectSchema = <T>() => z.custom<T>(isRecordLike)
@@ -103,7 +103,7 @@ function refineColumnOptions(
     type?: (typeof COLUMN_TYPES)[number]
     options?: z.infer<typeof selectOptionsSchema>
     multiple?: boolean
-  } & ColumnTypeMetadata,
+  } & ColumnMetadataPatch,
   ctx: z.RefinementCtx
 ): void {
   // Keys the type cannot be created without, checked before the ownership sweep
@@ -321,7 +321,10 @@ export const updateTableColumnBodySchema = z.object({
       unique: z.boolean().optional(),
       options: selectOptionsSchema.optional(),
       multiple: z.boolean().optional(),
-      precision: precisionSchema.optional(),
+      /** `null` clears the setting, returning the column to rendering values as
+       *  stored. Only the UPDATE surface accepts it — on a create there is
+       *  nothing to clear. */
+      precision: precisionSchema.nullable().optional(),
       includeTime: z.boolean().optional(),
       currencyCode: currencyCodeSchema.optional(),
     })

apps/sim/lib/copilot/tools/server/table/user-table.ts

@@ -37,6 +37,7 @@ import { columnTypeForLeaf, deriveOutputColumnName } from '@/lib/table/column-na
 import {
   columnTypeById,
   metadataKeysIn,
+  metadataWithoutClears,
   pickMetadata,
   TYPE_SPECIFIC_COLUMN_KEYS,
   validateTypeMetadata,
@@ -1787,7 +1788,7 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
                 newType: newType as (typeof COLUMN_TYPES)[number],
                 options,
                 multiple,
-                ...pickMetadata(metadataUpdates, genericMetadataKeys),
+                ...metadataWithoutClears(pickMetadata(metadataUpdates, genericMetadataKeys)),
                 ...(uniqFlag !== undefined ? { unique: uniqFlag } : {}),
               },
               requestId

apps/sim/lib/table/__tests__/column-types-contact.test.ts

@@ -16,6 +16,8 @@ import {
   isValueCompatible,
   ownersOfMetadataKey,
 } from '@/lib/table/column-types'
+import { coerceValue } from '@/lib/table/import'
+import { filterRulesToFilter } from '@/lib/table/query-builder/converters'
 import type { ColumnDefinition } from '@/lib/table/types'
 
 const column = (type: ColumnDefinition['type'], extra: Partial<ColumnDefinition> = {}) =>
@@ -223,6 +225,52 @@ describe('audit regressions', () => {
   })
 })
 
+describe('review-round regressions', () => {
+  it('reads a formatted filter value through the column that owns it', () => {
+    // `parseScalar` returns NaN for `50%` / `1h` / `$1,234.56`, so the value
+    // stayed a string, hit the numeric cast, and the range filter was rejected.
+    const cases: Array<[ColumnDefinition['type'], string, number]> = [
+      ['percent', '50%', 50],
+      ['duration', '1h', 3600],
+      ['duration', '1:30', 90],
+      ['currency', '$1,234.56', 1234.56],
+    ]
+    for (const [type, typed, expected] of cases) {
+      const col = column(type)
+      const rules = [
+        { id: 'r1', logicalOperator: 'and' as const, column: 'c', operator: 'gte', value: typed },
+      ]
+      const filter = filterRulesToFilter(rules, [{ ...col, id: 'c' }])
+      expect(filter, `${type} ${typed}`).toEqual({ c: { $gte: expected } })
+    }
+  })
+
+  it('leaves text- and opaque-id columns on their existing coercion', () => {
+    // The type-aware parse must apply ONLY to cast columns. A text column keeps
+    // `parseScalar`'s long-standing number coercion, and a select keeps its
+    // option id verbatim — an id of "1" coerced to a number would compare
+    // against the stored JSON string by containment and match nothing.
+    const eq = (value: string, col: ColumnDefinition) =>
+      filterRulesToFilter(
+        [{ id: 'r1', logicalOperator: 'and' as const, column: 'c', operator: 'eq', value }],
+        [{ ...col, id: 'c' }]
+      )
+    expect(eq('123', column('string'))).toEqual({ c: 123 })
+    expect(eq('1', column('select', { options: [{ id: '1', name: 'One' }] }))).toEqual({ c: '1' })
+  })
+
+  it('truncates an imported date for a date-only column', () => {
+    // CSV import was the one write path that bypassed `applyIncludeTime`.
+    const dateOnly = column('date', { includeTime: false })
+    expect(coerceValue('2024-01-15T13:45:00Z', 'date', { column: dateOnly })).toBe('2024-01-15')
+  })
+
+  it('leaves an imported date alone for a column that carries time', () => {
+    const withTime = column('date', { includeTime: true })
+    expect(coerceValue('2024-01-15T13:45:00Z', 'date', { column: withTime })).toContain('13:45')
+  })
+})
+
 describe('date includeTime', () => {
   it('truncates to a calendar day only when includeTime is explicitly false', () => {
     const dateOnly = column('date', { includeTime: false })

apps/sim/lib/table/column-types/registry.ts

@@ -41,7 +41,12 @@ import type {
 } from '@/lib/table/column-types/types'
 import { COLUMN_TYPES, TYPE_SPECIFIC_COLUMN_KEYS } from '@/lib/table/column-types/types'
 import { urlColumnType } from '@/lib/table/column-types/url'
-import type { ColumnDefinition, JsonValue } from '@/lib/table/types'
+import type {
+  ColumnDefinition,
+  ColumnMetadataPatch,
+  ColumnTypeMetadata,
+  JsonValue,
+} from '@/lib/table/types'
 
 export { COLUMN_TYPES }
 export { MULTI_SELECT_OPERATORS, SINGLE_SELECT_OPERATORS }
@@ -185,7 +190,7 @@ export function ownersOfMetadataKey(key: TypeSpecificColumnKey): ColumnTypeDefin
  * owner keeps its own writer — today only `select`'s `options` / `multiple`.
  * Callers branch on which set is non-empty instead of testing key names.
  */
-export function metadataKeysIn(updates: Partial<ColumnDefinition>): {
+export function metadataKeysIn(updates: ColumnMetadataPatch): {
   generic: TypeSpecificColumnKey[]
   dedicated: TypeSpecificColumnKey[]
 } {
@@ -202,6 +207,22 @@ export function metadataKeysIn(updates: Partial<ColumnDefinition>): {
   return { generic, dedicated }
 }
 
+/**
+ * A metadata patch with its clears dropped, for the conversion path.
+ *
+ * On a retype, "remove this key" and "never had this key" are the same thing —
+ * the converted column is rebuilt from the target type's owned keys — so a
+ * `null` is simply not carried across.
+ */
+export function metadataWithoutClears(patch: ColumnMetadataPatch): ColumnTypeMetadata {
+  const resolved: ColumnTypeMetadata = {}
+  for (const key of TYPE_SPECIFIC_COLUMN_KEYS) {
+    const value = patch[key]
+    if (value !== undefined && value !== null) Object.assign(resolved, { [key]: value })
+  }
+  return resolved
+}
+
 /** Whether a column of `type` may carry `key`. */
 export function typeOwnsMetadataKey(type: string | undefined, key: TypeSpecificColumnKey): boolean {
   return columnTypeById(type).ownedMetadata.includes(key)
@@ -215,10 +236,10 @@ export function typeOwnsMetadataKey(type: string | undefined, key: TypeSpecificC
  * this key" to `filterUndefined` further down the write path.
  */
 export function pickMetadata(
-  updates: Partial<ColumnDefinition>,
+  updates: ColumnMetadataPatch,
   keys: readonly TypeSpecificColumnKey[]
-): Partial<ColumnDefinition> {
-  const picked: Partial<ColumnDefinition> = {}
+): ColumnMetadataPatch {
+  const picked: ColumnMetadataPatch = {}
   for (const key of keys) {
     if (updates[key] !== undefined) Object.assign(picked, { [key]: updates[key] })
   }

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

@@ -12,10 +12,11 @@
 import {
   columnTypeById,
   metadataKeysIn,
+  metadataWithoutClears,
   ownersOfMetadataKey,
   pickMetadata,
 } from '@/lib/table/column-types'
-import type { ColumnDefinition } from '@/lib/table/types'
+import type { ColumnDefinition, ColumnMetadataPatch } from '@/lib/table/types'
 
 /**
  * Rejects a metadata update that the column's resulting type cannot accept.
@@ -35,7 +36,7 @@ import type { ColumnDefinition } from '@/lib/table/types'
 export function validateMetadataUpdate(
   currentColumn: ColumnDefinition,
   resultingType: string | undefined,
-  updates: Partial<ColumnDefinition>
+  updates: ColumnMetadataPatch
 ): string | null {
   const { generic, dedicated } = metadataKeysIn(updates)
   const definition = columnTypeById(resultingType)
@@ -60,10 +61,15 @@ export function validateMetadataUpdate(
   // `updates` wholesale would fold in a pending `name`, so rejecting a bad
   // value would name the column by a rename that this very request is refusing
   // to perform.
+  // A cleared key (`null`) validates as ABSENT — that is what the write will
+  // leave behind — rather than as a null the type's validator has no arm for.
   const resulting: ColumnDefinition = {
     ...currentColumn,
     ...(resultingType ? { type: definition.id } : {}),
-    ...pickMetadata(updates, [...generic, ...dedicated]),
+    ...metadataWithoutClears(pickMetadata(updates, [...generic, ...dedicated])),
+  }
+  for (const key of [...generic, ...dedicated]) {
+    if (updates[key] === null) delete resulting[key]
   }
   const errors = definition.validateDefinition?.(resulting) ?? []
   return errors[0] ?? null

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

@@ -19,6 +19,7 @@ import {
   columnTypeById,
   columnTypeOf,
   isValueCompatible,
+  metadataWithoutClears,
   pickMetadata,
   TYPE_SPECIFIC_COLUMN_KEYS,
   type TypeSpecificColumnKey,
@@ -707,12 +708,14 @@ export async function updateColumnType(
       // rename can be honoured without a conversion; anything else would be
       // silently discarded, and answering success for a change that never
       // happened is the worst outcome available.
+      // Read the metadata keys from the registry, not a hand-written list. The
+      // three that used to be named here meant a newly declared key (a
+      // `precision`, an `includeTime`) rode this path and was silently
+      // discarded while the request reported success.
       const carriesOtherWork =
         data.required !== undefined ||
         data.unique !== undefined ||
-        data.options !== undefined ||
-        data.multiple !== undefined ||
-        data.currencyCode !== undefined
+        TYPE_SPECIFIC_COLUMN_KEYS.some((key) => data[key] !== undefined)
       if (carriesOtherWork) {
         throw new Error(
           `Column "${column.name}" is already type "${data.newType}"; re-issue the request without a type change.`
@@ -1164,12 +1167,24 @@ export async function updateColumnMetadata(
     // stamp a default onto a column that predates that key — writing
     // `includeTime: false` onto a legacy date column and truncating every
     // stored time as a side effect of an unrelated metadata edit.
-    const merged: ColumnDefinition = { ...column, ...incoming }
+    // A `null` REMOVES its key rather than writing one — that is how a setting
+    // whose absence is meaningful (a `precision`, which absent means "render as
+    // stored") is returned to that state once set.
+    const sentKeys = Object.keys(incoming) as TypeSpecificColumnKey[]
+    const merged: ColumnDefinition = { ...column, ...metadataWithoutClears(incoming) }
+    for (const key of sentKeys) {
+      if (incoming[key] === null) delete merged[key]
+    }
     const defaults = definition.defaultMetadata?.(merged) ?? {}
-    const sentKeys = new Set(Object.keys(incoming))
     const updatedColumn: ColumnDefinition = {
       ...merged,
-      ...pickMetadata(defaults, [...sentKeys] as TypeSpecificColumnKey[]),
+      // Defaults only fill keys this request SET; a cleared key stays cleared.
+      ...metadataWithoutClears(
+        pickMetadata(
+          defaults,
+          sentKeys.filter((key) => incoming[key] !== null)
+        )
+      ),
     }
 
     const columnValidation = validateColumnDefinition(updatedColumn)