fix(tables): prevent early TTL expiration

Author: j15z

apps/sim/app/api/cron/cleanup-table-row-ttl/route.test.ts

@@ -70,6 +70,23 @@ describe('table row TTL cleanup route', () => {
     expect(mockEnqueue.mock.calls[0]?.[2]?.jobId).toBe(mockEnqueue.mock.calls[1]?.[2]?.jobId)
   })
 
+  it('uses a new id immediately after the next fifteen-minute window begins', async () => {
+    const request = () =>
+      createMockRequest(
+        'GET',
+        undefined,
+        {},
+        'http://localhost:3000/api/cron/cleanup-table-row-ttl'
+      )
+
+    vi.setSystemTime(new Date('2026-08-22T17:14:59.999Z'))
+    await GET(request())
+    vi.setSystemTime(new Date('2026-08-22T17:15:00.000Z'))
+    await GET(request())
+
+    expect(mockEnqueue.mock.calls[0]?.[2]?.jobId).not.toBe(mockEnqueue.mock.calls[1]?.[2]?.jobId)
+  })
+
   it('returns the cron auth refusal without touching the queue', async () => {
     mockVerifyCronAuth.mockReturnValue(new Response(null, { status: 401 }))
 

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/inline-editors.test.ts

@@ -0,0 +1,89 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { act, createElement, type ReactNode } from 'react'
+import { createRoot } from 'react-dom/client'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { ColumnDefinition } from '@/lib/table'
+import {
+  dateEditorRawValue,
+  InlineEditor,
+} from '@/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/inline-editors'
+import { cleanCellValue } from '@/app/workspace/[workspaceId]/tables/[tableId]/utils'
+
+const { mockUseTimezone } = vi.hoisted(() => ({ mockUseTimezone: vi.fn() }))
+
+vi.mock('@/hooks/queries/general-settings', () => ({ useTimezone: mockUseTimezone }))
+vi.mock('@sim/emcn', () => {
+  const passthrough = ({ children }: { children?: ReactNode }) => children ?? null
+  return {
+    Calendar: () => null,
+    cn: (...classes: unknown[]) => classes.filter(Boolean).join(' '),
+    DropdownMenu: passthrough,
+    DropdownMenuContent: passthrough,
+    DropdownMenuItem: passthrough,
+    DropdownMenuTrigger: passthrough,
+    Popover: passthrough,
+    PopoverAnchor: () => null,
+    PopoverContent: passthrough,
+    toast: { error: vi.fn() },
+  }
+})
+const column = (type: ColumnDefinition['type']): ColumnDefinition => ({ name: 'expires_at', type })
+
+describe('dateEditorRawValue', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockUseTimezone.mockReturnValue('America/Los_Angeles')
+  })
+
+  it('leaves TTL drafts for TTL coercion to resolve safely', () => {
+    const ttlColumn = column('ttl')
+    const timezone = 'America/New_York'
+    const repeatedWallClock = '11/01/2026 1:30:00 AM'
+
+    const repeatedRaw = dateEditorRawValue(repeatedWallClock, ttlColumn, timezone)
+    expect(repeatedRaw).toBe(repeatedWallClock)
+    expect(cleanCellValue(repeatedRaw, ttlColumn, timezone)).toBe(
+      Date.parse('2026-11-01T06:30:00Z') / 1000
+    )
+
+    const fractionalRaw = dateEditorRawValue('2023-11-14t22:13:20.001Z', ttlColumn, timezone)
+    expect(cleanCellValue(fractionalRaw, ttlColumn, timezone)).toBe(1_700_000_001)
+  })
+
+  it('keeps ordinary date drafts on their existing display parser', () => {
+    expect(dateEditorRawValue('11/01/2026 1:30:00 AM', column('date'), 'America/New_York')).toBe(
+      '2026-11-01T01:30:00-04:00'
+    )
+  })
+
+  it('keeps an open TTL edit in its starting timezone when the setting changes', () => {
+    const container = document.createElement('div')
+    document.body.appendChild(container)
+    const root = createRoot(container)
+    const onSave = vi.fn()
+    const value = Date.parse('2026-06-15T13:00:30Z') / 1000
+    const props = {
+      value,
+      column: column('ttl'),
+      onSave,
+      onCancel: vi.fn(),
+    }
+
+    ;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true
+    act(() => root.render(createElement(InlineEditor, props)))
+    mockUseTimezone.mockReturnValue('America/New_York')
+    act(() => root.render(createElement(InlineEditor, props)))
+
+    const input = container.querySelector('input')
+    expect(input?.value).toBe('06/15/2026 6:00:30 AM')
+    act(() => {
+      input?.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }))
+    })
+
+    expect(onSave).toHaveBeenCalledWith(value, 'enter')
+    act(() => root.unmount())
+    container.remove()
+  })
+})

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/inline-editors.tsx

