fix(tables): use native timestamp validation

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: j15z

apps/sim/background/cleanup-table-row-ttl.integration.test.ts

@@ -28,12 +28,13 @@ vi.mock('@/lib/table/events', () => ({ signalTableRowsChanged: signalChanged }))
 vi.mock('@/lib/table/trigger', () => ({ fireTableTrigger: fireTrigger }))
 
 import { db } from '@sim/db'
+import { validatedTimestampSql } from '@/lib/table/column-types/timestamp-sql'
 import { updateColumnConstraints } from '@/lib/table/columns/service'
 import { getDeleteSnapshotBatchSize } from '@/lib/table/constants'
 import { replaceTableRowsWithTx } from '@/lib/table/rows/service'
 import { getTableById } from '@/lib/table/service'
 import { fieldPredicate } from '@/lib/table/sql'
-import { normalizeTtlTimestamp } from '@/lib/table/ttl-values'
+import { normalizeTtlTimestamp, TTL_TIMESTAMP_VALIDATION } from '@/lib/table/ttl-values'
 import type { TableSchema } from '@/lib/table/types'
 import { checkBatchUniqueConstraintsDb, coerceRowToSchema } from '@/lib/table/validation'
 import { runCleanupTableRowTtl } from '@/background/cleanup-table-row-ttl'
