orange-orm 4.5.0 → 4.5.1-beta.1

package/src/nodeSqlite/newDatabase.js

@@ -0,0 +1,116 @@
+let createDomain = require('../createDomain');
+let newTransaction = require('./newTransaction');
+let _begin = require('../table/begin');
+let commit = require('../table/commit');
+let rollback = require('../table/rollback');
+let newPool = require('./newPool');
+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)
+		throw new Error('Connection string cannot be empty');
+	var pool;
+	if (!poolOptions)
+		pool = newPool.bind(null,connectionString, poolOptions);
+	else
+		pool = newPool(connectionString, poolOptions);
+
+	let c = {poolFactory: pool, hostLocal, express};
+
+	c.transaction = function(options, fn) {
+		if ((arguments.length === 1) && (typeof options === 'function')) {
+			fn = options;
+			options = undefined;
+		}
+		let domain = createDomain();
+
+		if (fn)
+			return domain.run(runInTransaction);
+		else
+			return domain.run(run);
+
+		function begin() {
+			return _begin(domain, options);
+		}
+
+		async function runInTransaction() {
+			let result;
+			let transaction = newTransaction(domain, pool, options);
+			await new Promise(transaction)
+				.then(begin)
+				.then(() => fn(domain))
+				.then((res) => result = res)
+				.then(() => commit(domain))
+				.then(null, (e) => rollback(domain, e));
+			return result;
+		}
+
+		function run() {
+			let p;
+			let transaction = newTransaction(domain, pool, options);
+			p = new Promise(transaction);
+
+			return p.then(begin);
+		}
+
+	};
+
+	c.createTransaction = function(options) {
+		let domain = createDomain();
+		let transaction = newTransaction(domain, pool);
+		let p = domain.run(() => new Promise(transaction).then(begin));
+
+		function run(fn) {
+			return p.then(() => fn(domain));
+		}
+		run.rollback = rollback.bind(null, domain);
+		run.commit = commit.bind(null, domain);
+		return run;
+
+		function begin() {
+			return _begin(domain, options);
+		}
+	};
+
+	c.query = function(query) {
+		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;
+
+		function onResult(result) {
+			releaseDbClient(domain);
+			return result;
+		}
+
+		function onError(e) {
+			releaseDbClient(domain);
+			throw e;
+		}
+	};
+
+
+	c.rollback = rollback;
+	c.commit = commit;
+
+	c.end = function() {
+		if (poolOptions)
+			return pool.end();
+		else
+			return Promise.resolve();
+	};
+
+	c.accept = function(caller) {
+		caller.visitSqlite();
+	};
+
+	return c;
+}
+
+module.exports = newDatabase;

package/src/nodeSqlite/newPool.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;

package/src/nodeSqlite/newTransaction.js

@@ -0,0 +1,87 @@
+const wrapQuery = require('./wrapQuery');
+const encodeBoolean = require('../sqlite/encodeBoolean');
+const encodeBinary = require('./encodeBinary');
+const decodeBinary = require('./decodeBinary');
+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.encodeBinary = encodeBinary;
+	rdb.decodeBinary = decodeBinary;
+	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;

package/src/nodeSqlite/pool/newGenericPool.js

