orange-orm 4.7.11 → 4.7.12

package/dist/index.browser.mjs

@@ -4591,6 +4591,7 @@ function requireNewEncode$7 () {
 	hasRequiredNewEncode$7 = 1;
 	var newPara = requireNewParameterized();
 	var purify = requirePurify$5();
+	var getSessionContext = requireGetSessionContext();
 	var getSessionSingleton = requireGetSessionSingleton();
 
 	function _new(column) {
@@ -4602,13 +4603,10 @@ function requireNewEncode$7 () {
 					return newPara('null');
 				return newPara('\'' + column.dbNull + '\'');
 			}
+			var ctx = getSessionContext(context);
 			var encodeCore = getSessionSingleton(context, 'encodeJSON') || ((v) => v);
-
-			if (encodeCore) {
-				value = encodeCore(value);
-			}
-			return newPara('?', [value]);
-
+			var formatIn = ctx.formatJSONIn;
+			return newPara(formatIn ? formatIn('?') : '?', [encodeCore(value)]);
 		};
 
 		encode.unsafe = function(context, candidate) {

package/dist/index.mjs

@@ -4592,6 +4592,7 @@ function requireNewEncode$7 () {
 	hasRequiredNewEncode$7 = 1;
 	var newPara = requireNewParameterized();
 	var purify = requirePurify$5();
+	var getSessionContext = requireGetSessionContext();
 	var getSessionSingleton = requireGetSessionSingleton();
 
 	function _new(column) {
@@ -4603,13 +4604,10 @@ function requireNewEncode$7 () {
 					return newPara('null');
 				return newPara('\'' + column.dbNull + '\'');
 			}
+			var ctx = getSessionContext(context);
 			var encodeCore = getSessionSingleton(context, 'encodeJSON') || ((v) => v);
-
-			if (encodeCore) {
-				value = encodeCore(value);
-			}
-			return newPara('?', [value]);
-
+			var formatIn = ctx.formatJSONIn;
+			return newPara(formatIn ? formatIn('?') : '?', [encodeCore(value)]);
 		};
 
 		encode.unsafe = function(context, candidate) {
@@ -14975,6 +14973,7 @@ var hasRequiredWrapQuery$8;
 function requireWrapQuery$8 () {
 	if (hasRequiredWrapQuery$8) return wrapQuery_1$8;
 	hasRequiredWrapQuery$8 = 1;
+
 	const log = requireLog();
 	const replaceParamChar = requireReplaceParamChar$1();
 	const tryGetSessionContext = requireTryGetSessionContext();
@@ -14986,87 +14985,136 @@ function requireWrapQuery$8 () {
 			try {
 				log.emitQuery({ sql: query.sql(), parameters: query.parameters });
 				const sql = replaceParamChar(query, query.parameters);
-				let rdb = tryGetSessionContext(context);
-				let transactionHandler = rdb.transactionHandler;
-
-				if (sql.length < 18 && query.parameters.length === 0) {
-					if (sql === 'BEGIN TRANSACTION' || sql === 'BEGIN') {
-						if (transactionHandler)
-							return onCompleted(new Error('Already inside a transaction'), []);
-						beginTransaction(connection).then(_transactionHandler => {
-							rdb.transactionHandler = _transactionHandler;
-							onCompleted(null, []);
-						}, onCompleted);
+				const params = Array.isArray(query.parameters) ? query.parameters : [];
+
+				const rdb = tryGetSessionContext(context);
+				let th = rdb.transactionHandler;
+
+				// --- tx control (short statements, no params) ---
+				if (sql.length < 18 && params.length === 0) {
+					const cmd = sql.trim().toUpperCase();
+
+					if (cmd === 'BEGIN' || cmd === 'BEGIN TRANSACTION') {
+						if (th && !th.closing) return onCompleted(new Error('Already inside a transaction'), []);
+						beginTransaction(connection).then(
+							(_th) => {
+								rdb.transactionHandler = _th;
+								onCompleted(null, []);
+							},
+							(err) => onCompleted(err, [])
+						);
 						return;
 					}
-					else if (sql === 'COMMIT') {
-						if (!transactionHandler)
-							return onCompleted(new Error('Cannot commit outside transaction'), []);
-						transactionHandler.resolve();
-						transactionHandler.promise.then(() => onCompleted(null, []), err => onCompleted(err, []));
+
+					if (cmd === 'COMMIT') {
+						if (!th) return onCompleted(new Error('Cannot commit outside transaction'), []);
+						try {
+							th.closing = true;   // mark tx as closing; don’t reuse
+							th.resolve();        // resolve the *inner* control promise -> triggers commit
+							// IMPORTANT: wait for the *outer* promise (commit finished on the wire)
+							await th.settled;
+							th.closed = true;
+							rdb.transactionHandler = undefined;
+							onCompleted(null, []);
+						} catch (e) {
+							th.closed = true;
+							rdb.transactionHandler = undefined;
+							onCompleted(e, []);
+						}
 						return;
 					}
-					else if (sql === 'ROLLBACK') {
-						if (!transactionHandler)
-							return onCompleted(new Error('Cannot rollback outside transaction'), []);
-						transactionHandler.reject(new Error('__rollback__'));
-						transactionHandler.promise.then(null, (err) => {
-							if (err.message === '__rollback__')
-								onCompleted(null, []);
-							else
-								onCompleted(err, []);
-						});
+
+					if (cmd === 'ROLLBACK') {
+						if (!th) return onCompleted(new Error('Cannot rollback outside transaction'), []);
+						try {
+							th.closing = true;
+							th.reject(new Error('__rollback__')); // reject inner promise -> triggers rollback
+							// Wait for outer promise to settle (rollback finished)
+							try {
+								await th.settled;
+							} catch (e) {
+								// connection.begin() rejects on rollback; that’s expected
+								if (e?.message !== '__rollback__') throw e;
+							}
+							th.closed = true;
+							rdb.transactionHandler = undefined;
+							onCompleted(null, []);
+						} catch (e) {
+							th.closed = true;
+							rdb.transactionHandler = undefined;
+							onCompleted(e, []);
+						}
 						return;
 					}
 				}
 
-				let result;
-				const _connection = transactionHandler?.tx || connection;
-				if (query.parameters.length === 0)
-					result = await _connection.unsafe(sql);
-				else
-					result = await _connection.unsafe(sql, query.parameters);
+				// --- regular query ---
+				const conn = th && th.tx && !th.closing ? th.tx : connection;
+				const result = params.length === 0
+					? await conn.unsafe(sql)
+					: await conn.unsafe(sql, params);
+
 				onCompleted(null, result);
-			}
-			catch (e) {
+			} catch (e) {
 				onCompleted(e);
 			}
 		}
-
 	}
 
 	function beginTransaction(connection) {
-
-		let beginIsResolved = false;
-		let resolve;
-		let reject;
+		let resolveCommit;
+		let rejectRollback;
 		let resolveBegin;
 		let rejectBegin;
 
-		let sqlPromise = new Promise((res, rej) => {
-			resolve = res;
-			reject = rej;
+		// This promise is controlled by our code: resolve() -> COMMIT, reject() -> ROLLBACK
+		const controlPromise = new Promise((res, rej) => {
+			resolveCommit = res;
+			rejectRollback = rej;
 		});
-		let beginPromise = new Promise((res,rej) => {
+
+		// We resolve this when Bun gives us the tx object
+		const beginPromise = new Promise((res, rej) => {
 			resolveBegin = res;
 			rejectBegin = rej;
 		});
-		connection.begin(async (tx) => {
-			beginIsResolved = true;
+
+		// Start the transaction
+		const settled = connection.begin(async (tx) => {
+			// hand back the handler
 			resolveBegin({
 				tx,
-				resolve,
-				reject,
-				promise: sqlPromise,
-			});
-			return sqlPromise;
-		}).then(null,
-			e => {
-				if (!beginIsResolved)
-					rejectBegin(e);
-				if (e?.message !== '__rollback__')
-					throw e;
+				resolve: resolveCommit,     // call to request COMMIT
+				reject: rejectRollback,     // call to request ROLLBACK
+				promise: controlPromise,    // (inner) resolves/rejects when we signal commit/rollback
+				settled: null,              // will be set to the outer promise below
+				closing: false,
+				closed: false,
 			});
+			// keep tx open until caller resolves/rejects controlPromise
+			return controlPromise;
+		})
+			.then(
+				() => { /* commit finished */ },
+				(e) => {
+					// rollback or begin failure — propagate only non-sentinel errors
+					if (e?.message !== '__rollback__') throw e;
+				}
+			);
+
+		// Attach the outer promise to the handler once it exists
+		settled.then(null, () => {}); // keep microtasks rolling
+		beginPromise.then(
+			(handler) => { handler.settled = settled; },
+			() => {}
+		);
+
+		// Ensure beginPromise rejects if connection.begin() fails before callback runs
+		settled.catch((e) => {
+			// If callback never ran, resolveBegin is still undefined; reject beginPromise
+			if (!resolveBegin) rejectBegin?.(e);
+		});
+
 		return beginPromise;
 	}
 
@@ -15074,6 +15122,20 @@ function requireWrapQuery$8 () {
 	return wrapQuery_1$8;
 }
 
+var formatJSONIn_1;
+var hasRequiredFormatJSONIn;
+
+function requireFormatJSONIn () {
+	if (hasRequiredFormatJSONIn) return formatJSONIn_1;
+	hasRequiredFormatJSONIn = 1;
+	function formatJSONIn(value) {
+		return `${value}::jsonb`;
+	}
+
+	formatJSONIn_1 = formatJSONIn;
+	return formatJSONIn_1;
+}
+
 var encodeJSON;
 var hasRequiredEncodeJSON;
 
@@ -15112,6 +15174,7 @@ function requireNewTransaction$9 () {
 	var selectForUpdateSql = requireSelectForUpdateSql$4();
 	var limitAndOffset = requireLimitAndOffset$4();
 	var formatDateOut = requireFormatDateOut$3();
+	var formatJSONIn = requireFormatJSONIn();
 	var encodeJSON = requireEncodeJSON();
 	var insertSql = requireInsertSql$4();
 	var insert = requireInsert$4();
@@ -15128,6 +15191,7 @@ function requireNewTransaction$9 () {
 		rdb.encodeDate = encodeDate;
 		rdb.encodeBinary = encodeBinary;
 		rdb.decodeBinary = decodeBinary;
+		rdb.formatJSONIn = formatJSONIn;
 		rdb.encodeJSON = encodeJSON;
 		rdb.formatDateOut = formatDateOut;
 		rdb.deleteFromSql = deleteFromSql;

package/docs/changelog.md

@@ -1,4 +1,6 @@
 ## Changelog
+__4.7.12__  
+Bugfix: Bun Postgres: Race Condition After Transaction Commit [#133](https://github.com/alfateam/orange-orm/issues/133)  
 __4.7.11__  
 Support for bigint [#102](https://github.com/alfateam/orange-orm/issues/102)  
 __4.7.10__  

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orange-orm",
-  "version": "4.7.11",
+  "version": "4.7.12",
   "main": "./src/index.js",
   "module": "./dist/index.mjs",
   "browser": "./dist/index.browser.mjs",
@@ -50,6 +50,10 @@
   },
   "scripts": {
     "test": "vitest run --threads=false",
+    "test:bun": "bun test --timeout=30000 ./tests/*.bun.test.js",
+    "test:deno": "deno test --allow-all --unstable *.deno.test.js",
+    "test:all": "echo 'Running Node.js tests...' && npm run test:node && echo 'Running Bun tests...' && npm run test:bun && echo 'Running Deno tests...' && npm run test:deno && echo 'All tests completed!'",
+    "test:all:parallel": "concurrently \"npm:test:node\" \"npm:test:bun\" \"npm:test:deno\"",
     "coverage": "vitest run --coverage.enabled --coverage.reporter='text-summary' --threads=false",
     "testw": "vitest --threads=false update",
     "tscheck": "tsc ./src/index.d.ts --module commonjs --target es2022 --noEmit true --strict true --esModuleInterop true",
@@ -158,4 +162,4 @@
     "undef": true,
     "node": true
   }
-}
+}

package/src/bunPg/formatJSONIn.js

@@ -0,0 +1,5 @@
+function formatJSONIn(value) {
+	return `${value}::jsonb`;
+}
+
+module.exports = formatJSONIn;

package/src/bunPg/newTransaction.js

@@ -6,6 +6,7 @@ var deleteFromSql = require('../pg/deleteFromSql');
 var selectForUpdateSql = require('../pg/selectForUpdateSql');
 var limitAndOffset = require('../pg/limitAndOffset');
 var formatDateOut = require('../pg/formatDateOut');
+var formatJSONIn = require('./formatJSONIn');
 var encodeJSON = require('../pg/encodeJSON');
 var insertSql = require('../pg/insertSql');
 var insert = require('../pg/insert');
@@ -22,6 +23,7 @@ function newResolveTransaction(domain, pool, { readonly = false } = {}) {
 	rdb.encodeDate = encodeDate;
 	rdb.encodeBinary = encodeBinary;
 	rdb.decodeBinary = decodeBinary;
+	rdb.formatJSONIn = formatJSONIn;
 	rdb.encodeJSON = encodeJSON;
 	rdb.formatDateOut = formatDateOut;
 	rdb.deleteFromSql = deleteFromSql;

package/src/bunPg/wrapQuery.js

@@ -1,3 +1,5 @@
+'use strict';
+
 const log = require('../table/log');
 const replaceParamChar = require('../pg/replaceParamChar');
 const tryGetSessionContext = require('../table/tryGetSessionContext');
@@ -9,88 +11,137 @@ function wrapQuery(context, connection) {
 		try {
 			log.emitQuery({ sql: query.sql(), parameters: query.parameters });
 			const sql = replaceParamChar(query, query.parameters);
-			let rdb = tryGetSessionContext(context);
-			let transactionHandler = rdb.transactionHandler;
-
-			if (sql.length < 18 && query.parameters.length === 0) {
-				if (sql === 'BEGIN TRANSACTION' || sql === 'BEGIN') {
-					if (transactionHandler)
-						return onCompleted(new Error('Already inside a transaction'), []);
-					beginTransaction(connection).then(_transactionHandler => {
-						rdb.transactionHandler = _transactionHandler;
-						onCompleted(null, []);
-					}, onCompleted);
+			const params = Array.isArray(query.parameters) ? query.parameters : [];
+
+			const rdb = tryGetSessionContext(context);
+			let th = rdb.transactionHandler;
+
+			// --- tx control (short statements, no params) ---
+			if (sql.length < 18 && params.length === 0) {
+				const cmd = sql.trim().toUpperCase();
+
+				if (cmd === 'BEGIN' || cmd === 'BEGIN TRANSACTION') {
+					if (th && !th.closing) return onCompleted(new Error('Already inside a transaction'), []);
+					beginTransaction(connection).then(
+						(_th) => {
+							rdb.transactionHandler = _th;
+							onCompleted(null, []);
+						},
+						(err) => onCompleted(err, [])
+					);
 					return;
 				}
-				else if (sql === 'COMMIT') {
-					if (!transactionHandler)
-						return onCompleted(new Error('Cannot commit outside transaction'), []);
-					transactionHandler.resolve();
-					transactionHandler.promise.then(() => onCompleted(null, []), err => onCompleted(err, []));
+
+				if (cmd === 'COMMIT') {
+					if (!th) return onCompleted(new Error('Cannot commit outside transaction'), []);
+					try {
+						th.closing = true;   // mark tx as closing; don’t reuse
+						th.resolve();        // resolve the *inner* control promise -> triggers commit
+						// IMPORTANT: wait for the *outer* promise (commit finished on the wire)
+						await th.settled;
+						th.closed = true;
+						rdb.transactionHandler = undefined;
+						onCompleted(null, []);
+					} catch (e) {
+						th.closed = true;
+						rdb.transactionHandler = undefined;
+						onCompleted(e, []);
+					}
 					return;
 				}
-				else if (sql === 'ROLLBACK') {
-					if (!transactionHandler)
-						return onCompleted(new Error('Cannot rollback outside transaction'), []);
-					transactionHandler.reject(new Error('__rollback__'));
-					transactionHandler.promise.then(null, (err) => {
-						if (err.message === '__rollback__')
-							onCompleted(null, []);
-						else
-							onCompleted(err, []);
-					});
+
+				if (cmd === 'ROLLBACK') {
+					if (!th) return onCompleted(new Error('Cannot rollback outside transaction'), []);
+					try {
+						th.closing = true;
+						th.reject(new Error('__rollback__')); // reject inner promise -> triggers rollback
+						// Wait for outer promise to settle (rollback finished)
+						try {
+							await th.settled;
+						} catch (e) {
+							// connection.begin() rejects on rollback; that’s expected
+							if (e?.message !== '__rollback__') throw e;
+						}
+						th.closed = true;
+						rdb.transactionHandler = undefined;
+						onCompleted(null, []);
+					} catch (e) {
+						th.closed = true;
+						rdb.transactionHandler = undefined;
+						onCompleted(e, []);
+					}
 					return;
 				}
 			}
 
-			let result;
-			const _connection = transactionHandler?.tx || connection;
-			if (query.parameters.length === 0)
-				result = await _connection.unsafe(sql);
-			else
-				result = await _connection.unsafe(sql, query.parameters);
+			// --- regular query ---
+			const conn = th && th.tx && !th.closing ? th.tx : connection;
+			const result = params.length === 0
+				? await conn.unsafe(sql)
+				: await conn.unsafe(sql, params);
+
 			onCompleted(null, result);
-		}
-		catch (e) {
+		} catch (e) {
 			onCompleted(e);
 		}
 	}
-
 }
 
 function beginTransaction(connection) {
-
-	let beginIsResolved = false;
-	let resolve;
-	let reject;
+	let resolveCommit;
+	let rejectRollback;
 	let resolveBegin;
 	let rejectBegin;
 
-	let sqlPromise = new Promise((res, rej) => {
-		resolve = res;
-		reject = rej;
+	// This promise is controlled by our code: resolve() -> COMMIT, reject() -> ROLLBACK
+	const controlPromise = new Promise((res, rej) => {
+		resolveCommit = res;
+		rejectRollback = rej;
 	});
-	let beginPromise = new Promise((res,rej) => {
+
+	// We resolve this when Bun gives us the tx object
+	const beginPromise = new Promise((res, rej) => {
 		resolveBegin = res;
 		rejectBegin = rej;
 	});
-	connection.begin(async (tx) => {
-		beginIsResolved = true;
+
+	// Start the transaction
+	const settled = connection.begin(async (tx) => {
+		// hand back the handler
 		resolveBegin({
 			tx,
-			resolve,
-			reject,
-			promise: sqlPromise,
-		});
-		return sqlPromise;
-	}).then(null,
-		e => {
-			if (!beginIsResolved)
-				rejectBegin(e);
-			if (e?.message !== '__rollback__')
-				throw e;
+			resolve: resolveCommit,     // call to request COMMIT
+			reject: rejectRollback,     // call to request ROLLBACK
+			promise: controlPromise,    // (inner) resolves/rejects when we signal commit/rollback
+			settled: null,              // will be set to the outer promise below
+			closing: false,
+			closed: false,
 		});
+		// keep tx open until caller resolves/rejects controlPromise
+		return controlPromise;
+	})
+		.then(
+			() => { /* commit finished */ },
+			(e) => {
+				// rollback or begin failure — propagate only non-sentinel errors
+				if (e?.message !== '__rollback__') throw e;
+			}
+		);
+
+	// Attach the outer promise to the handler once it exists
+	settled.then(null, () => {}); // keep microtasks rolling
+	beginPromise.then(
+		(handler) => { handler.settled = settled; },
+		() => {}
+	);
+
+	// Ensure beginPromise rejects if connection.begin() fails before callback runs
+	settled.catch((e) => {
+		// If callback never ran, resolveBegin is still undefined; reject beginPromise
+		if (!resolveBegin) rejectBegin?.(e);
+	});
+
 	return beginPromise;
 }
 
-module.exports = wrapQuery;
+module.exports = wrapQuery;

package/src/table/column/json/newEncode.js

@@ -1,5 +1,6 @@
 var newPara = require('../../query/newParameterized');
 var purify = require('./purify');
+var getSessionContext = require('../../getSessionContext');
 var getSessionSingleton = require('../../getSessionSingleton');
 
 function _new(column) {
@@ -11,13 +12,10 @@ function _new(column) {
 				return newPara('null');
 			return newPara('\'' + column.dbNull + '\'');
 		}
+		var ctx = getSessionContext(context);
 		var encodeCore = getSessionSingleton(context, 'encodeJSON') || ((v) => v);
-
-		if (encodeCore) {
-			value = encodeCore(value);
-		}
-		return newPara('?', [value]);
-
+		var formatIn = ctx.formatJSONIn;
+		return newPara(formatIn ? formatIn('?') : '?', [encodeCore(value)]);
 	};
 
 	encode.unsafe = function(context, candidate) {

package/vitest.config.js

@@ -0,0 +1,17 @@
+// vitest.config.js
+/** @type {import('vitest').UserConfig} */
+module.exports = {
+	test: {
+		// Copied baseline excludes (since configDefaults is ESM-only)
+		exclude: [
+			'**/node_modules/**',
+			'**/dist/**',
+			'**/cypress/**',
+			'**/.{idea,git,cache}/**',
+			'**/coverage/**',
+			'**/*.deno.test.js',
+			'**/*.bun.test.js',
+		],
+		threads: false,
+	},
+};