@@ -582,6 +583,12 @@ describe.skipIf(!url)('Expiration with real PostgreSQL transactions', () => {
       unnest(${samples}::text[], ${normalized}::text[]) AS instants(input, normalized)
       WHERE input::timestamptz != normalized::timestamptz`
     expect(result.mismatch).toBe(0)
+    const guarded = await db.execute(sql`WITH samples AS MATERIALIZED (
+      SELECT jsonb_array_elements_text(${JSON.stringify(samples)}::jsonb) AS value
+    ) SELECT count(*)::int AS mismatch FROM samples
+      WHERE ${validatedTimestampSql(sql`samples.value`, TTL_TIMESTAMP_VALIDATION)}
+        IS DISTINCT FROM samples.value::timestamptz`)
+    expect(guarded[0].mismatch).toBe(0)
     measurements.postgresTimestampSamples = samples.length
   })
 

apps/sim/background/cleanup-table-row-ttl.test.ts

@@ -134,6 +134,17 @@ describe('table row TTL cleanup', () => {
           invalid_offset_day: '2026-02-30T12:00:00-07:00',
           invalid_offset: '2026-09-07T12:00:00+16:00',
           invalid_fraction: '2026-09-07T12:00:00.0000001Z',
+          rounding_future: '2026-09-07T12:00:00.5000001Z',
+          no_offset: '2020-01-01T00:00:00',
+          day_only: '2020-01-01',
+          relative_now: 'now',
+          relative_today: 'today',
+          relative_yesterday: 'yesterday',
+          epoch_alias: 'epoch',
+          past_infinity: '-infinity',
+          compact_offset: '2020-01-01T00:00:00+0000',
+          named_zone: '2020-01-01 00:00:00 America/Los_Angeles',
+          trailing_newline: '2020-01-01T00:00:00Z\n',
         }
         for (const [id, value] of Object.entries(values)) {
           await client`INSERT INTO user_table_rows (id, table_id, workspace_id, data) VALUES (${id}, ${table.id}, ${table.workspaceId}, ${client.json({ 'col-ttl': value })})`
@@ -241,7 +252,7 @@ describe('table row TTL cleanup', () => {
       .sql.replace(/\s+/g, ' ')
       .replace(/\$\d+/g, '?')
       .trim()
-    expect(query).toContain('THEN (table_row.data->>?)::timestamptz <= ?::timestamptz')
+    expect(query).toContain('THEN (table_row.data->>?)::timestamptz END <= ?::timestamptz')
     expect(query).toContain('ORDER BY table_row.created_at, table_row.id')
     expect(query).toContain('octet_length(table_row.data::text) AS snapshot_bytes')
     expect(query).toContain('cumulative_snapshot_bytes <= ?')

apps/sim/background/cleanup-table-row-ttl.ts

@@ -5,6 +5,7 @@ import { task } from '@trigger.dev/sdk'
 import { type SQL, sql } from 'drizzle-orm'
 import { asOrchestrationError } from '@/lib/core/orchestration/types'
 import { getColumnId } from '@/lib/table/column-keys'
+import { validatedTimestampSql } from '@/lib/table/column-types/timestamp-sql'
 import { getDeleteSnapshotBatchSize, TABLE_LIMITS } from '@/lib/table/constants'
 import { signalTableRowsChanged } from '@/lib/table/events'
 import { assertRowDelete, TableLockedError } from '@/lib/table/mutation-locks'
@@ -13,7 +14,7 @@ import type { DeletedTableRow } from '@/lib/table/rows/ordering'
 import { withLockedTable } from '@/lib/table/service'
 import { fireTableTrigger } from '@/lib/table/trigger'
 import { isTableRowTtlEnabled } from '@/lib/table/ttl-availability'
-import { TTL_TIMESTAMP_PATTERN } from '@/lib/table/ttl-values'
+import { TTL_TIMESTAMP_VALIDATION } from '@/lib/table/ttl-values'
 import type { RowData, TableSchema } from '@/lib/table/types'
 
 const logger = createLogger('CleanupTableRowTtl')
@@ -59,20 +60,9 @@ export interface TableRowTtlCleanupResult {
   limitReached: boolean
 }
 
-/** Guards the timestamp cast, including calendar validity, on PostgreSQL 14+. */
+/** Shares PostgreSQL's validated instant projection with Expiration comparisons. */
 function expiredTtlPredicate(cell: SQL, nowUtc: string): SQL {
-  return sql`CASE
-    WHEN ${cell} ~ ${TTL_TIMESTAMP_PATTERN}
-    THEN CASE
-      WHEN substring(${cell}, 9, 2)::int <= extract(day FROM (
-        make_date(substring(${cell}, 1, 4)::int, substring(${cell}, 6, 2)::int, 1)
-          + interval '1 month - 1 day'
-      ))
-      THEN (${cell})::timestamptz <= ${nowUtc}::timestamptz
-      ELSE false
-    END
-    ELSE false
-  END`
+  return sql`${validatedTimestampSql(cell, TTL_TIMESTAMP_VALIDATION)} <= ${nowUtc}::timestamptz`
 }
 
 async function listExpiredTtlTables(nowUtc: string): Promise<ExpiredTtlTableRef[]> {

apps/sim/lib/table/column-types/comparison-sql.ts

@@ -1,16 +1,14 @@
 import { type SQL, sql } from 'drizzle-orm'
 import { columnTypeOf } from '@/lib/table/column-types/registry'
+import { validatedTimestampSql } from '@/lib/table/column-types/timestamp-sql'
 import type { ColumnDefinition } from '@/lib/table/types'
 
 /** Casts stored text for equality, treating malformed explicit timestamps as absent instants. */
 export function columnTextForEquality(cell: SQL, column: ColumnDefinition): SQL {
   const definition = columnTypeOf(column)
   if (!definition.valueForEquality || !definition.jsonbCast) return cell
-  const cast = sql`(${cell})::${sql.raw(definition.jsonbCast)}`
-  if (!definition.timestampPattern) return cast
-  return sql`CASE WHEN ${cell} ~ ${definition.timestampPattern} THEN CASE
-    WHEN substring(${cell}, 9, 2)::int <= extract(day FROM (
-      make_date(substring(${cell}, 1, 4)::int, substring(${cell}, 6, 2)::int, 1)
-        + interval '1 month - 1 day'
-    )) THEN ${cast} END END`
+  if (definition.timestampValidation) {
+    return validatedTimestampSql(cell, definition.timestampValidation)
+  }
+  return sql`(${cell})::${sql.raw(definition.jsonbCast)}`
 }

apps/sim/lib/table/column-types/timestamp-sql.ts

@@ -0,0 +1,12 @@
+import { type SQL, sql } from 'drizzle-orm'
+import type { TimestampValidation } from '@/lib/table/column-types/types'
+
+/** PostgreSQL 16+ validates the cast; the format and precision rules prevent implicit or rounded instants. */
+export function validatedTimestampSql(cell: SQL, validation: TimestampValidation): SQL {
+  return sql`CASE
+    WHEN ${cell} ~* ${validation.pattern}
+      AND pg_input_is_valid(${cell}, 'timestamptz')
+      AND COALESCE(length(substring(${cell} from '[.]([0-9]+)')), 0) <= ${validation.maxFractionDigits}
+    THEN (${cell})::timestamptz
+  END`
+}

apps/sim/lib/table/column-types/ttl.test.ts

@@ -89,6 +89,15 @@ describe('TTL column type', () => {
     '2026-09-07T14:30:00.0000001Z',
     '2026-09-07 14:30:00Z',
     '2026-09-07T14:30:00Z ',
+    '2026-09-07T14:30:00Z\n',
+    '2026-09-07T14:30:00+0700',
+    '2026-09-07T14:30:00 America/Los_Angeles',
+    '2026-09-07T14:30:00Z[UTC]',
+    'now',
+    'today',
+    'epoch',
+    'infinity',
+    '-infinity',
     '2026-02-29T12:00:00Z',
     '2026-02-30T12:00:00Z',
     '2026-02-30T12:00:00-07:00',

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

@@ -4,7 +4,7 @@ import {
   isTtlTimestamp,
   normalizeTtlTimestamp,
   TTL_FORMAT_ERROR,
-  TTL_TIMESTAMP_PATTERN,
+  TTL_TIMESTAMP_VALIDATION,
   ttlInstantForComparison,
 } from '@/lib/table/ttl-values'
 
@@ -14,7 +14,7 @@ export const ttlColumnType: ColumnTypeDefinition = {
   maxPerTable: 1,
   icon: TypeTtl,
   jsonbCast: 'timestamptz',
-  timestampPattern: TTL_TIMESTAMP_PATTERN,
+  timestampValidation: TTL_TIMESTAMP_VALIDATION,
   storesOpaqueIds: false,
   supportsUnique: true,
   sampleValue: '2024-01-31T00:00:00-00:00',

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

@@ -70,6 +70,12 @@ export type TypeSpecificColumnKey = (typeof TYPE_SPECIFIC_COLUMN_KEYS)[number]
 /** Result of coercing a raw value toward a column's declared type. */
 export type CoerceResult = { ok: true; value: JsonValue } | { ok: false }
 
+/** Additional format and precision rules for native PostgreSQL timestamp validation. */
+export interface TimestampValidation {
+  readonly pattern: string
+  readonly maxFractionDigits: number
+}
+
 export interface ColumnTypeDefinition {
   readonly id: ColumnType
 
@@ -84,8 +90,8 @@ export interface ColumnTypeDefinition {
    * comparison is correct. Single source for both filter ranges and sort order.
    */
   readonly jsonbCast: 'numeric' | 'timestamptz' | null
-  /** Strict ISO shape guard for timestamp comparisons against potentially malformed stored cells. */
-  readonly timestampPattern?: string
+  /** Guards timestamp comparisons against malformed stored cells without guessing a timezone. */
+  readonly timestampValidation?: TimestampValidation
 
   /**
    * Wire operators a column of this type accepts, or `null` for "all

apps/sim/lib/table/ttl-values.ts

@@ -1,40 +1,46 @@
+import { z } from 'zod'
+
 export const TTL_FORMAT_ERROR =
   'Expiration must be an ISO timestamp with Z or an explicit UTC offset (for example, 2026-09-07T14:30:00-07:00), with at most 6 fractional second digits'
 
-/** Shared JavaScript/PostgreSQL shape guard; numeric offsets fit PostgreSQL's supported range. */
-export const TTL_TIMESTAMP_PATTERN =
-  '^((?!0000)[0-9]{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12][0-9]|3[01]))[Tt]((?:0[0-9]|1[0-9]|2[0-3]):[0-5][0-9])(?::([0-5][0-9])(?:[.]([0-9]{1,6}))?)?([Zz]|[+-](?:0[0-9]|1[0-5]):[0-5][0-9])$'
+/** Zod owns the ISO format; SQL also checks native timestamptz validity before casting. */
+export const TTL_TIMESTAMP_VALIDATION = {
+  pattern: z.regexes.datetime({ offset: true }).source,
+  maxFractionDigits: 6,
+} as const
 
-const TTL_TIMESTAMP_REGEX = new RegExp(TTL_TIMESTAMP_PATTERN)
+const timestampSchema = z.iso.datetime({ offset: true })
 
 function parseTtlTimestamp(value: unknown) {
-  if (typeof value !== 'string') return null
-  const match = TTL_TIMESTAMP_REGEX.exec(value)
-  if (!match) return null
+  if (typeof value !== 'string' || value !== value.trim()) return null
+  const result = timestampSchema.safeParse(value.toUpperCase())
+  if (!result.success) return null
 
-  const [, day, time, second, fractionalSecond, offset] = match
-  const wallClock = `${day}T${time}:${second ?? '00'}`
-  const wallMilliseconds = Date.parse(`${wallClock}Z`)
+  const timestamp = result.data
+  const offset = timestamp.endsWith('Z') ? 'Z' : timestamp.slice(-6)
+  const [dateTime, fractionalSecond = ''] = timestamp.slice(0, -offset.length).split('.')
   if (
-    !Number.isFinite(wallMilliseconds) ||
-    new Date(wallMilliseconds).toISOString() !== `${wallClock}.000Z`
+    timestamp.startsWith('0000-') ||
+    (offset !== 'Z' && Number(offset.slice(1, 3)) > 15) ||
+    fractionalSecond.length > TTL_TIMESTAMP_VALIDATION.maxFractionDigits
   ) {
     return null
   }
 
-  const instant = new Date(`${wallClock}${offset.toUpperCase()}`)
+  const wallClock = dateTime.length === 16 ? `${dateTime}:00` : dateTime
+  const instant = new Date(`${wallClock}${offset}`)
   if (
     !Number.isFinite(instant.getTime()) ||
     instant.getUTCFullYear() < 1 ||
     instant.getUTCFullYear() > 9999
   ) {
     return null
   }
-  const fraction = (fractionalSecond ?? '').replace(/0+$/, '')
+  const fraction = fractionalSecond.replace(/0+$/, '')
   return {
     wallClock,
     fraction: fraction ? `.${fraction}` : '',
-    offset: offset.toUpperCase() === 'Z' ? '-00:00' : offset,
+    offset: offset === 'Z' ? '-00:00' : offset,
     instant,
   }
 }