prisma-pglite-bridge 1.0.0 → 1.1.0

package/dist/index.cjs

@@ -109,6 +109,38 @@ const EQP_MESSAGES = new Set([
 const MAX_BACKEND_MESSAGE_LENGTH = 1073741824;
 //#endregion
 //#region src/duplex/row-description.ts
+const readUInt32BE = (buf, offset) => {
+	/* c8 ignore start — callers guard fixed-width reads */
+	const b1 = buf[offset] ?? 0;
+	const b2 = buf[offset + 1] ?? 0;
+	const b3 = buf[offset + 2] ?? 0;
+	const b4 = buf[offset + 3] ?? 0;
+	/* c8 ignore stop */
+	return (b1 << 24 | b2 << 16 | b3 << 8 | b4) >>> 0;
+};
+const readUInt16BE = (buf, offset) => {
+	/* c8 ignore start — callers guard fixed-width reads */
+	const b1 = buf[offset] ?? 0;
+	const b2 = buf[offset + 1] ?? 0;
+	/* c8 ignore stop */
+	return b1 << 8 | b2;
+};
+const rowDescriptionNeedsRewrite = (buf, start = 0, end = buf.length) => {
+	if (end - start < 7) return false;
+	const fieldCount = readUInt16BE(buf, start + 5);
+	let p = start + 7;
+	for (let i = 0; i < fieldCount; i++) {
+		while (p < end && buf[p] !== 0) p++;
+		p++;
+		/* c8 ignore next — defense-in-depth: framer caller passes a complete frame */
+		if (p + 18 > end) return false;
+		const tableOID = readUInt32BE(buf, p);
+		p += 6;
+		if (readUInt32BE(buf, p) === 18 && tableOID !== 0 && tableOID < 16384) return true;
+		p += 12;
+	}
+	return false;
+};
 /**
 * Widens any field whose dataTypeOID is 18 ("char") to oid 25 (text) — but
 * only when the field originates from a pg_catalog relation (tableOID is
@@ -121,6 +153,7 @@ const MAX_BACKEND_MESSAGE_LENGTH = 1073741824;
 * fixed-size in place.
 */
 const rewriteRowDescriptionInPlace = (buf) => {
+	if (!rowDescriptionNeedsRewrite(buf)) return;
 	const fieldCount = buf.readInt16BE(5);
 	let p = 7;
 	for (let i = 0; i < fieldCount; i++) {
@@ -213,7 +246,7 @@ var BackendMessageFramer = class {
 								this.emitReadyForQuery();
 								this.rfqBytesRead = 0;
 							}
-						} else if (msgType === 84) {
+						} else if (msgType === 84) if (rowDescriptionNeedsRewrite(chunk, offset, offset + totalLen)) {
 							flushPassthrough(offset);
 							if (this.suppressIntermediateReadyForQuery && this.rfqBytesRead === 6) this.dropHeldReadyForQuery();
 							this.emitRewrittenRowDescription(Buffer.from(chunk.subarray(offset, offset + totalLen)));
@@ -221,6 +254,10 @@ var BackendMessageFramer = class {
 							if (this.suppressIntermediateReadyForQuery && this.rfqBytesRead === 6) this.dropHeldReadyForQuery();
 							if (passthroughStart < 0) passthroughStart = offset;
 						}
+						else {
+							if (this.suppressIntermediateReadyForQuery && this.rfqBytesRead === 6) this.dropHeldReadyForQuery();
+							if (passthroughStart < 0) passthroughStart = offset;
+						}
 						offset += totalLen;
 						continue;
 					}
@@ -502,6 +539,15 @@ var FrontendMessageBuffer = class {
 * after each sub-message (PGlite's single-user mode). These are stripped,
 * keeping only the final ReadyForQuery after Sync.
 */
+const TERMINATE_MESSAGE = new Uint8Array([
+	88,
+	0,
+	0,
+	0,
+	4
+]);
+const PROTOCOL_CLEANUP_RAW_BYTES = 8 * 1024 * 1024;
+const PROTOCOL_CLEANUP_CALLS = 32;
 /**
 * Duplex stream that bridges `pg.Client` to an in-process PGlite instance.
 *
@@ -553,6 +599,9 @@ var PGliteDuplex = class extends node_stream.Duplex {
 	/** Memoized rollback so concurrent teardown paths (e.g., `_final` then
 	*  `_destroy`) don't issue duplicate `ROLLBACK` statements. */
 	rollbackPromise;
+	pendingProtocolCleanupBytes = 0;
+	pendingProtocolCleanupCalls = 0;
+	protocolCleanupUnsupported = false;
 	/** Resolves once the stream has fully torn down (post-`_final` rollback,
 	*  post-`_destroy`). Single-shot, mirroring the `'close'` event. */
 	onClose;
@@ -766,20 +815,38 @@ var PGliteDuplex = class extends node_stream.Duplex {
 		let batch;
 		/* c8 ignore next 3 — flushPipeline only runs after Sync is appended */
 		if (messages.length === 1) batch = messages[0] ?? new Uint8Array(0);
-		else {
-			const total = messages.reduce((sum, p) => sum + p.length, 0);
-			batch = new Uint8Array(total);
-			let offset = 0;
-			for (const part of messages) {
-				batch.set(part, offset);
-				offset += part.length;
-			}
-		}
+		else batch = this.tryContiguousPipelineBatch(messages) ?? this.concatPipeline(messages);
 		await this.runWithTiming((detectErrors) => this.streamProtocol(batch, {
 			detectErrors,
 			suppressIntermediateRfq: true
 		}));
 	}
+	tryContiguousPipelineBatch(messages) {
+		const first = messages[0];
+		/* c8 ignore next — caller only passes non-empty pipelines */
+		if (first === void 0) return void 0;
+		const buffer = first.buffer;
+		const start = first.byteOffset;
+		let end = start + first.byteLength;
+		for (let i = 1; i < messages.length; i++) {
+			const part = messages[i];
+			/* c8 ignore next — pipeline array has no holes */
+			if (part === void 0) return void 0;
+			if (part.buffer !== buffer || part.byteOffset !== end) return;
+			end += part.byteLength;
+		}
+		return new Uint8Array(buffer, start, end - start);
+	}
+	concatPipeline(messages) {
+		const total = messages.reduce((sum, p) => sum + p.length, 0);
+		const batch = new Uint8Array(total);
+		let offset = 0;
+		for (const part of messages) {
+			batch.set(part, offset);
+			offset += part.length;
+		}
+		return batch;
+	}
 	/**
 	* Acquires the session, runs the op under `pglite.runExclusive`, and
 	* updates internal stats and/or publishes diagnostics events when enabled.
@@ -835,10 +902,8 @@ var PGliteDuplex = class extends node_stream.Duplex {
 		}
 	}
 	/**
-	* Sends a message (or pipelined batch) to PGlite and pushes response
-	* chunks directly to the stream as they arrive. Avoids collecting and
-	* concatenating for large multi-row responses (e.g., findMany 500 rows
-	* = ~503 onRawData chunks).
+	* Sends a message (or pipelined batch) to PGlite and pushes the raw protocol
+	* response to the stream.
 	*
 	* For pipelined Extended Query batches, pass `suppressIntermediateRfq`
 	* so only the final ReadyForQuery reaches the client.
@@ -863,15 +928,47 @@ var PGliteDuplex = class extends node_stream.Duplex {
 			}
 		});
 		await waitPGliteReady(this.pglite, this.timeout);
-		await this.pglite.execProtocolRawStream(message, {
-			syncToFs: this.syncToFs,
-			onRawData: (chunk) => {
-				framer.write(chunk);
+		let rawBytes = 0;
+		let streamFailed = false;
+		try {
+			await this.pglite.execProtocolRawStream(message, {
+				syncToFs: this.syncToFs,
+				onRawData: (chunk) => {
+					rawBytes += chunk.byteLength;
+					framer.write(chunk);
+				}
+			});
+		} catch (err) {
+			streamFailed = true;
+			throw err;
+		} finally {
+			this.pendingProtocolCleanupBytes += rawBytes;
+			this.pendingProtocolCleanupCalls++;
+			if (!this.protocolCleanupUnsupported && (streamFailed || this.pendingProtocolCleanupBytes >= PROTOCOL_CLEANUP_RAW_BYTES || this.pendingProtocolCleanupCalls >= PROTOCOL_CLEANUP_CALLS)) {
+				await this.clearPGliteProtocolMessages();
+				this.pendingProtocolCleanupBytes = 0;
+				this.pendingProtocolCleanupCalls = 0;
 			}
-		});
+		}
 		framer.flush({ dropHeldReadyForQuery: this.tornDown });
 		return !errSeen;
 	}
+	async clearPGliteProtocolMessages() {
+		if (this.protocolCleanupUnsupported) return;
+		const { execProtocolStream } = this.pglite;
+		if (typeof execProtocolStream !== "function") {
+			this.protocolCleanupUnsupported = true;
+			return;
+		}
+		try {
+			await execProtocolStream.call(this.pglite, TERMINATE_MESSAGE, {
+				syncToFs: false,
+				throwOnError: false
+			});
+		} catch {
+			this.protocolCleanupUnsupported = true;
+		}
+	}
 	acquireSession() {
 		return this.sessionLock?.acquire(this.duplexId);
 	}
@@ -1109,7 +1206,7 @@ const wrapTypesWithFastArrayParsers = (types) => {
 //#endregion
 //#region src/pool/pg-bridge-client.ts
 var PgBridgeClient = class PgBridgeClient extends pg.default.Client {
-	querySubmissionChain = Promise.resolve();
+	querySubmissionChain;
 	static OptionsKey = Symbol("PgBridgeClientOptions");
 	constructor(config) {
 		const { [PgBridgeClient.OptionsKey]: bridge, ...clientConfig } = config ?? {};
@@ -1123,33 +1220,41 @@ var PgBridgeClient = class PgBridgeClient extends pg.default.Client {
 	}
 	query(...args) {
 		const first = args[0];
-		const callSuper = () => super.query.apply(this, args);
-		if (first === null || first === void 0) return callSuper();
-		if (typeof first.submit === "function") return callSuper();
-		if (isObject(first) && isTypesLike(first.types)) args[0] = {
-			...first,
-			types: wrapTypesWithFastArrayParsers(first.types)
+		const submit = () => {
+			return super.query.apply(this, args);
 		};
-		const prior = this.querySubmissionChain;
-		let signalDone;
-		this.querySubmissionChain = new Promise((resolve) => {
-			signalDone = resolve;
-		});
+		if (first === null || first === void 0) return submit();
+		if (typeof first.submit === "function") return submit();
 		const cbIndex = args.findIndex((arg) => typeof arg === "function");
 		if (cbIndex !== -1) {
 			const origCb = args[cbIndex];
-			args[cbIndex] = (err, res) => {
-				signalDone();
-				origCb(err, res);
-			};
-			prior.then(callSuper).catch((err) => {
-				signalDone();
+			const promiseArgs = args.slice();
+			promiseArgs.splice(cbIndex, 1);
+			try {
+				this.query(...promiseArgs).then((res) => origCb(null, res), (err) => origCb(err, void 0));
+			} catch (err) {
 				origCb(err, void 0);
-			});
+			}
 			return;
 		}
-		const p = prior.then(callSuper);
-		p.then(signalDone, signalDone);
+		if (isObject(first) && isTypesLike(first.types)) args[0] = {
+			...first,
+			types: wrapTypesWithFastArrayParsers(first.types)
+		};
+		const prior = this.querySubmissionChain;
+		let p;
+		if (prior === void 0) try {
+			p = submit();
+		} catch (err) {
+			return Promise.reject(err);
+		}
+		else p = prior.then(submit);
+		let done;
+		const clearChain = () => {
+			if (this.querySubmissionChain === done) this.querySubmissionChain = void 0;
+		};
+		done = p.then(clearChain, clearChain);
+		this.querySubmissionChain = done;
 		return p;
 	}
 };