prisma-pglite-bridge 0.5.1 → 0.5.3

package/README.md

@@ -15,18 +15,6 @@ pnpm add -D prisma-pglite-bridge @electric-sql/pglite @prisma/adapter-pg pg
 The last three are peer dependencies you may already have.
 TypeScript users also need `@types/pg`.
 
-### Bridge fs-sync policy
-
-The adapter defaults `syncToFs` to `'auto'`:
-
-- in-memory PGlite (`new PGlite()` or `memory://...`) resolves to `false`
-- persistent `dataDir` usage resolves to `true`
-
-That keeps bridge-heavy test workloads on the lower-memory fast path
-without changing durability defaults for persistent databases.
-If you use a custom `fs`, set `syncToFs` explicitly because the
-adapter cannot infer whether that storage is durable.
-
 ## Quickstart
 
 ```typescript
@@ -77,6 +65,18 @@ it from environment variables, network input, or any value that
 crosses a trust boundary, and keep the migrations directory
 writable only by trusted processes.
 
+## Bridge fs-sync policy
+
+The adapter defaults `syncToFs` to `'auto'`:
+
+- in-memory PGlite (`new PGlite()` or `memory://...`) resolves to `false`
+- persistent `dataDir` usage resolves to `true`
+
+That keeps bridge-heavy test workloads on the lower-memory fast path
+without changing durability defaults for persistent databases.
+If you use a custom `fs`, set `syncToFs` explicitly because the
+adapter cannot infer whether that storage is durable.
+
 ## API
 
 ### `createPgliteAdapter(options)`
@@ -107,15 +107,20 @@ Returns:
   Note: this clears all data including seed data — re-seed after
   reset if needed.
 - `close()` — shuts down the pool. The caller-supplied PGlite
-  instance is not closed — you own its lifecycle. Not needed in
-  tests (process exit handles it); use in long-running scripts
-  or dev servers.
+  instance is not closed — you own its lifecycle. Recommended in
+  explicit test teardown, long-running scripts, and dev servers so
+  the pool is released promptly and leak warnings do not fire.
 - `stats()` — returns telemetry when `statsLevel` is `'basic'` or
   `'full'`, else `undefined`. See [Stats collection](#stats-collection).
 - `adapterId` — a unique `symbol` identifying this adapter. Use it
   to filter events from the public
   [diagnostics channels](#diagnostics-channels) when multiple
   adapters share a process.
+- `snapshotDb()` — captures the current DB contents into an internal
+  snapshot so later `resetDb()` calls restore to that state instead of
+  truncating to empty.
+- `resetSnapshot()` — discards the current snapshot so later
+  `resetDb()` calls truncate back to empty again.
 
 ### `createPool(options)`
 
@@ -137,7 +142,7 @@ Returns `pool` (pg.Pool), `adapterId` (a unique `symbol` for
 [diagnostics channel](#diagnostics-channels) filtering), and
 `close()` (which shuts down the pool only — the caller-supplied
 PGlite instance is not closed). Accepts `pglite` (required),
-`max`, and `adapterId`.
+`max`, `adapterId`, and `syncToFs`.
 
 ### `PGliteBridge`
 
@@ -186,6 +191,7 @@ the in-memory PGlite version:
 import { PGlite } from '@electric-sql/pglite';
 import { createPgliteAdapter } from 'prisma-pglite-bridge';
 import { PrismaClient } from '@prisma/client';
+import { beforeEach, vi } from 'vitest';
 
 const pglite = new PGlite();
 const { adapter, resetDb } = await createPgliteAdapter({

package/dist/index.cjs

@@ -585,7 +585,10 @@ var PGliteBridge = class extends node_stream.Duplex {
 		const message = this.input.consume(len);
 		await this.acquireSession();
 		await this.pglite.runExclusive(async () => {
-			await this.execAndPush(message, false);
+			await this.streamProtocol(message, {
+				detectErrors: false,
+				suppressIntermediateRfq: false
+			});
 		});
 		this.phase = "ready";
 	}
@@ -623,7 +626,10 @@ var PGliteBridge = class extends node_stream.Duplex {
 				await this.flushPipeline();
 				continue;
 			}
-			await this.runWithTiming((detectErrors) => this.execAndPush(message, detectErrors));
+			await this.runWithTiming((detectErrors) => this.streamProtocol(message, {
+				detectErrors,
+				suppressIntermediateRfq: false
+			}));
 		}
 	}
 	/**
@@ -640,7 +646,10 @@ var PGliteBridge = class extends node_stream.Duplex {
 		const messages = this.pipeline;
 		this.pipeline = [];
 		const batch = concat(messages);
-		await this.runWithTiming((detectErrors) => this.runPipelineBatch(batch, detectErrors));
+		await this.runWithTiming((detectErrors) => this.streamProtocol(batch, {
+			detectErrors,
+			suppressIntermediateRfq: true
+		}));
 	}
 	/**
 	* Acquires the session, runs the op under `pglite.runExclusive`, and
@@ -694,42 +703,22 @@ var PGliteBridge = class extends node_stream.Duplex {
 			});
 		}
 	}
-	async runPipelineBatch(batch, detectErrors) {
-		let errSeen = false;
-		const framer = new BackendMessageFramer({
-			suppressIntermediateReadyForQuery: true,
-			onChunk: (chunk) => {
-				/* c8 ignore next — race-only: tornDown becomes true mid-stream */
-				if (!this.tornDown && chunk.length > 0) this.push(chunk);
-			},
-			onErrorResponse: () => {
-				if (detectErrors) errSeen = true;
-			},
-			onReadyForQuery: (status) => {
-				if (this.sessionLock) this.sessionLock.updateStatus(this.bridgeId, status);
-			}
-		});
-		await this.pglite.execProtocolRawStream(batch, {
-			syncToFs: this.syncToFs,
-			onRawData: (chunk) => {
-				/* c8 ignore next — race-only: tornDown becomes true mid-stream */
-				if (!this.tornDown) framer.write(chunk);
-			}
-		});
-		framer.flush({ dropHeldReadyForQuery: this.tornDown });
-		return !errSeen;
-	}
 	/**
-	* Sends a message 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 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).
+	*
+	* For pipelined Extended Query batches, pass `suppressIntermediateRfq`
+	* so only the final ReadyForQuery reaches the client.
 	*
 	* Must be called inside runExclusive.
 	*/
