dynamic import

Author: Lars-Erik Roald

README.md

@@ -23,15 +23,15 @@ The ultimate Object Relational Mapper for Node.js and Typescript, offering seaml
 - **Works in the Browser**: You can securely use Orange in the browser by utilizing the Express.js plugin, which serves to safeguard sensitive database credentials from exposure at the client level and protect against SQL injection. This method mirrors a traditional REST API, augmented with advanced TypeScript tooling for enhanced functionality.
 
 ## Supported Databases and Runtimes
-|               | Node | Deno | Bun |
-| ------------- | :-----: | :-----: | :-----: | 
-| Postgres      | ✅ | ✅ | ✅ |
-| MS SQL        | ✅ |  | ✅ |
-| MySQL         | ✅ | ✅ | ✅ |
-| Oracle        | ✅ | ✅ | ✅ |
-| SAP ASE       | ✅ |  |  |
-| SQLite        | ✅ | ✅ | ✅ |
-| Cloudflare D1 | ✅ |  |  |
+|               | Node | Deno | Bun |Cloudflare |
+| ------------- | :-----: | :-----: | :-----: | :-----: | 
+| Postgres      | ✅ | ✅ | ✅ | ✅
+| MS SQL        | ✅ |  | ✅ | 
+| MySQL         | ✅ | ✅ | ✅ | 
+| Oracle        | ✅ | ✅ | ✅ | 
+| SAP ASE       | ✅ |  |  | 
+| SQLite        | ✅ | ✅ | ✅ | 
+| Cloudflare D1 |  |  |  | ✅
 
 
 ✅ Postgres  

src/sqlite/newDatabase.js src/bunSqlite/newDatabase.jssrc/sqlite/newDatabase.js renamed to src/bunSqlite/newDatabase.js

@@ -0,0 +1,19 @@
+const promisify = require('../promisify');
+const pools = require('../pools');
+const end = require('../sqlite/pool/end');
+const newGenericPool = require('./pool/newGenericPool');
+const newId = require('../newId');
+
+function newPool(connectionString, poolOptions) {
+	let pool = newGenericPool(connectionString, poolOptions);
+	let id = newId();
+	let boundEnd = end.bind(null, pool, id);
+	let c = {};
+
+	c.connect = pool.connect;
+	c.end = promisify(boundEnd);
+	pools[id] = c;
+	return c;
+}
+
+module.exports = newPool;

src/bunSqlite/newPool.js

@@ -0,0 +1,83 @@
+const wrapQuery = require('./wrapQuery');
+const encodeBoolean = require('../sqlite/encodeBoolean');
+const deleteFromSql = require('../sqlite/deleteFromSql');
+const selectForUpdateSql = require('../sqlite/selectForUpdateSql');
+const lastInsertedSql = require('../sqlite/lastInsertedSql');
+const limitAndOffset = require('../sqlite/limitAndOffset');
+const insertSql = require('../sqlite/insertSql');
+const insert = require('../sqlite/insert');
+const quote = require('../sqlite/quote');
+
+function newResolveTransaction(domain, pool, { readonly = false } = {})  {
+	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 = quote;
+
+	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, client, done) {
+			try {
+				if (err) {
+					onError(err);
+					return;
+				}
+				client.executeQuery = wrapQuery(client);
+				rdb.dbClient = client;
+				rdb.dbClientDone = done;
+				domain.rdb = rdb;
+				onSuccess();
+			} catch (e) {
+				onError(e);
+			}
+		}
+	};
+}
+
+function decodeJSON(value) {
+	return JSON.parse(value);
+}
+
+module.exports = newResolveTransaction;

src/bunSqlite/newTransaction.js

@@ -0,0 +1,55 @@
+/* eslint-disable no-prototype-builtins */
+var defaults = require('../../poolDefaults');
+
+var genericPool = require('../../generic-pool');
+var sqlite;
+
+function newGenericPool(connectionString, poolOptions) {
+	poolOptions = poolOptions || {};
+	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: async function(cb) {
+			try {
+				try {
+					if (!sqlite)
+						sqlite = await import('bun:sqlite');
+				}
+				catch (err) {
+					return cb(err, null);
+				}
+
+				var client = new sqlite.DatabaseSync(connectionString);
+				client.poolCount = 0;
+				cb(null, client);
+			}
+			catch(err) {
+				return cb(err, null);
+			}
+		},
+
+		destroy: function(client) {
+			client.poolCount = undefined;
+			client.close();
+		}
+	});
+	//monkey-patch with connect method
+	pool.connect = function(cb) {
+		pool.acquire(function(err, client) {
+			if(err)  return cb(err, null, function() {/*NOOP*/});
+			client.poolCount++;
+			cb(null, client, function(err) {
+				if(err) {
+					pool.destroy(client);
+				} else {
+					pool.release(client);
+				}
+			});
+		});
+	};
+	return pool;
+}
+
+module.exports = newGenericPool;