@@ -37,6 +37,21 @@ interface InlineEditorProps {
   onCancel: () => void
 }
 
+/**
+ * Produces the raw draft that the column type will coerce on save. Ordinary
+ * date columns keep their display parser for partial dates; other date-editor
+ * types receive the untouched draft so their own safety rules are not erased.
+ */
+export function dateEditorRawValue(
+  draft: string,
+  column: ColumnDefinition,
+  timeZone: string,
+  storageValue?: string
+): string {
+  if (storageValue !== undefined) return storageValue
+  return column.type === 'date' ? (displayToStorage(draft, timeZone) ?? draft) : draft
+}
+
 /** Redirect wheel gestures over an inline editor to the surrounding table scroll container. */
 function handleEditorWheel(e: React.WheelEvent<HTMLInputElement>) {
   e.preventDefault()
@@ -68,7 +83,10 @@ function InlineDateEditor({
    *  and refocuses while a popover interaction is in flight (covers browsers
    *  where buttons don't take focus on click). */
   const popoverPointerAtRef = useRef(0)
-  const timeZone = useTimezone()
+  const effectiveTimeZone = useTimezone()
+  /** Keep one wall-clock interpretation for the lifetime of this edit. */
+  const editTimeZoneRef = useRef(effectiveTimeZone)
+  const timeZone = editTimeZoneRef.current
 
   const storedValue = formatValueForInput(value, column.type, timeZone)
   const initialDraft =
@@ -118,7 +136,7 @@ function InlineDateEditor({
         onSave(storedValue ? cleanCellValue(storedValue, column, timeZone) : null, reason)
         return
       }
-      const raw = storageVal ?? displayToStorage(current, timeZone) ?? current
+      const raw = dateEditorRawValue(current, column, timeZone, storageVal)
       if (raw && Number.isNaN(Date.parse(raw))) {
         if (reason === 'blur') {
           if (!invalid) toast.error('Invalid date')

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/utils.test.ts

@@ -206,4 +206,19 @@ describe('formatValueForInput', () => {
       cleanCellValue('2023-11-14', { name: 'expires_at', type: 'ttl' }, 'America/New_York')
     ).toBe(1_699_938_000)
   })
+
+  it('uses the latest effective timezone for each TTL edit', () => {
+    const column = { name: 'expires_at', type: 'ttl' } as const
+    const input = '2026-06-15 09:00:30'
+
+    expect(cleanCellValue(input, column, 'America/New_York')).toBe(
+      Date.parse('2026-06-15T13:00:30Z') / 1000
+    )
+    expect(cleanCellValue(input, column, 'Asia/Kathmandu')).toBe(
+      Date.parse('2026-06-15T03:15:30Z') / 1000
+    )
+    expect(cleanCellValue(input, column, 'America/New_York')).toBe(
+      Date.parse('2026-06-15T13:00:30Z') / 1000
+    )
+  })
 })

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/utils.ts

@@ -147,46 +147,12 @@ export function storageToDisplay(stored: string, options?: { seconds?: boolean }
  */
 export function displayToStorage(display: string, timeZone?: string): string | null {
   const trimmed = display.trim()
-  const withTime = trimmed.match(
-    /^(\d{1,2})\/(\d{1,2})\/(\d{4})[ ,]+(\d{1,2}):(\d{2})(?::(\d{2}))?(?:\s*(AM|PM))?$/i
-  )
-  if (withTime) {
-    const [, m, d, y, h, min, sec, meridiem] = withTime
-    let hours = Number(h)
-    if (meridiem) {
-      if (hours < 1 || hours > 12) return null
-      hours = (hours % 12) + (meridiem.toUpperCase() === 'PM' ? 12 : 0)
-    } else if (hours > 23) {
-      return null
-    }
-    if (Number(min) > 59 || Number(sec ?? 0) > 59) return null
-    if (!isValidCalendarDay(Number(y), Number(m), Number(d))) return null
-    const pad = (n: string) => n.padStart(2, '0')
-    // Route through the shared normalizer so the wall time resolves in the
-    // effective zone.
-    return normalizeDateCellValue(
-      `${y}-${pad(m)}-${pad(d)}T${String(hours).padStart(2, '0')}:${min}:${sec ?? '00'}`,
-      { timezone: timeZone }
-    )
-  }
-  const full = trimmed.match(/^(\d{1,2})\/(\d{1,2})\/(\d{4})$/)
-  if (full) {
-    if (!isValidCalendarDay(Number(full[3]), Number(full[1]), Number(full[2]))) return null
-    return `${full[3]}-${full[1].padStart(2, '0')}-${full[2].padStart(2, '0')}`
-  }
   const partial = trimmed.match(/^(\d{1,2})\/(\d{1,2})$/)
   if (partial) {
     const year = Number(todayLocalCalendarDate(timeZone).slice(0, 4))
-    if (!isValidCalendarDay(year, Number(partial[1]), Number(partial[2]))) return null
-    return `${year}-${partial[1].padStart(2, '0')}-${partial[2].padStart(2, '0')}`
+    return normalizeDateCellValue(
+      `${year}-${partial[1].padStart(2, '0')}-${partial[2].padStart(2, '0')}`
+    )
   }
   return normalizeDateCellValue(trimmed, { timezone: timeZone })
 }
-
-/** True when Y/M/D is a real calendar day — `Date` rolls impossible days over
- *  (02/30 → 03/02) instead of rejecting them, so compare the round-trip. */
-function isValidCalendarDay(year: number, month: number, day: number): boolean {
-  if (month < 1 || month > 12 || day < 1 || day > 31) return false
-  const check = new Date(year, month - 1, day)
-  return check.getMonth() === month - 1 && check.getDate() === day
-}

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

@@ -65,7 +65,7 @@ describe('table row TTL cleanup', () => {
   })
 
   it('compares TTL values with whole Date.now epoch seconds', async () => {
-    const nowEpochMilliseconds = 1_700_000_000_123
+    const nowEpochMilliseconds = 1_700_000_000_999
     const nowEpochSeconds = 1_700_000_000
     const nowSpy = vi.spyOn(Date, 'now').mockReturnValue(nowEpochMilliseconds)
     mockDeleteExecute.mockResolvedValue([{ count: 0, lastId: null }])

apps/sim/hooks/queries/general-settings.test.ts

@@ -0,0 +1,49 @@
+/**
+ * @vitest-environment node
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { mockGetBrowserTimezone, mockUseQuery } = vi.hoisted(() => ({
+  mockGetBrowserTimezone: vi.fn(),
+  mockUseQuery: vi.fn(),
+}))
+
+vi.mock('@tanstack/react-query', () => ({
+  useMutation: vi.fn(),
+  useQuery: mockUseQuery,
+  useQueryClient: vi.fn(),
+}))
+vi.mock('@/lib/core/utils/timezone', () => ({ getBrowserTimezone: mockGetBrowserTimezone }))
+
+import { useTimezone } from '@/hooks/queries/general-settings'
+
+describe('useTimezone', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockGetBrowserTimezone.mockReturnValue('America/Los_Angeles')
+  })
+
+  it('uses the browser timezone while no preference is saved', () => {
+    mockUseQuery.mockReturnValue({ data: { timezone: null } })
+
+    expect(useTimezone()).toBe('America/Los_Angeles')
+  })
+
+  it('uses a saved timezone instead of the browser fallback', () => {
+    mockUseQuery.mockReturnValue({ data: { timezone: 'Asia/Kathmandu' } })
+
+    expect(useTimezone()).toBe('Asia/Kathmandu')
+    expect(mockGetBrowserTimezone).not.toHaveBeenCalled()
+  })
+
+  it('reads the current setting again after it changes', () => {
+    let timezone: string | null = 'America/New_York'
+    mockUseQuery.mockImplementation(() => ({ data: { timezone } }))
+
+    expect(useTimezone()).toBe('America/New_York')
+    timezone = 'Asia/Tokyo'
+    expect(useTimezone()).toBe('Asia/Tokyo')
+    timezone = null
+    expect(useTimezone()).toBe('America/Los_Angeles')
+  })
+})

apps/sim/lib/core/utils/timezone.test.ts

@@ -8,7 +8,7 @@ import {
   zonedClockDate,
   zonedWallClockToUtc,
   zonedWallClockWithOffset,
-} from './timezone'
+} from '@/lib/core/utils/timezone'
 
 describe('formatInstantInTimeZone', () => {
   it.each([
@@ -150,6 +150,53 @@ describe('zonedWallClockToUtc', () => {
       expect(new Date(stampedWallClock).toISOString()).toBe(expectedInstant)
     }
   )
+
+  it.each([
+    ['America/New_York', '2026-11-01T01:30', '2026-11-01T05:30:00.000Z', '-04:00'],
+    ['Europe/Berlin', '2026-10-25T02:30', '2026-10-25T00:30:00.000Z', '+02:00'],
+    ['Australia/Lord_Howe', '2026-04-05T01:45', '2026-04-04T14:45:00.000Z', '+11:00'],
+  ])(
+    'can choose the earlier instant for an ambiguous fall-back wall-clock in %s',
+    (timeZone, wallClock, expectedInstant, expectedOffset) => {
+      const options = { ambiguousTime: 'earlier' as const }
+      const instant = zonedWallClockToUtc(wallClock, timeZone, options)
+      const stampedWallClock = zonedWallClockWithOffset(wallClock, timeZone, options)
+
+      expect(instant.toISOString()).toBe(expectedInstant)
+      expect(stampedWallClock).toBe(`${wallClock}${expectedOffset}`)
+      expect(new Date(stampedWallClock).toISOString()).toBe(expectedInstant)
+    }
+  )
+
+  it('does not retain timezone state between consecutive resolutions', () => {
+    const wallClock = '2026-06-15T09:00:30'
+
+    expect(zonedWallClockToUtc(wallClock, 'America/New_York').toISOString()).toBe(
+      '2026-06-15T13:00:30.000Z'
+    )
+    expect(zonedWallClockToUtc(wallClock, 'Asia/Kathmandu').toISOString()).toBe(
+      '2026-06-15T03:15:30.000Z'
+    )
+    expect(zonedWallClockToUtc(wallClock, 'America/New_York').toISOString()).toBe(
+      '2026-06-15T13:00:30.000Z'
+    )
+  })
+
+  it('can serialize historical sub-minute offsets toward a later instant', () => {
+    const wallClock = '1970-01-01T00:00:00'
+    const timezone = 'Africa/Monrovia'
+    const exactInstant = zonedWallClockToUtc(wallClock, timezone)
+    const options = { offsetMinuteRounding: 'floor' as const }
+
+    expect(exactInstant.toISOString()).toBe('1970-01-01T00:44:30.000Z')
+    expect(zonedWallClockWithOffset(wallClock, timezone, options)).toBe('1970-01-01T00:00:00-00:45')
+    expect(formatInstantInTimeZone(exactInstant, timezone, options)).toBe(
+      '1970-01-01T00:00:00-00:45'
+    )
+    expect(
+      Date.parse(zonedWallClockWithOffset(wallClock, timezone, options))
+    ).toBeGreaterThanOrEqual(exactInstant.getTime())
+  })
 })
 
 describe('wallClockNow', () => {