-	async execAndPush(message, detectErrors) {
+	async streamProtocol(message, options) {
+		const { detectErrors, suppressIntermediateRfq } = options;
 		let errSeen = false;
 		const framer = new BackendMessageFramer({
-			suppressIntermediateReadyForQuery: false,
+			suppressIntermediateReadyForQuery: suppressIntermediateRfq,
 			onChunk: (chunk) => {
 				/* c8 ignore next — race-only: tornDown becomes true mid-stream */
 				if (!this.tornDown && chunk.length > 0) this.push(chunk);
@@ -756,6 +745,49 @@ var PGliteBridge = class extends node_stream.Duplex {
 	}
 };
 //#endregion
+//#region src/bridge-client.ts
+const bridgeClientOptionsKey = Symbol("bridgeClientOptions");
+var BridgeClient = class extends pg.default.Client {
+	querySubmissionChain = Promise.resolve();
+	constructor(config) {
+		const { [bridgeClientOptionsKey]: bridge, ...clientConfig } = config ?? {};
+		if (!bridge) throw new Error("BridgeClient requires bridge options");
+		super({
+			...clientConfig,
+			user: "postgres",
+			database: "postgres",
+			stream: () => new PGliteBridge(bridge.pglite, bridge.sessionLock, bridge.adapterId, bridge.telemetry, bridge.syncToFs)
+		});
+	}
+	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();
+		const prior = this.querySubmissionChain;
+		let signalDone;
+		this.querySubmissionChain = new Promise((resolve) => {
+			signalDone = resolve;
+		});
+		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();
+				origCb(err, void 0);
+			});
+			return;
+		}
+		const p = prior.then(callSuper);
+		p.then(signalDone, signalDone);
+		return p;
+	}
+};
+//#endregion
 //#region src/utils/session-lock.ts
 /**
 * Session-level lock for PGlite's single-session model.
@@ -904,20 +936,18 @@ const createPool$1 = async (options) => {
 	const syncToFs = resolveSyncToFs(pglite, options.syncToFs);
 	await pglite.waitReady;
 	const sessionLock = new SessionLock();
-	const Client = class extends pg.default.Client {
-		constructor(config = {}) {
-			super({
-				...config,
-				user: "postgres",
-				database: "postgres",
-				stream: () => new PGliteBridge(pglite, sessionLock, adapterId, telemetry, syncToFs)
-			});
+	const poolConfig = {
+		Client: BridgeClient,
+		max,
+		[bridgeClientOptionsKey]: {
+			pglite,
+			sessionLock,
+			adapterId,
+			telemetry,
+			syncToFs
 		}
 	};
-	const pool = new pg.default.Pool({
-		Client,
-		max
-	});
+	const pool = new pg.default.Pool(poolConfig);
 	const close = () => pool.end();
 	return {
 		pool,