joist-orm 2.3.0-next.5 → 2.3.0-next.51

package/build/drivers/PostgresDriver.js

@@ -1,306 +1,289 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostgresDriver = void 0;
-exports.setupLatestPgTypes = setupLatestPgTypes;
-const joist_core_1 = require("joist-core");
-const pg_1 = __importDefault(require("pg"));
-const pg_types_1 = require("pg-types");
-const postgres_array_1 = __importDefault(require("postgres-array"));
+import { registerDatabaseBinaryParsers, registerTemporalBinaryParsers } from "./binaryParsers.js";
+import { ensureLazyDataRows } from "./patchPgProtocol.js";
+import { executeRowDataQuery, isRowDataCapableClient } from "./WireRowData.js";
+import { JoinRowOperation, PojoRowData, SequenceIdAssigner, buildRawQuery, cleanSql, driverAfterBegin, driverAfterCommit, driverBeforeBegin, driverBeforeCommit, ensureRectangularArraySizes, fail, generateOps, getRuntimeConfig, kq, kqDot, partition } from "joist-core";
+import pg from "pg";
+import { builtins, getTypeParser } from "pg-types";
+import array from "postgres-array";
+//#region src/drivers/PostgresDriver.ts
 /**
- * Implements the `Driver` interface for Postgres.
- *
- * This is the canonical driver implementation and leverages several aspects of
- * Postgres for the best performance, i.e.:
- *
- * - Deferred foreign key constraints are used to allow bulk inserting/updating
- * all entities without any topographic sorting/ordering issues.
- *
- * - Sequences are used to bulk-assign + then bulk-insert all entities, to again
- * avoid issues with ordering issues (cannot bulk insert A w/o knowing the id of B).
- *
- * - We use a pg-specific bulk update syntax.
- */
-class PostgresDriver {
-    pool;
-    #idAssigner;
-    #preloadPlugin;
-    #onQuery;
-    constructor(pool, opts) {
-        this.pool = pool;
-        this.#idAssigner =
-            opts?.idAssigner ??
-                new joist_core_1.SequenceIdAssigner(async (sql) => {
-                    this.#onQuery?.(sql);
-                    return (await pool.query(sql)).rows;
-                });
-        this.#preloadPlugin = opts?.preloadPlugin;
-        this.#onQuery = opts?.onQuery;
-        setupLatestPgTypes((0, joist_core_1.getRuntimeConfig)().temporal);
-    }
-    async executeFind(em, parsed, settings) {
-        const { sql, bindings } = (0, joist_core_1.buildRawQuery)(parsed, { limit: em.entityLimit, ...settings });
-        return this.executeQuery(em, sql, bindings);
-    }
-    async executeQuery(em, sql, bindings) {
-        const pgSql = toPgParams(sql);
-        this.#onQuery?.(pgSql);
-        const client = this.getMaybeInTxnClient(em);
-        return client.query(pgSql, bindings).then((result) => result.rows);
-    }
-    async transaction(em, fn) {
-        if (em.txn) {
-            return fn(em.txn);
-        }
-        const client = await this.pool.connect();
-        let result;
-        try {
-            await (0, joist_core_1.driverBeforeBegin)(em, client);
-            this.#onQuery?.("BEGIN;");
-            await client.query("BEGIN");
-            em.txn = client;
-            try {
-                await (0, joist_core_1.driverAfterBegin)(em, client);
-                result = await fn(client);
-                await (0, joist_core_1.driverBeforeCommit)(em, client);
-                this.#onQuery?.("COMMIT;");
-                await client.query("COMMIT");
-            }
-            catch (e) {
-                await client.query("ROLLBACK");
-                throw e;
-            }
-            finally {
-                em.txn = undefined;
-            }
-            await (0, joist_core_1.driverAfterCommit)(em, client);
-        }
-        finally {
-            client.release();
-        }
-        return result;
-    }
-    async assignNewIds(_, todos) {
-        return this.#idAssigner.assignNewIds(todos);
-    }
-    async flush(em, entityTodos, joinRows) {
-        const client = (em.txn ?? (0, joist_core_1.fail)("Expected EntityManager.txn to be set"));
-        await this.#idAssigner.assignNewIds(entityTodos);
-        const ops = (0, joist_core_1.generateOps)(entityTodos);
-        const onQuery = this.#onQuery;
-        // Do INSERTs+UPDATEs first so that we avoid DELETE cascades invalidating oplocks
-        // See https://github.com/joist-orm/joist-orm/issues/591
-        await Promise.all([
-            ...ops.inserts.map((op) => batchInsert(client, op, onQuery)),
-            ...ops.updates.map((op) => batchUpdate(client, op, onQuery)),
-            ...ops.deletes.map((op) => batchDelete(client, op, onQuery)),
-            ...Object.entries(joinRows).flatMap(([joinTableName, todo]) => {
-                return [
-                    m2mBatchInsert(client, joinTableName, todo, onQuery),
-                    m2mBatchDelete(client, joinTableName, todo, onQuery),
-                ];
-            }),
-        ]);
-    }
-    get defaultPlugins() {
-        return { preloadPlugin: this.#preloadPlugin };
-    }
-    getMaybeInTxnClient(em) {
-        return em.txn || this.pool;
-    }
-}
-exports.PostgresDriver = PostgresDriver;
+* Implements the `Driver` interface for Postgres.
+*
+* This is the canonical driver implementation and leverages several aspects of
+* Postgres for the best performance, i.e.:
+*
+* - Deferred foreign key constraints are used to allow bulk inserting/updating
+* all entities without any topographic sorting/ordering issues.
+*
+* - Sequences are used to bulk-assign + then bulk-insert all entities, to again
+* avoid issues with ordering issues (cannot bulk insert A w/o knowing the id of B).
+*
+* - We use a pg-specific bulk update syntax.
+*
+* Query pipelining is enabled for clients created after driver construction unless the pool was
+* configured with `pipeline: false`.
+*/
+var PostgresDriver = class {
+	pool;
+	#idAssigner;
+	#preloadPlugin;
+	#onQuery;
+	lazyRows;
+	/** Defined only when `lazyRows` is enabled; its presence is the capability signal the EM checks. */
+	executeFindRowData;
+	#databaseBinaryParsers = void 0;
+	constructor(pool, opts) {
+		this.pool = pool;
+		pool.options.pipeline ??= true;
+		this.#idAssigner = opts?.idAssigner ?? new SequenceIdAssigner(async (sql) => {
+			this.#onQuery?.(sql);
+			return (await pool.query(sql)).rows;
+		});
+		this.#preloadPlugin = opts?.preloadPlugin;
+		this.#onQuery = opts?.onQuery;
+		this.lazyRows = (opts?.lazyRows ?? false) && ensureLazyDataRows();
+		if (opts?.lazyRows && !this.lazyRows) console.warn("joist-orm: lazyRows was requested, but patching pg-protocol failed; using classic rows.");
+		this.executeFindRowData = this.lazyRows ? (em, parsed, settings) => this.#executeFindRowData(em, parsed, settings) : void 0;
+		setupLatestPgTypes(getRuntimeConfig().temporal);
+	}
+	async executeFind(em, parsed, settings) {
+		const { sql, bindings } = buildRawQuery(parsed, {
+			limit: em.entityLimit,
+			...settings
+		});
+		return this.executeQuery(em, sql, bindings);
+	}
+	async #executeFindRowData(em, parsed, settings) {
+		await (this.#databaseBinaryParsers ??= registerDatabaseBinaryParsers(this.pool).catch((err) => {
+			this.#databaseBinaryParsers = void 0;
+			throw err;
+		}));
+		const { sql, bindings } = buildRawQuery(parsed, {
+			limit: em.entityLimit,
+			...settings
+		});
+		const pgSql = toPgParams(sql);
+		this.#onQuery?.(pgSql);
+		const txnClient = em.txn;
+		const client = txnClient ?? await this.pool.connect();
+		try {
+			if (!isRowDataCapableClient(client)) {
+				warnUnsupportedClientOnce();
+				return new PojoRowData((await client.query(pgSql, bindings)).rows);
+			}
+			return await executeRowDataQuery(client, pgSql, bindings);
+		} finally {
+			if (!txnClient) client.release();
+		}
+	}
+	async executeQuery(em, sql, bindings) {
+		const pgSql = toPgParams(sql);
+		this.#onQuery?.(pgSql);
+		return this.getMaybeInTxnClient(em).query(pgSql, bindings).then((result) => result.rows);
+	}
+	async transaction(em, fn) {
+		if (em.txn) return fn(em.txn);
+		const client = await this.pool.connect();
+		let result;
+		try {
+			await driverBeforeBegin(em, client);
+			this.#onQuery?.("BEGIN;");
+			await client.query("BEGIN");
+			em.txn = client;
+			try {
+				await driverAfterBegin(em, client);
+				result = await fn(client);
+				await driverBeforeCommit(em, client);
+				this.#onQuery?.("COMMIT;");
+				await client.query("COMMIT");
+			} catch (e) {
+				await client.query("ROLLBACK");
+				throw e;
+			} finally {
+				em.txn = void 0;
+			}
+			await driverAfterCommit(em, client);
+		} finally {
+			client.release();
+		}
+		return result;
+	}
+	async assignNewIds(_, todos) {
+		return this.#idAssigner.assignNewIds(todos);
+	}
+	async flush(em, entityTodos, joinRows) {
+		const client = em.txn ?? fail("Expected EntityManager.txn to be set");
+		await this.#idAssigner.assignNewIds(entityTodos);
+		const ops = generateOps(entityTodos);
+		const onQuery = this.#onQuery;
+		await Promise.all([
+			...ops.inserts.map((op) => batchInsert(client, op, onQuery)),
+			...ops.updates.map((op) => batchUpdate(client, op, onQuery)),
+			...ops.deletes.map((op) => batchDelete(client, op, onQuery)),
+			...Object.entries(joinRows).flatMap(([joinTableName, todo]) => {
+				return [m2mBatchInsert(client, joinTableName, todo, onQuery), m2mBatchDelete(client, joinTableName, todo, onQuery)];
+			})
+		]);
+	}
+	get defaultPlugins() {
+		return { preloadPlugin: this.#preloadPlugin };
+	}
+	getMaybeInTxnClient(em) {
+		return em.txn || this.pool;
+	}
+};
 async function batchInsert(client, op, onQuery) {
-    const { tableName, columns, columnValues } = op;
-    const [cte, bindings] = buildUnnestCte("data", columns, columnValues);
-    const sql = (0, joist_core_1.cleanSql)(`
+	const { tableName, columns, columnValues } = op;
+	const [cte, bindings] = buildUnnestCte("data", columns, columnValues);
+	const pgSql = toPgParams(cleanSql(`
     ${cte}
-    INSERT INTO ${(0, joist_core_1.kq)(tableName)} (${columns.map((c) => (0, joist_core_1.kq)(c.columnName)).join(", ")})
+    INSERT INTO ${kq(tableName)} (${columns.map((c) => kq(c.columnName)).join(", ")})
     SELECT * FROM data
-  `);
-    const pgSql = toPgParams(sql);
-    onQuery?.(pgSql);
-    return client.query(pgSql, bindings);
+  `));
+	onQuery?.(pgSql);
+	return client.query(pgSql, bindings);
 }
 async function batchUpdate(client, op, onQuery) {
-    const { tableName, columns, columnValues, updatedAt } = op;
-    const [cte, bindings] = buildUnnestCte("data", columns, columnValues);
-    // JS Dates only have millisecond-level precision, so we may have dropped/lost accuracy when
-    // reading Postgres's microsecond-level `timestamptz` values; using `date_trunc` "downgrades"
-    // the pg data to match what we have in the JS Date.
-    //
-    // ...but Temporal's types don't have this flaw.
-    const truncateToMills = !(0, joist_core_1.getRuntimeConfig)().temporal;
-    const maybeUpdatedAt = updatedAt && truncateToMills
-        ? ` AND date_trunc('milliseconds', ${(0, joist_core_1.kqDot)(tableName, updatedAt)}) = data.__original_updated_at`
-        : updatedAt
-            ? ` AND ${(0, joist_core_1.kqDot)(tableName, updatedAt)} = data.__original_updated_at`
-            : "";
-    const sql = `
+	const { tableName, columns, columnValues, updatedAt } = op;
+	const [cte, bindings] = buildUnnestCte("data", columns, columnValues);
+	const truncateToMills = !getRuntimeConfig().temporal;
+	const maybeUpdatedAt = updatedAt && truncateToMills ? ` AND date_trunc('milliseconds', ${kqDot(tableName, updatedAt)}) = data.__original_updated_at` : updatedAt ? ` AND ${kqDot(tableName, updatedAt)} = data.__original_updated_at` : "";
+	const sql = `
     ${cte}
-    UPDATE ${(0, joist_core_1.kq)(tableName)}
-    SET ${columns
-        .filter((c) => c.columnName !== "id" && c.columnName !== "__original_updated_at")
-        .map((c) => `${(0, joist_core_1.kq)(c.columnName)} = data.${(0, joist_core_1.kq)(c.columnName)}`)
-        .join(", ")}
+    UPDATE ${kq(tableName)}
+    SET ${columns.filter((c) => c.columnName !== "id" && c.columnName !== "__original_updated_at").map((c) => `${kq(c.columnName)} = data.${kq(c.columnName)}`).join(", ")}
     FROM data
-    WHERE ${(0, joist_core_1.kq)(tableName)}.id = data.id ${maybeUpdatedAt}
-    RETURNING ${(0, joist_core_1.kq)(tableName)}.id
+    WHERE ${kq(tableName)}.id = data.id ${maybeUpdatedAt}
+    RETURNING ${kq(tableName)}.id
   `;
-    const pgSql = toPgParams((0, joist_core_1.cleanSql)(sql));
-    onQuery?.(pgSql);
-    const result = await client.query(pgSql, bindings);
-    const results = result.rows;
-    const ids = columnValues[0]; // assume id is the 1st column
-    if (results.length !== ids.length) {
-        const updated = new Set(results.map((r) => r.id));
-        const missing = ids.filter((id) => !updated.has(id));
-        throw new Error(`Oplock failure for ${tableName} rows ${missing.join(", ")}`);
-    }
+	const pgSql = toPgParams(cleanSql(sql));
+	onQuery?.(pgSql);
+	const results = (await client.query(pgSql, bindings)).rows;
+	const ids = columnValues[0];
+	if (results.length !== ids.length) {
+		const updated = new Set(results.map((r) => r.id));
+		const missing = ids.filter((id) => !updated.has(id));
+		throw new Error(`Oplock failure for ${tableName} rows ${missing.join(", ")}`);
+	}
 }
 async function batchDelete(client, op, onQuery) {
-    const { tableName, ids } = op;
-    const pgSql = toPgParams(`DELETE FROM ${(0, joist_core_1.kq)(tableName)} WHERE id = ANY(?)`);
-    onQuery?.(pgSql);
-    await client.query(pgSql, [ids]);
+	const { tableName, ids } = op;
+	const pgSql = toPgParams(`DELETE FROM ${kq(tableName)} WHERE id = ANY(?)`);
+	onQuery?.(pgSql);
+	await client.query(pgSql, [ids]);
 }
 /** Creates a CTE named `tableName` that bulk-injects the `columnValues` into a SQL query. */
 function buildUnnestCte(tableName, columns, columnValues) {
-    (0, joist_core_1.ensureRectangularArraySizes)(columns, columnValues);
-    const selects = columns.map((c) => {
-        if (c.dbType.endsWith("[]")) {
-            if (c.isNullableArray) {
-                return `unnest_arrays(?::${c.dbType}[], true) as ${(0, joist_core_1.kq)(c.columnName)}`;
-            }
-            else {
-                return `unnest_arrays(?::${c.dbType}[]) as ${(0, joist_core_1.kq)(c.columnName)}`;
-            }
-        }
-        else {
-            return `unnest(?::${c.dbType}[]) as ${(0, joist_core_1.kq)(c.columnName)}`;
-        }
-    });
-    const sql = `WITH ${tableName} AS (SELECT ${selects.join(", ")})`;
-    return [sql, columnValues];
+	ensureRectangularArraySizes(columns, columnValues);
+	return [`WITH ${tableName} AS (SELECT ${columns.map((c) => {
+		if (c.dbType.endsWith("[]")) {
+			if (c.isNullableArray) return `unnest_arrays(?::${c.dbType}[], true) as ${kq(c.columnName)}`;
+			else return `unnest_arrays(?::${c.dbType}[]) as ${kq(c.columnName)}`;
+		} else return `unnest(?::${c.dbType}[]) as ${kq(c.columnName)}`;
+	}).join(", ")})`, columnValues];
 }
 async function m2mBatchInsert(client, joinTableName, todo, onQuery) {
-    const { m2m, newRows } = todo;
-    if (newRows.length === 0)
-        return;
-    const col1Values = newRows.map((row) => todo.dbValue(row, m2m.columnName));
-    const col2Values = newRows.map((row) => todo.dbValue(row, m2m.otherColumnName));
-    if (m2m.hasJoinTableId) {
-        const sql = (0, joist_core_1.cleanSql)(`
-      WITH data AS (SELECT unnest(?::int[]) as ${(0, joist_core_1.kq)(m2m.columnName)}, unnest(?::int[]) as ${(0, joist_core_1.kq)(m2m.otherColumnName)})
-      INSERT INTO ${(0, joist_core_1.kq)(joinTableName)} (${(0, joist_core_1.kq)(m2m.columnName)}, ${(0, joist_core_1.kq)(m2m.otherColumnName)})
+	const { m2m, newRows } = todo;
+	if (newRows.length === 0) return;
+	const col1Values = newRows.map((row) => todo.dbValue(row, m2m.columnName));
+	const col2Values = newRows.map((row) => todo.dbValue(row, m2m.otherColumnName));
+	if (m2m.hasJoinTableId) {
+		const pgSql = toPgParams(cleanSql(`
+      WITH data AS (SELECT unnest(?::int[]) as ${kq(m2m.columnName)}, unnest(?::int[]) as ${kq(m2m.otherColumnName)})
+      INSERT INTO ${kq(joinTableName)} (${kq(m2m.columnName)}, ${kq(m2m.otherColumnName)})
       SELECT * FROM data
-      ON CONFLICT (${(0, joist_core_1.kq)(m2m.columnName)}, ${(0, joist_core_1.kq)(m2m.otherColumnName)}) DO UPDATE SET id = ${(0, joist_core_1.kq)(joinTableName)}.id
+      ON CONFLICT (${kq(m2m.columnName)}, ${kq(m2m.otherColumnName)}) DO UPDATE SET id = ${kq(joinTableName)}.id
       RETURNING id;
-    `);
-        const pgSql = toPgParams(sql);
-        onQuery?.(pgSql);
-        const { rows } = await client.query(pgSql, [col1Values, col2Values]);
-        for (let i = 0; i < rows.length; i++) {
-            newRows[i].id = rows[i].id;
-            newRows[i].op = joist_core_1.JoinRowOperation.Flushed;
-            newRows[i].persisted = true;
-        }
-    }
-    else {
-        // Id-less join tables have no surrogate id to return; the FK pair is the PK, so just
-        // insert and let any duplicate be a no-op.
-        const sql = (0, joist_core_1.cleanSql)(`
-      WITH data AS (SELECT unnest(?::int[]) as ${(0, joist_core_1.kq)(m2m.columnName)}, unnest(?::int[]) as ${(0, joist_core_1.kq)(m2m.otherColumnName)})
-      INSERT INTO ${(0, joist_core_1.kq)(joinTableName)} (${(0, joist_core_1.kq)(m2m.columnName)}, ${(0, joist_core_1.kq)(m2m.otherColumnName)})
+    `));
+		onQuery?.(pgSql);
+		const { rows } = await client.query(pgSql, [col1Values, col2Values]);
+		for (let i = 0; i < rows.length; i++) {
+			newRows[i].id = rows[i].id;
+			newRows[i].op = JoinRowOperation.Flushed;
+			newRows[i].persisted = true;
+		}
+	} else {
+		const pgSql = toPgParams(cleanSql(`
+      WITH data AS (SELECT unnest(?::int[]) as ${kq(m2m.columnName)}, unnest(?::int[]) as ${kq(m2m.otherColumnName)})
+      INSERT INTO ${kq(joinTableName)} (${kq(m2m.columnName)}, ${kq(m2m.otherColumnName)})
       SELECT * FROM data
-      ON CONFLICT (${(0, joist_core_1.kq)(m2m.columnName)}, ${(0, joist_core_1.kq)(m2m.otherColumnName)}) DO NOTHING;
-    `);
-        const pgSql = toPgParams(sql);
-        onQuery?.(pgSql);
-        await client.query(pgSql, [col1Values, col2Values]);
-        for (const row of newRows) {
-            row.op = joist_core_1.JoinRowOperation.Flushed;
-            row.persisted = true;
-        }
-    }
+      ON CONFLICT (${kq(m2m.columnName)}, ${kq(m2m.otherColumnName)}) DO NOTHING;
+    `));
+		onQuery?.(pgSql);
+		await client.query(pgSql, [col1Values, col2Values]);
+		for (const row of newRows) {
+			row.op = JoinRowOperation.Flushed;
+			row.persisted = true;
+		}
+	}
 }
 async function m2mBatchDelete(client, joinTableName, todo, onQuery) {
-    const { m2m, deletedRows } = todo;
-    if (deletedRows.length === 0)
-        return;
-    // Rows with a surrogate id are deleted by id; rows without one — id-less tables, or `remove`s
-    // done against an unloaded ManyToManyCollection — are deleted by their (col1, col2) composite.
-    const [haveIds, noIds] = (0, joist_core_1.partition)(deletedRows, (r) => {
-        // We used to use `id !== -1` as a marker for "row is/is-not persisted in the db" -- but when adding support
-        // for id-column-less m2m tables, we couldn't use `id === -1` as this marker anymore, so now rely on a dedicated
-        // `persisted` key instead.
-        //
-        // So, ideally, this `id !== -1` could go away _except_ that our internal verisoning plugin leverages this "m2m rows
-        // with an id=-1 delete by their FK values" to handle our versioned m2m tables. And for now it's easier to
-        // keep/restore this `id !== -1` than refactor that.
-        return r.id !== undefined && r.id !== -1;
-    });
-    if (haveIds.length > 0) {
-        const pgSql = toPgParams(`DELETE FROM ${(0, joist_core_1.kq)(joinTableName)} WHERE id = ANY(?)`);
-        onQuery?.(pgSql);
-        await client.query(pgSql, [haveIds.map((r) => r.id)]);
-    }
-    if (noIds.length > 0) {
-        const data = noIds
-            // Watch for m2m rows that got added-then-removed to entities that were themselves added-then-removed,
-            // as the deTagId will be undefined for those, as we're skipping adding them to the database.
-            .filter((row) => !todo.isNew(row, m2m.columnName) && !todo.isNew(row, m2m.otherColumnName))
-            .map((row) => [todo.dbValue(row, m2m.columnName), todo.dbValue(row, m2m.otherColumnName)]);
-        if (data.length > 0) {
-            const pgSql = toPgParams(`
-        DELETE FROM ${(0, joist_core_1.kq)(joinTableName)}
-        WHERE (${(0, joist_core_1.kq)(m2m.columnName)}, ${(0, joist_core_1.kq)(m2m.otherColumnName)}) IN (
+	const { m2m, deletedRows } = todo;
+	if (deletedRows.length === 0) return;
+	const [haveIds, noIds] = partition(deletedRows, (r) => {
+		return r.id !== void 0 && r.id !== -1;
+	});
+	if (haveIds.length > 0) {
+		const pgSql = toPgParams(`DELETE FROM ${kq(joinTableName)} WHERE id = ANY(?)`);
+		onQuery?.(pgSql);
+		await client.query(pgSql, [haveIds.map((r) => r.id)]);
+	}
+	if (noIds.length > 0) {
+		const data = noIds.filter((row) => !todo.isNew(row, m2m.columnName) && !todo.isNew(row, m2m.otherColumnName)).map((row) => [todo.dbValue(row, m2m.columnName), todo.dbValue(row, m2m.otherColumnName)]);
+		if (data.length > 0) {
+			const pgSql = toPgParams(`
+        DELETE FROM ${kq(joinTableName)}
+        WHERE (${kq(m2m.columnName)}, ${kq(m2m.otherColumnName)}) IN (
           SELECT (data->>0)::int, (data->>1)::int FROM jsonb_array_elements(?) data
         )`);
-            onQuery?.(pgSql);
-            await client.query(pgSql, [JSON.stringify(data)]);
-        }
-    }
-    deletedRows.forEach((row) => {
-        row.id = undefined;
-        row.persisted = false;
-        row.op = joist_core_1.JoinRowOperation.Flushed;
-    });
+			onQuery?.(pgSql);
+			await client.query(pgSql, [JSON.stringify(data)]);
+		}
+	}
+	deletedRows.forEach((row) => {
+		row.id = void 0;
+		row.persisted = false;
+		row.op = JoinRowOperation.Flushed;
+	});
 }
 /**
- * Configures the `pg` driver with the best type parsers.
- *
- * In particular, pg's default `TIMESTAMPTZ` parser is very inefficient, and even just
- * pulling in the latest `pg-types` and installing the fixed parser makes a noticable
- * difference.
- */
+* Configures the `pg` driver with the best type parsers.
+*
+* In particular, pg's default `TIMESTAMPTZ` parser is very inefficient, and even just
+* pulling in the latest `pg-types` and installing the fixed parser makes a noticable
+* difference.
+*/
 function setupLatestPgTypes(temporal) {
-    if (temporal) {
-        // Don't eagerly parse the strings, instead defer to the serde logic
-        const noop = (s) => s;
-        const noopArray = (s) => postgres_array_1.default.parse(s, noop);
-        const { TIMESTAMP, TIMESTAMPTZ, DATE } = pg_1.default.types.builtins;
-        pg_1.default.types.setTypeParser(DATE, noop);
-        pg_1.default.types.setTypeParser(TIMESTAMP, noop);
-        pg_1.default.types.setTypeParser(TIMESTAMPTZ, noop);
-        // Use `as number` b/c the typings of shadowed pg-types from `pg` and `pg-types` top-level don't line up
-        pg_1.default.types.setTypeParser(1182, noopArray); // date[]
-        pg_1.default.types.setTypeParser(1115, noopArray); // timestamp[]
-        pg_1.default.types.setTypeParser(1185, noopArray); // timestamptz[]
-    }
-    else {
-        pg_1.default.types.setTypeParser(pg_1.default.types.builtins.TIMESTAMPTZ, (0, pg_types_1.getTypeParser)(pg_types_1.builtins.TIMESTAMPTZ));
-    }
+	if (temporal) {
+		const noop = (s) => s;
+		const noopArray = (s) => array.parse(s, noop);
+		const { TIMESTAMP, TIMESTAMPTZ, DATE } = pg.types.builtins;
+		pg.types.setTypeParser(DATE, noop);
+		pg.types.setTypeParser(TIMESTAMP, noop);
+		pg.types.setTypeParser(TIMESTAMPTZ, noop);
+		pg.types.setTypeParser(1182, noopArray);
+		pg.types.setTypeParser(1115, noopArray);
+		pg.types.setTypeParser(1185, noopArray);
+		registerTemporalBinaryParsers();
+	} else pg.types.setTypeParser(pg.types.builtins.TIMESTAMPTZ, getTypeParser(builtins.TIMESTAMPTZ));
 }
 const questionMarks = /(?<!@)\?/g;
 /**
- * Converts our knex-style `?` placeholders to pg-native `$1, $2, ...` numbered parameters.
- *
- * We skipping postgres operators like `@?`. */
+* Converts our knex-style `?` placeholders to pg-native `$1, $2, ...` numbered parameters.
+*
+* We skipping postgres operators like `@?`. */
 function toPgParams(sql) {
-    let i = 0;
-    return sql.replace(questionMarks, () => `$${++i}`);
+	let i = 0;
+	return sql.replace(questionMarks, () => `$${++i}`);
+}
+let warnedUnsupportedClient = false;
+/** Warns once when lazyRows degrades to classic rows for an unsupported client, i.e. pg-native. */
+function warnUnsupportedClientOnce() {
+	if (warnedUnsupportedClient) return;
+	warnedUnsupportedClient = true;
+	console.warn("joist-orm: lazyRows is enabled, but this client does not support it; using classic rows.");
 }
+//#endregion
+export { PostgresDriver, setupLatestPgTypes };
+
 //# sourceMappingURL=PostgresDriver.js.map