src/bunSqlite/pool/newGenericPool.js

@@ -0,0 +1,23 @@
+var log = require('../table/log');
+
+function wrapQuery(connection) {
+	return runQuery;
+
+	function runQuery(query, onCompleted) {
+		try {
+			var params = query.parameters;
+			var sql = query.sql();
+			log.emitQuery({ sql, parameters: params });
+
+			var statement = connection.prepare(sql);
+			const rows = statement.all.apply(statement, params);
+			onCompleted(null, rows);
+		}
+		catch (e) {
+			onCompleted(e);
+		}
+	}
+
+}
+
+module.exports = wrapQuery;

src/bunSqlite/wrapQuery.js

@@ -2,6 +2,8 @@ const hostExpress = require('./hostExpress');
 const hostLocal = require('./hostLocal');
 const client = require('./client/index.js');
 const map = require('./client/map');
+const runtimes = require('./runtimes');
+
 let _mySql;
 let _pg;
 let _sqlite;
@@ -70,8 +72,16 @@ Object.defineProperty(connectViaPool, 'pg', {
 
 Object.defineProperty(connectViaPool, 'sqlite', {
 	get: function() {
-		if (!_sqlite)
-			_sqlite = require('./sqlite/newDatabase');
+		if (!_sqlite) {
+			if (runtimes.deno || (runtimes.node && runtimes.node.major >= 22))
+				_sqlite = require('./nodeSqlite/newDatabase');
+			else if (runtimes.deno)
+				_sqlite = require('./denoSqlite');
+			else if (runtimes.node)
+				_sqlite = require('./sqlite3/newDatabase');
+			else
+				throw new Error('SQLite is not supported in this environment');
+		}
 		return _sqlite;
 	}
 });

src/index.js

@@ -3,7 +3,7 @@
 
 var defaults = require('../../poolDefaults');
 var genericPool = require('../../generic-pool');
-var mssql = require('msnodesqlv8');
+var mssql;
 
 function newGenericPool(connectionString, poolOptions) {
 	poolOptions = poolOptions || {};
@@ -12,7 +12,14 @@ function newGenericPool(connectionString, poolOptions) {
 		idleTimeoutMillis: poolOptions.idleTimeout || defaults.poolIdleTimeout,
 		reapIntervalMillis: poolOptions.reapIntervalMillis || defaults.reapIntervalMillis,
 		log: poolOptions.log || defaults.poolLog,
-		create: function(cb) {
+		create: async function(cb) {
+			try {
+				if (!mssql)
+					mssql = await import('msnodesqlv8');
+			}
+			catch (err) {
+				return cb(err, null);
+			}
 			var client;
 			mssql.open(connectionString, onConnected);
 

src/mssql/pool/newGenericPool.js

@@ -2,7 +2,7 @@
 /* eslint-disable no-prototype-builtins */
 var defaults = require('../../poolDefaults');
 var genericPool = require('../../generic-pool');
-var mysql = require('mysql2');
+var mysql;
 
 function newGenericPool(connectionString, poolOptions) {
 	if (typeof connectionString === 'string')
@@ -15,7 +15,16 @@ function newGenericPool(connectionString, poolOptions) {
 		idleTimeoutMillis: poolOptions.idleTimeout || defaults.poolIdleTimeout,
 		reapIntervalMillis: poolOptions.reapIntervalMillis || defaults.reapIntervalMillis,
 		log: poolOptions.log,
-		create: function(cb) {
+		create: async function(cb) {
+			try {
+				if(!mysql) {
+					mysql = await import('mysql2');
+					mysql = mysql.default || mysql;
+				}
+			}
+			catch(err) {
+				return cb(err, null);
+			}
 			var innerPool = mysql.createPool(connectionString);
 			return cb(null, innerPool);
 			// innerPool.getConnection(onConnected);