Minor performance improvements

package.json

@@ -1,6 +1,6 @@
 {
   "name": "orange-orm",
-  "version": "4.2.0",
+  "version": "4.3.0-beta.3",
   "main": "./src/index.js",
   "browser": "./src/client/index.mjs",
   "bin": {
@@ -47,7 +47,8 @@
     "build": "rollup -c ./src/client/rollup.config.js && npm run concat",
     "lint": "eslint ./",
     "fix": "eslint ./ --fix",
-    "owasp": "owasp-dependency-check --project \"MY_PROJECT\" --scan \"package-lock.json\" --exclude \"dependency-check-bin\" --out \"owasp\" --format HTML"
+    "owasp": "owasp-dependency-check --project \"MY_PROJECT\" --scan \"package-lock.json\" --exclude \"dependency-check-bin\" --out \"owasp\" --format HTML",
+    "beta": "publish --tag beta"
   },
   "dependencies": {
     "@lroal/on-change": "^4.0.2",
@@ -103,11 +104,11 @@
   "devDependencies": {
     "@rollup/plugin-commonjs": "^21.0.1",
     "@rollup/plugin-node-resolve": "^13.0.0",
-    "@typescript-eslint/eslint-plugin": "^5.42.1",
-    "@typescript-eslint/parser": "^5.42.1",
+    "@typescript-eslint/eslint-plugin": "^6.x",
+    "@typescript-eslint/parser": "^6.x",
     "@vitest/coverage-v8": "^0.34.1",
     "cors": "^2.8.5",
-    "eslint": "^8.6.0",
+    "eslint": "^8.57.0",
     "eslint-plugin-jest": "^27.1.7",
     "express": "^4.18.2",
     "msnodesqlv8": "^4.1.0",

src/getManyDto.js

@@ -128,7 +128,7 @@ async function decode(strategy, span, rows, keys = rows.length > 0 ? Object.keys
 		for (let j = 0; j < aggregateKeys.length; j++) {
 			const key = aggregateKeys[j];
 			const parse = span.aggregates[key].column?.decode || Number.parseFloat;
-			outRow[key] =  parse(row[keys[j+columnsLength]]);
+			outRow[key] = parse(row[keys[j + columnsLength]]);
 		}
 
 		outRows[i] = outRow;
@@ -141,8 +141,18 @@ async function decode(strategy, span, rows, keys = rows.length > 0 ? Object.keys
 	span._ids = fkIds;
 
 	keys.splice(0, columnsLength + aggregateKeys.length);
+	if (span.legs.toArray().length === 0)
+		return outRows;
+
+	const all = [];
+
+	if (shouldCreateMap)
+		all.push(decodeManyRelations(strategy, span).then(() => decodeRelations2(strategy, span, rows, outRows, keys)));
+	else
+		all.push(decodeRelations2(strategy, span, rows, outRows, keys));
+
+	await Promise.all(all);
 
-	await decodeRelations(strategy, span, rows, outRows, keys);
 	return outRows;
 
 
@@ -165,19 +175,10 @@ async function decode(strategy, span, rows, keys = rows.length > 0 ? Object.keys
 
 }
 
-async function decodeRelations(strategy, span, rawRows, resultRows, keys) {
+async function decodeManyRelations(strategy, span) {
 	const promises = [];
 	const c = {};
-	c.visitJoin = function(leg) {
-		const name = leg.name;
-		const p = decode(strategy[name], leg.span, rawRows, keys).then((rows) => {
-			for (let i = 0; i < rows.length; i++) {
-				resultRows[i][name] = rows[i];
-			}
-		});
-		promises.push(p);
-	};
-
+	c.visitJoin = () => { };
 	c.visitOne = c.visitJoin;
 
 	c.visitMany = function(leg) {
@@ -205,6 +206,74 @@ async function decodeRelations(strategy, span, rawRows, resultRows, keys) {
 	await Promise.all(promises);
 }
 
+async function decodeRelations2(strategy, span, rawRows, resultRows, keys) {
+	const promises = [];
+	const c = {};
+	c.visitJoin = function(leg) {
+		const name = leg.name;
+		const p = decode(strategy[name], leg.span, rawRows, keys).then((rows) => {
+			for (let i = 0; i < rows.length; i++) {
+				resultRows[i][name] = rows[i];
+			}
+		});
+		promises.push(p);
+	};
+
+	c.visitOne = c.visitJoin;
+
+	c.visitMany = () => { };
+
+
+	span.legs.forEach(onEachLeg);
+
+	function onEachLeg(leg) {
+		leg.accept(c);
+	}
+
+	await Promise.all(promises);
+}
+
+
+// async function decodeRelations(strategy, span, rawRows, resultRows, keys) {
+// 	const promises = [];
+// 	const c = {};
+// 	c.visitJoin = function (leg) {
+// 		const name = leg.name;
+// 		const p = decode(strategy[name], leg.span, rawRows, keys).then((rows) => {
+// 			for (let i = 0; i < rows.length; i++) {
+// 				resultRows[i][name] = rows[i];
+// 			}
+// 		});
+// 		promises.push(p);
+// 	};
+
+// 	c.visitOne = c.visitJoin;
+
+// 	c.visitMany = function (leg) {
+// 		const name = leg.name;
+// 		const table = span.table;
+// 		const relation = table._relations[name];
+// 		const filter = createOneFilter(relation, span._ids);
+// 		const rowsMap = span._rowsMap;
+// 		const p = getManyDto(relation.childTable, filter, strategy[name], leg.span).then(subRows => {
+// 			for (let i = 0; i < subRows.length; i++) {
+// 				const key = leg.columns.map(column => subRows[i][column.alias]);
+// 				const parentRow = getFromMap(rowsMap, table._primaryColumns, key);
+// 				parentRow[name].push(subRows[i]);
+// 			}
+// 		});
+// 		promises.push(p);
+// 	};
+
+// 	span.legs.forEach(onEachLeg);
+
+// 	function onEachLeg(leg) {
+// 		leg.accept(c);
+// 	}
+
+// 	await Promise.all(promises);
+// }
+
 function createOneFilter(relation, ids) {
 	const columns = relation.joinRelation.columns;
 
@@ -216,7 +285,7 @@ function createOneFilter(relation, ids) {
 
 	function createCompositeFilter() {
 		let filter = emptyFilter;
-		for(let id of ids) {
+		for (let id of ids) {
 			let nextFilter;
 			for (let i = 0; i < columns.length; i++) {
 				if (nextFilter)

src/mssql/newDatabase.js

@@ -43,7 +43,7 @@ function newDatabase(connectionString, poolOptions) {
 
 		async function runInTransaction() {
 			let result;
-			let transaction = newTransaction(domain, pool);
+			let transaction = newTransaction(domain, pool, options);
 			await new Promise(transaction)
 				.then(begin)
 				.then(fn)
@@ -59,7 +59,7 @@ function newDatabase(connectionString, poolOptions) {
 
 		function run() {
 			let p;
-			let transaction = newTransaction(domain, pool);
+			let transaction = newTransaction(domain, pool, options);
 			if (useHook())
 				p = new Promise(transaction);
 			else

src/mssql/newTransaction.js

@@ -8,12 +8,63 @@ const formatDateOut = require('../tedious/formatDateOut');
 const insertSql = require('../tedious/insertSql');
 const insert = require('../tedious/insert');
 
-function newResolveTransaction(domain, pool) {
+function newResolveTransaction(domain, pool, { readonly } = {}) {
 	var rdb = {poolFactory: pool};
 	if (!pool.connect) {
 		pool = pool();
 		rdb.pool = pool;
 	}
+	rdb.engine = 'mssqlNative';
+	rdb.encodeBoolean = encodeBoolean;
+	rdb.decodeJSON = decodeJSON;
+	rdb.encodeJSON = JSON.stringify;
+	rdb.formatDateOut = formatDateOut;
+	rdb.deleteFromSql = deleteFromSql;
+	rdb.selectForUpdateSql = selectForUpdateSql;
+	rdb.outputInsertedSql = outputInsertedSql;
+	rdb.insertSql = insertSql;
+	rdb.insert = insert;
+	rdb.lastInsertedIsSeparate = false;
+	rdb.multipleStatements = true;
+	rdb.begin = 'BEGIN TRANSACTION';
+	rdb.limit = (span) => {
+		if (span.offset)
+			return '';
+		else if (span.limit || span.limit === 0)
+			return 'TOP ' + span.limit;
+		else
+			return '';
+	};
+	rdb.limitAndOffset = limitAndOffset;
+	rdb.accept = function(caller) {
+		caller.visitSqlite();
+	};
+	rdb.aggregateCount = 0;
+	rdb.quote = (name) => `[${name}]`;
+
+	if (readonly) {
+		rdb.dbClient = {
+			executeQuery: function(query, callback) {
+				pool.connect((err, client, done) => {
+					if (err) {
+						return callback(err);
+					}
+					try {
+						client.setUseUTC(false);
+						wrapQuery(client)(query, (err, res) => {
+							done();
+							callback(err, res);
+						});
+					} catch (e) {
+						done();
+						callback(e);
+					}
+				});
+			}
+		};
+		domain.rdb = rdb;
+		return (onSuccess) => onSuccess();
+	}
 
 	return function(onSuccess, onError) {
 		pool.connect(onConnected);
@@ -26,35 +77,8 @@ function newResolveTransaction(domain, pool) {
 				}
 				client.setUseUTC(false);
 				client.executeQuery = wrapQuery(client);
-				rdb.engine = 'mssqlNative';
 				rdb.dbClient = client;
 				rdb.dbClientDone = done;
-				rdb.encodeBoolean = encodeBoolean;
-				rdb.decodeJSON = decodeJSON;
-				rdb.encodeJSON = JSON.stringify;
-				rdb.formatDateOut = formatDateOut;
-				rdb.deleteFromSql = deleteFromSql;
-				rdb.selectForUpdateSql = selectForUpdateSql;
-				rdb.outputInsertedSql = outputInsertedSql;
-				rdb.insertSql = insertSql;
-				rdb.insert = insert;
-				rdb.lastInsertedIsSeparate = false;
-				rdb.multipleStatements = true;
-				rdb.begin = 'BEGIN TRANSACTION';
-				rdb.limit = (span) => {
-					if (span.offset)
-						return '';
-					else if (span.limit || span.limit === 0)
-						return 'TOP ' + span.limit;
-					else
-						return '';
-				};
-				rdb.limitAndOffset = limitAndOffset;
-				rdb.accept = function(caller) {
-					caller.visitSqlite();
-				};
-				rdb.aggregateCount = 0;
-				rdb.quote = (name) => `[${name}]`;
 				domain.rdb = rdb;
 				onSuccess();
 			} catch (e) {

src/mySql/newDatabase.js

@@ -42,7 +42,7 @@ function newDatabase(connectionString, poolOptions) {
 
 		async function runInTransaction() {
 			let result;
-			let transaction = newTransaction(domain, pool);
+			let transaction = newTransaction(domain, pool, options);
 			await new Promise(transaction)
 				.then(begin)
 				.then(fn)
@@ -58,7 +58,7 @@ function newDatabase(connectionString, poolOptions) {
 
 		function run() {
 			let p;
-			let transaction = newTransaction(domain, pool);
+			let transaction = newTransaction(domain, pool, options);
 			if (useHook())
 				p = new Promise(transaction);
 			else

src/mySql/newTransaction.js

@@ -7,42 +7,65 @@ const limitAndOffset = require('./limitAndOffset');
 const insertSql = require('./insertSql');
 const insert = require('./insert');
 
-function newResolveTransaction(domain, pool) {
+function newResolveTransaction(domain, pool, { readonly } = {}) {
 	var rdb = {poolFactory: pool};
 	if (!pool.connect) {
 		pool = pool();
 		rdb.pool = pool;
 	}
+	rdb.engine = 'mysql';
+	rdb.encodeBoolean = encodeBoolean;
+	rdb.encodeJSON = JSON.stringify;
+	rdb.deleteFromSql = deleteFromSql;
+	rdb.selectForUpdateSql = selectForUpdateSql;
+	rdb.lastInsertedIsSeparate = true;
+	rdb.lastInsertedSql = lastInsertedSql;
+	rdb.insertSql = insertSql;
+	rdb.insert = insert;
+	rdb.multipleStatements = false;
+	rdb.limitAndOffset = limitAndOffset;
+	rdb.accept = function(caller) {
+		caller.visitMySql();
+	};
+	rdb.aggregateCount = 0;
+	rdb.quote = (name) => `\`${name}\``;
+
+
+	if (readonly) {
+		rdb.dbClient = {
+			executeQuery: function(query, callback) {
+				pool.connect((err, client, done) => {
+					if (err) {
+						return callback(err);
+					}
+					try {
+						wrapQuery(client)(query, (err, res) => {
+							done();
+							callback(err, res);
+						});
+					} catch (e) {
+						done();
+						callback(e);
+					}
+				});
+			}
+		};
+		domain.rdb = rdb;
+		return (onSuccess) => onSuccess();
+	}
 
 	return function(onSuccess, onError) {
 		pool.connect(onConnected);
 
-		function onConnected(err, connection, done) {
+		function onConnected(err, client, done) {
 			try {
 				if (err) {
 					onError(err);
 					return;
 				}
-				connection.executeQuery = wrapQuery(connection);
-				// connection.streamQuery = wrapQueryStream(connection);
-				rdb.engine = 'mysql';
-				rdb.dbClient = connection;
+				client.executeQuery = wrapQuery(client);
+				rdb.dbClient = client;
 				rdb.dbClientDone = done;
-				rdb.encodeBoolean = encodeBoolean;
-				rdb.encodeJSON = JSON.stringify;
-				rdb.deleteFromSql = deleteFromSql;
-				rdb.selectForUpdateSql = selectForUpdateSql;
-				rdb.lastInsertedIsSeparate = true;
-				rdb.lastInsertedSql = lastInsertedSql;
-				rdb.insertSql = insertSql;
-				rdb.insert = insert;
-				rdb.multipleStatements = false;
-				rdb.limitAndOffset = limitAndOffset;
-				rdb.accept = function(caller) {
-					caller.visitMySql();
-				};
-				rdb.aggregateCount = 0;
-				rdb.quote = (name) => `\`${name}\``;
 				domain.rdb = rdb;
 				onSuccess();
 			} catch (e) {