orange-orm 4.9.0 → 4.10.0-beta.0

package/docs/changelog.md

@@ -1,4 +1,6 @@
 ## Changelog
+__4.9.1__  
+Fix: Avoid double-quoting aliases in discriminator join SQL [#144](https://github.com/alfateam/orange-orm/issues/144)    
 __4.9.0__  
 Node.js 22.5+: Continues using built-in `node:sqlite` (no action needed)  
 Node.js 18-22.4: Now requires `better-sqlite3` instead of `sqlite3`  

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "orange-orm",
-    "version": "4.9.0",
+    "version": "4.10.0-beta.0",
     "publishConfig": {
         "access": "public"
     },

package/src/bunPg/newDatabase.js

@@ -10,7 +10,6 @@ let express = require('../hostExpress');
 let hostLocal = require('../hostLocal');
 let doQuery = require('../query');
 let releaseDbClient = require('../table/releaseDbClient');
-let setSessionSingleton = require('../table/setSessionSingleton');
 
 function newDatabase(connectionString, poolOptions) {
 	if (!connectionString)
@@ -27,10 +26,9 @@ function newDatabase(connectionString, poolOptions) {
 		}
 		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;
@@ -49,14 +47,6 @@ function newDatabase(connectionString, poolOptions) {
 			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;
@@ -97,7 +87,6 @@ function newDatabase(connectionString, poolOptions) {
 		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;
 

package/src/bunPg/newTransaction.js

@@ -40,6 +40,7 @@ function newResolveTransaction(domain, pool, { readonly = false } = {}) {
 	rdb.aggregateCount = 0;
 	rdb.quote = quote;
 	rdb.cache = {};
+	rdb.changes = [];
 
 	if (readonly) {
 		rdb.dbClient = {

package/src/bunSqlite/newDatabase.js

@@ -7,8 +7,8 @@ let newPool = require('./newPool');
 let express = require('../hostExpress');
 let hostLocal = require('../hostLocal');
 let doQuery = require('../query');
+let doSqliteFunction = require('../sqliteFunction');
 let releaseDbClient = require('../table/releaseDbClient');
-let setSessionSingleton = require('../table/setSessionSingleton');
 
 function newDatabase(connectionString, poolOptions) {
 	if (!connectionString)
@@ -25,10 +25,9 @@ function newDatabase(connectionString, poolOptions) {
 		}
 		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);
@@ -46,13 +45,6 @@ function newDatabase(connectionString, poolOptions) {
 			return result;
 		}
 
-		function run() {
-			let p;
-			let transaction = newTransaction(domain, pool, options);
-			p = new Promise(transaction);
-
-			return p.then(begin);
-		}
 
 	};
 
@@ -77,7 +69,6 @@ function newDatabase(connectionString, poolOptions) {
 		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;
 
@@ -92,6 +83,24 @@ function newDatabase(connectionString, poolOptions) {
 		}
 	};
 
+	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;

package/src/bunSqlite/newTransaction.js

@@ -39,6 +39,7 @@ function newResolveTransaction(domain, pool, { readonly = false } = {})  {
 	rdb.aggregateCount = 0;
 	rdb.quote = quote;
 	rdb.cache = {};
+	rdb.changes = [];
 
 	if (readonly) {
 		rdb.dbClient = {

package/src/client/index.js

@@ -51,6 +51,7 @@ function rdbClient(options = {}) {
 		}
 	};
 	client.query = query;
+	client.function = sqliteFunction;
 	client.transaction = runInTransaction;
 	client.db = baseUrl;
 	client.mssql = onProvider.bind(null, 'mssql');
@@ -139,6 +140,11 @@ function rdbClient(options = {}) {
 		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 });
@@ -822,6 +828,7 @@ function rdbClient(options = {}) {
 				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]);
@@ -1059,4 +1066,4 @@ function onChange(target, onChange) {
 }
 
 
-module.exports = rdbClient();
+module.exports = rdbClient();

package/src/client/netAdapter.js

@@ -10,6 +10,7 @@ function httpAdapter(baseURL, path, axiosInterceptor) {
 		post,
 		patch,
 		query,
+		sqliteFunction,
 		express
 	};
 
@@ -65,6 +66,10 @@ function httpAdapter(baseURL, path, axiosInterceptor) {
 		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');
 	}
@@ -78,7 +83,8 @@ function netAdapter(url, tableName, { axios, tableOptions }) {
 		get,
 		post,
 		patch,
-		query
+		query,
+		sqliteFunction
 	};
 
 	return c;
@@ -103,6 +109,11 @@ function netAdapter(url, tableName, { axios, tableOptions }) {
 		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') {
@@ -132,4 +143,4 @@ function netAdapter(url, tableName, { axios, tableOptions }) {
 
 }
 
-module.exports = netAdapter;
+module.exports = netAdapter;

package/src/d1/newDatabase.js

@@ -8,7 +8,6 @@ let express = require('../hostExpress');
 let hostLocal = require('../hostLocal');
 let doQuery = require('../query');
 let releaseDbClient = require('../table/releaseDbClient');
-let setSessionSingleton = require('../table/setSessionSingleton');
 
 function newDatabase(d1Database, poolOptions) {
 	if (!d1Database)
@@ -25,10 +24,9 @@ function newDatabase(d1Database, poolOptions) {
 		}
 		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;
@@ -47,13 +45,6 @@ function newDatabase(d1Database, poolOptions) {
 			return _begin(domain, transactionLess);
 		}
 
-		function run() {
-			let p;
-			let transaction = newTransaction(domain, pool, options);
-			p = new Promise(transaction);
-
-			return p.then(begin);
-		}
 
 	};
 
@@ -81,7 +72,6 @@ function newDatabase(d1Database, poolOptions) {
 		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;
 

package/src/d1/newTransaction.js

@@ -35,6 +35,7 @@ function newResolveTransaction(domain, pool, { readonly = false } = {})  {
 	rdb.aggregateCount = 0;
 	rdb.quote = (name) => `"${name}"`;
 	rdb.cache = {};
+	rdb.changes = [];
 
 	if (readonly) {
 		rdb.dbClient = {

package/src/getTSDefinition.js

@@ -441,6 +441,7 @@ export interface ExpressConfig {
 	concurrency?: Concurrency;
 	readonly?: boolean;
 	disableBulkDeletes?: boolean;
+	hooks?: ExpressHooks;
 }
 
 export interface ExpressContext {
@@ -449,6 +450,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()}
 }
 `;
@@ -515,4 +528,4 @@ export interface ExpressTables {${getExpressTables()}
 	}
 }
 
-module.exports = getTSDefinition;
+module.exports = getTSDefinition;

package/src/hostExpress.js

@@ -8,13 +8,18 @@ function hostExpress(hostLocal, client, options = {}) {
 	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
 
 		});
 	}
@@ -117,4 +122,4 @@ function hostExpress(hostLocal, client, options = {}) {
 	return handler;
 }
 
-module.exports = hostExpress;
+module.exports = hostExpress;

package/src/hostLocal.js

@@ -2,6 +2,7 @@ let executePath = require('./hostExpress/executePath');
 let getMeta = require('./hostExpress/getMeta');
 let setSessionSingleton = require('./table/setSessionSingleton');
 let executeQuery = require('./query');
+let executeSqliteFunction = require('./sqliteFunction');
 let hostExpress = require('./hostExpress');
 const readonlyOps = ['getManyDto', 'getMany', 'aggregate', 'count'];
 // { db, table, defaultConcurrency,
@@ -12,9 +13,12 @@ const readonlyOps = ['getManyDto', 'getMany', 'aggregate', 'count'];
 // 	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);
@@ -65,10 +69,41 @@ function hostLocal() {
 				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;
 
@@ -103,6 +138,31 @@ function hostLocal() {
 
 	}
 
+	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);
 	}
@@ -110,4 +170,4 @@ function hostLocal() {
 	return c;
 }
 
-module.exports = hostLocal;
+module.exports = hostLocal;

package/src/map2.d.ts

@@ -903,6 +903,10 @@ export type DBClient<M extends Record<string, TableDefinition<M>>> = {
   and(f: Filter | RawFilter[], ...filters: RawFilter[]): Filter;
   or(f: Filter | RawFilter[], ...filters: RawFilter[]): Filter;
   not(): Filter;
+  /**
+   * Register a user-defined SQLite function on the connection.
+   */
+  function(name: string, fn: (...args: any[]) => unknown): Promise<unknown> | void;
   query(filter: RawFilter | string): Promise<unknown[]>;
   query<T>(filter: RawFilter | string): Promise<T[]>;
   createPatch(original: any[], modified: any[]): JsonPatch;
@@ -924,16 +928,29 @@ type ExpressConfig<M extends Record<string, TableDefinition<M>>> = {
   [TableName in keyof M]?: ExpressTableConfig<M>;
 } & {
   db?: Pool | ((connectors: Connectors) => Pool | Promise<Pool>);
+  hooks?: ExpressHooks<M>;
 }
 
 type ExpressTableConfig<M extends Record<string, TableDefinition<M>>> = {
   baseFilter?: RawFilter | ((db: DBClient<M>, req: import('express').Request, res: import('express').Response) => RawFilter);
 }
 
+type ExpressTransactionHooks<M extends Record<string, TableDefinition<M>>> = {
+  beforeBegin?: (db: DBClient<M>, req: import('express').Request, res: import('express').Response) => void | Promise<void>;
+  afterBegin?: (db: DBClient<M>, req: import('express').Request, res: import('express').Response) => void | Promise<void>;
+  beforeCommit?: (db: DBClient<M>, req: import('express').Request, res: import('express').Response) => void | Promise<void>;
+  afterCommit?: (db: DBClient<M>, req: import('express').Request, res: import('express').Response) => void | Promise<void>;
+  afterRollback?: (db: DBClient<M>, req: import('express').Request, res: import('express').Response, error?: unknown) => void | Promise<void>;
+}
+
+type ExpressHooks<M extends Record<string, TableDefinition<M>>> = ExpressTransactionHooks<M> & {
+  transaction?: ExpressTransactionHooks<M>;
+}
+
 export type DeepExpand<T> =
   T extends Date ? T :
   T extends Array<infer U> ? Array<DeepExpand<U>> :
   T extends object ? { [K in keyof T]: DeepExpand<T[K]> } :
   T;
 
-export function db<M extends Record<string, TableDefinition<M>>>(): DBClient<M>;
+export function db<M extends Record<string, TableDefinition<M>>>(): DBClient<M>;

package/src/mssql/newDatabase.js

@@ -8,7 +8,6 @@ let express = require('../hostExpress');
 let hostLocal = require('../hostLocal');
 let doQuery = require('../query');
 let releaseDbClient = require('../table/releaseDbClient');
-let setSessionSingleton = require('../table/setSessionSingleton');
 
 function newDatabase(connectionString, poolOptions) {
 	if (!connectionString)
@@ -25,10 +24,9 @@ function newDatabase(connectionString, poolOptions) {
 		}
 		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;
@@ -46,13 +44,6 @@ function newDatabase(connectionString, poolOptions) {
 			return _begin(domain, options);
 		}
 
-		function run() {
-			let p;
-			let transaction = newTransaction(domain, pool, options);
-			p = new Promise(transaction);
-
-			return p.then(begin);
-		}
 
 	};
 
@@ -81,7 +72,6 @@ function newDatabase(connectionString, poolOptions) {
 		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;
 

package/src/mssql/newTransaction.js

@@ -48,6 +48,7 @@ function newResolveTransaction(domain, pool, { readonly = false } = {}) {
 	rdb.aggregateCount = 0;
 	rdb.quote = quote;
 	rdb.cache = {};
+	rdb.changes = [];
 
 	if (readonly) {
 		rdb.dbClient = {

package/src/mySql/newDatabase.js

@@ -8,7 +8,6 @@ let express = require('../hostExpress');
 let hostLocal = require('../hostLocal');
 let doQuery = require('../query');
 let releaseDbClient = require('../table/releaseDbClient');
-let setSessionSingleton = require('../table/setSessionSingleton');
 
 function newDatabase(connectionString, poolOptions) {
 	if (!connectionString)
@@ -25,10 +24,9 @@ function newDatabase(connectionString, poolOptions) {
 		}
 		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;
@@ -46,13 +44,6 @@ function newDatabase(connectionString, poolOptions) {
 			return _begin(domain, options);
 		}
 
-		function run() {
-			let p;
-			let transaction = newTransaction(domain, pool, options);
-			p = new Promise(transaction);
-
-			return p.then(begin);
-		}
 
 	};
 
@@ -78,7 +69,6 @@ function newDatabase(connectionString, poolOptions) {
 		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;
 

package/src/mySql/newTransaction.js

@@ -34,6 +34,7 @@ function newResolveTransaction(domain, pool, { readonly = false } = {}) {
 	rdb.aggregateCount = 0;
 	rdb.quote = quote;
 	rdb.cache = {};
+	rdb.changes = [];
 
 	if (readonly) {
 		rdb.dbClient = {