improvement(table): cast jsonb date filters/sorts to timestamptz

::timestamp strips timezone offsets from ISO strings, making comparisons
depend on the server TimeZone setting. ::timestamptz preserves the offset
so chronological comparisons are correct regardless of server config.

Author: waleedlatif1

apps/sim/lib/table/__tests__/sql.test.ts

@@ -4,13 +4,13 @@
  * SQL Builder Unit Tests
  *
  * Tests the table SQL query builder. Assertions inspect the generated SQL
- * string so cast selection (numeric vs timestamp) is verified end-to-end.
+ * string so cast selection (numeric vs timestamptz) is verified end-to-end.
  *
  * Rendering: `drizzle-orm` is globally mocked in `vitest.setup.ts`. The mock
  * represents tagged-template fragments as `{ strings, values }`, raw fragments
  * as `{ rawSql }`, and joined fragments as `{ fragments, separator }`. The
  * local `renderSql` helper walks that shape recursively so we can assert real
- * substrings like `::timestamp` against the generated SQL.
+ * substrings like `::timestamptz` against the generated SQL.
  */
 import { describe, expect, it } from 'vitest'
 import { buildFilterClause, buildSortClause } from '@/lib/table/sql'
@@ -205,25 +205,25 @@ describe('SQL Builder', () => {
       ['$gte', '>='],
       ['$lt', '<'],
       ['$lte', '<='],
-    ] as const)('emits ::timestamp on both sides for %s on a date column', (operator, sqlOp) => {
+    ] as const)('emits ::timestamptz on both sides for %s on a date column', (operator, sqlOp) => {
       const filter = { birthDate: { [operator]: '2024-01-01' } } as Filter
       const out = render(buildFilterClause(filter, TABLE, dateCols))
-      expect(out).toContain(`(${TABLE}.data->>'birthDate')::timestamp ${sqlOp} `)
-      expect(out).toContain('::timestamp')
+      expect(out).toContain(`(${TABLE}.data->>'birthDate')::timestamptz ${sqlOp} `)
+      expect(out).toContain('::timestamptz')
       expect(out).not.toContain('::numeric')
       // RHS cast — without it Postgres would compare as text (lexicographic).
-      expect(out.match(/::timestamp/g)?.length).toBe(2)
+      expect(out.match(/::timestamptz/g)?.length).toBe(2)
     })
 
-    it('combined range ($gte + $lte) emits two ::timestamp pairs', () => {
+    it('combined range ($gte + $lte) emits two ::timestamptz pairs', () => {
       const out = render(
         buildFilterClause(
           { birthDate: { $gte: '2024-01-01', $lte: '2024-12-31' } },
           TABLE,
           dateCols
         )
       )
-      expect(out.match(/::timestamp/g)?.length).toBe(4)
+      expect(out.match(/::timestamptz/g)?.length).toBe(4)
       expect(out).not.toContain('::numeric')
       expect(out).toContain(' AND ')
     })
@@ -236,7 +236,7 @@ describe('SQL Builder', () => {
           dateCols
         )
       )
-      expect(out).toContain('::timestamp')
+      expect(out).toContain('::timestamptz')
       expect(out).not.toContain('::numeric')
     })
 
@@ -248,7 +248,7 @@ describe('SQL Builder', () => {
           dateCols
         )
       )
-      expect(out).toContain('::timestamp')
+      expect(out).toContain('::timestamptz')
       expect(out).not.toContain('::numeric')
       expect(out).toContain(' OR ')
     })
@@ -261,7 +261,7 @@ describe('SQL Builder', () => {
       const out = render(
         buildFilterClause({ birthDate: { $gte: '2024-01-01' }, age: { $gt: 18 } }, TABLE, cols)
       )
-      expect(out).toContain('::timestamp')
+      expect(out).toContain('::timestamptz')
       expect(out).toContain('::numeric')
     })
   })
@@ -284,10 +284,10 @@ describe('SQL Builder', () => {
       expect(out).toBe(`(${TABLE}.data->>'salary')::numeric DESC NULLS LAST`)
     })
 
-    it('sorts date columns with ::timestamp NULLS LAST', () => {
+    it('sorts date columns with ::timestamptz NULLS LAST', () => {
       const cols: ColumnDefinition[] = [{ name: 'birthDate', type: 'date' }]
       const out = render(buildSortClause({ birthDate: 'asc' }, TABLE, cols))
-      expect(out).toBe(`(${TABLE}.data->>'birthDate')::timestamp ASC NULLS LAST`)
+      expect(out).toBe(`(${TABLE}.data->>'birthDate')::timestamptz ASC NULLS LAST`)
     })
 
     it('sorts createdAt / updatedAt as direct column refs', () => {

apps/sim/lib/table/sql.ts

@@ -30,12 +30,12 @@ type ColumnTypeMap = ReadonlyMap<string, ColumnType>
  * truth for both filter range operators and sort ordering — keeps the two
  * paths from drifting apart.
  */
-function jsonbCastForType(type: ColumnType | undefined): 'numeric' | 'timestamp' | null {
+function jsonbCastForType(type: ColumnType | undefined): 'numeric' | 'timestamptz' | null {
   switch (type) {
     case 'number':
       return 'numeric'
     case 'date':
-      return 'timestamp'
+      return 'timestamptz'
     default:
       return null
   }
@@ -386,7 +386,10 @@ function buildContainmentClause(tableName: string, field: string, value: JsonVal
  * Builds a typed range comparison against a JSONB cell.
  *
  * `number` columns cast both sides to `numeric`; `date` columns cast both sides
- * to `timestamp` so date strings compare chronologically. Unknown/other types
+ * to `timestamptz` so date strings compare chronologically and timezone offsets
+ * in ISO strings (e.g. `2024-01-01T00:00:00Z`) are preserved rather than
+ * silently stripped (which would make results depend on the server's TimeZone
+ * setting). Unknown/other types
  * fall back to `numeric` (legacy default — preserves behavior for ad-hoc fields
  * with no schema entry). The right-hand value is cast explicitly because
  * drizzle parameterizes it as `text`; without the cast, Postgres would compare
@@ -405,8 +408,8 @@ function buildComparisonClause(
   const escapedField = field.replace(/'/g, "''")
   const cast = jsonbCastForType(columnType) ?? 'numeric'
   const cell = sql.raw(`(${tableName}.data->>'${escapedField}')::${cast}`)
-  return cast === 'timestamp'
-    ? sql`${cell} ${sql.raw(operator)} ${value}::timestamp`
+  return cast === 'timestamptz'
+    ? sql`${cell} ${sql.raw(operator)} ${value}::timestamptz`
     : sql`${cell} ${sql.raw(operator)} ${value}`
 }