@@ -0,0 +1,50 @@
+/* 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 {
+				if (!sqlite)
+					sqlite = await import('node:sqlite');
+				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;

package/src/nodeSqlite/wrapQuery.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;

package/src/oracle/pool/newGenericPool.js

@@ -3,10 +3,7 @@
 
 var defaults = require('../../poolDefaults');
 var genericPool = require('../../generic-pool');
-var oracle = require('oracledb');
-
-oracle.outFormat = oracle.OUT_FORMAT_OBJECT;
-oracle.fetchAsBuffer = [ oracle.BLOB ];
+var oracle;
 
 function newGenericPool(connectionString, poolOptions) {
 	poolOptions = poolOptions || {};
@@ -15,8 +12,19 @@ function newGenericPool(connectionString, poolOptions) {
 		idleTimeoutMillis: poolOptions.idleTimeout || defaults.poolIdleTimeout,
 		reapIntervalMillis: poolOptions.reapIntervalMillis || defaults.reapIntervalMillis,
 		log: poolOptions.log,
-		create: function(cb) {
+		create: async function(cb) {
 			var client;
+			try {
+				if (!oracle) {
+					oracle = await import('oracledb');
+					oracle = oracle.default || oracle;
+					oracle.outFormat = oracle.OUT_FORMAT_OBJECT;
+					oracle.fetchAsBuffer = [ oracle.BLOB ];
+				}
+			}
+			catch (err) {
+				return cb(err, null);
+			}
 			oracle.getConnection(connectionString, onConnected);
 			function onConnected(err, _client) {
 				client = _client;

package/src/pg/newDatabase.js

@@ -11,11 +11,6 @@ let hostLocal = require('../hostLocal');
 let doQuery = require('../query');
 let releaseDbClient = require('../table/releaseDbClient');
 let setSessionSingleton = require('../table/setSessionSingleton');
-let types = require('pg').types;
-
-types.setTypeParser(1700, function(val) {
-	return parseFloat(val);
-});
 
 function newDatabase(connectionString, poolOptions) {
 	if (!connectionString)

package/src/pg/pool/newPgPool.js

@@ -4,12 +4,11 @@ var log = require('../../table/log');
 
 var defaults = require('../../poolDefaults');
 var genericPool = require('../../generic-pool');
-var _pg = require('pg');
+var pg;
 var parseSearchPathParam = require('./parseSearchPathParam');
 
 function newPgPool(connectionString, poolOptions) {
 	poolOptions = poolOptions || {};
-	let pg = poolOptions.native ? _pg.native : _pg;
 
 	// @ts-ignore
 	var pool = genericPool.Pool({
@@ -17,7 +16,20 @@ function newPgPool(connectionString, poolOptions) {
 		idleTimeoutMillis: poolOptions.idleTimeout || defaults.poolIdleTimeout,
 		reapIntervalMillis: poolOptions.reapIntervalMillis || defaults.reapIntervalMillis,
 		log: poolOptions.log,
-		create: function(cb) {
+		create: async function(cb) {
+			try {
+				if (!pg) {
+					pg = await import('pg');
+					pg  = pg.default || pg;
+					let types = pg.types || pg.types;
+					types.setTypeParser(1700, function(val) {
+						return parseFloat(val);
+					});
+				}
+			}
+			catch(e) {
+				return cb(e, null);
+			}
 			var client = new pg.Client(connectionString);
 			client.connect(function(err) {
 				if (err) return cb(err, null);

package/src/{client/rollup.config.js → rollup.config.browser.js}

@@ -5,7 +5,7 @@ import nodeResolve from '@rollup/plugin-node-resolve';
 export default {
 	input: './src/indexBrowser.js',
 	output: {
-		file: './src/client/index.mjs',
+		file: './dist/index.browser.mjs',
 		format: 'esm',
 		interop: 'auto'
 	},

package/src/rollup.config.server.js

@@ -0,0 +1,32 @@
+import json from '@rollup/plugin-json';
+import commonjs from '@rollup/plugin-commonjs';
+import nodeResolve from '@rollup/plugin-node-resolve';
+
+export default {
+	input: './src/index.js',
+	output: {
+		file: './dist/index.mjs',
+		format: 'esm',
+		interop: 'auto'
+	},
+
+	// plugins: [json(), commonjs()],
+	plugins: [json(), nodeResolve({ preferBuiltins: false }), commonjs({
+		transformMixedEsModules: true,
+		esmExternals: true,      // Add this
+		requireReturnsDefault: 'preferred'  // Change this
+	})],
+	external(id) {
+		// If it's in node_modules, mark as external
+		return id.includes('node_modules');
+	},
+	onwarn: (warning, warn) => {
+		if (warning.code === 'CIRCULAR_DEPENDENCY') {
+			// Log the full circular dependency warning message
+			console.warn(`[CIRCULAR DEPENDENCY] ${warning.message}`);
+		} else {
+			// For all other warnings, use Rollup's default handler.
+			warn(warning);
+		}
+	},
+};

package/src/runtimes.js

@@ -0,0 +1,24 @@
+// @ts-ignore
+// eslint-disable-next-line no-undef
+const deno = typeof Deno !== 'undefined' && Deno.version?.deno;
+// @ts-ignore
+// eslint-disable-next-line no-undef
+const bun = typeof Bun !== 'undefined' && Bun.version;
+const node = (typeof process !== 'undefined' && process.versions?.node && !deno && !bun) ? process.versions.node : false;
+
+function parseVersion(version) {
+	if (version) {
+		const versionArray = version.split('.');
+		return {
+			version,
+			major: parseInt(versionArray[0]),
+			minor: parseInt(versionArray[1]),
+			patch: parseInt(versionArray[2])
+		};
+	}
+	else
+		return false;
+}
+
+
+module.exports = { deno: parseVersion(deno), bun: parseVersion(bun), node: parseVersion(node) };

package/src/sqlite3/deleteFromSql.js

@@ -0,0 +1,10 @@
+const format = 'delete from %s where %s.rowId in (SELECT %s.rowId FROM %s %s%s)';
+const formatString = require('../format');
+const quote = require('./quote');
+
+function deleteFromSql(table, alias, whereSql) {
+	const name = quote(table._dbName);
+	alias = quote(alias);
+	return formatString(format, name, name, alias, name, alias, whereSql);
+}
+module.exports = deleteFromSql;

package/src/sqlite3/encodeBoolean.js

@@ -0,0 +1,7 @@
+function encodeBoolean(bool) {
+	if (bool)
+		return 1;
+	return 0;
+}
+
+module.exports = encodeBoolean;

package/src/sqlite3/encodeBuffer.js

@@ -0,0 +1,7 @@
+//unused because using sql parameters instead
+//Remove ?
+function encodeBuffer(buffer) {
+	return 'E\'\\\\x' + buffer.toString('hex') + '\'';
+}
+
+module.exports = encodeBuffer;

package/src/sqlite3/insert.js

@@ -0,0 +1,21 @@
+let newInsertCommand = require('../table/commands/newInsertCommand');
+let newInsertCommandCore = require('../table/commands/newInsertCommandCore');
+let newGetLastInsertedCommand = require('../table/commands/newGetLastInsertedCommand');
+let executeQueries = require('../table/executeQueries');
+let pushCommand = require('../table/commands/pushCommand');
+
+
+function insertDefault(context, table, row, options) {
+	let commands = [];
+	let insertCmd = newInsertCommand(newInsertCommandCore.bind(null, context), table, row, options);
+	insertCmd.disallowCompress = true;
+	pushCommand(context, insertCmd);
+
+	let selectCmd = newGetLastInsertedCommand(context, table, row, insertCmd);
+	commands.push(selectCmd);
+
+	return executeQueries(context, commands).then((result) => result[result.length - 1]);
+
+}
+
+module.exports = insertDefault;

package/src/sqlite3/insertSql.js

@@ -0,0 +1,67 @@
+const quote = require('./quote');
+
+function insertSql(_context, table, row, options) {
+	let columnNames = [];
+	let conflictColumnUpdateSql = '';
+	let values = [];
+
+	let sql = 'INSERT INTO ' + quote(table._dbName) + ' ';
+	addDiscriminators();
+	addColumns();
+
+	if (columnNames.length === 0) {
+		sql += 'DEFAULT VALUES';
+	} else {
+		sql = sql + '(' + columnNames.join(',') + ') ' + 'VALUES (' + values.join(',') + ')' + onConflict();
+	}
+
+	return sql;
+
+	function onConflict() {
+		if (options.concurrency === 'skipOnConflict' || options.concurrency === 'overwrite') {
+			const primaryKeys = table._primaryColumns.map(x => quote(x._dbName)).join(',');
+			return ` ON CONFLICT(${primaryKeys}) ${conflictColumnUpdateSql}`;
+		} else {
+			return '';
+		}
+	}
+
+	function addDiscriminators() {
+		let discriminators = table._columnDiscriminators;
+		for (let i = 0; i < discriminators.length; i++) {
+			let parts = discriminators[i].split('=');
+			columnNames.push(quote(parts[0]));
+			values.push(parts[1]);
+		}
+	}
+
+	function addColumns() {
+		let conflictColumnUpdates = [];
+		let columns = table._columns;
+		for (let i = 0; i < columns.length; i++) {
+			let column = columns[i];
+			const columnName = quote(column._dbName);
+			if (row['__' + column.alias] !== undefined) {
+				columnNames.push(columnName);
+				values.push('%s');
+				addConflictUpdate(column);
+			}
+		}
+		if (conflictColumnUpdates.length === 0)
+			conflictColumnUpdateSql =  'DO NOTHING';
+		else
+			conflictColumnUpdateSql = 'DO UPDATE SET ' + conflictColumnUpdates.join(',');
+
+		function addConflictUpdate(column) {
+			let concurrency = options[column.alias]?.concurrency || options.concurrency;
+			const tableName = table._dbName;
+			const columnName = quote(column._dbName);
+			if (concurrency === 'overwrite') {
+				conflictColumnUpdates.push(`${columnName}=excluded.${columnName}`);
+			} else if (concurrency === 'optimistic')
+				conflictColumnUpdates.push(`${columnName} = CASE WHEN ${tableName}.${columnName} <> excluded.${columnName} THEN '12345678-1234-1234-1234-123456789012Conflict when updating ${columnName}12345678-1234-1234-1234-123456789012' ELSE ${tableName}.${columnName} END`);
+		}
+	}
+}
+
+module.exports = insertSql;

package/src/sqlite3/lastInsertedSql.js

@@ -0,0 +1,12 @@
+function lastInsertedSql(context, table, keyValues) {
+	return keyValues.map((value,i) => {
+		let column = table._primaryColumns[i];
+		if (value === undefined && column.tsType === 'NumberColumn')
+			return 'rowid IN (select last_insert_rowid())';
+		else
+			return column.eq(context, value);
+	});
+
+}
+
+module.exports = lastInsertedSql;

package/src/sqlite3/limitAndOffset.js

@@ -0,0 +1,18 @@
+function limitAndOffset(span) {
+	if (span.offset)
+		return ` limit ${limit()} offset ${span.offset}`;
+	else if (span.limit || span.limit === 0)
+		return ` limit ${span.limit}`;
+	else
+		return '';
+
+	function limit() {
+		if (span.limit || span.limit === 0)
+			return span.limit;
+		else
+			return '-1';
+	}
+
+}
+
+module.exports = limitAndOffset;