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

package/dist/runtime-C-Hh2m1R.mjs

@@ -0,0 +1,645 @@
+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 { suppressIdleConnectionErrors, suppressIdleConnectionErrors as suppressIdleConnectionErrors$1 } from "@prisma/orm-framework/utils/suppress-idle-connection-errors";
+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 suppressIdleConnectionErrors(await 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;
+		this.directClient.on("error", () => {
+			this.#closed = true;
+			this.#connected = false;
+		});
+	}
+	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.#closed) throw driverError("DRIVER.NOT_CONNECTED", "Postgres connection lost or closed. Create a new client to reconnect.");
+		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: suppressIdleConnectionErrors(new Pool({
+				connectionString: binding.url,
+				connectionTimeoutMillis: 2e4,
+				idleTimeoutMillis: 3e4
+			})) },
+			cursor: cursorOpts,
+			preparedStatements
+		});
+		case "pgPool": return new PostgresPoolDriverImpl({
+			connect: { pool: suppressIdleConnectionErrors(binding.pool) },
+			cursor: cursorOpts,
+			preparedStatements
+		});
+		case "pgClient": return new PostgresDirectDriverImpl({
+			connect: { client: suppressIdleConnectionErrors(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 { suppressIdleConnectionErrors$1 as n, postgresRuntimeDriverDescriptor as t };
+
+//# sourceMappingURL=runtime-C-Hh2m1R.mjs.map