fix(tables): share one inferred-column builder across every import path

The append route and the import runner each had their own inline copy of
"infer a type, build a column", so the `includeTime: true` added to the
create-from-CSV path never reached them. An appended date column was persisted
DATE-ONLY while its rows were coerced WITH their times — the schema and the
data disagreeing about the same column, which then shows up as wrong display,
wrong filters, and truncation on the next write.

Fixing the third copy in place would have left a fourth: the import runner had
the same inline call. The decision now lives in `inferredColumnDefinition`, and
all four sites call it — because the inferred TYPE is not the whole answer, and
splitting the two halves across call sites is what let them drift.

Pinned by asserting the entry points agree with each other rather than
restating the expected value in each, plus that the inferred column survives
persistence so the stored shape matches how its rows were coerced.

Author: waleedlatif1

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

@@ -27,7 +27,7 @@ import {
   dispatchAfterBatchInsert,
   generateColumnId,
   getMaxRowsPerTable,
-  inferColumnType,
+  inferredColumnDefinition,
   markTableJobRunning,
   releaseJobClaim,
   sanitizeName,
@@ -230,15 +230,21 @@ export const POST = withRouteHandler(async (request: NextRequest, { params }: Ro
           suffix++
         }
         usedNames.add(columnName.toLowerCase())
-        const inferredType = inferColumnType(rows.map((r) => r[header]))
+        // Same helper the create-from-CSV path uses, so the two cannot answer
+        // differently. Inlining just the TYPE here persisted an appended date
+        // column as date-only while its rows were coerced with their times.
+        const inferred = inferredColumnDefinition(
+          columnName,
+          rows.map((r) => r[header])
+        )
         // Pre-assign the id so the prospective schema (used to coerce rows) and
         // the persisted column (created in importAppendRows) share the same key.
         const id = generateColumnId()
-        additions.push({ id, name: columnName, type: inferredType })
+        additions.push({ ...inferred, id })
         newColumns.push({
+          ...inferred,
           id,
-          name: columnName,
-          type: inferredType as TableSchema['columns'][number]['type'],
+          type: inferred.type as TableSchema['columns'][number]['type'],
           required: false,
           unique: false,
         })

apps/sim/lib/table/__tests__/backward-compatibility.test.ts

@@ -19,8 +19,13 @@ import { describe, expect, it } from 'vitest'
 import { COLUMN_TYPE_REGISTRY } from '@/lib/table/column-types'
 import { TABLE_LIMITS } from '@/lib/table/constants'
 import { TableRequestError, tableNotFound } from '@/lib/table/errors'
-import { coerceValue, inferColumnType } from '@/lib/table/import'
-import { buildAddedColumns } from '@/lib/table/service'
+import {
+  coerceValue,
+  inferColumnType,
+  inferredColumnDefinition,
+  inferSchemaFromCsv,
+} from '@/lib/table/import'
+import { buildAddedColumn, buildAddedColumns } from '@/lib/table/service'
 import { buildFilterClause, buildSortClause } from '@/lib/table/sql'
 import type { ColumnDefinition, Filter, JsonValue, Sort } from '@/lib/table/types'
 import { validateColumnDefinition } from '@/lib/table/validation'
@@ -302,3 +307,44 @@ describe('caller-fixable failures are typed, not string-matched', () => {
     expect(new TableRequestError('anything').status).toBe(400)
   })
 })
+
+describe('every import path builds an inferred column identically', () => {
+  const withTimes = [{ when: '2024-01-15T14:30' }, { when: '2024-02-20T09:00' }]
+
+  it('gives an inferred date column includeTime through the shared helper', () => {
+    const column = inferredColumnDefinition(
+      'when',
+      withTimes.map((r) => r.when)
+    )
+    expect(column.type).toBe('date')
+    expect(column.includeTime).toBe(true)
+  })
+
+  it('agrees with inferSchemaFromCsv, which is the other entry point', () => {
+    // Three call sites built this inline and drifted: the append route and the
+    // import runner persisted an appended date column as date-only while its
+    // rows were coerced WITH their times.
+    const viaSchema = inferSchemaFromCsv(['when'], withTimes).columns[0]
+    const viaHelper = inferredColumnDefinition(
+      'when',
+      withTimes.map((r) => r.when)
+    )
+    expect(viaSchema).toEqual(viaHelper)
+  })
+
+  it('survives persistence, so the stored column matches how rows were coerced', () => {
+    const inferred = inferredColumnDefinition(
+      'when',
+      withTimes.map((r) => r.when)
+    )
+    const stored = buildAddedColumn(inferred, 'col_1')
+    expect(stored.includeTime).toBe(true)
+    // And a value with a time round-trips rather than being truncated.
+    expect(String(coerceValue('2024-01-15T14:30', 'date', { column: stored }))).toContain('14:30')
+  })
+
+  it('adds no date metadata to a non-date inferred column', () => {
+    expect(inferredColumnDefinition('n', ['1', '2']).includeTime).toBeUndefined()
+    expect(inferredColumnDefinition('s', ['a', 'b']).type).toBe('string')
+  })
+})

apps/sim/lib/table/import-runner.ts

@@ -11,7 +11,7 @@ import {
   type CsvHeaderMapping,
   coerceRowsForTable,
   createCsvParser,
-  inferColumnType,
+  inferredColumnDefinition,
   inferSchemaFromCsv,
   sanitizeName,
   type TableSchema,
@@ -217,7 +217,14 @@ export async function runTableImport(payload: TableImportPayload): Promise<void>
             suffix++
           }
           usedNames.add(columnName.toLowerCase())
-          additions.push({ name: columnName, type: inferColumnType(sample.map((r) => r[header])) })
+          // Shared with both import routes, so an appended date column is
+          // never persisted date-only while its rows carry times.
+          additions.push(
+            inferredColumnDefinition(
+              columnName,
+              sample.map((r) => r[header])
+            )
+          )
           updatedMapping[header] = columnName
         }
         const updated = await addImportColumns(

apps/sim/lib/table/import.ts

@@ -292,6 +292,32 @@ export async function parseCsvBuffer(
  * column would also have to guess an ISO code from a symbol, and guessing wrong
  * mislabels every amount in the column.
  */
+/**
+ * The column definition an import creates for a header, from its sampled values.
+ *
+ * The single place that turns an inferred type into a persisted column, because
+ * the type alone is not the whole answer. Both import entry points call it —
+ * creating a table from a CSV, and appending a CSV that introduces new headers
+ * — and when the second had its own inline copy, an appended date column was
+ * persisted date-only while its rows were coerced WITH their times.
+ */
+export function inferredColumnDefinition(name: string, values: unknown[]): ColumnDefinition {
+  const type = inferColumnType(values)
+  return {
+    name,
+    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 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 } : {}),
+  }
+}
+
 export function inferColumnType(values: unknown[]): InferredCsvColumnType {
   const nonEmpty = values.filter((v) => v !== null && v !== undefined && v !== '')
   if (nonEmpty.length === 0) return 'string'
@@ -372,20 +398,10 @@ export function inferSchemaFromCsv(
     seen.add(colName.toLowerCase())
     headerToColumn.set(header, colName)
 
-    const type = inferColumnType(sample.map((r) => r[header]))
-    return {
-      name: colName,
-      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
+    return inferredColumnDefinition(
+      colName,
+      sample.map((r) => r[header])
+    )
   })
 
   return { columns, headerToColumn }