orange-orm 4.4.0-beta.1 → 4.5.0-beta.0

package/src/client/map.js

@@ -48,6 +48,7 @@ function map(index, context, providers, fn) {
 	context.sap = connect.bind(null, 'sap');
 	context.oracle = connect.bind(null, 'oracle');
 	context.sqlite = connect.bind(null, 'sqlite');
+	context.d1 = connect.bind(null, 'd1');
 	context.http = function(url) {
 		return index({ db: url, providers});
 	};

package/src/d1/newDatabase.js

@@ -0,0 +1,133 @@
+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 useHook = require('../useHook');
+let promise = require('promise/domains');
+let versionArray = process.version.replace('v', '').split('.');
+let major = parseInt(versionArray[0]);
+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)
+		throw new Error('Missing d1Database');
+	var pool;
+	if (!poolOptions)
+		pool = newPool.bind(null,d1Database, poolOptions);
+	else
+		pool = newPool(d1Database, 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 if ((major >= 12) && useHook()) {
+			domain.exitContext = true;
+			return domain.start().then(run);
+		}
+		else
+			return domain.run(run);
+
+		function begin() {
+			const transactionLess = true;
+			return _begin(transactionLess);
+		}
+
+		async function runInTransaction() {
+			let result;
+			let transaction = newTransaction(domain, pool, options);
+			await new Promise(transaction)
+				.then(begin)
+				.then(fn)
+				.then((res) => result = res)
+				.then(c.commit)
+				.then(null, c.rollback);
+			return result;
+		}
+
+		function run() {
+			let p;
+			let transaction = newTransaction(domain, pool, options);
+			if (useHook())
+				p = new Promise(transaction);
+			else
+				p = new promise(transaction);
+
+			return p.then(begin);
+		}
+
+	};
+
+	c.createTransaction = function() {
+		let domain = createDomain();
+		let transaction = newTransaction(domain, pool);
+		let p = domain.run(() => new Promise(transaction).then(_begin));
+
+		function run(fn) {
+			return p.then(domain.run.bind(domain, fn));
+		}
+		return run;
+	};
+
+	c.bindTransaction = function() {
+		// @ts-ignore
+		var domain = process.domain;
+		let p = domain.run(() => true);
+
+		function run(fn) {
+			return p.then(domain.run.bind(domain, fn));
+		}
+		return run;
+	};
+
+	c.query = function(query) {
+		let domain = createDomain();
+		let transaction = newTransaction(domain, pool);
+		let p = domain.run(() => new Promise(transaction)
+			.then(() => setSessionSingleton('changes', []))
+			.then(() => doQuery(query).then(onResult, onError)));
+		return p;
+
+		function onResult(result) {
+			releaseDbClient();
+			return result;
+		}
+
+		function onError(e) {
+			releaseDbClient();
+			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/d1/newPool.js

@@ -0,0 +1,19 @@
+var pools = require('../pools');
+var promise = require('../table/promise');
+var end = require('./pool/end');
+var newGenericPool = require('./pool/newGenericPool');
+var newId = require('../newId');
+
+function newPool(d1Database, poolOptions) {
+	var pool = newGenericPool(d1Database, poolOptions);
+	var id = newId();
+	var boundEnd = end.bind(null, pool, id);
+	var c = {};
+
+	c.connect = pool.connect;
+	c.end = promise.denodeify(boundEnd);
+	pools[id] = c;
+	return c;
+}
+
+module.exports = newPool;

package/src/d1/newTransaction.js

@@ -0,0 +1,82 @@
+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');
+
+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 = (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, 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/d1/pool/defaults.js

@@ -0,0 +1,45 @@
+module.exports = {
+	// database host defaults to localhost
+	host: 'localhost',
+
+	//database user's name
+	user: process.platform === 'win32' ? process.env.USERNAME : process.env.USER,
+
+	//name of database to connect
+	database: process.platform === 'win32' ? process.env.USERNAME : process.env.USER,
+
+	//database user's password
+	password: null,
+
+	//database port
+	port: 5432,
+
+	//number of rows to return at a time from a prepared statement's
+	//portal. 0 will return all rows at once
+	rows: 0,
+
+	// binary result mode
+	binary: false,
+
+	//Connection pool options - see https://github.com/coopernurse/node-pool
+	//number of connections to use in connection pool
+	//0 will disable connection pooling
+	poolSize: 0,
+
+	//max milliseconds a client can go unused before it is removed
+	//from the pool and destroyed
+	poolIdleTimeout: 30000,
+
+	//frequeny to check for idle clients within the client pool
+	reapIntervalMillis: 1000,
+
+	//pool log function / boolean
+	poolLog: false,
+
+	client_encoding: '',
+
+	ssl: false,
+
+	application_name : undefined,
+	fallback_application_name: undefined
+};

package/src/d1/pool/end.js

@@ -0,0 +1,13 @@
+var pools = require('../../pools');
+
+function endPool(genericPool, id, done) {
+	genericPool.drain(onDrained);
+
+	function onDrained() {
+		genericPool.destroyAllNow();
+		delete pools[id];
+		done();
+	}
+}
+
+module.exports = endPool;

package/src/d1/pool/newGenericPool.js

@@ -0,0 +1,52 @@
+/* eslint-disable no-prototype-builtins */
+var EventEmitter = require('events').EventEmitter;
+
+var defaults = require('./defaults');
+var genericPool = require('../../generic-pool');
+
+function newGenericPool(d1Database, poolOptions) {
+	poolOptions = poolOptions || {};
+	// @ts-ignore
+	var pool = genericPool.Pool({
+		max: 1,
+		idleTimeoutMillis: poolOptions.idleTimeout || defaults.poolIdleTimeout,
+		reapIntervalMillis: poolOptions.reapIntervalMillis || defaults.reapIntervalMillis,
+		log: poolOptions.log || defaults.poolLog,
+		create: function(cb) {
+			var client = {d1: d1Database, poolCount: 0};
+
+			return cb(null, client);
+		},
+
+		destroy: function() {
+		}
+	});
+	//mixin EventEmitter to pool
+	EventEmitter.call(pool);
+	for(var key in EventEmitter.prototype) {
+		if(EventEmitter.prototype.hasOwnProperty(key)) {
+			pool[key] = EventEmitter.prototype[key];
+		}
+	}
+	//monkey-patch with connect method
+	pool.connect = function(cb) {
+		var domain = process.domain;
+		pool.acquire(function(err, client) {
+			if(domain) {
+				cb = domain.bind(cb);
+			}
+			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/d1/wrapQuery.js

@@ -0,0 +1,22 @@
+var log = require('../table/log');
+
+function wrapQuery(client) {
+
+	return runQuery;
+
+	function runQuery(query, onCompleted) {
+
+		var params = query.parameters;
+		var sql = query.sql();
+		log.emitQuery({sql, parameters: params});
+		client.d1.prepare(sql, params).bind(...params).all().then(onInnerCompleted, onCompleted);
+
+		function onInnerCompleted(response) {
+			onCompleted(null, response.results);
+		}
+
+	}
+
+}
+
+module.exports = wrapQuery;

package/src/d1test.js

@@ -0,0 +1,35 @@
+import { connect } from '@cloudflare/d1';
+
+const databaseId = process.env.D1_DATABASE_ID;
+const accountId = process.env.D1_ACCOUNT_ID;
+const apiToken = process.env.D1_API_TOKEN;
+
+export class Database {
+	constructor() {
+		this.db = connect({
+			databaseId,
+			accountId,
+			apiToken,
+		});
+	}
+
+	async createUser(name, email) {
+		return await this.db
+			.prepare('INSERT INTO users (name, email) VALUES (?, ?)')
+			.bind(name, email)
+			.run();
+	}
+
+	async getUsers() {
+		return await this.db
+			.prepare('SELECT * FROM users')
+			.all();
+	}
+
+	async getUserById(id) {
+		return await this.db
+			.prepare('SELECT * FROM users WHERE id = ?')
+			.bind(id)
+			.first();
+	}
+}

package/src/index.d.ts

@@ -1,5 +1,6 @@
 import type { Options } from './ajv';
 import type { RequestHandler } from 'express';
+import type { D1Database } from '@cloudflare/workers-types';
 import type { ConnectionConfiguration } from 'tedious';
 import type { PoolAttributes } from 'oracledb';
 import type { AllowedDbMap, DbMapper, MappedDbDef } from './map';
@@ -10,6 +11,7 @@ declare namespace r {
 
     function table(name: string): Table;
     function end(): Promise<void>;
+    function d1(database: D1Database, options?: PoolOptions): Pool;
     function postgres(connectionString: string, options?: PoolOptions): Pool;
     function sqlite(connectionString: string, options?: PoolOptions): Pool;
     function sap(connectionString: string, options?: PoolOptions): Pool;

package/src/index.js

@@ -2,6 +2,7 @@ var hostExpress = require('./hostExpress');
 var client = require('./client/index.js');
 var _mySql;
 var _pg;
+var _d1;
 var _sqlite;
 var _mssqlNative;
 var _sap;
@@ -76,6 +77,14 @@ Object.defineProperty(connectViaPool, 'sqlite', {
 	}
 });
 
+Object.defineProperty(connectViaPool, 'd1', {
+	get: function() {
+		if (!_d1)
+			_d1 = require('./d1/newDatabase');
+		return _d1;
+	}
+});
+
 Object.defineProperty(connectViaPool, 'mssqlNative', {
 	get: function() {
 		if (!_mssqlNative)

package/src/map.d.ts

@@ -1,5 +1,6 @@
 import type { Options } from './ajv';
 import type { ConnectionConfiguration } from 'tedious';
+import type { D1Database } from '@cloudflare/workers-types';
 import type { PoolAttributes } from 'oracledb';
 import type { AxiosInterceptorManager, InternalAxiosRequestConfig, AxiosResponse } from 'axios';
 
@@ -29,6 +30,7 @@ type MappedDb<T> = {
 
 type DbConnectable<T> = {
 	http(url: string): MappedDbInstance<T>;
+	d1(database: D1Database): MappedDbInstance<T>;
 	postgres(connectionString: string, options?: PoolOptions): MappedDbInstance<T>;
 	sqlite(connectionString: string, options?: PoolOptions): MappedDbInstance<T>;
 	sap(connectionString: string, options?: PoolOptions): MappedDbInstance<T>;
@@ -59,6 +61,7 @@ type DbOptions<T> = {
 
 interface Connectors {
 	http(url: string): Pool;
+	d1(database: D1Database): Pool;
 	postgres(connectionString: string, options?: PoolOptions): Pool;
 	sqlite(connectionString: string, options?: PoolOptions): Pool;
 	sap(connectionString: string, options?: PoolOptions): Pool;

package/src/mssql/newTransaction.js

@@ -8,7 +8,7 @@ const formatDateOut = require('../tedious/formatDateOut');
 const insertSql = require('../tedious/insertSql');
 const insert = require('../tedious/insert');
 
-function newResolveTransaction(domain, pool, { readonly } = {}) {
+function newResolveTransaction(domain, pool, { readonly = false } = {}) {
 	var rdb = {poolFactory: pool};
 	if (!pool.connect) {
 		pool = pool();

package/src/mySql/newTransaction.js

@@ -7,7 +7,7 @@ const limitAndOffset = require('./limitAndOffset');
 const insertSql = require('./insertSql');
 const insert = require('./insert');
 
-function newResolveTransaction(domain, pool, { readonly } = {}) {
+function newResolveTransaction(domain, pool, { readonly = false } = {}) {
 	var rdb = {poolFactory: pool};
 	if (!pool.connect) {
 		pool = pool();

package/src/oracle/newTransaction.js

@@ -9,7 +9,7 @@ const insert = require('./insert');
 const formatDateOut = require('./formatDateOut');
 const formatDateIn = require('./formatDateIn');
 
-function newResolveTransaction(domain, pool, { readonly } = {}) {
+function newResolveTransaction(domain, pool, { readonly = false } = {}) {
 	var rdb = {poolFactory: pool};
 	if (!pool.connect) {
 		pool = pool();

package/src/pg/newTransaction.js

@@ -9,7 +9,7 @@ var encodeJSON = require('./encodeJSON');
 var insertSql = require('./insertSql');
 var insert = require('./insert');
 
-function newResolveTransaction(domain, pool, { readonly } = {}) {
+function newResolveTransaction(domain, pool, { readonly = false } = {}) {
 	var rdb = { poolFactory: pool };
 	if (!pool.connect) {
 		pool = pool();

package/src/sap/newTransaction.js

@@ -8,7 +8,7 @@ const insertSql = require('./insertSql');
 const insert = require('./insert');
 const limitAndOffset = require('./limitAndOffset');
 
-function newResolveTransaction(domain, pool, { readonly } = {}) {
+function newResolveTransaction(domain, pool, { readonly = false } = {}) {
 	var rdb = {poolFactory: pool};
 	if (!pool.connect) {
 		pool = pool();

package/src/sqlite/newTransaction.js

@@ -7,7 +7,7 @@ const limitAndOffset = require('./limitAndOffset');
 const insertSql = require('./insertSql');
 const insert = require('./insert');
 
-function newResolveTransaction(domain, pool, { readonly } = {})  {
+function newResolveTransaction(domain, pool, { readonly = false } = {})  {
 	var rdb = {poolFactory: pool};
 	if (!pool.connect) {
 		pool = pool();

package/src/table/begin.js

@@ -5,7 +5,7 @@ let setSessionSingleton = require('./setSessionSingleton');
 function begin(readonly) {
 	setSessionSingleton('changes', []);
 	if (readonly) {
-		setSessionSingleton('readonly', true);
+		setSessionSingleton('transactionLess', true);
 		return Promise.resolve();
 	}
 	return executeQuery(beginCommand());

package/src/table/commit.js

@@ -20,7 +20,7 @@ function commit(result) {
 			await executeChanges(changes);
 			changes = popChanges();
 		}
-		if (!getSessionSingleton('readonly'))
+		if (!getSessionSingleton('transactionLess'))
 			pushCommand(commitCommand);
 		return executeChanges(popChanges());
 	}

package/src/tedious/newTransaction.js

@@ -10,7 +10,7 @@ const formatJSONOut = require('./formatJSONOut');
 const insertSql = require('./insertSql');
 const insert = require('./insert');
 
-function newResolveTransaction(domain, pool, { readonly } = {}) {
+function newResolveTransaction(domain, pool, { readonly = false } = {}) {
 	var rdb = {poolFactory: pool};
 	if (!pool.connect) {
 		pool = pool();