@leonardovida-md/drizzle-neo-duckdb 1.0.2 → 1.1.0

package/src/olap.ts

@@ -0,0 +1,190 @@
+import { is } from 'drizzle-orm/entity';
+import { sql, Subquery, type SQLWrapper } from 'drizzle-orm';
+import type { AnyPgColumn, PgTable } from 'drizzle-orm/pg-core';
+import type { PgViewBase } from 'drizzle-orm/pg-core/view-base';
+import type { SelectedFields } from 'drizzle-orm/pg-core/query-builders';
+import { SQL } from 'drizzle-orm/sql/sql';
+import { Column, getTableName } from 'drizzle-orm';
+import type { DuckDBDatabase } from './driver.ts';
+
+export const countN = (expr: SQLWrapper = sql`*`) =>
+  sql<number>`count(${expr})`.mapWith(Number);
+
+export const sumN = (expr: SQLWrapper) =>
+  sql<number>`sum(${expr})`.mapWith(Number);
+
+export const avgN = (expr: SQLWrapper) =>
+  sql<number>`avg(${expr})`.mapWith(Number);
+
+export const sumDistinctN = (expr: SQLWrapper) =>
+  sql<number>`sum(distinct ${expr})`.mapWith(Number);
+
+export const percentileCont = (p: number, expr: SQLWrapper) =>
+  sql<number>`percentile_cont(${p}) within group (order by ${expr})`.mapWith(
+    Number
+  );
+
+export const median = (expr: SQLWrapper) => percentileCont(0.5, expr);
+
+export const anyValue = <T = unknown>(expr: SQLWrapper) =>
+  sql<T>`any_value(${expr})`;
+
+type PartitionOrder =
+  | {
+      partitionBy?: SQLWrapper | SQLWrapper[];
+      orderBy?: SQLWrapper | SQLWrapper[];
+    }
+  | undefined;
+
+function normalizeArray<T>(value?: T | T[]): T[] {
+  if (!value) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+function overClause(options?: PartitionOrder) {
+  const partitions = normalizeArray(options?.partitionBy);
+  const orders = normalizeArray(options?.orderBy);
+
+  const chunks: SQLWrapper[] = [];
+
+  if (partitions.length > 0) {
+    chunks.push(sql`partition by ${sql.join(partitions, sql`, `)}`);
+  }
+
+  if (orders.length > 0) {
+    chunks.push(sql`order by ${sql.join(orders, sql`, `)}`);
+  }
+
+  if (chunks.length === 0) {
+    return sql``;
+  }
+
+  return sql`over (${sql.join(chunks, sql` `)})`;
+}
+
+export const rowNumber = (options?: PartitionOrder) =>
+  sql<number>`row_number() ${overClause(options)}`.mapWith(Number);
+
+export const rank = (options?: PartitionOrder) =>
+  sql<number>`rank() ${overClause(options)}`.mapWith(Number);
+
+export const denseRank = (options?: PartitionOrder) =>
+  sql<number>`dense_rank() ${overClause(options)}`.mapWith(Number);
+
+export const lag = <T = unknown>(
+  expr: SQLWrapper,
+  offset = 1,
+  defaultValue?: SQLWrapper,
+  options?: PartitionOrder
+) =>
+  defaultValue
+    ? sql<T>`lag(${expr}, ${offset}, ${defaultValue}) ${overClause(options)}`
+    : sql<T>`lag(${expr}, ${offset}) ${overClause(options)}`;
+
+export const lead = <T = unknown>(
+  expr: SQLWrapper,
+  offset = 1,
+  defaultValue?: SQLWrapper,
+  options?: PartitionOrder
+) =>
+  defaultValue
+    ? sql<T>`lead(${expr}, ${offset}, ${defaultValue}) ${overClause(options)}`
+    : sql<T>`lead(${expr}, ${offset}) ${overClause(options)}`;
+
+type ValueExpr = SQL | SQL.Aliased | AnyPgColumn;
+type GroupKey = ValueExpr;
+type MeasureMap = Record<string, ValueExpr>;
+type NonAggMap = Record<string, ValueExpr>;
+
+function keyAlias(key: SQLWrapper, fallback: string): string {
+  if (is(key, SQL.Aliased)) {
+    return key.fieldAlias ?? fallback;
+  }
+  if (is(key, Column)) {
+    return `${getTableName(key.table)}.${key.name}`;
+  }
+  return fallback;
+}
+
+export class OlapBuilder {
+  private source?: PgTable | Subquery | PgViewBase | SQL;
+  private keys: GroupKey[] = [];
+  private measureMap: MeasureMap = {};
+  private nonAggregates: NonAggMap = {};
+  private wrapNonAggWithAnyValue = false;
+  private orderByClauses: ValueExpr[] = [];
+
+  constructor(private db: DuckDBDatabase) {}
+
+  from(source: PgTable | Subquery | PgViewBase | SQL): this {
+    this.source = source;
+    return this;
+  }
+
+  groupBy(keys: GroupKey[]): this {
+    this.keys = keys;
+    return this;
+  }
+
+  measures(measures: MeasureMap): this {
+    this.measureMap = measures;
+    return this;
+  }
+
+  selectNonAggregates(
+    fields: NonAggMap,
+    options: { anyValue?: boolean } = {}
+  ): this {
+    this.nonAggregates = fields;
+    this.wrapNonAggWithAnyValue = options.anyValue ?? false;
+    return this;
+  }
+
+  orderBy(...clauses: ValueExpr[]): this {
+    this.orderByClauses = clauses;
+    return this;
+  }
+
+  build() {
+    if (!this.source) {
+      throw new Error('olap: .from() is required');
+    }
+    if (this.keys.length === 0) {
+      throw new Error('olap: .groupBy() is required');
+    }
+    if (Object.keys(this.measureMap).length === 0) {
+      throw new Error('olap: .measures() is required');
+    }
+
+    const selection: Record<string, ValueExpr> = {};
+
+    this.keys.forEach((key, idx) => {
+      const alias = keyAlias(key, `key_${idx}`);
+      selection[alias] = key;
+    });
+
+    Object.entries(this.nonAggregates).forEach(([alias, expr]) => {
+      selection[alias] = this.wrapNonAggWithAnyValue ? anyValue(expr) : expr;
+    });
+
+    Object.assign(selection, this.measureMap);
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Drizzle's query builder types don't allow reassignment after groupBy
+    let query: any = this.db
+      .select(selection as SelectedFields)
+      .from(this.source!)
+      .groupBy(...this.keys);
+
+    if (this.orderByClauses.length > 0) {
+      query = query.orderBy(...this.orderByClauses);
+    }
+
+    return query;
+  }
+
+  run() {
+    return this.build();
+  }
+}
+
+export const olap = (db: DuckDBDatabase) => new OlapBuilder(db);

package/src/pool.ts

@@ -0,0 +1,104 @@
+import { DuckDBConnection, DuckDBInstance } from '@duckdb/node-api';
+import { closeClientConnection, type DuckDBConnectionPool } from './client.ts';
+
+/** Pool size presets for different MotherDuck instance types */
+export type PoolPreset =
+  | 'pulse'
+  | 'standard'
+  | 'jumbo'
+  | 'mega'
+  | 'giga'
+  | 'local'
+  | 'memory';
+
+/** Pool sizes optimized for each MotherDuck instance type */
+export const POOL_PRESETS: Record<PoolPreset, number> = {
+  pulse: 4, // Auto-scaling, ad-hoc analytics
+  standard: 6, // Balanced ETL/ELT workloads
+  jumbo: 8, // Complex queries, high-volume
+  mega: 12, // Large-scale transformations
+  giga: 16, // Maximum parallelism
+  local: 8, // Local DuckDB file
+  memory: 4, // In-memory testing
+};
+
+export interface DuckDBPoolConfig {
+  /** Maximum concurrent connections. Defaults to 4. */
+  size?: number;
+}
+
+/**
+ * Resolve pool configuration to a concrete size.
+ * Returns false if pooling is disabled.
+ */
+export function resolvePoolSize(
+  pool: DuckDBPoolConfig | PoolPreset | false | undefined
+): number | false {
+  if (pool === false) return false;
+  if (pool === undefined) return 4;
+  if (typeof pool === 'string') return POOL_PRESETS[pool];
+  return pool.size ?? 4;
+}
+
+export interface DuckDBConnectionPoolOptions {
+  /** Maximum concurrent connections. Defaults to 4. */
+  size?: number;
+}
+
+export function createDuckDBConnectionPool(
+  instance: DuckDBInstance,
+  options: DuckDBConnectionPoolOptions = {}
+): DuckDBConnectionPool & { size: number } {
+  const size = options.size && options.size > 0 ? options.size : 4;
+  const idle: DuckDBConnection[] = [];
+  const waiting: Array<(conn: DuckDBConnection) => void> = [];
+  let total = 0;
+  let closed = false;
+
+  const acquire = async (): Promise<DuckDBConnection> => {
+    if (closed) {
+      throw new Error('DuckDB connection pool is closed');
+    }
+
+    if (idle.length > 0) {
+      return idle.pop() as DuckDBConnection;
+    }
+
+    if (total < size) {
+      total += 1;
+      return await DuckDBConnection.create(instance);
+    }
+
+    return await new Promise((resolve) => {
+      waiting.push(resolve);
+    });
+  };
+
+  const release = async (connection: DuckDBConnection): Promise<void> => {
+    if (closed) {
+      await closeClientConnection(connection);
+      return;
+    }
+
+    const waiter = waiting.shift();
+    if (waiter) {
+      waiter(connection);
+      return;
+    }
+
+    idle.push(connection);
+  };
+
+  const close = async (): Promise<void> => {
+    closed = true;
+    const toClose = idle.splice(0, idle.length);
+    await Promise.all(toClose.map((conn) => closeClientConnection(conn)));
+  };
+
+  return {
+    acquire,
+    release,
+    close,
+    size,
+  };
+}

package/src/select-builder.ts

@@ -6,11 +6,7 @@ import {
   type SelectedFields,
   type TableLikeHasEmptySelection,
 } from 'drizzle-orm/pg-core/query-builders';
-import {
-  PgColumn,
-  PgTable,
-  type PgSession,
-} from 'drizzle-orm/pg-core';
+import { PgColumn, PgTable, type PgSession } from 'drizzle-orm/pg-core';
 import { Subquery, ViewBaseConfig, type SQLWrapper } from 'drizzle-orm';
 import { PgViewBase } from 'drizzle-orm/pg-core/view-base';
 import type {
@@ -25,7 +21,7 @@ import { getTableColumns, type DrizzleTypeError } from 'drizzle-orm/utils';
 interface PgViewBaseInternal<
   TName extends string = string,
   TExisting extends boolean = boolean,
-  TSelectedFields extends ColumnsSelection = ColumnsSelection
+  TSelectedFields extends ColumnsSelection = ColumnsSelection,
 > extends PgViewBase<TName, TExisting, TSelectedFields> {
   [ViewBaseConfig]?: {
     selectedFields: SelectedFields;
@@ -34,7 +30,7 @@ interface PgViewBaseInternal<
 
 export class DuckDBSelectBuilder<
   TSelection extends SelectedFields | undefined,
-  TBuilderMode extends 'db' | 'qb' = 'db'
+  TBuilderMode extends 'db' | 'qb' = 'db',
 > extends PgSelectBuilder<TSelection, TBuilderMode> {
   private _fields: TSelection;
   private _session: PgSession | undefined;

package/src/session.ts

@@ -19,13 +19,25 @@ import { adaptArrayOperators } from './sql/query-rewriters.ts';
 import { mapResultRow } from './sql/result-mapper.ts';
 import type { DuckDBDialect } from './dialect.ts';
 import { TransactionRollbackError } from 'drizzle-orm/errors';
-import type { DuckDBClientLike, RowData } from './client.ts';
-import { executeOnClient, prepareParams } from './client.ts';
+import type {
+  DuckDBClientLike,
+  DuckDBConnectionPool,
+  RowData,
+} from './client.ts';
+import {
+  executeArrowOnClient,
+  executeInBatches,
+  executeOnClient,
+  prepareParams,
+  type ExecuteInBatchesOptions,
+} from './client.ts';
+import { isPool } from './client.ts';
+import type { DuckDBConnection } from '@duckdb/node-api';
 
 export type { DuckDBClientLike, RowData } from './client.ts';
 
 export class DuckDBPreparedQuery<
-  T extends PreparedQueryConfig
+  T extends PreparedQueryConfig,
 > extends PgPreparedQuery<T> {
   static readonly [entityKind]: string = 'DuckDBPreparedQuery';
 
@@ -37,7 +49,9 @@ export class DuckDBPreparedQuery<
     private logger: Logger,
     private fields: SelectedFieldsOrdered | undefined,
     private _isResponseInArrayMode: boolean,
-    private customResultMapper: ((rows: unknown[][]) => T['execute']) | undefined,
+    private customResultMapper:
+      | ((rows: unknown[][]) => T['execute'])
+      | undefined,
     private rewriteArrays: boolean,
     private rejectStringArrayLiterals: boolean,
     private warnOnStringArrayLiteral?: (sql: string) => void
@@ -71,17 +85,10 @@ export class DuckDBPreparedQuery<
 
     this.logger.logQuery(rewrittenQuery, params);
 
-    const {
-      fields,
-      joinsNotNullableMap,
-      customResultMapper,
-    } = this as typeof this & { joinsNotNullableMap?: Record<string, boolean> };
+    const { fields, joinsNotNullableMap, customResultMapper } =
+      this as typeof this & { joinsNotNullableMap?: Record<string, boolean> };
 
-    const rows = await executeOnClient(
-      this.client,
-      rewrittenQuery,
-      params
-    );
+    const rows = await executeOnClient(this.client, rewrittenQuery, params);
 
     if (rows.length === 0 || !fields) {
       return rows as T['execute'];
@@ -115,7 +122,7 @@ export interface DuckDBSessionOptions {
 
 export class DuckDBSession<
   TFullSchema extends Record<string, unknown> = Record<string, never>,
-  TSchema extends TablesRelationalConfig = Record<string, never>
+  TSchema extends TablesRelationalConfig = Record<string, never>,
 > extends PgSession<DuckDBQueryResultHKT, TFullSchema, TSchema> {
   static readonly [entityKind]: string = 'DuckDBSession';
 
@@ -164,8 +171,18 @@ export class DuckDBSession<
   override async transaction<T>(
     transaction: (tx: DuckDBTransaction<TFullSchema, TSchema>) => Promise<T>
   ): Promise<T> {
+    let pinnedConnection: DuckDBConnection | undefined;
+    let pool: DuckDBConnectionPool | undefined;
+
+    let clientForTx: DuckDBClientLike = this.client;
+    if (isPool(this.client)) {
+      pool = this.client;
+      pinnedConnection = await pool.acquire();
+      clientForTx = pinnedConnection;
+    }
+
     const session = new DuckDBSession(
-      this.client,
+      clientForTx,
       this.dialect,
       this.schema,
       this.options
@@ -177,15 +194,21 @@ export class DuckDBSession<
       this.schema
     );
 
-    await tx.execute(sql`BEGIN TRANSACTION;`);
-
     try {
-      const result = await transaction(tx);
-      await tx.execute(sql`commit`);
-      return result;
-    } catch (error) {
-      await tx.execute(sql`rollback`);
-      throw error;
+      await tx.execute(sql`BEGIN TRANSACTION;`);
+
+      try {
+        const result = await transaction(tx);
+        await tx.execute(sql`commit`);
+        return result;
+      } catch (error) {
+        await tx.execute(sql`rollback`);
+        throw error;
+      }
+    } finally {
+      if (pinnedConnection && pool) {
+        await pool.release(pinnedConnection);
+      }
     }
   }
 
@@ -199,11 +222,67 @@ export class DuckDBSession<
       []
     );
   };
+
+  executeBatches<T extends RowData = RowData>(
+    query: SQL,
+    options: ExecuteInBatchesOptions = {}
+  ): AsyncGenerator<GenericRowData<T>[], void, void> {
+    const builtQuery = this.dialect.sqlToQuery(query);
+    const params = prepareParams(builtQuery.params, {
+      rejectStringArrayLiterals: this.rejectStringArrayLiterals,
+      warnOnStringArrayLiteral: this.rejectStringArrayLiterals
+        ? undefined
+        : () => this.warnOnStringArrayLiteral(builtQuery.sql),
+    });
+    const rewrittenQuery = this.rewriteArrays
+      ? adaptArrayOperators(builtQuery.sql)
+      : builtQuery.sql;
+
+    if (this.rewriteArrays && rewrittenQuery !== builtQuery.sql) {
+      this.logger.logQuery(
+        `[duckdb] original query before array rewrite: ${builtQuery.sql}`,
+        params
+      );
+    }
+
+    this.logger.logQuery(rewrittenQuery, params);
+
+    return executeInBatches(
+      this.client,
+      rewrittenQuery,
+      params,
+      options
+    ) as AsyncGenerator<GenericRowData<T>[], void, void>;
+  }
+
+  async executeArrow(query: SQL): Promise<unknown> {
+    const builtQuery = this.dialect.sqlToQuery(query);
+    const params = prepareParams(builtQuery.params, {
+      rejectStringArrayLiterals: this.rejectStringArrayLiterals,
+      warnOnStringArrayLiteral: this.rejectStringArrayLiterals
+        ? undefined
+        : () => this.warnOnStringArrayLiteral(builtQuery.sql),
+    });
+    const rewrittenQuery = this.rewriteArrays
+      ? adaptArrayOperators(builtQuery.sql)
+      : builtQuery.sql;
+
+    if (this.rewriteArrays && rewrittenQuery !== builtQuery.sql) {
+      this.logger.logQuery(
+        `[duckdb] original query before array rewrite: ${builtQuery.sql}`,
+        params
+      );
+    }
+
+    this.logger.logQuery(rewrittenQuery, params);
+
+    return executeArrowOnClient(this.client, rewrittenQuery, params);
+  }
 }
 
 type PgTransactionInternals<
   TFullSchema extends Record<string, unknown> = Record<string, never>,
-  TSchema extends TablesRelationalConfig = Record<string, never>
+  TSchema extends TablesRelationalConfig = Record<string, never>,
 > = {
   dialect: DuckDBDialect;
   session: DuckDBSession<TFullSchema, TSchema>;
@@ -211,13 +290,13 @@ type PgTransactionInternals<
 
 type DuckDBTransactionWithInternals<
   TFullSchema extends Record<string, unknown> = Record<string, never>,
-  TSchema extends TablesRelationalConfig = Record<string, never>
+  TSchema extends TablesRelationalConfig = Record<string, never>,
 > = PgTransactionInternals<TFullSchema, TSchema> &
   DuckDBTransaction<TFullSchema, TSchema>;
 
 export class DuckDBTransaction<
   TFullSchema extends Record<string, unknown>,
-  TSchema extends TablesRelationalConfig
+  TSchema extends TablesRelationalConfig,
 > extends PgTransaction<DuckDBQueryResultHKT, TFullSchema, TSchema> {
   static readonly [entityKind]: string = 'DuckDBTransaction';
 
@@ -240,15 +319,32 @@ export class DuckDBTransaction<
   }
 
   setTransaction(config: PgTransactionConfig): Promise<void> {
+    // Cast needed: PgTransaction doesn't expose dialect/session properties in public API
     type Tx = DuckDBTransactionWithInternals<TFullSchema, TSchema>;
     return (this as unknown as Tx).session.execute(
       sql`set transaction ${this.getTransactionConfigSQL(config)}`
     );
   }
 
+  executeBatches<T extends RowData = RowData>(
+    query: SQL,
+    options: ExecuteInBatchesOptions = {}
+  ): AsyncGenerator<GenericRowData<T>[], void, void> {
+    // Cast needed: PgTransaction doesn't expose session property in public API
+    type Tx = DuckDBTransactionWithInternals<TFullSchema, TSchema>;
+    return (this as unknown as Tx).session.executeBatches<T>(query, options);
+  }
+
+  executeArrow(query: SQL): Promise<unknown> {
+    // Cast needed: PgTransaction doesn't expose session property in public API
+    type Tx = DuckDBTransactionWithInternals<TFullSchema, TSchema>;
+    return (this as unknown as Tx).session.executeArrow(query);
+  }
+
   override async transaction<T>(
     transaction: (tx: DuckDBTransaction<TFullSchema, TSchema>) => Promise<T>
   ): Promise<T> {
+    // Cast needed: PgTransaction doesn't expose dialect/session properties in public API
     type Tx = DuckDBTransactionWithInternals<TFullSchema, TSchema>;
     const nestedTx = new DuckDBTransaction<TFullSchema, TSchema>(
       (this as unknown as Tx).dialect,
@@ -268,7 +364,6 @@ export type GenericTableData<T = RowData> = T[];
 const arrayLiteralWarning =
   'Received a stringified Postgres-style array literal. Use duckDbList()/duckDbArray() or pass native arrays instead. You can also set rejectStringArrayLiterals=true to throw.';
 
-
 export interface DuckDBQueryResultHKT extends PgQueryResultHKT {
   type: GenericTableData<Assume<this['row'], RowData>>;
 }

package/src/sql/query-rewriters.ts

@@ -1,13 +1,3 @@
-const selectionRegex = /select\s+(.+)\s+from/i;
-const tableIdPropSelectionRegex = new RegExp(
-  [
-    `("(.+)"\\."(.+)")`, // table identifier + property
-    `(\\s+as\\s+'?(.+?)'?\\.'?(.+?)'?)?`, // optional AS clause
-  ].join(''),
-  'i'
-);
-const noTableIdPropSelectionRegex = /"(.+)"(\s+as\s+'?\1'?)?/i;
-
 export function adaptArrayOperators(query: string): string {
   type ArrayOperator = {
     token: '@>' | '<@' | '&&';
@@ -34,6 +24,7 @@ export function adaptArrayOperators(query: string): string {
     let inString = false;
     for (; idx >= 0; idx--) {
       const ch = source[idx];
+      if (ch === undefined) break;
       if (ch === "'" && source[idx - 1] !== '\\') {
         inString = !inString;
       }
@@ -62,6 +53,7 @@ export function adaptArrayOperators(query: string): string {
     let inString = false;
     for (; idx < source.length; idx++) {
       const ch = source[idx];
+      if (ch === undefined) break;
       if (ch === "'" && source[idx - 1] !== '\\') {
         inString = !inString;
       }
@@ -85,10 +77,7 @@ export function adaptArrayOperators(query: string): string {
     let idx = rewritten.indexOf(token);
     while (idx !== -1) {
       const [leftStart, leftExpr] = walkLeft(rewritten, idx - 1);
-      const [rightEnd, rightExpr] = walkRight(
-        rewritten,
-        idx + token.length
-      );
+      const [rightEnd, rightExpr] = walkRight(rewritten, idx + token.length);
 
       const left = leftExpr.trim();
       const right = rightExpr.trim();
@@ -98,9 +87,7 @@ export function adaptArrayOperators(query: string): string {
       })`;
 
       rewritten =
-        rewritten.slice(0, leftStart) +
-        replacement +
-        rewritten.slice(rightEnd);
+        rewritten.slice(0, leftStart) + replacement + rewritten.slice(rightEnd);
 
       idx = rewritten.indexOf(token, leftStart + replacement.length);
     }
@@ -108,40 +95,3 @@ export function adaptArrayOperators(query: string): string {
 
   return rewritten;
 }
-
-export function queryAdapter(query: string): string {
-  const selection = selectionRegex.exec(query);
-
-  if (selection?.length !== 2) {
-    return query;
-  }
-
-  const fields = selection[1]
-    .split(',')
-    .map((field) => {
-      const trimmedField = field.trim();
-      const tableProp = tableIdPropSelectionRegex.exec(trimmedField);
-      if (tableProp) {
-        const [, identifier, table, column, , aliasTable, aliasColumn] =
-          tableProp;
-
-        const asAlias = `'${aliasTable ?? table}.${aliasColumn ?? column}'`;
-        if (tableProp[4]) {
-          return trimmedField.replace(tableProp[4], ` as ${asAlias}`);
-        }
-        return `${identifier} as ${asAlias}`;
-      }
-
-      const noTableProp = noTableIdPropSelectionRegex.exec(trimmedField);
-      if (noTableProp) {
-        const [, column, alias] = noTableProp;
-        const asAlias = ` as '${column}'`;
-        return alias ? trimmedField.replace(alias, asAlias) : `${trimmedField}${asAlias}`;
-      }
-
-      return trimmedField;
-    })
-    .filter(Boolean) as string[];
-
-  return query.replace(selection[1], fields.join(', '));
-}

package/src/sql/result-mapper.ts

@@ -88,7 +88,10 @@ function normalizeTimestampString(
   return value;
 }
 
-function normalizeTimestamp(value: unknown, withTimezone: boolean): Date | unknown {
+function normalizeTimestamp(
+  value: unknown,
+  withTimezone: boolean
+): Date | unknown {
   if (value instanceof Date) {
     return value;
   }
@@ -96,8 +99,7 @@ function normalizeTimestamp(value: unknown, withTimezone: boolean): Date | unkno
     const hasOffset =
       value.endsWith('Z') || /[+-]\d{2}:?\d{2}$/.test(value.trim());
     const spaced = value.replace(' ', 'T');
-    const normalized =
-      withTimezone || hasOffset ? spaced : `${spaced}+00`;
+    const normalized = withTimezone || hasOffset ? spaced : `${spaced}+00`;
     return new Date(normalized);
   }
   return value;
@@ -177,9 +179,7 @@ function mapDriverValue(
     if (normalized instanceof Date) {
       return normalized;
     }
-    return decoder.mapFromDriverValue(
-      toDecoderInput(decoder, normalized)
-    );
+    return decoder.mapFromDriverValue(toDecoderInput(decoder, normalized));
   }
 
   if (is(decoder, PgDateString)) {