@prisma/orm-target-postgres 8.0.0-rc.4-dev.7 → 8.0.0-rc.4-dev.9

package/dist/{control-Y6FxMu3o.mjs → control-DzK5mSLo.mjs}

@@ -3,6 +3,7 @@ import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { SqlQueryError } from "@prisma/orm-family-sql/errors";
 import { errorRuntime } from "@prisma/orm-framework/errors/execution";
 import { redactDatabaseUrl } from "@prisma/orm-framework/utils/redact-db-url";
+import { suppressIdleConnectionErrors } from "@prisma/orm-framework/utils/suppress-idle-connection-errors";
 import { Client } from "pg";
 //#region ../../../3-targets/7-drivers/postgres/dist/control.mjs
 var PostgresControlDriver = class {
@@ -33,8 +34,7 @@ var PostgresControlDriver = class {
 const postgresDriverDescriptor = {
 	...postgresDriverDescriptorMeta,
 	async create(url) {
-		const client = new Client({ connectionString: url });
-		client.on("error", () => {});
+		const client = suppressIdleConnectionErrors(new Client({ connectionString: url }));
 		try {
 			await client.connect();
 			return new PostgresControlDriver(client);
@@ -62,4 +62,4 @@ const postgresDriverDescriptor = {
 //#endregion
 export { postgresDriverDescriptor as n, PostgresControlDriver as t };
 
-//# sourceMappingURL=control-Y6FxMu3o.mjs.map
+//# sourceMappingURL=control-DzK5mSLo.mjs.map

package/dist/control-DzK5mSLo.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-DzK5mSLo.mjs","names":[],"sources":["../../../../3-targets/7-drivers/postgres/dist/control.mjs"],"sourcesContent":["import { i as postgresDriverDescriptorMeta, r as normalizePgError } from \"./normalize-error-CNjgVO71.mjs\";\nimport { errorRuntime } from \"@internal/errors/execution\";\nimport { SqlQueryError } from \"@internal/sql-errors\";\nimport { ifDefined } from \"@internal/utils/defined\";\nimport { redactDatabaseUrl } from \"@internal/utils/redact-db-url\";\nimport { suppressIdleConnectionErrors } from \"@internal/utils/suppress-idle-connection-errors\";\nimport { Client } from \"pg\";\n//#region src/exports/control.ts\nvar PostgresControlDriver = class {\n\tclient;\n\tfamilyId = \"sql\";\n\ttargetId = \"postgres\";\n\tconstructor(client) {\n\t\tthis.client = client;\n\t}\n\tasync query(sql, params) {\n\t\ttry {\n\t\t\treturn { rows: (await this.client.query(sql, params)).rows };\n\t\t} catch (error) {\n\t\t\tthrow normalizePgError(error);\n\t\t}\n\t}\n\tasync databaseName() {\n\t\tconst name = (await this.query(\"select current_database() as name\")).rows[0]?.name;\n\t\treturn typeof name === \"string\" && name.length > 0 ? name : void 0;\n\t}\n\tasync close() {\n\t\tawait this.client.end().catch(() => {});\n\t}\n};\n/**\n* Postgres driver descriptor for CLI config.\n*/\nconst postgresDriverDescriptor = {\n\t...postgresDriverDescriptorMeta,\n\tasync create(url) {\n\t\tconst client = suppressIdleConnectionErrors(new Client({ connectionString: url }));\n\t\ttry {\n\t\t\tawait client.connect();\n\t\t\treturn new PostgresControlDriver(client);\n\t\t} catch (error) {\n\t\t\tconst normalized = normalizePgError(error);\n\t\t\tconst redacted = redactDatabaseUrl(url);\n\t\t\ttry {\n\t\t\t\tawait client.end();\n\t\t\t} catch {}\n\t\t\tconst codeFromSqlState = SqlQueryError.is(normalized) ? normalized.sqlState : void 0;\n\t\t\tconst causeCode = \"cause\" in normalized && normalized.cause ? normalized.cause.code : void 0;\n\t\t\tconst sqlState = codeFromSqlState ?? causeCode;\n\t\t\tthrow errorRuntime(\"DRIVER.CONNECTION_FAILED\", \"Database connection failed\", {\n\t\t\t\twhy: normalized.message,\n\t\t\t\tfix: \"Verify the database URL, ensure the database is reachable, and confirm credentials/permissions\",\n\t\t\t\tmeta: {\n\t\t\t\t\t...ifDefined(\"sqlState\", sqlState),\n\t\t\t\t\t...redacted\n\t\t\t\t},\n\t\t\t\tcause: error\n\t\t\t});\n\t\t}\n\t}\n};\n//#endregion\nexport { PostgresControlDriver, postgresDriverDescriptor as default };\n\n//# sourceMappingURL=control.mjs.map"],"mappings":";;;;;;;;AAQA,IAAI,wBAAwB,MAAM;CACjC;CACA,WAAW;CACX,WAAW;CACX,YAAY,QAAQ;EACnB,KAAK,SAAS;CACf;CACA,MAAM,MAAM,KAAK,QAAQ;EACxB,IAAI;GACH,OAAO,EAAE,OAAO,MAAM,KAAK,OAAO,MAAM,KAAK,MAAM,EAAA,CAAG,KAAK;EAC5D,SAAS,OAAO;GACf,MAAM,iBAAiB,KAAK;EAC7B;CACD;CACA,MAAM,eAAe;EACpB,MAAM,QAAQ,MAAM,KAAK,MAAM,mCAAmC,EAAA,CAAG,KAAK,EAAE,EAAE;EAC9E,OAAO,OAAO,SAAS,YAAY,KAAK,SAAS,IAAI,OAAO,KAAK;CAClE;CACA,MAAM,QAAQ;EACb,MAAM,KAAK,OAAO,IAAI,CAAC,CAAC,YAAY,CAAC,CAAC;CACvC;AACD;;;;AAIA,MAAM,2BAA2B;CAChC,GAAG;CACH,MAAM,OAAO,KAAK;EACjB,MAAM,SAAS,6BAA6B,IAAI,OAAO,EAAE,kBAAkB,IAAI,CAAC,CAAC;EACjF,IAAI;GACH,MAAM,OAAO,QAAQ;GACrB,OAAO,IAAI,sBAAsB,MAAM;EACxC,SAAS,OAAO;GACf,MAAM,aAAa,iBAAiB,KAAK;GACzC,MAAM,WAAW,kBAAkB,GAAG;GACtC,IAAI;IACH,MAAM,OAAO,IAAI;GAClB,QAAQ,CAAC;GACT,MAAM,mBAAmB,cAAc,GAAG,UAAU,IAAI,WAAW,WAAW,KAAK;GACnF,MAAM,YAAY,WAAW,cAAc,WAAW,QAAQ,WAAW,MAAM,OAAO,KAAK;GAC3F,MAAM,WAAW,oBAAoB;GACrC,MAAM,aAAa,4BAA4B,8BAA8B;IAC5E,KAAK,WAAW;IAChB,KAAK;IACL,MAAM;KACL,GAAG,UAAU,YAAY,QAAQ;KACjC,GAAG;IACJ;IACA,OAAO;GACR,CAAC;EACF;CACD;AACD"}

package/dist/driver.d.mts

@@ -1,3 +1,3 @@
 import { t as PostgresControlDriver } from "./control-BaUpALVp.mjs";
-import { i as QueryResult, n as PostgresDriverCreateOptions, r as PostgresRuntimeDriver, t as PostgresBinding } from "./runtime-lHBKgjB9.mjs";
-export { type PostgresBinding, PostgresControlDriver, type PostgresDriverCreateOptions, PostgresRuntimeDriver, type QueryResult };
+import { i as QueryResult, n as PostgresDriverCreateOptions, o as suppressIdleConnectionErrors, r as PostgresRuntimeDriver, t as PostgresBinding } from "./runtime-DtoNQntj.mjs";
+export { type PostgresBinding, PostgresControlDriver, type PostgresDriverCreateOptions, PostgresRuntimeDriver, type QueryResult, suppressIdleConnectionErrors };

package/dist/driver.mjs

@@ -1,2 +1,3 @@
-import { t as PostgresControlDriver } from "./control-Y6FxMu3o.mjs";
-export { PostgresControlDriver };
+import { t as PostgresControlDriver } from "./control-DzK5mSLo.mjs";
+import { n as suppressIdleConnectionErrors } from "./runtime-C-Hh2m1R.mjs";
+export { PostgresControlDriver, suppressIdleConnectionErrors };

package/dist/driver__control.mjs

@@ -1,2 +1,2 @@
-import { n as postgresDriverDescriptor, t as PostgresControlDriver } from "./control-Y6FxMu3o.mjs";
+import { n as postgresDriverDescriptor, t as PostgresControlDriver } from "./control-DzK5mSLo.mjs";
 export { PostgresControlDriver, postgresDriverDescriptor as default };

package/dist/driver__runtime.d.mts

@@ -1,2 +1,2 @@
-import { a as postgresRuntimeDriverDescriptor, i as QueryResult, n as PostgresDriverCreateOptions, r as PostgresRuntimeDriver, t as PostgresBinding } from "./runtime-lHBKgjB9.mjs";
-export { type PostgresBinding, type PostgresDriverCreateOptions, PostgresRuntimeDriver, type QueryResult, postgresRuntimeDriverDescriptor as default };
+import { a as postgresRuntimeDriverDescriptor, i as QueryResult, n as PostgresDriverCreateOptions, o as suppressIdleConnectionErrors, r as PostgresRuntimeDriver, t as PostgresBinding } from "./runtime-DtoNQntj.mjs";
+export { type PostgresBinding, type PostgresDriverCreateOptions, PostgresRuntimeDriver, type QueryResult, postgresRuntimeDriverDescriptor as default, suppressIdleConnectionErrors };

package/dist/driver__runtime.mjs

@@ -1,639 +1,2 @@
-import { i as postgresDriverDescriptorMeta, n as isPostgresError, r as normalizePgError, t as isAlreadyConnectedError } from "./normalize-error-CNjgVO71-CLlZ3CuJ.mjs";
-import { blindCast } from "@prisma/orm-framework/utils/casts";
-import { Pool } from "pg";
-import Cursor from "pg-cursor";
-//#region ../../../3-targets/7-drivers/postgres/dist/runtime.mjs
-function driverError(code, message, details) {
-	const error = new Error(message);
-	Object.defineProperty(error, "name", {
-		value: "RuntimeError",
-		configurable: true
-	});
-	return details === void 0 ? Object.assign(error, {
-		code,
-		category: "DRIVER",
-		severity: "error"
-	}) : Object.assign(error, {
-		code,
-		category: "DRIVER",
-		severity: "error",
-		details
-	});
-}
-function callbackToPromise(fn) {
-	return new Promise((resolve, reject) => {
-		fn((err, result) => {
-			if (err) {
-				reject(err);
-				return;
-			}
-			resolve(result);
-		});
-	});
-}
-let nextNamedPortalId = 1;
-/** Streaming cursor for a server-side named prepared statement. */
-var NamedCursor = class extends Cursor {
-	name;
-	constructor(opts) {
-		super(opts.text, [...opts.values], opts.config);
-		this.name = opts.name;
-		this.submit = this.submitNamed;
-	}
-	submitNamed(connection) {
-		const self = this;
-		const conn = connection;
-		self.state = "submitted";
-		self.connection = conn;
-		self._portal = `np_${nextNamedPortalId++}`;
-		if (!conn.parsedStatements[this.name]) {
-			const parseMessage = {
-				text: self.text,
-				name: this.name,
-				types: []
-			};
-			conn.parse(parseMessage, true);
-		}
-		const bindMessage = {
-			portal: self._portal,
-			statement: this.name,
-			values: self.values ?? []
-		};
-		conn.bind(bindMessage, true);
-		conn.describe({
-			type: "P",
-			name: self._portal
-		}, true);
-		conn.flush();
-		if (self._conf.types) self._result._getTypeParser = self._conf.types.getTypeParser;
-		conn.once("noData", self._ifNoData);
-		conn.once("rowDescription", self._rowDescription);
-	}
-};
-const DEFAULT_BATCH_SIZE = 100;
-const DEFAULT_PREPARED_STATEMENTS = true;
-function createHandleAllocator() {
-	let next = 1;
-	return { mint: () => `pn_${next++}` };
-}
-function buildConnectionOptions(options) {
-	return {
-		...options.cursor?.disabled ? { cursorDisabled: true } : {
-			cursorBatchSize: options.cursor?.batchSize ?? DEFAULT_BATCH_SIZE,
-			cursorDisabled: false
-		},
-		preparedStatementsEnabled: options.preparedStatements ?? DEFAULT_PREPARED_STATEMENTS,
-		handleAllocator: createHandleAllocator()
-	};
-}
-function isStalePreparedStatementError(error) {
-	if (!(error instanceof Error) || !("code" in error) || typeof error.code !== "string") return false;
-	const code = error.code;
-	return code === "26000" || code === "0A000";
-}
-var AsyncMutex = class {
-	#queue = Promise.resolve();
-	async lock() {
-		const previous = this.#queue;
-		let releaseLock;
-		this.#queue = new Promise((resolve) => {
-			releaseLock = resolve;
-		});
-		await previous;
-		return () => {
-			releaseLock?.();
-			releaseLock = void 0;
-		};
-	}
-};
-const clientQueryLocks = /* @__PURE__ */ new WeakMap();
-function acquireClientQueryLock(client) {
-	let mutex = clientQueryLocks.get(client);
-	if (mutex === void 0) {
-		mutex = new AsyncMutex();
-		clientQueryLocks.set(client, mutex);
-	}
-	return mutex.lock();
-}
-var PostgresQueryable = class {
-	options;
-	constructor(options) {
-		this.options = options;
-	}
-	async *query(request) {
-		try {
-			const preparedStatementHandle = request.preparedStatementHandle;
-			if (preparedStatementHandle === void 0 || !this.options.preparedStatementsEnabled) {
-				yield* this.runQuery(request);
-				return;
-			}
-			const name = this.preparedStatementName(preparedStatementHandle);
-			yield* this.withStaleHandleStreamRetry(preparedStatementHandle, name, (name) => this.runQuery(request, name));
-		} catch (error) {
-			throw normalizePgError(error);
-		}
-	}
-	async execute(request) {
-		try {
-			const preparedStatementHandle = request.preparedStatementHandle;
-			if (preparedStatementHandle === void 0 || !this.options.preparedStatementsEnabled) return await this.runExecute(request);
-			const name = this.preparedStatementName(preparedStatementHandle);
-			return await this.withStaleHandleRetry(preparedStatementHandle, name, (name) => this.runExecute(request, name));
-		} catch (error) {
-			throw normalizePgError(error);
-		}
-	}
-	preparedStatementName(handle) {
-		const existingName = handle.get();
-		if (typeof existingName === "string") return existingName;
-		const mintedName = this.options.handleAllocator.mint();
-		handle.set(mintedName);
-		return mintedName;
-	}
-	async withStaleHandleRetry(preparedStatementHandle, name, attempt) {
-		try {
-			return await attempt(name);
-		} catch (error) {
-			if (!isStalePreparedStatementError(error)) throw error;
-			const retryName = this.options.handleAllocator.mint();
-			preparedStatementHandle.set(retryName);
-			try {
-				return await attempt(retryName);
-			} catch (retryError) {
-				throw prepareFailedError(retryError, retryName);
-			}
-		}
-	}
-	async *withStaleHandleStreamRetry(preparedStatementHandle, name, attempt) {
-		const stream = await this.withStaleHandleRetry(preparedStatementHandle, name, async (name) => {
-			const iterator = attempt(name)[Symbol.asyncIterator]();
-			return {
-				iterator,
-				first: await iterator.next()
-			};
-		});
-		if (stream.first.done) return;
-		let streamCompleted = false;
-		try {
-			yield stream.first.value;
-			while (true) {
-				const next = await stream.iterator.next();
-				if (next.done) {
-					streamCompleted = true;
-					return;
-				}
-				yield next.value;
-			}
-		} finally {
-			if (!streamCompleted) await stream.iterator.return?.();
-		}
-	}
-	async runExecute(request, name) {
-		const client = await this.acquireClient();
-		try {
-			const releaseLock = await acquireClientQueryLock(client);
-			try {
-				return { affectedRows: (await client.query({
-					name,
-					text: request.sql,
-					values: blindCast(request.params ?? [])
-				})).rowCount ?? 0 };
-			} finally {
-				releaseLock();
-			}
-		} finally {
-			await this.releaseClient(client);
-		}
-	}
-	inExplicitTransaction() {
-		return false;
-	}
-	async *runQuery(request, name) {
-		const client = await this.acquireClient();
-		try {
-			if (!this.options.cursorDisabled) {
-				const releaseLock = await acquireClientQueryLock(client);
-				try {
-					for await (const row of this.streamWithPortalProtection(client, request, this.options.cursorBatchSize, name)) yield blindCast(row);
-					return;
-				} catch (cursorError) {
-					if (!(cursorError instanceof Error) || isPostgresError(cursorError)) throw cursorError;
-				} finally {
-					releaseLock();
-				}
-			}
-			for await (const row of this.executeBuffered(client, request.sql, request.params, name)) yield blindCast(row);
-		} finally {
-			await this.releaseClient(client);
-		}
-	}
-	async explain(request) {
-		const text = `EXPLAIN (FORMAT JSON) ${request.sql}`;
-		const client = await this.acquireClient();
-		try {
-			const releaseLock = await acquireClientQueryLock(client);
-			try {
-				return { rows: blindCast((await client.query(text, request.params === void 0 ? void 0 : [...request.params]).catch(rethrowNormalizedError)).rows) };
-			} finally {
-				releaseLock();
-			}
-		} finally {
-			await this.releaseClient(client);
-		}
-	}
-	async *streamWithPortalProtection(client, request, cursorBatchSize, name) {
-		if (this.inExplicitTransaction()) {
-			yield* this.executeWithCursor(client, request.sql, request.params, cursorBatchSize, name);
-			return;
-		}
-		await client.query("BEGIN");
-		let streamFailed = false;
-		try {
-			yield* this.executeWithCursor(client, request.sql, request.params, cursorBatchSize, name);
-		} catch (error) {
-			streamFailed = true;
-			throw error;
-		} finally {
-			await this.commitStreamSpan(client, streamFailed);
-		}
-	}
-	async commitStreamSpan(client, streamFailed) {
-		try {
-			await client.query("COMMIT");
-		} catch (commitError) {
-			if (!streamFailed) throw commitError;
-		}
-	}
-	async *executeWithCursor(client, sql, params, cursorBatchSize, name) {
-		const values = blindCast(params ?? []);
-		const cursor = client.query(name === void 0 ? new Cursor(sql, values) : new NamedCursor({
-			name,
-			text: sql,
-			values
-		}));
-		try {
-			while (true) {
-				const rows = await readCursor(cursor, cursorBatchSize);
-				if (rows.length === 0) break;
-				for (const row of rows) yield row;
-			}
-		} finally {
-			await closeCursor(cursor);
-		}
-	}
-	async *executeBuffered(client, sql, params, name) {
-		const config = {
-			name,
-			text: sql,
-			values: blindCast(params ?? [])
-		};
-		const releaseLock = await acquireClientQueryLock(client);
-		let result;
-		try {
-			result = await client.query(config);
-		} finally {
-			releaseLock();
-		}
-		for (const row of blindCast(result.rows)) yield row;
-	}
-};
-var PostgresConnectionImpl = class extends PostgresQueryable {
-	#connection;
-	#onRelease;
-	#onDestroy;
-	#txState;
-	constructor(connection, options, onRelease, onDestroy, txState) {
-		super(options);
-		this.#connection = connection;
-		this.#onRelease = onRelease;
-		this.#onDestroy = onDestroy;
-		this.#txState = txState ?? { open: false };
-	}
-	acquireClient() {
-		return Promise.resolve(this.#connection);
-	}
-	releaseClient(_client) {
-		return Promise.resolve();
-	}
-	inExplicitTransaction() {
-		return this.#txState.open;
-	}
-	async beginTransaction() {
-		const releaseLock = await acquireClientQueryLock(this.#connection);
-		try {
-			await this.#connection.query("BEGIN").catch(rethrowNormalizedError);
-		} finally {
-			releaseLock();
-		}
-		this.#txState.open = true;
-		return new PostgresTransactionImpl(this.#connection, this.options, () => {
-			this.#txState.open = false;
-		});
-	}
-	async release() {
-		const conn = this.#connection;
-		if ("release" in conn) conn.release();
-		const onRelease = this.#onRelease;
-		this.#onRelease = void 0;
-		this.#onDestroy = void 0;
-		onRelease?.();
-	}
-	async destroy(reason) {
-		const onDestroy = this.#onDestroy;
-		const onRelease = this.#onRelease;
-		this.#onDestroy = void 0;
-		this.#onRelease = void 0;
-		const conn = this.#connection;
-		if ("release" in conn) {
-			const releaseArg = reason instanceof Error ? reason : /* @__PURE__ */ new Error("Connection destroyed");
-			conn.release(releaseArg);
-		}
-		if (onDestroy) await onDestroy(reason);
-		else onRelease?.();
-	}
-};
-var PostgresTransactionImpl = class extends PostgresQueryable {
-	#connection;
-	#onSettled;
-	constructor(connection, options, onSettled) {
-		super(options);
-		this.#connection = connection;
-		this.#onSettled = onSettled;
-	}
-	acquireClient() {
-		return Promise.resolve(this.#connection);
-	}
-	releaseClient(_client) {
-		return Promise.resolve();
-	}
-	inExplicitTransaction() {
-		return true;
-	}
-	#settle() {
-		const onSettled = this.#onSettled;
-		this.#onSettled = void 0;
-		onSettled?.();
-	}
-	async commit() {
-		const releaseLock = await acquireClientQueryLock(this.#connection);
-		try {
-			await this.#connection.query("COMMIT").catch(rethrowNormalizedError);
-		} finally {
-			releaseLock();
-			this.#settle();
-		}
-	}
-	async rollback() {
-		const releaseLock = await acquireClientQueryLock(this.#connection);
-		try {
-			await this.#connection.query("ROLLBACK").catch(rethrowNormalizedError);
-		} finally {
-			releaseLock();
-			this.#settle();
-		}
-	}
-};
-var PostgresPoolDriverImpl = class extends PostgresQueryable {
-	pool;
-	#closed = false;
-	constructor(options) {
-		super(buildConnectionOptions(options));
-		this.pool = options.connect.pool;
-	}
-	get state() {
-		return this.#closed ? "closed" : "connected";
-	}
-	async connect(_binding) {}
-	async acquireConnection() {
-		return new PostgresConnectionImpl(await this.acquireClient(), this.options);
-	}
-	async close() {
-		if (this.#closed) return;
-		this.#closed = true;
-		await this.pool.end();
-	}
-	async acquireClient() {
-		return this.pool.connect();
-	}
-	async releaseClient(client) {
-		client.release();
-	}
-};
-var PostgresDirectDriverImpl = class extends PostgresQueryable {
-	directClient;
-	#connectionMutex = new AsyncMutex();
-	#closed = false;
-	#connected = false;
-	#connectPromise;
-	#txState = { open: false };
-	constructor(options) {
-		super(buildConnectionOptions(options));
-		this.directClient = options.connect.client;
-	}
-	inExplicitTransaction() {
-		return this.#txState.open;
-	}
-	get state() {
-		return this.#closed ? "closed" : "connected";
-	}
-	async connect(_binding) {}
-	async acquireConnection() {
-		const releaseLease = await this.#connectionMutex.lock();
-		try {
-			return new PostgresConnectionImpl(await this.acquireClient(), this.options, releaseLease, async () => {
-				try {
-					await this.#closeWhileHoldingLease();
-				} finally {
-					releaseLease();
-				}
-			}, this.#txState);
-		} catch (error) {
-			releaseLease();
-			throw error;
-		}
-	}
-	async close() {
-		const releaseLease = await this.#connectionMutex.lock();
-		try {
-			await this.#closeWhileHoldingLease();
-		} finally {
-			releaseLease();
-		}
-	}
-	async #closeWhileHoldingLease() {
-		if (this.#closed) return;
-		this.#closed = true;
-		await this.directClient.end();
-		this.#connected = false;
-	}
-	async acquireClient() {
-		if (this.#connected) return this.directClient;
-		if (this.#connectPromise !== void 0) {
-			await this.#connectPromise;
-			return this.directClient;
-		}
-		this.#connectPromise = (async () => {
-			try {
-				await this.directClient.connect();
-			} catch (error) {
-				if (!isAlreadyConnectedError(error)) throw error;
-			} finally {
-				this.#connectPromise = void 0;
-			}
-			this.#connected = true;
-		})();
-		await this.#connectPromise;
-		return this.directClient;
-	}
-	async releaseClient(_client) {}
-};
-function createBoundDriverFromBinding(binding, cursorOpts, extraOpts) {
-	const preparedStatements = extraOpts?.preparedStatements;
-	switch (binding.kind) {
-		case "url": return new PostgresPoolDriverImpl({
-			connect: { pool: new Pool({
-				connectionString: binding.url,
-				connectionTimeoutMillis: 2e4,
-				idleTimeoutMillis: 3e4
-			}) },
-			cursor: cursorOpts,
-			preparedStatements
-		});
-		case "pgPool": return new PostgresPoolDriverImpl({
-			connect: { pool: binding.pool },
-			cursor: cursorOpts,
-			preparedStatements
-		});
-		case "pgClient": return new PostgresDirectDriverImpl({
-			connect: { client: binding.client },
-			cursor: cursorOpts,
-			preparedStatements
-		});
-	}
-}
-function readCursor(cursor, size) {
-	return callbackToPromise((cb) => {
-		cursor.read(size, (err, rows) => cb(err, rows));
-	});
-}
-function closeCursor(cursor) {
-	return callbackToPromise((cb) => cursor.close(cb));
-}
-function rethrowNormalizedError(error) {
-	throw normalizePgError(error);
-}
-function prepareFailedError(retryError, handle) {
-	const cause = normalizePgError(retryError);
-	return Object.assign(driverError("DRIVER.PREPARE_FAILED", `Prepared statement failed again after re-preparing with a fresh handle: ${cause.message}`, { handle }), { cause });
-}
-const USE_BEFORE_CONNECT_MESSAGE = "Postgres driver not connected. Call connect(binding) before acquireConnection or execute.";
-const ALREADY_CONNECTED_MESSAGE = "Postgres driver already connected. Call close() before reconnecting with a new binding.";
-function unboundQuery() {
-	return { [Symbol.asyncIterator]() {
-		return { async next() {
-			throw driverError("DRIVER.NOT_CONNECTED", USE_BEFORE_CONNECT_MESSAGE);
-		} };
-	} };
-}
-var PostgresUnboundDriverImpl = class {
-	familyId = "sql";
-	targetId = "postgres";
-	#delegate = null;
-	#closed = false;
-	#cursorOpts;
-	#preparedStatements;
-	constructor(options) {
-		this.#cursorOpts = options?.cursor;
-		this.#preparedStatements = options?.preparedStatements;
-	}
-	get state() {
-		if (this.#delegate !== null) return "connected";
-		if (this.#closed) return "closed";
-		return "unbound";
-	}
-	#requireDelegate() {
-		const delegate = this.#delegate;
-		if (delegate === null) throw driverError("DRIVER.NOT_CONNECTED", USE_BEFORE_CONNECT_MESSAGE);
-		return delegate;
-	}
-	async connect(binding) {
-		if (this.#delegate !== null) throw driverError("DRIVER.ALREADY_CONNECTED", ALREADY_CONNECTED_MESSAGE, { bindingKind: binding.kind });
-		this.#delegate = createBoundDriverFromBinding(binding, this.#cursorOpts, { preparedStatements: this.#preparedStatements });
-		this.#closed = false;
-	}
-	async acquireConnection() {
-		const delegate = this.#requireDelegate();
-		const connection = await delegate.acquireConnection();
-		return this.#wrapConnection(connection, delegate);
-	}
-	/**
-	* Wraps an acquired connection so that teardown paths which close the
-	* underlying delegate (notably `destroy()` on a pgClient binding, where
-	* the single socket means a destroyed connection invalidates the driver)
-	* also reset our own `#delegate` reference. Without this, a failed
-	* transaction rollback would leave the outer unbound wrapper reporting
-	* `connected` while routing subsequent work to an already-ended delegate.
-	*/
-	#wrapConnection(connection, delegate) {
-		const syncDelegateState = () => {
-			if (this.#delegate === delegate && delegate.state === "closed") {
-				this.#delegate = null;
-				this.#closed = true;
-			}
-		};
-		const wrapped = {
-			beginTransaction: connection.beginTransaction.bind(connection),
-			query: connection.query.bind(connection),
-			execute: connection.execute.bind(connection),
-			release: async () => {
-				try {
-					await connection.release();
-				} finally {
-					syncDelegateState();
-				}
-			},
-			destroy: async (reason) => {
-				try {
-					await connection.destroy(reason);
-				} finally {
-					syncDelegateState();
-				}
-			}
-		};
-		if (connection.explain) wrapped.explain = connection.explain.bind(connection);
-		return wrapped;
-	}
-	async close() {
-		const delegate = this.#delegate;
-		if (delegate !== null) {
-			this.#delegate = null;
-			await delegate.close();
-		}
-		this.#closed = true;
-	}
-	query(request) {
-		const delegate = this.#delegate;
-		return delegate === null ? unboundQuery() : delegate.query(request);
-	}
-	async execute(request) {
-		const delegate = this.#delegate;
-		if (delegate === null) throw driverError("DRIVER.NOT_CONNECTED", USE_BEFORE_CONNECT_MESSAGE);
-		return delegate.execute(request);
-	}
-	async explain(request) {
-		const delegate = this.#requireDelegate();
-		const explain = delegate.explain;
-		if (explain === void 0) throw driverError("DRIVER.NOT_CONNECTED", USE_BEFORE_CONNECT_MESSAGE);
-		return explain.call(delegate, request);
-	}
-};
-const postgresRuntimeDriverDescriptor = {
-	...postgresDriverDescriptorMeta,
-	create(options) {
-		return new PostgresUnboundDriverImpl(options);
-	}
-};
-//#endregion
-export { postgresRuntimeDriverDescriptor as default };
-
-//# sourceMappingURL=driver__runtime.mjs.map
+import { n as suppressIdleConnectionErrors, t as postgresRuntimeDriverDescriptor } from "./runtime-C-Hh2m1R.mjs";
+export { postgresRuntimeDriverDescriptor as default, suppressIdleConnectionErrors };