fix(sql): read PostgreSQL dates in ISO and UTC

migrateScheduleDates() reads the legacy dates as text, and on PostgreSQL
that text depends on the session. A DateStyle other than ISO, such as
'SQL, DMY', printed "25/10/2026 02:30:00", which the conversion
rejected. The TimeZone sets the offset printed for timestamptz values
(Knex tables): before standard time it has seconds, such as
"1900-01-01 00:09:21+00:09:21" in Europe/Paris, which the conversion
rejected too. Both failures rolled back the migration, which could not
run on such a database.

The migration now sets DateStyle to ISO and TimeZone to UTC for the
read, as transaction-local settings, then restores the previous values
so the rest of an outer transaction, such as the Kysely Migrator or an
AdonisJS migration, keeps them. The restore only follows a successful
read: a failed statement aborts the transaction, so a restore would
fail and hide the error, and the rollback undoes the settings anyway.

The converted values are unchanged: a timestamptz is an instant whatever
the TimeZone, and a timestamp has no offset.

Author: RomainLanz

src/services/knex_queue_schema.ts

@@ -224,7 +224,7 @@ export class KnexQueueSchemaService {
       // Convert every value before the first schema change, so an unreadable
       // value fails the migration without leaving the table half migrated.
       const rows = state.legacy.length
-        ? await this.#withDatabaseTimeZone(trx, dialect, options.databaseTimeZone, async () => {
+        ? await this.#withLegacyDateSession(trx, dialect, options.databaseTimeZone, async () => {
             return (await trx(tableName).select(
               'id',
               ...state.legacy.map((name) => this.#legacyDateAsText(dialect, name))
@@ -321,15 +321,42 @@ export class KnexQueueSchemaService {
   }
 
   /**
-   * Run `callback` with the MySQL session time zone set to `timeZone`, then
-   * restore it. MySQL converts stored dates through the session time zone.
+   * Run `callback`, which reads the legacy dates as text, with the session
+   * settings that text depends on, then restore them.
+   *
+   * - PostgreSQL: the DateStyle sets the format, and the TimeZone the offset
+   *   of timestamptz values, which has seconds before standard time (Paris
+   *   was +00:09:21 in 1900). ISO and UTC give text the conversion reads.
+   * - MySQL: stored dates are converted through the session time zone, set
+   *   to `timeZone` when given.
    */
-  async #withDatabaseTimeZone<T>(
+  async #withLegacyDateSession<T>(
     trx: Knex.Transaction,
     dialect: 'pg' | 'mysql' | 'sqlite',
     timeZone: string | undefined,
     callback: () => Promise<T>
   ): Promise<T> {
+    if (dialect === 'pg') {
+      const {
+        rows: [current],
+      } = await trx.raw(
+        "select current_setting('DateStyle') as date_style, current_setting('TimeZone') as time_zone"
+      )
+      await trx.raw(
+        "select set_config('DateStyle', 'ISO', true), set_config('TimeZone', 'UTC', true)"
+      )
+
+      // Only after a success: a failed statement aborts the transaction, so a
+      // restore would fail and hide the error, and the rollback undoes these
+      // transaction-local settings anyway.
+      const result = await callback()
+      await trx.raw("select set_config('DateStyle', ?, true), set_config('TimeZone', ?, true)", [
+        current.date_style,
+        current.time_zone,
+      ])
+      return result
+    }
+
     if (dialect !== 'mysql' || timeZone === undefined) return callback()
 
     const [[current]] = await trx.raw('select @@session.time_zone as time_zone')

src/services/kysely_queue_schema.ts

@@ -216,7 +216,7 @@ export class KyselyQueueSchemaService<DB> {
       // Convert every value before the first schema change, so an unreadable
       // value fails the migration without leaving the table half migrated.
       const rows = state.legacy.length
-        ? await this.#withDatabaseTimeZone(trx, options.databaseTimeZone, async () => {
+        ? await this.#withLegacyDateSession(trx, options.databaseTimeZone, async () => {
             // The query builder applies withSchema(), unlike raw SQL table references.
             return (await (trx as unknown as Kysely<Record<string, Record<string, unknown>>>)
               .selectFrom(tableName)
@@ -364,14 +364,40 @@ export class KyselyQueueSchemaService<DB> {
   }
 
   /**
-   * Run `callback` with the MySQL session time zone set to `timeZone`, then
-   * restore it. MySQL converts stored dates through the session time zone.
+   * Run `callback`, which reads the legacy dates as text, with the session
+   * settings that text depends on, then restore them.
+   *
+   * - PostgreSQL: the DateStyle sets the format, and the TimeZone the offset
+   *   of timestamptz values, which has seconds before standard time (Paris
+   *   was +00:09:21 in 1900). ISO and UTC give text the conversion reads.
+   * - MySQL: stored dates are converted through the session time zone, set
+   *   to `timeZone` when given.
    */
-  async #withDatabaseTimeZone<T>(
+  async #withLegacyDateSession<T>(
     trx: Transaction<DB>,
     timeZone: string | undefined,
     callback: () => Promise<T>
   ): Promise<T> {
+    if (this.#dialect === 'postgres') {
+      const current = await sql<{ dateStyle: string; timeZone: string }>`
+        select current_setting('DateStyle') as ${sql.ref('dateStyle')},
+          current_setting('TimeZone') as ${sql.ref('timeZone')}
+      `.execute(trx)
+      await sql`select set_config('DateStyle', 'ISO', true), set_config('TimeZone', 'UTC', true)`.execute(
+        trx
+      )
+
+      // Only after a success: a failed statement aborts the transaction, so a
+      // restore would fail and hide the error, and the rollback undoes these
+      // transaction-local settings anyway.
+      const result = await callback()
+      const { dateStyle, timeZone: sessionTimeZone } = current.rows[0]
+      await sql`select set_config('DateStyle', ${dateStyle}, true), set_config('TimeZone', ${sessionTimeZone}, true)`.execute(
+        trx
+      )
+      return result
+    }
+
     if (this.#dialect !== 'mysql' || timeZone === undefined) return callback()
 
     const current = await sql<{

tests/schedule_dates_migration.spec.ts

@@ -287,6 +287,39 @@ for (const dialect of ['sqlite', 'postgres', 'mysql'] as const) {
       })
     }
 
+    if (dialect === 'postgres') {
+      test('reads dates whatever the DateStyle and TimeZone of the session', async ({
+        assert,
+        cleanup,
+      }) => {
+        const sessionConnection = Knex({
+          client: 'pg',
+          connection: { ...pgConfig(), options: '-c DateStyle=SQL,DMY -c TimeZone=Europe/Paris' },
+        })
+        cleanup(() => sessionConnection.destroy())
+        const createdAt = await insertLegacySchedule()
+        // Paris used a local mean time offset of +00:09:21 in 1900.
+        await connection(TABLE).update({ from_date: new Date('1900-01-01T00:00:00.000Z') })
+
+        // Inside an outer transaction, as in an AdonisJS migration, which keeps
+        // the settings the migration changes until it ends.
+        const settings = await sessionConnection.transaction(async (trx) => {
+          await new KnexQueueSchemaService(trx).migrateScheduleDates(TABLE, {
+            timezone: WRITER_TIME_ZONE,
+          })
+          const { rows } = await trx.raw(
+            "select current_setting('DateStyle') as date_style, current_setting('TimeZone') as time_zone"
+          )
+          return rows[0]
+        })
+        assert.deepEqual(settings, { date_style: 'SQL, DMY', time_zone: 'Europe/Paris' })
+        const legacy = await adapter().getSchedule('legacy')
+        assert.equal(legacy!.from!.toISOString(), '1900-01-01T00:00:00.000Z')
+        await connection(TABLE).update({ from_date: null })
+        await assertMigratedSchedules(assert, adapter(), createdAt)
+      })
+    }
+
     if (dialect === 'postgres') {
       test('migrates a schema-qualified table', async ({ assert, cleanup }) => {
         await connection.raw('create schema if not exists review_tenant')
@@ -580,6 +613,35 @@ for (const dialect of ['sqlite', 'postgres', 'mysql'] as const) {
       })
     }
 
+    if (dialect === 'postgres') {
+      test('reads dates whatever the DateStyle of the session', async ({ assert, cleanup }) => {
+        const sessionConnection = new Kysely<any>({
+          dialect: new PostgresDialect({
+            pool: new Pool({
+              ...pgConfig(),
+              options: '-c DateStyle=SQL,DMY -c TimeZone=Europe/Paris',
+            }),
+          }),
+        })
+        cleanup(() => sessionConnection.destroy())
+        const createdAt = await insertLegacySchedule()
+
+        // Inside an outer transaction, as in the Kysely Migrator, which keeps
+        // the settings the migration changes until it ends.
+        const settings = await sessionConnection.transaction().execute(async (trx) => {
+          await new KyselyQueueSchemaService(trx, { dialect }).migrateScheduleDates(TABLE, {
+            timezone: WRITER_TIME_ZONE,
+          })
+          const { rows } = await sql<{ date_style: string; time_zone: string }>`
+            select current_setting('DateStyle') as date_style, current_setting('TimeZone') as time_zone
+          `.execute(trx)
+          return rows[0]
+        })
+        assert.deepEqual(settings, { date_style: 'SQL, DMY', time_zone: 'Europe/Paris' })
+        await assertMigratedSchedules(assert, adapter(), createdAt)
+      })
+    }
+
     if (dialect === 'postgres') {
       test('migrates a schema-qualified table', async ({ assert, cleanup }) => {
         await sql`create schema if not exists review_tenant`.execute(connection)