fix(tables): carry type metadata through the import column-create path

`addTableColumnsWithTx` built each column from five fields and dropped
everything else the caller supplied, so an imported date column landed with
`includeTime` absent — the "predates the key" state — and coercion and the grid
then treated a column created moments ago as a legacy instant column. It now
carries the type's owned keys and defaults, the same way `addTableColumn` does.

An inferred date column is stamped `includeTime: true` rather than taking the
sidebar's date-only default. The pattern that infers `date` accepts
`2024-01-15T14:30`, so the file may genuinely contain times, and defaulting to
date-only would truncate every one of them on write. Creating a Date column by
hand still defaults to date-only: there the user sees the toggle and there is
no data to lose yet.

Author: waleedlatif1

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

@@ -21,7 +21,7 @@ import {
 } from '@/lib/table/column-types'
 import { metadataMigrationFor } from '@/lib/table/column-types/registry.server'
 import { buildConvertedColumn } from '@/lib/table/columns/service'
-import { coerceValue } from '@/lib/table/import'
+import { coerceValue, inferSchemaFromCsv } from '@/lib/table/import'
 import { filterRulesToFilter, prunePredicateForColumns } from '@/lib/table/query-builder/converters'
 import { buildFilterClause } from '@/lib/table/sql'
 import type { ColumnDefinition } from '@/lib/table/types'
@@ -586,6 +586,31 @@ describe('server-side operand canonicalization', () => {
   })
 })
 
+describe('imported column metadata', () => {
+  it('gives an inferred date column an explicit includeTime that keeps its times', () => {
+    // The pattern that infers `date` accepts `2024-01-15T14:30`, so the file
+    // may genuinely contain times. Stamping the sidebar's date-only default
+    // would truncate every one of them; leaving it ABSENT would put a freshly
+    // created column into the "predates the key" state.
+    const { columns } = inferSchemaFromCsv(
+      ['when'],
+      [{ when: '2024-01-15T14:30' }, { when: '2024-02-20T09:00' }]
+    )
+    expect(columns[0].type).toBe('date')
+    expect(columns[0].includeTime).toBe(true)
+
+    // And the value survives the write path unchanged.
+    const coerced = coerceValue('2024-01-15T14:30', 'date', { column: columns[0] })
+    expect(String(coerced)).toContain('14:30')
+  })
+
+  it('leaves a non-date inferred column without date metadata', () => {
+    const { columns } = inferSchemaFromCsv(['n'], [{ n: '1' }, { n: '2' }])
+    expect(columns[0].type).toBe('number')
+    expect(columns[0].includeTime).toBeUndefined()
+  })
+})
+
 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/import.ts

@@ -372,9 +372,19 @@ export function inferSchemaFromCsv(
     seen.add(colName.toLowerCase())
     headerToColumn.set(header, colName)
 
+    const type = inferColumnType(sample.map((r) => r[header]))
     return {
       name: colName,
-      type: inferColumnType(sample.map((r) => r[header])),
+      type,
+      // An inferred date column keeps its times. The pattern that infers `date`
+      // accepts `2024-01-15T14:30`, so the file may genuinely contain them —
+      // and stamping the sidebar's date-only default here would truncate every
+      // one of them on write. Set explicitly rather than left absent so a fresh
+      // column is never in the "predates the key" state.
+      //
+      // Deliberately different from creating a Date column by hand: there the
+      // user sees the toggle and there is no data to lose yet.
+      ...(type === 'date' ? { includeTime: true } : {}),
     } satisfies ColumnDefinition
   })
 

apps/sim/lib/table/service.ts

@@ -20,6 +20,12 @@ import { resolveRestoredFolderId } from '@/lib/folders/queries'
 import { notifyWorkspaceTablesChanged } from '@/lib/realtime/notify'
 import { assertRowCapacity, notifyTableRowUsage } from '@/lib/table/billing'
 import { generateColumnId, getColumnId, withGeneratedColumnIds } from '@/lib/table/column-keys'
+import {
+  columnTypeById,
+  metadataWithoutClears,
+  ownedKeysOf,
+  pickMetadata,
+} from '@/lib/table/column-types'
 import { COLUMN_TYPES, NAME_PATTERN, TABLE_LIMITS } from '@/lib/table/constants'
 import { tableNotFound } from '@/lib/table/errors'
 import { appendTableEvent } from '@/lib/table/events'
@@ -29,6 +35,7 @@ import { nKeysBetween } from '@/lib/table/order-key'
 import type { DbTransaction } from '@/lib/table/planner'
 import { setTableTxTimeouts } from '@/lib/table/tx'
 import {
+  type ColumnTypeMetadata,
   type CreateTableData,
   TABLE_LOCK_FLAGS,
   TABLE_LOCK_KINDS,
@@ -465,7 +472,13 @@ export async function createTable(
 export async function addTableColumnsWithTx(
   trx: DbTransaction,
   table: TableDefinition,
-  columns: { id?: string; name: string; type: string; required?: boolean; unique?: boolean }[],
+  columns: (ColumnTypeMetadata & {
+    id?: string
+    name: string
+    type: string
+    required?: boolean
+    unique?: boolean
+  })[],
   requestId: string
 ): Promise<TableDefinition> {
   if (columns.length === 0) return table
@@ -501,12 +514,21 @@ export async function addTableColumnsWithTx(
     // Honor a caller-assigned id (the CSV append path pre-assigns so coercion
     // and persistence agree); otherwise mint one.
     const id = column.id ?? generateColumnId()
+    const type = column.type as TableSchema['columns'][number]['type']
     additions.push({
       id,
       name: column.name,
-      type: column.type as TableSchema['columns'][number]['type'],
+      type,
       required: column.required ?? false,
       unique: column.unique ?? false,
+      // Carry the type's own metadata, mirroring `addTableColumn`. Building the
+      // column from these five fields alone dropped everything else the caller
+      // supplied — an imported date column lost its `includeTime` and landed in
+      // the "predates the key" state, where the grid and coercion treat it as a
+      // legacy instant column rather than as what the import decided.
+      // A create has nothing to clear, so resolve any nulls away.
+      ...metadataWithoutClears(pickMetadata(column, ownedKeysOf(type))),
+      ...columnTypeById(type).defaultMetadata?.({ name: column.name, type }),
     })
   }