orange-orm 4.9.0 → 4.10.0-beta.0

package/dist/index.mjs

@@ -466,6 +466,7 @@ export interface ExpressConfig {
 	concurrency?: Concurrency;
 	readonly?: boolean;
 	disableBulkDeletes?: boolean;
+	hooks?: ExpressHooks;
 }
 
 export interface ExpressContext {
@@ -474,6 +475,18 @@ export interface ExpressContext {
 	client: RdbClient;
 }		
 
+export interface ExpressTransactionHooks {
+	beforeBegin?: (db: Pool, request: import('express').Request, response: import('express').Response) => void | Promise<void>;
+	afterBegin?: (db: Pool, request: import('express').Request, response: import('express').Response) => void | Promise<void>;
+	beforeCommit?: (db: Pool, request: import('express').Request, response: import('express').Response) => void | Promise<void>;
+	afterCommit?: (db: Pool, request: import('express').Request, response: import('express').Response) => void | Promise<void>;
+	afterRollback?: (db: Pool, request: import('express').Request, response: import('express').Response, error?: unknown) => void | Promise<void>;
+}
+
+export interface ExpressHooks extends ExpressTransactionHooks {
+	transaction?: ExpressTransactionHooks;
+}
+
 export interface ExpressTables {${getExpressTables()}
 }
 `;
@@ -611,13 +624,18 @@ function requireHostExpress () {
 		const dbOptions = { db: options.db || client.db };
 		let c = {};
 		const readonly = { readonly: options.readonly};
+		const sharedHooks = options.hooks;
 		for (let tableName in client.tables) {
+			const tableOptions = options[tableName] || {};
+			const hooks = tableOptions.hooks || sharedHooks;
 			c[tableName] = hostLocal({
 				...dbOptions,
 				...readonly,
-				...options[tableName],
+				...tableOptions,
 				table: client.tables[tableName],
-				isHttp: true, client
+				isHttp: true,
+				client,
+				hooks
 
 			});
 		}
@@ -2201,6 +2219,35 @@ function requireQuery () {
 	return query;
 }
 
+var sqliteFunction;
+var hasRequiredSqliteFunction;
+
+function requireSqliteFunction () {
+	if (hasRequiredSqliteFunction) return sqliteFunction;
+	hasRequiredSqliteFunction = 1;
+	const executeChanges = requireExecuteChanges();
+	const popChanges = requirePopChanges();
+	const getSessionSingleton = requireGetSessionSingleton();
+
+	function executeQueries(context, ...rest) {
+		var changes = popChanges(context);
+
+		return executeChanges(context, changes).then(onDoneChanges);
+
+		function onDoneChanges() {
+			var client = getSessionSingleton(context, 'dbClient');
+			if (client && typeof client.function === 'function')
+				return client.function.apply(client, rest);
+			if (client && typeof client.createFunction === 'function')
+				return client.createFunction.apply(client, rest);
+			throw new Error('SQLite client does not support user-defined functions');
+		}
+	}
+
+	sqliteFunction = executeQueries;
+	return sqliteFunction;
+}
+
 var hostLocal_1;
 var hasRequiredHostLocal;
 
@@ -2211,6 +2258,7 @@ function requireHostLocal () {
 	let getMeta = requireGetMeta();
 	let setSessionSingleton = requireSetSessionSingleton();
 	let executeQuery = requireQuery();
+	let executeSqliteFunction = requireSqliteFunction();
 	let hostExpress = requireHostExpress();
 	const readonlyOps = ['getManyDto', 'getMany', 'aggregate', 'count'];
 	// { db, table, defaultConcurrency,
@@ -2221,9 +2269,12 @@ function requireHostLocal () {
 	// 	disableBulkDeletes, isBrowser }
 	function hostLocal() {
 		const _options = arguments[0];
-		let { table, transaction, db, isHttp } = _options;
+		let { table, transaction, db, isHttp, hooks, client } = _options;
+		const transactionHooks = hooks && hooks.transaction;
+		const getTransactionHook = (name) =>
+			(transactionHooks && transactionHooks[name]) || (hooks && hooks[name]);
 
-		let c = { get, post, patch, query, express };
+		let c = { get, post, patch, query, sqliteFunction, express };
 
 		function get() {
 			return getMeta(table);
@@ -2274,10 +2325,41 @@ function requireHostLocal () {
 					else
 						db = dbPromise;
 				}
-				if (readonlyOps.includes(body.path))
+				const beforeBegin = getTransactionHook('beforeBegin');
+				const afterBegin = getTransactionHook('afterBegin');
+				const beforeCommit = getTransactionHook('beforeCommit');
+				const afterCommit = getTransactionHook('afterCommit');
+				const afterRollback = getTransactionHook('afterRollback');
+				const hasTransactionHooks = !!(beforeBegin
+					|| afterBegin
+					|| beforeCommit
+					|| afterCommit
+					|| afterRollback);
+				if (!hasTransactionHooks && readonlyOps.includes(body.path))
 					await db.transaction({ readonly: true }, fn);
-				else
-					await db.transaction(fn);
+				else {
+					await db.transaction(async (context) => {
+						const hookDb = typeof client === 'function'
+							? client({ transaction: (fn) => fn(context) })
+							: (client || db);
+						if (afterCommit)
+							setSessionSingleton(context, 'afterCommitHook', () =>
+								afterCommit(hookDb, request, response)
+							);
+						if (afterRollback)
+							setSessionSingleton(context, 'afterRollbackHook', (error) =>
+								afterRollback(hookDb, request, response, error)
+							);
+						if (beforeBegin)
+							await beforeBegin(hookDb, request, response);
+						if (afterBegin)
+							await afterBegin(hookDb, request, response);
+						await fn(context);
+						if (beforeCommit)
+							await beforeCommit(hookDb, request, response);
+					});
+				}
+
 			}
 			return result;
 
@@ -2312,6 +2394,31 @@ function requireHostLocal () {
 
 		}
 
+		async function sqliteFunction() {
+			let args = arguments;
+			let result;
+
+			if (transaction)
+				await transaction(fn);
+			else {
+				if (typeof db === 'function') {
+					let dbPromise = db();
+					if (dbPromise.then)
+						db = await dbPromise;
+					else
+						db = dbPromise;
+				}
+				result = await db.sqliteFunction.apply(null, arguments);
+			}
+
+			return result;
+
+			async function fn(...args1) {
+				result = await executeSqliteFunction.apply(null, [...args1, ...args]);
+			}
+
+		}
+
 		function express(client, options) {
 			return hostExpress(hostLocal, client, options);
 		}
@@ -2402,6 +2509,7 @@ function requireNetAdapter () {
 			post,
 			patch,
 			query,
+			sqliteFunction,
 			express
 		};
 
@@ -2457,6 +2565,10 @@ function requireNetAdapter () {
 			throw new Error('Queries are not supported through http');
 		}
 
+		function sqliteFunction() {
+			throw new Error('Sqlite Function is not supported through http');
+		}
+
 		function express() {
 			throw new Error('Hosting in express is not supported on the client side');
 		}
@@ -2470,7 +2582,8 @@ function requireNetAdapter () {
 			get,
 			post,
 			patch,
-			query
+			query,
+			sqliteFunction
 		};
 
 		return c;
@@ -2495,6 +2608,11 @@ function requireNetAdapter () {
 			return adapter.query.apply(null, arguments);
 		}
 
+		async function sqliteFunction() {
+			const adapter = await getInnerAdapter();
+			return adapter.sqliteFunction.apply(null, arguments);
+		}
+
 		async function getInnerAdapter() {
 			const db = await getDb();
 			if (typeof db === 'string') {
@@ -2783,6 +2901,7 @@ function requireClient () {
 			}
 		};
 		client.query = query;
+		client.function = sqliteFunction;
 		client.transaction = runInTransaction;
 		client.db = baseUrl;
 		client.mssql = onProvider.bind(null, 'mssql');
@@ -2871,6 +2990,11 @@ function requireClient () {
 			return adapter.query.apply(null, arguments);
 		}
 
+		async function sqliteFunction() {
+			const adapter = netAdapter(baseUrl, undefined, { tableOptions: { db: baseUrl, transaction } });
+			return adapter.sqliteFunction.apply(null, arguments);
+		}
+
 		function express(arg) {
 			if (providers.express) {
 				return providers.express(client, { ...options, ...arg });
@@ -3554,6 +3678,7 @@ function requireClient () {
 					return;
 
 				let body = stringify({ patch, options: { ...tableOptions, ...concurrencyOptions, strategy, deduceStrategy } });
+
 				let adapter = netAdapter(url, tableName, { axios: axiosInterceptor, tableOptions });
 				let { changed, strategy: newStrategy } = await adapter.patch(body);
 				copyInto(changed, [row]);
@@ -4133,8 +4258,10 @@ function requireNewShallowJoinSqlCore () {
 
 	function _new(context, rightTable, leftColumns, rightColumns, leftAlias, rightAlias, filter) {
 		const quote = getSessionSingleton(context, 'quote');
-		leftAlias = quote(leftAlias);
-		rightAlias = quote(rightAlias);
+		const leftAliasRaw = leftAlias;
+		const rightAliasRaw = rightAlias;
+		leftAlias = quote(leftAliasRaw);
+		rightAlias = quote(rightAliasRaw);
 		var sql = '';
 		var delimiter = '';
 		for (var i = 0; i < leftColumns.length; i++) {
@@ -4148,7 +4275,7 @@ function requireNewShallowJoinSqlCore () {
 			sql += delimiter + leftAlias + '.' + quote(leftColumn._dbName) + '=' + rightAlias + '.' + quote(rightColumn._dbName);
 		}
 
-		sql += newDiscriminatorSql(context, rightTable, rightAlias);
+		sql += newDiscriminatorSql(context, rightTable, rightAliasRaw);
 		var result = newParameterized(sql);
 		if (filter)
 			result = result.append(delimiter).append(filter);
@@ -12970,14 +13097,34 @@ function requireCommit () {
 	const getSessionSingleton = requireGetSessionSingleton();
 
 	function _commit(context, result) {
+		let hookError;
 		return popAndPushChanges()
+			.then(callAfterCommit)
 			.then(releaseDbClient.bind(null, context))
-			.then(onReleased);
+			.then(onReleased)
+			.then(throwHookErrorIfAny);
 
 		function onReleased() {
 			return result;
 		}
 
+		function throwHookErrorIfAny(res) {
+			if (hookError)
+				throw hookError;
+			return res;
+		}
+
+		function callAfterCommit() {
+			const hook = getSessionSingleton(context, 'afterCommitHook');
+			if (!hook)
+				return Promise.resolve();
+			return Promise.resolve()
+				.then(() => hook())
+				.catch((e) => {
+					hookError = e;
+				});
+		}
+
 		async function popAndPushChanges() {
 			let changes = popChanges(context);
 			while (changes.length > 0) {
@@ -13078,10 +13225,13 @@ function requireRollback () {
 	const getSessionSingleton = requireGetSessionSingleton();
 
 	function _rollback(context, e) {
+		let hookError;
 		var chain = resultToPromise()
 			.then(() => popChanges(context))
 			.then(executeRollback)
-			.then(() => releaseDbClient(context));
+			.then(callAfterRollback)
+			.then(() => releaseDbClient(context))
+			.then(throwHookErrorIfAny);
 
 
 		function executeRollback() {
@@ -13091,6 +13241,23 @@ function requireRollback () {
 			return executeQuery(context, rollbackCommand);
 		}
 
+		function callAfterRollback() {
+			const hook = getSessionSingleton(context, 'afterRollbackHook');
+			if (!hook)
+				return Promise.resolve();
+			return Promise.resolve()
+				.then(() => hook(e))
+				.catch((err) => {
+					hookError = err;
+				});
+		}
+
+		function throwHookErrorIfAny(res) {
+			if (hookError)
+				throw hookError;
+			return res;
+		}
+
 		if (e) {
 			if (e.message?.indexOf('ORA-01476: divisor is equal to zero') > -1)
 				return newThrow(context, new Error('Conflict when updating a column'), chain);
@@ -13951,6 +14118,7 @@ function requireNewTransaction$b () {
 		rdb.aggregateCount = 0;
 		rdb.quote = quote;
 		rdb.cache = {};
+		rdb.changes = [];
 
 		if (readonly) {
 			rdb.dbClient = {
@@ -14050,7 +14218,6 @@ function requireBegin () {
 	let setSessionSingleton = requireSetSessionSingleton();
 
 	function begin(context, transactionLess) {
-		setSessionSingleton(context, 'changes', []);
 		if (transactionLess) {
 			setSessionSingleton(context, 'transactionLess', true);
 			return Promise.resolve();
@@ -14869,7 +15036,6 @@ function requireNewDatabase$b () {
 	let hostLocal = requireHostLocal();
 	let doQuery = requireQuery();
 	let releaseDbClient = requireReleaseDbClient();
-	let setSessionSingleton = requireSetSessionSingleton();
 
 	function newDatabase(connectionString, poolOptions) {
 		if (!connectionString)
@@ -14886,10 +15052,9 @@ function requireNewDatabase$b () {
 			}
 			let domain = createDomain();
 
-			if (fn)
-				return domain.run(runInTransaction);
-			else
-				return domain.run(run);
+			if (!fn)
+				throw new Error('transaction requires a function');
+			return domain.run(runInTransaction);
 
 			async function runInTransaction() {
 				let result;
@@ -14907,13 +15072,6 @@ function requireNewDatabase$b () {
 				return _begin(domain, options);
 			}
 
-			function run() {
-				let p;
-				let transaction = newTransaction(domain, pool, options);
-				p = new Promise(transaction);
-
-				return p.then(begin);
-			}
 
 		};
 
@@ -14939,7 +15097,6 @@ function requireNewDatabase$b () {
 			let domain = createDomain();
 			let transaction = newTransaction(domain, pool);
 			let p = domain.run(() => new Promise(transaction)
-				.then(() => setSessionSingleton(domain, 'changes', []))
 				.then(() => doQuery(domain, query).then(onResult, onError)));
 			return p;
 
@@ -15385,6 +15542,7 @@ function requireNewTransaction$a () {
 		rdb.aggregateCount = 0;
 		rdb.quote = quote;
 		rdb.cache = {};
+		rdb.changes = [];
 
 		if (readonly) {
 			rdb.dbClient = {
@@ -15627,7 +15785,6 @@ function requireNewDatabase$a () {
 	let hostLocal = requireHostLocal();
 	let doQuery = requireQuery();
 	let releaseDbClient = requireReleaseDbClient();
-	let setSessionSingleton = requireSetSessionSingleton();
 
 	function newDatabase(connectionString, poolOptions) {
 		poolOptions = poolOptions || { min: 1 };
@@ -15642,10 +15799,9 @@ function requireNewDatabase$a () {
 			}
 			let domain = createDomain();
 
-			if (fn)
-				return domain.run(runInTransaction);
-			else
-				return domain.run(run);
+			if (!fn)
+				throw new Error('transaction requires a function');
+			return domain.run(runInTransaction);
 
 			async function runInTransaction() {
 				let result;
@@ -15664,14 +15820,6 @@ function requireNewDatabase$a () {
 				return _begin(domain, options);
 			}
 
-			function run() {
-				let p;
-				let transaction = newTransaction(domain, pool, options);
-				p = new Promise(transaction);
-
-				return p.then(begin)
-					.then(negotiateSchema);
-			}
 
 			function negotiateSchema(previous) {
 				let schema = options && options.schema;
@@ -15712,7 +15860,6 @@ function requireNewDatabase$a () {
 			let domain = createDomain();
 			let transaction = newTransaction(domain, pool);
 			let p = domain.run(() => new Promise(transaction)
-				.then(() => setSessionSingleton(domain, 'changes', []))
 				.then(() => doQuery(domain, query).then(onResult, onError)));
 			return p;
 
@@ -16147,6 +16294,7 @@ function requireNewTransaction$9 () {
 		rdb.aggregateCount = 0;
 		rdb.quote = quote;
 		rdb.cache = {};
+		rdb.changes = [];
 
 		if (readonly) {
 			rdb.dbClient = {
@@ -16368,7 +16516,6 @@ function requireNewDatabase$9 () {
 	let hostLocal = requireHostLocal();
 	let doQuery = requireQuery();
 	let releaseDbClient = requireReleaseDbClient();
-	let setSessionSingleton = requireSetSessionSingleton();
 
 	function newDatabase(connectionString, poolOptions) {
 		if (!connectionString)
@@ -16385,10 +16532,9 @@ function requireNewDatabase$9 () {
 			}
 			let domain = createDomain();
 
-			if (fn)
-				return domain.run(runInTransaction);
-			else
-				return domain.run(run);
+			if (!fn)
+				throw new Error('transaction requires a function');
+			return domain.run(runInTransaction);
 
 			async function runInTransaction() {
 				let result;
@@ -16407,14 +16553,6 @@ function requireNewDatabase$9 () {
 				return _begin(domain, options);
 			}
 
-			function run() {
-				let p;
-				let transaction = newTransaction(domain, pool, options);
-				p = new Promise(transaction);
-
-				return p.then(begin)
-					.then(negotiateSchema);
-			}
 
 			function negotiateSchema(previous) {
 				let schema = options && options.schema;
@@ -16455,7 +16593,6 @@ function requireNewDatabase$9 () {
 			let domain = createDomain();
 			let transaction = newTransaction(domain, pool);
 			let p = domain.run(() => new Promise(transaction)
-				.then(() => setSessionSingleton(domain, 'changes', []))
 				.then(() => doQuery(domain, query).then(onResult, onError)));
 			return p;
 
@@ -16633,6 +16770,7 @@ function requireNewTransaction$8 () {
 		rdb.aggregateCount = 0;
 		rdb.quote = quote;
 		rdb.cache = {};
+		rdb.changes = [];
 
 		if (readonly) {
 			rdb.dbClient = {
@@ -16898,7 +17036,6 @@ function requireNewDatabase$8 () {
 	let hostLocal = requireHostLocal();
 	let doQuery = requireQuery();
 	let releaseDbClient = requireReleaseDbClient();
-	let setSessionSingleton = requireSetSessionSingleton();
 
 	function newDatabase(connectionString, poolOptions) {
 		if (!connectionString)
@@ -16915,10 +17052,9 @@ function requireNewDatabase$8 () {
 			}
 			let domain = createDomain();
 
-			if (fn)
-				return domain.run(runInTransaction);
-			else
-				return domain.run(run);
+			if (!fn)
+				throw new Error('transaction requires a function');
+			return domain.run(runInTransaction);
 
 			async function runInTransaction() {
 				let result;
@@ -16937,15 +17073,6 @@ function requireNewDatabase$8 () {
 				return _begin(domain, options);
 			}
 
-			function run() {
-				let p;
-				let transaction = newTransaction(domain, pool, options);
-				p = new Promise(transaction);
-
-				return p.then(begin)
-					.then(negotiateSchema);
-			}
-
 			function negotiateSchema(previous) {
 				let schema = options && options.schema;
 				if (!schema)
@@ -16985,7 +17112,6 @@ function requireNewDatabase$8 () {
 			let domain = createDomain();
 			let transaction = newTransaction(domain, pool);
 			let p = domain.run(() => new Promise(transaction)
-				.then(() => setSessionSingleton(domain, 'changes', []))
 				.then(() => doQuery(domain, query).then(onResult, onError)));
 			return p;
 
@@ -17389,6 +17515,7 @@ function requireNewTransaction$7 () {
 		rdb.aggregateCount = 0;
 		rdb.quote = quote;
 		rdb.cache = {};
+		rdb.changes = [];
 
 		if (readonly) {
 			rdb.dbClient = {
@@ -17585,8 +17712,8 @@ function requireNewDatabase$7 () {
 	let express = requireHostExpress();
 	let hostLocal = requireHostLocal();
 	let doQuery = requireQuery();
+	let doSqliteFunction = requireSqliteFunction();
 	let releaseDbClient = requireReleaseDbClient();
-	let setSessionSingleton = requireSetSessionSingleton();
 
 	function newDatabase(connectionString, poolOptions) {
 		if (!connectionString)
@@ -17602,11 +17729,9 @@ function requireNewDatabase$7 () {
 				options = undefined;
 			}
 			let domain = createDomain();
-
-			if (fn)
-				return domain.run(runInTransaction);
-			else
-				return domain.run(run);
+			if (!fn)
+				throw new Error('transaction requires a function');
+			return domain.run(runInTransaction);
 
 			function begin() {
 				return _begin(domain, options);
@@ -17620,30 +17745,27 @@ function requireNewDatabase$7 () {
 					.then(() => fn(domain))
 					.then((res) => result = res)
 					.then(() => commit(domain))
-					.then(null, (e) => rollback(domain, e));
+					.then(null, (e) => Promise.resolve(rollback(domain, e)));
 				return result;
 			}
 
-			function run() {
-				let p;
-				let transaction = newTransaction(domain, pool, options);
-				p = new Promise(transaction);
-
-				return p.then(begin);
-			}
 
 		};
 
 		c.createTransaction = function(options) {
+			console.dir('create transaction');
 			let domain = createDomain();
 			let transaction = newTransaction(domain, pool);
 			let p = domain.run(() => new Promise(transaction).then(begin));
-
 			function run(fn) {
 				return p.then(() => fn(domain));
 			}
-			run.rollback = rollback.bind(null, domain);
-			run.commit = commit.bind(null, domain);
+			run.rollback = function(error) {
+				return Promise.resolve(rollback(domain, error));
+			};
+			run.commit = function() {
+				return Promise.resolve(commit(domain));
+			};
 			return run;
 
 			function begin() {
@@ -17655,7 +17777,6 @@ function requireNewDatabase$7 () {
 			let domain = createDomain();
 			let transaction = newTransaction(domain, pool);
 			let p = domain.run(() => new Promise(transaction)
-				.then(() => setSessionSingleton(domain, 'changes', []))
 				.then(() => doQuery(domain, query).then(onResult, onError)));
 			return p;
 
@@ -17670,6 +17791,23 @@ function requireNewDatabase$7 () {
 			}
 		};
 
+		c.sqliteFunction = function(...args) {
+			let domain = createDomain();
+			let transaction = newTransaction(domain, pool);
+			let p = domain.run(() => new Promise(transaction)
+				.then(() => doSqliteFunction(domain, ...args).then(onResult, onError)));
+			return p;
+
+			function onResult(result) {
+				releaseDbClient(domain);
+				return result;
+			}
+
+			function onError(e) {
+				releaseDbClient(domain);
+				throw e;
+			}
+		};
 
 		c.rollback = rollback;
 		c.commit = commit;
@@ -17810,6 +17948,7 @@ function requireNewTransaction$6 () {
 		rdb.aggregateCount = 0;
 		rdb.quote = quote;
 		rdb.cache = {};
+		rdb.changes = [];
 
 		if (readonly) {
 			rdb.dbClient = {
@@ -17989,8 +18128,8 @@ function requireNewDatabase$6 () {
 	let express = requireHostExpress();
 	let hostLocal = requireHostLocal();
 	let doQuery = requireQuery();
+	let doSqliteFunction = requireSqliteFunction();
 	let releaseDbClient = requireReleaseDbClient();
-	let setSessionSingleton = requireSetSessionSingleton();
 
 	function newDatabase(connectionString, poolOptions) {
 		if (!connectionString)
@@ -18007,10 +18146,9 @@ function requireNewDatabase$6 () {
 			}
 			let domain = createDomain();
 
-			if (fn)
-				return domain.run(runInTransaction);
-			else
-				return domain.run(run);
+			if (!fn)
+				throw new Error('transaction requires a function');
+			return domain.run(runInTransaction);
 
 			function begin() {
 				return _begin(domain, options);
@@ -18028,13 +18166,6 @@ function requireNewDatabase$6 () {
 				return result;
 			}
 
-			function run() {
-				let p;
-				let transaction = newTransaction(domain, pool, options);
-				p = new Promise(transaction);
-
-				return p.then(begin);
-			}
 
 		};
 
@@ -18059,7 +18190,6 @@ function requireNewDatabase$6 () {
 			let domain = createDomain();
 			let transaction = newTransaction(domain, pool);
 			let p = domain.run(() => new Promise(transaction)
-				.then(() => setSessionSingleton(domain, 'changes', []))
 				.then(() => doQuery(domain, query).then(onResult, onError)));
 			return p;
 
@@ -18074,6 +18204,24 @@ function requireNewDatabase$6 () {
 			}
 		};
 
+		c.sqliteFunction = function(...args) {
+			let domain = createDomain();
+			let transaction = newTransaction(domain, pool);
+			let p = domain.run(() => new Promise(transaction)
+				.then(() => doSqliteFunction(domain, ...args).then(onResult, onError)));
+			return p;
+
+			function onResult(result) {
+				releaseDbClient(domain);
+				return result;
+			}
+
+			function onError(e) {
+				releaseDbClient(domain);
+				throw e;
+			}
+		};
+
 
 		c.rollback = rollback;
 		c.commit = commit;
@@ -18233,6 +18381,7 @@ function requireNewTransaction$5 () {
 		rdb.aggregateCount = 0;
 		rdb.quote = quote;
 		rdb.cache = {};
+		rdb.changes = [];
 
 		if (readonly) {
 			rdb.dbClient = {
@@ -18434,8 +18583,8 @@ function requireNewDatabase$5 () {
 	let express = requireHostExpress();
 	let hostLocal = requireHostLocal();
 	let doQuery = requireQuery();
+	let doSqliteFunction = requireSqliteFunction();
 	let releaseDbClient = requireReleaseDbClient();
-	let setSessionSingleton = requireSetSessionSingleton();
 
 	function newDatabase(connectionString, poolOptions) {
 		if (!connectionString)
@@ -18452,10 +18601,9 @@ function requireNewDatabase$5 () {
 			}
 			let domain = createDomain();
 
-			if (fn)
-				return domain.run(runInTransaction);
-			else
-				return domain.run(run);
+			if (!fn)
+				throw new Error('transaction requires a function');
+			return domain.run(runInTransaction);
 
 			function begin() {
 				return _begin(domain, options);
@@ -18473,13 +18621,6 @@ function requireNewDatabase$5 () {
 				return result;
 			}
 
-			function run() {
-				let p;
-				let transaction = newTransaction(domain, pool, options);
-				p = new Promise(transaction);
-
-				return p.then(begin);
-			}
 
 		};
 
@@ -18504,7 +18645,6 @@ function requireNewDatabase$5 () {
 			let domain = createDomain();
 			let transaction = newTransaction(domain, pool);
 			let p = domain.run(() => new Promise(transaction)
-				.then(() => setSessionSingleton(domain, 'changes', []))
 				.then(() => doQuery(domain, query).then(onResult, onError)));
 			return p;
 
@@ -18519,6 +18659,24 @@ function requireNewDatabase$5 () {
 			}
 		};
 
+		c.sqliteFunction = function(...args) {
+			let domain = createDomain();
+			let transaction = newTransaction(domain, pool);
+			let p = domain.run(() => new Promise(transaction)
+				.then(() => doSqliteFunction(domain, ...args).then(onResult, onError)));
+			return p;
+
+			function onResult(result) {
+				releaseDbClient(domain);
+				return result;
+			}
+
+			function onError(e) {
+				releaseDbClient(domain);
+				throw e;
+			}
+		};
+
 
 		c.rollback = rollback;
 		c.commit = commit;
@@ -18658,6 +18816,7 @@ function requireNewTransaction$4 () {
 		rdb.aggregateCount = 0;
 		rdb.quote = (name) => `"${name}"`;
 		rdb.cache = {};
+		rdb.changes = [];
 
 		if (readonly) {
 			rdb.dbClient = {
@@ -18845,7 +19004,6 @@ function requireNewDatabase$4 () {
 	let hostLocal = requireHostLocal();
 	let doQuery = requireQuery();
 	let releaseDbClient = requireReleaseDbClient();
-	let setSessionSingleton = requireSetSessionSingleton();
 
 	function newDatabase(d1Database, poolOptions) {
 		if (!d1Database)
@@ -18862,10 +19020,9 @@ function requireNewDatabase$4 () {
 			}
 			let domain = createDomain();
 
-			if (fn)
-				return domain.run(runInTransaction);
-			else
-				return domain.run(run);
+			if (!fn)
+				throw new Error('transaction requires a function');
+			return domain.run(runInTransaction);
 
 			async function runInTransaction() {
 				let result;
@@ -18884,13 +19041,6 @@ function requireNewDatabase$4 () {
 				return _begin(domain, transactionLess);
 			}
 
-			function run() {
-				let p;
-				let transaction = newTransaction(domain, pool, options);
-				p = new Promise(transaction);
-
-				return p.then(begin);
-			}
 
 		};
 
@@ -18918,7 +19068,6 @@ function requireNewDatabase$4 () {
 			let domain = createDomain();
 			let transaction = newTransaction(domain, pool);
 			let p = domain.run(() => new Promise(transaction)
-				.then(() => setSessionSingleton(domain, 'changes', []))
 				.then(() => doQuery(domain, query).then(onResult, onError)));
 			return p;
 
@@ -19659,6 +19808,7 @@ function requireNewTransaction$3 () {
 		rdb.aggregateCount = 0;
 		rdb.quote = quote;
 		rdb.cache = {};
+		rdb.changes = [];
 
 		if (readonly) {
 			rdb.dbClient = {
@@ -19872,7 +20022,6 @@ function requireNewDatabase$3 () {
 	let hostLocal = requireHostLocal();
 	let doQuery = requireQuery();
 	let releaseDbClient = requireReleaseDbClient();
-	let setSessionSingleton = requireSetSessionSingleton();
 
 	function newDatabase(connectionString, poolOptions) {
 		if (!connectionString)
@@ -19889,10 +20038,9 @@ function requireNewDatabase$3 () {
 			}
 			let domain = createDomain();
 
-			if (fn)
-				return domain.run(runInTransaction);
-			else
-				return domain.run(run);
+			if (!fn)
+				throw new Error('transaction requires a function');
+			return domain.run(runInTransaction);
 
 			async function runInTransaction() {
 				let result;
@@ -19910,13 +20058,6 @@ function requireNewDatabase$3 () {
 				return _begin(domain, options);
 			}
 
-			function run() {
-				let p;
-				let transaction = newTransaction(domain, pool, options);
-				p = new Promise(transaction);
-
-				return p.then(begin);
-			}
 
 		};
 
@@ -19945,7 +20086,6 @@ function requireNewDatabase$3 () {
 			let domain = createDomain();
 			let transaction = newTransaction(domain, pool);
 			let p = domain.run(() => new Promise(transaction)
-				.then(() => setSessionSingleton(domain, 'changes', []))
 				.then(() => doQuery(domain, query).then(onResult, onError)));
 			return p;
 
@@ -20383,6 +20523,7 @@ function requireNewTransaction$2 () {
 		rdb.aggregateCount = 0;
 		rdb.quote = quote;
 		rdb.cache = {};
+		rdb.changes = [];
 
 		if (readonly) {
 			rdb.dbClient = {
@@ -20641,7 +20782,6 @@ function requireNewDatabase$2 () {
 	let hostLocal = requireHostLocal();
 	let doQuery = requireQuery();
 	let releaseDbClient = requireReleaseDbClient();
-	let setSessionSingleton = requireSetSessionSingleton();
 
 	function newDatabase(connectionString, poolOptions) {
 		if (!connectionString)
@@ -20658,10 +20798,9 @@ function requireNewDatabase$2 () {
 			}
 			let domain = createDomain();
 
-			if (fn)
-				return domain.run(runInTransaction);
-			else
-				return domain.run(run);
+			if (!fn)
+				throw new Error('transaction requires a function');
+			return domain.run(runInTransaction);
 
 			function begin() {
 				return _begin(domain, options);
@@ -20680,13 +20819,6 @@ function requireNewDatabase$2 () {
 			}
 
 
-			function run() {
-				let p;
-				let transaction = newTransaction(domain, pool, options);
-				p = new Promise(transaction);
-
-				return p.then(begin);
-			}
 
 		};
 
@@ -20714,7 +20846,6 @@ function requireNewDatabase$2 () {
 			let domain = createDomain();
 			let transaction = newTransaction(domain, pool);
 			let p = domain.run(() => new Promise(transaction)
-				.then(() => setSessionSingleton(domain, 'changes', []))
 				.then(() => doQuery(domain, query).then(onResult, onError)));
 			return p;
 
@@ -21155,6 +21286,7 @@ function requireNewTransaction$1 () {
 		rdb.aggregateCount = 0;
 		rdb.quote = quote;
 		rdb.cache = {};
+		rdb.changes = [];
 
 		if (readonly) {
 			rdb.dbClient = {
@@ -21292,7 +21424,6 @@ function requireNewDatabase$1 () {
 	let hostLocal = requireHostLocal();
 	let doQuery = requireQuery();
 	let releaseDbClient = requireReleaseDbClient();
-	let setSessionSingleton = requireSetSessionSingleton();
 
 	function newDatabase(connectionString, poolOptions) {
 		if (!connectionString)
@@ -21309,10 +21440,9 @@ function requireNewDatabase$1 () {
 			}
 			let domain = createDomain();
 
-			if (fn)
-				return domain.run(runInTransaction);
-			else
-				return domain.run(run);
+			if (!fn)
+				throw new Error('transaction requires a function');
+			return domain.run(runInTransaction);
 
 
 			function begin() {
@@ -21332,13 +21462,6 @@ function requireNewDatabase$1 () {
 
 			}
 
-			function run() {
-				let p;
-				let transaction = newTransaction(domain, pool, options);
-				p = new Promise(transaction);
-
-				return p.then(begin);
-			}
 
 		};
 
@@ -21368,7 +21491,6 @@ function requireNewDatabase$1 () {
 			let domain = createDomain();
 			let transaction = newTransaction(domain, pool);
 			let p = domain.run(() => new Promise(transaction)
-				.then(() => setSessionSingleton(domain, 'changes', []))
 				.then(() => doQuery(domain, query).then(onResult, onError)));
 			return p;
 
@@ -21958,6 +22080,7 @@ function requireNewTransaction () {
 		rdb.aggregateCount = 0;
 		rdb.quote = quote;
 		rdb.cache = {};
+		rdb.changes = [];
 
 		if (readonly) {
 			rdb.dbClient = {
@@ -22166,7 +22289,6 @@ function requireNewDatabase () {
 	let hostLocal = requireHostLocal();
 	let doQuery = requireQuery();
 	let releaseDbClient = requireReleaseDbClient();
-	let setSessionSingleton = requireSetSessionSingleton();
 
 	function newDatabase(connectionString, poolOptions) {
 		if (!connectionString)
@@ -22183,10 +22305,9 @@ function requireNewDatabase () {
 			}
 			let domain = createDomain();
 
-			if (fn)
-				return domain.run(runInTransaction);
-			else
-				return domain.run(run);
+			if (!fn)
+				throw new Error('transaction requires a function');
+			return domain.run(runInTransaction);
 
 
 			function begin() {
@@ -22206,13 +22327,6 @@ function requireNewDatabase () {
 
 			}
 
-			function run() {
-				let p;
-				let transaction = newTransaction(domain, pool, options);
-				p = new Promise(transaction);
-
-				return p.then(begin);
-			}
 
 		};
 
@@ -22237,7 +22351,6 @@ function requireNewDatabase () {
 			let domain = createDomain();
 			let transaction = newTransaction(domain, pool);
 			let p = domain.run(() => new Promise(transaction)
-				.then(() => setSessionSingleton(domain, 'changes', []))
 				.then(() => doQuery(domain, query).then(onResult, onError)));
 			return p;