orange-orm 4.9.0 → 4.10.0-beta.0

package/dist/index.browser.mjs

@@ -465,6 +465,7 @@ export interface ExpressConfig {
 	concurrency?: Concurrency;
 	readonly?: boolean;
 	disableBulkDeletes?: boolean;
+	hooks?: ExpressHooks;
 }
 
 export interface ExpressContext {
@@ -473,6 +474,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()}
 }
 `;
@@ -610,13 +623,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
 
 			});
 		}
@@ -2200,6 +2218,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;
 
@@ -2210,6 +2257,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,
@@ -2220,9 +2268,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);
@@ -2273,10 +2324,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;
 
@@ -2311,6 +2393,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);
 		}
@@ -2401,6 +2508,7 @@ function requireNetAdapter () {
 			post,
 			patch,
 			query,
+			sqliteFunction,
 			express
 		};
 
@@ -2456,6 +2564,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');
 		}
@@ -2469,7 +2581,8 @@ function requireNetAdapter () {
 			get,
 			post,
 			patch,
-			query
+			query,
+			sqliteFunction
 		};
 
 		return c;
@@ -2494,6 +2607,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') {
@@ -2782,6 +2900,7 @@ function requireClient () {
 			}
 		};
 		client.query = query;
+		client.function = sqliteFunction;
 		client.transaction = runInTransaction;
 		client.db = baseUrl;
 		client.mssql = onProvider.bind(null, 'mssql');
@@ -2870,6 +2989,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 });
@@ -3553,6 +3677,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]);
@@ -4132,8 +4257,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++) {
@@ -4147,7 +4274,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);
@@ -12936,14 +13063,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) {
@@ -13044,10 +13191,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() {
@@ -13057,6 +13207,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);
@@ -13938,6 +14105,7 @@ function requireNewTransaction$2 () {
 		rdb.aggregateCount = 0;
 		rdb.quote = (name) => `"${name}"`;
 		rdb.cache = {};
+		rdb.changes = [];
 
 		if (readonly) {
 			rdb.dbClient = {
@@ -14041,7 +14209,6 @@ function requireBegin () {
 	let setSessionSingleton = requireSetSessionSingleton();
 
 	function begin(context, transactionLess) {
-		setSessionSingleton(context, 'changes', []);
 		if (transactionLess) {
 			setSessionSingleton(context, 'transactionLess', true);
 			return Promise.resolve();
@@ -14838,7 +15005,6 @@ function requireNewDatabase$2 () {
 	let hostLocal = requireHostLocal();
 	let doQuery = requireQuery();
 	let releaseDbClient = requireReleaseDbClient();
-	let setSessionSingleton = requireSetSessionSingleton();
 
 	function newDatabase(d1Database, poolOptions) {
 		if (!d1Database)
@@ -14855,10 +15021,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);
 
 			async function runInTransaction() {
 				let result;
@@ -14877,13 +15042,6 @@ function requireNewDatabase$2 () {
 				return _begin(domain, transactionLess);
 			}
 
-			function run() {
-				let p;
-				let transaction = newTransaction(domain, pool, options);
-				p = new Promise(transaction);
-
-				return p.then(begin);
-			}
 
 		};
 
@@ -14911,7 +15069,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;
 
@@ -15356,6 +15513,7 @@ function requireNewTransaction$1 () {
 		rdb.aggregateCount = 0;
 		rdb.quote = quote;
 		rdb.cache = {};
+		rdb.changes = [];
 
 		if (readonly) {
 			rdb.dbClient = {
@@ -15598,7 +15756,6 @@ function requireNewDatabase$1 () {
 	let hostLocal = requireHostLocal();
 	let doQuery = requireQuery();
 	let releaseDbClient = requireReleaseDbClient();
-	let setSessionSingleton = requireSetSessionSingleton();
 
 	function newDatabase(connectionString, poolOptions) {
 		poolOptions = poolOptions || { min: 1 };
@@ -15613,10 +15770,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);
 
 			async function runInTransaction() {
 				let result;
@@ -15635,14 +15791,6 @@ function requireNewDatabase$1 () {
 				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;
@@ -15683,7 +15831,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;
 
@@ -15885,6 +16032,7 @@ function requireNewTransaction () {
 		rdb.aggregateCount = 0;
 		rdb.quote = quote;
 		rdb.cache = {};
+		rdb.changes = [];
 
 		if (readonly) {
 			rdb.dbClient = {
@@ -16150,7 +16298,6 @@ function requireNewDatabase () {
 	let hostLocal = requireHostLocal();
 	let doQuery = requireQuery();
 	let releaseDbClient = requireReleaseDbClient();
-	let setSessionSingleton = requireSetSessionSingleton();
 
 	function newDatabase(connectionString, poolOptions) {
 		if (!connectionString)
@@ -16167,10 +16314,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);
 
 			async function runInTransaction() {
 				let result;
@@ -16189,15 +16335,6 @@ function requireNewDatabase () {
 				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)
@@ -16237,7 +16374,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;