orange-orm 4.3.0-beta.0 → 4.3.0-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orange-orm",
-  "version": "4.3.0-beta.0",
+  "version": "4.3.0-beta.1",
   "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",
@@ -63,7 +64,6 @@
     "glob": "^10.3.4",
     "module-definition": "^4.0.0",
     "node-cls": "^1.0.5",
-    "postgres": "^3.4.4",
     "promise": "^8.0.3",
     "rfdc": "^1.2.0",
     "uuid": "^8.3.2"
@@ -72,7 +72,6 @@
     "msnodesqlv8": "^4.1.0",
     "mysql2": "^2.2.5 || ^3.9.4",
     "oracledb": "^6.3.0",
-    "postgres": "^3.4.4",
     "pg": "^8.5.1",
     "pg-native": "^3.0.0",
     "pg-query-stream": "^3.3.2",
@@ -80,9 +79,6 @@
     "tedious": "^15.1.2 || ^16.0.0 || ^18.1.0"
   },
   "peerDependenciesMeta": {
-    "postgres": {
-      "optional": true
-    },
     "pg": {
       "optional": true
     },
@@ -119,7 +115,6 @@
     "mysql2": "^3.9.4",
     "oracledb": "^6.3.0",
     "owasp-dependency-check": "^0.0.21",
-    "postgres": "^3.4.4",
     "pg": "^8.5.1",
     "pg-query-stream": "^3.3.2",
     "rollup": "^2.52.7",

package/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

package/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) {

package/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

package/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) {

package/src/oracle/newDatabase.js

@@ -47,7 +47,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

package/src/oracle/newTransaction.js

@@ -9,13 +9,58 @@ const insert = require('./insert');
 const formatDateOut = require('./formatDateOut');
 const formatDateIn = require('./formatDateIn');
 
-function newResolveTransaction(domain, pool) {
+function newResolveTransaction(domain, pool, { readonly } = {}) {
 	var rdb = {poolFactory: pool};
 	if (!pool.connect) {
 		pool = pool();
 		rdb.pool = pool;
 	}
 
+	rdb.begin = 'SET TRANSACTION ISOLATION LEVEL READ COMMITTED';
+	rdb.engine = 'oracle';
+	rdb.encodeBoolean = encodeBoolean;
+	rdb.decodeJSON = decodeJSON;
+	rdb.encodeJSON = JSON.stringify;
+	rdb.formatDateOut = formatDateOut;
+	rdb.formatDateIn = formatDateIn;
+	rdb.deleteFromSql = deleteFromSql;
+	rdb.selectForUpdateSql = selectForUpdateSql;
+	rdb.lastInsertedSql = lastInsertedSql;
+	rdb.insertSql = insertSql;
+	rdb.insert = insert;
+	rdb.lastInsertedIsSeparate = true;
+	rdb.multipleStatements = false;
+	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 {
+						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,29 +71,10 @@ function newResolveTransaction(domain, pool) {
 					return;
 				}
 				client.executeQuery = wrapQuery(client);
-				rdb.begin = 'SET TRANSACTION ISOLATION LEVEL READ COMMITTED';
-				rdb.engine = 'oracle';
 				rdb.dbClient = client;
 				rdb.dbClientDone = done;
-				rdb.encodeBoolean = encodeBoolean;
-				rdb.decodeJSON = decodeJSON;
-				rdb.encodeJSON = JSON.stringify;
-				rdb.formatDateOut = formatDateOut;
-				rdb.formatDateIn = formatDateIn;
-				rdb.deleteFromSql = deleteFromSql;
-				rdb.selectForUpdateSql = selectForUpdateSql;
-				rdb.lastInsertedSql = lastInsertedSql;
-				rdb.insertSql = insertSql;
-				rdb.insert = insert;
-				rdb.lastInsertedIsSeparate = true;
-				rdb.multipleStatements = false;
-				rdb.limitAndOffset = limitAndOffset;
-				rdb.accept = function(caller) {
-					caller.visitSqlite();
-				};
-				rdb.aggregateCount = 0;
-				rdb.quote = (name) => `"${name}"`;
 				domain.rdb = rdb;
+
 				onSuccess();
 			} catch (e) {
 				onError(e);

package/src/pg/encodeBoolean.js

@@ -1,5 +1,5 @@
 function encodeBoolean(bool) {
-	return bool;
+	return bool.toString();
 }
 
 module.exports = encodeBoolean;

package/src/pg/encodeDate.js

@@ -1,7 +1,7 @@
 function encodeDate(date) {
 	if (date.toISOString)
-		return  '' + date.toISOString() + '';
-	return '' + date + '';
+		return  '\'' + date.toISOString() + '\'';
+	return '\'' + date + '\'';
 }
 
 module.exports = encodeDate;

package/src/pg/encodeJSON.js

@@ -1,16 +1,15 @@
 function encode(arg) {
-	// if (Array.isArray(arg))
-	// 	return new JsonBArrayParam(arg);
-	// else
-	return arg;
+	if (Array.isArray(arg))
+		return new JsonBArrayParam(arg);
+	else
+		return arg;
 }
 
-//todo
-// class JsonBArrayParam {
-// 	constructor(actualArray) { this.actualArray = actualArray; }
-// 	toPostgres() {
-// 		return JSON.stringify(this.actualArray);
-// 	}
-// }
+class JsonBArrayParam {
+	constructor(actualArray) { this.actualArray = actualArray; }
+	toPostgres() {
+		return JSON.stringify(this.actualArray);
+	}
+}
 
 module.exports = encode;

package/src/pg/newDatabase.js

@@ -52,7 +52,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(negotiateSchema)
@@ -69,7 +69,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

package/src/pg/newTransaction.js

@@ -1,5 +1,4 @@
 var wrapQuery = require('./wrapQuery');
-var wrapQueryStream = require('./wrapQueryStream');
 var encodeDate = require('./encodeDate');
 var encodeBoolean = require('./encodeBoolean');
 var deleteFromSql = require('./deleteFromSql');
@@ -10,13 +9,54 @@ var encodeJSON = require('./encodeJSON');
 var insertSql = require('./insertSql');
 var insert = require('./insert');
 
-function newResolveTransaction(domain, pool) {
-	var rdb = {poolFactory: pool};
+function newResolveTransaction(domain, pool, { readonly } = {}) {
+	var rdb = { poolFactory: pool };
 	if (!pool.connect) {
 		pool = pool();
 		rdb.pool = pool;
 	}
 
+	rdb.engine = 'pg';
+	rdb.encodeBoolean = encodeBoolean;
+	rdb.encodeDate = encodeDate;
+	rdb.encodeJSON = encodeJSON;
+	rdb.formatDateOut = formatDateOut;
+	rdb.deleteFromSql = deleteFromSql;
+	rdb.selectForUpdateSql = selectForUpdateSql;
+	rdb.lastInsertedIsSeparate = false;
+	rdb.insertSql = insertSql;
+	rdb.insert = insert;
+	rdb.multipleStatements = true;
+	rdb.limitAndOffset = limitAndOffset;
+	rdb.accept = function(caller) {
+		caller.visitPg();
+	};
+	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);
 
@@ -27,26 +67,8 @@ function newResolveTransaction(domain, pool) {
 					return;
 				}
 				client.executeQuery = wrapQuery(client);
-				client.streamQuery = wrapQueryStream(client);
-				rdb.engine = 'pg';
 				rdb.dbClient = client;
 				rdb.dbClientDone = done;
-				rdb.encodeBoolean = encodeBoolean;
-				rdb.encodeDate = encodeDate;
-				rdb.encodeJSON = encodeJSON;
-				rdb.formatDateOut = formatDateOut;
-				rdb.deleteFromSql = deleteFromSql;
-				rdb.selectForUpdateSql = selectForUpdateSql;
-				rdb.lastInsertedIsSeparate = false;
-				rdb.insertSql = insertSql;
-				rdb.insert = insert;
-				rdb.multipleStatements = true;
-				rdb.limitAndOffset = limitAndOffset;
-				rdb.accept = function(caller) {
-					caller.visitPg();
-				};
-				rdb.aggregateCount = 0;
-				rdb.quote = (name) => `"${name}"`;
 				domain.rdb = rdb;
 				onSuccess();
 			} catch (e) {
@@ -56,4 +78,4 @@ function newResolveTransaction(domain, pool) {
 	};
 }
 
-module.exports = newResolveTransaction;
+module.exports = newResolveTransaction;

package/src/pg/pool/newPgPool.js

@@ -4,19 +4,45 @@ var EventEmitter = require('events').EventEmitter;
 
 var defaults = require('./defaults');
 var genericPool = require('../../generic-pool');
-var pg = require('postgres');
+var _pg = require('pg');
 
 function newPgPool(connectionString, poolOptions) {
 	poolOptions = poolOptions || {};
+	let pg = poolOptions.native ? _pg.native : _pg;
 	var pool = genericPool.Pool({
 		max: poolOptions.size || poolOptions.poolSize || defaults.poolSize,
 		idleTimeoutMillis: poolOptions.idleTimeout || defaults.poolIdleTimeout,
 		reapIntervalMillis: poolOptions.reapIntervalMillis || defaults.reapIntervalMillis,
 		log: poolOptions.log || defaults.poolLog,
 		create: function(cb) {
-			var client = pg(connectionString, {max: 1});
-			client.poolCount = 0;
-			cb(null, client);
+			var client = new pg.Client(connectionString);
+			client.connect(function(err) {
+				if (err) return cb(err, null);
+
+				//handle connected client background errors by emitting event
+				//via the pg object and then removing errored client from the pool
+				client.on('error', function(e) {
+					pool.emit('error', e, client);
+
+					// If the client is already being destroyed, the error
+					// occurred during stream ending. Do not attempt to destroy
+					// the client again.
+					if (!client._destroying) {
+						pool.destroy(client);
+					}
+				});
+
+				// Remove connection from pool on disconnect
+				client.on('end', function(_e) {
+					// Do not enter infinite loop between pool.destroy
+					// and client 'end' event...
+					if (!client._destroying) {
+						pool.destroy(client);
+					}
+				});
+				client.poolCount = 0;
+				return cb(null, client);
+			});
 		},
 		destroy: function(client) {
 			client._destroying = true;

package/src/pg/wrapQuery.js

@@ -2,7 +2,7 @@ var log = require('../table/log');
 var replaceParamChar = require('./replaceParamChar');
 
 function wrapQuery(connection) {
-	// var runOriginalQuery = connection.query;
+	var runOriginalQuery = connection.query;
 	return runQuery;
 
 	function runQuery(query, onCompleted) {
@@ -13,15 +13,18 @@ function wrapQuery(connection) {
 			values: params,
 			types: query.types
 		};
-		log.emitQuery({ sql, parameters: params });
+		log.emitQuery({sql, parameters: params});
 
-		connection.unsafe(sql, params).then(onInnerCompleted, onCompleted);
-		// runOriginalQuery.call(connection, query, onInnerCompleted);
+		runOriginalQuery.call(connection, query, onInnerCompleted);
 
-		function onInnerCompleted(result) {
-			// if (Array.isArray(result))
-			// 	result = result[result.length - 1];
-			onCompleted(null, result);
+		function onInnerCompleted(err, result) {
+			if (err)
+				onCompleted(err);
+			else {
+				if (Array.isArray(result))
+					result = result[result.length-1];
+				onCompleted(null, result.rows);
+			}
 		}
 	}
 

package/src/sap/newDatabase.js

@@ -47,7 +47,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

package/src/sap/newTransaction.js

@@ -8,12 +8,63 @@ const insertSql = require('./insertSql');
 const insert = require('./insert');
 const limitAndOffset = require('./limitAndOffset');
 
-function newResolveTransaction(domain, pool) {
+function newResolveTransaction(domain, pool, { readonly } = {}) {
 	var rdb = {poolFactory: pool};
 	if (!pool.connect) {
 		pool = pool();
 		rdb.pool = pool;
 	}
+	rdb.engine = 'sap';
+	rdb.encodeBoolean = encodeBoolean;
+	rdb.decodeJSON = decodeJSON;
+	rdb.encodeJSON = JSON.stringify;
+	rdb.deleteFromSql = deleteFromSql;
+	rdb.selectForUpdateSql = selectForUpdateSql;
+	rdb.formatDateOut = formatDateOut;
+	rdb.lastInsertedSql = lastInsertedSql;
+	rdb.insertSql = insertSql;
+	rdb.insert = insert;
+	rdb.lastInsertedIsSeparate = true;
+	rdb.multipleStatements = false;
+	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.visitSap();
+	};
+	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);
@@ -25,35 +76,8 @@ function newResolveTransaction(domain, pool) {
 					return;
 				}
 				client.executeQuery = wrapQuery(client);
-				rdb.engine = 'sap';
 				rdb.dbClient = client;
 				rdb.dbClientDone = done;
-				rdb.encodeBoolean = encodeBoolean;
-				rdb.decodeJSON = decodeJSON;
-				rdb.encodeJSON = JSON.stringify;
-				rdb.deleteFromSql = deleteFromSql;
-				rdb.selectForUpdateSql = selectForUpdateSql;
-				rdb.formatDateOut = formatDateOut;
-				rdb.lastInsertedSql = lastInsertedSql;
-				rdb.insertSql = insertSql;
-				rdb.insert = insert;
-				rdb.lastInsertedIsSeparate = true;
-				rdb.multipleStatements = false;
-				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.visitSap();
-				};
-				rdb.aggregateCount = 0;
-				rdb.quote = (name) => `[${name}]`;
 				domain.rdb = rdb;
 				onSuccess();
 			} catch (e) {

package/src/sqlite/newDatabase.js

@@ -47,7 +47,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

package/src/sqlite/newTransaction.js

@@ -7,12 +7,52 @@ 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 = 'sqlite';
+	rdb.encodeBoolean = encodeBoolean;
+	rdb.decodeJSON = decodeJSON;
+	rdb.encodeJSON = JSON.stringify;
+	rdb.deleteFromSql = deleteFromSql;
+	rdb.selectForUpdateSql = selectForUpdateSql;
+	rdb.lastInsertedSql = lastInsertedSql;
+	rdb.insertSql = insertSql;
+	rdb.insert = insert;
+	rdb.lastInsertedIsSeparate = true;
+	rdb.multipleStatements = false;
+	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 {
+						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);
@@ -24,25 +64,8 @@ function newResolveTransaction(domain, pool) {
 					return;
 				}
 				client.executeQuery = wrapQuery(client);
-				rdb.engine = 'sqlite';
 				rdb.dbClient = client;
 				rdb.dbClientDone = done;
-				rdb.encodeBoolean = encodeBoolean;
-				rdb.decodeJSON = decodeJSON;
-				rdb.encodeJSON = JSON.stringify;
-				rdb.deleteFromSql = deleteFromSql;
-				rdb.selectForUpdateSql = selectForUpdateSql;
-				rdb.lastInsertedSql = lastInsertedSql;
-				rdb.insertSql = insertSql;
-				rdb.insert = insert;
-				rdb.lastInsertedIsSeparate = true;
-				rdb.multipleStatements = false;
-				rdb.limitAndOffset = limitAndOffset;
-				rdb.accept = function(caller) {
-					caller.visitSqlite();
-				};
-				rdb.aggregateCount = 0;
-				rdb.quote = (name) => `"${name}"`;
 				domain.rdb = rdb;
 				onSuccess();
 			} catch (e) {

package/src/tedious/newDatabase.js

@@ -47,7 +47,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)
@@ -60,7 +60,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

package/src/tedious/newTransaction.js

@@ -10,12 +10,64 @@ const formatJSONOut = require('./formatJSONOut');
 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 = 'mssql';
+	rdb.getManyDto = getManyDto;
+	rdb.encodeBoolean = encodeBoolean;
+	rdb.decodeJSON = decodeJSON;
+	rdb.encodeJSON = JSON.stringify;
+	rdb.deleteFromSql = deleteFromSql;
+	rdb.selectForUpdateSql = selectForUpdateSql;
+	rdb.outputInsertedSql = outputInsertedSql;
+	rdb.lastInsertedIsSeparate = false;
+	rdb.insertSql = insertSql;
+	rdb.insert = insert;
+	rdb.formatDateOut = formatDateOut;
+	rdb.formatJSONOut = formatJSONOut;
+	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 {
+						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);
@@ -27,37 +79,8 @@ function newResolveTransaction(domain, pool) {
 					return;
 				}
 				client.executeQuery = wrapQuery(client);
-				rdb.engine = 'mssql';
-				rdb.getManyDto = getManyDto;
 				rdb.dbClient = client;
 				rdb.dbClientDone = done;
-				rdb.encodeBoolean = encodeBoolean;
-				rdb.decodeJSON = decodeJSON;
-				rdb.encodeJSON = JSON.stringify;
-				rdb.deleteFromSql = deleteFromSql;
-				rdb.selectForUpdateSql = selectForUpdateSql;
-				rdb.outputInsertedSql = outputInsertedSql;
-				rdb.lastInsertedIsSeparate = false;
-				rdb.insertSql = insertSql;
-				rdb.insert = insert;
-				rdb.formatDateOut = formatDateOut;
-				rdb.formatJSONOut = formatJSONOut;
-				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) {

package/src/getManyDto2.js

@@ -1,301 +0,0 @@
-const emptyFilter = require('./emptyFilter');
-const newQuery = require('./getManyDto/newQuery');
-const negotiateRawSqlFilter = require('./table/column/negotiateRawSqlFilter');
-const strategyToSpan = require('./table/strategyToSpan');
-const executeQueries = require('./table/executeQueries');
-
-async function getManyDto(table, filter, strategy, spanFromParent) {
-	filter = negotiateRawSqlFilter(filter, table);
-	if (strategy && strategy.where) {
-		let arg = typeof strategy.where === 'function' ? strategy.where(table) : strategy.where;
-		filter = filter.and(arg);
-	}
-
-	let span = spanFromParent || strategyToSpan(table, strategy);
-	let alias = table._dbName;
-
-	const query = newQuery(table, filter, span, alias);
-	const res = await executeQueries([query]);
-	return decode(strategy, span, await res[0]);
-}
-
-function newCreateRow(span) {
-	let columnsMap = span.columns;
-	const columns = span.table._columns.filter(column => !columnsMap || columnsMap.get(column));
-	const protoRow = createProto(columns, span);
-	const manyNames = [];
-
-	const c = {};
-	c.visitJoin = () => { };
-	c.visitOne = () => { };
-	c.visitMany = function(leg) {
-		manyNames.push(leg.name);
-	};
-
-	span.legs.forEach(onEachLeg);
-	return createRow;
-
-	function onEachLeg(leg) {
-		leg.accept(c);
-	}
-
-	function createRow() {
-		const obj = Object.create(protoRow);
-		for (let i = 0; i < manyNames.length; i++) {
-			obj[manyNames[i]] = [];
-		}
-		return obj;
-	}
-}
-
-function createProto(columns, span) {
-	let obj = {};
-	for (let i = 0; i < columns.length; i++) {
-		obj[columns[i].alias] = null;
-	}
-	for (let key in span.aggregates) {
-		obj[key] = null;
-	}
-	const c = {};
-
-	c.visitJoin = function(leg) {
-		obj[leg.name] = null;
-	};
-	c.visitOne = c.visitJoin;
-	c.visitMany = function(leg) {
-		obj[leg.name] = null;
-	};
-
-	span.legs.forEach(onEachLeg);
-
-	function onEachLeg(leg) {
-		leg.accept(c);
-	}
-
-	return obj;
-}
-
-function hasManyRelations(span) {
-	let result;
-	const c = {};
-	c.visitJoin = () => { };
-	c.visitOne = c.visitJoin;
-	c.visitMany = function() {
-		result = true;
-	};
-
-	span.legs.forEach(onEachLeg);
-	return result;
-
-	function onEachLeg(leg) {
-		leg.accept(c);
-	}
-}
-
-async function decode(strategy, span, rows, keys = rows.length > 0 ? Object.keys(rows[0]) : []) {
-	const table = span.table;
-	let columnsMap = span.columns;
-	const columns = table._columns.filter(column => !columnsMap || columnsMap.get(column));
-	const rowsLength = rows.length;
-	const columnsLength = columns.length;
-	const primaryColumns = table._primaryColumns;
-	const primaryColumnsLength = primaryColumns.length;
-	const rowsMap = new Map();
-	const fkIds = new Array(rows.length);
-	const getIds = createGetIds();
-	const aggregateKeys = Object.keys(span.aggregates);
-
-	const outRows = new Array(rowsLength);
-	const createRow = newCreateRow(span);
-	const shouldCreateMap = hasManyRelations(span);
-	for (let i = 0; i < rowsLength; i++) {
-		const row = rows[i];
-		let outRow = createRow();
-		let pkWithNullCount = 0;
-		for (let j = 0; j < primaryColumnsLength; j++) {
-			if (row[keys[j]] === null)
-				pkWithNullCount++;
-			if (pkWithNullCount === primaryColumnsLength) {
-				outRow = null;
-				break;
-			}
-			const column = columns[j];
-			outRow[column.alias] = column.decode(row[keys[j]]);
-		}
-
-		outRows[i] = outRow;
-		if (shouldCreateMap) {
-			fkIds[i] = getIds(outRow);
-			addToMap(rowsMap, primaryColumns, outRow);
-		}
-	}	
-	span._rowsMap = rowsMap;
-	span._ids = fkIds;
-	const manyPromise = decodeManyRelations(strategy, span, rows, outRows, keys);
-
-	for (let i = 0; i < rowsLength; i++) {
-		const row = rows[i];
-		let outRow = outRows[i];
-		if (outRow === null)
-			continue;
-		for (let j = primaryColumnsLength; j < columnsLength; j++) {
-			const column = columns[j];
-			outRow[column.alias] = column.decode(row[keys[j]]);
-		}
-
-		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]]);
-		}
-	}
-	
-
-	keys.splice(0, columnsLength + aggregateKeys.length);
-
-	await decodeRelations(strategy, span, rows, outRows, keys);
-	await manyPromise;
-	return outRows;
-
-
-	function createGetIds() {
-		const primaryColumns = table._primaryColumns;
-		const length = primaryColumns.length;
-		if (length === 1) {
-			const alias = table._primaryColumns[0].alias;
-			return (row) => row[alias];
-		}
-		else
-			return (row) => {
-				const result = new Array(length);
-				for (let i = 0; i < length; i++) {
-					result[i] = row[primaryColumns[i].alias];
-				}
-				return result;
-			};
-	}
-
-}
-
-async function decodeManyRelations(strategy, span, rawRows, resultRows, keys) {
-	const promises = [];
-	const c = {};
-	c.visitJoin = () => {};
-	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);
-}
-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;
-
-	if (columns.length === 1)
-		return columns[0].in(ids);
-
-	else
-		return createCompositeFilter();
-
-	function createCompositeFilter() {
-		let filter = emptyFilter;
-		for(let id of ids) {
-			let nextFilter;
-			for (let i = 0; i < columns.length; i++) {
-				if (nextFilter)
-					nextFilter = nextFilter.and(columns[i].eq(id[i]));
-				else
-					nextFilter = columns[i].eq(id[i]);
-			}
-			filter = filter.or(nextFilter);
-		}
-		return filter;
-	}
-}
-
-function addToMap(map, primaryColumns, row) {
-
-	const lastIndex = primaryColumns.length - 1;
-	for (let i = 0; i < lastIndex; i++) {
-		const id = row[primaryColumns[i].alias];
-		if (map.has(id))
-			map = map.get(id);
-		else {
-			const next = new Map();
-			map.set(id, next);
-			map = next;
-		}
-	}
-	map.set(row[primaryColumns[lastIndex].alias], row);
-}
-
-function getFromMap(map, primaryColumns, values) {
-	const length = primaryColumns.length;
-	for (let i = 0; i < length; i++) {
-		map = map.get(values[i]);
-	}
-	return map;
-}
-
-
-module.exports = getManyDto;