orange-orm 3.10.2

package/src/client/map.js

@@ -0,0 +1,110 @@
+const _newTable = require('../table');
+const createProviders = require('./createProviders');
+
+function mapRoot(index, fn) {
+
+	const providers = createProviders(index);
+
+	return map(index, context, providers, fn);
+
+	function context(arg) {
+
+		const tables = {};
+		for (let name in context) {
+			if (context[name] && context[name]._dbName)
+				tables[name] = context[name];
+		}
+
+		if (arg && arg.db && typeof arg.db === 'function') {
+			return index({
+				...arg,
+				db: providers(arg.db),
+				tables, providers
+			});
+		}
+		else
+			return index({
+				...arg, tables, providers
+			});
+	}
+}
+
+
+function map(index, context, providers, fn) {
+	let next = fn({ table: newTable, ...context });
+
+	for (let name in next) {
+		if (next[name] && next[name]._dbName) {
+			context[name] = next[name];
+			context[name].map = mapTable.bind(null, context[name]);
+		}
+	}
+	context.map = map.bind(null, index, context, providers);
+	context.pg = connect.bind(null, 'pg');
+	context.postgres = connect.bind(null, 'pg');
+	context.mssql = connect.bind(null, 'mssql');
+	context.mssqlNative = connect.bind(null, 'mssqlNative');
+	context.mysql = connect.bind(null, 'mysql');
+	context.sap = connect.bind(null, 'sap');
+	context.oracle = connect.bind(null, 'oracle');
+	context.sqlite = connect.bind(null, 'sqlite');
+	context.http = function(url) {
+		return index({ db: url, providers});
+	};
+
+	function connect(name, ...args) {
+		const provider = index[name];
+		const pool = provider.apply(null, args);
+
+		const tables = {};
+		for (let name in context) {
+			if (context[name] && context[name]._dbName)
+				tables[name] = context[name];
+		}
+
+		return index({ db: pool, tables, providers });
+	}
+
+	return context;
+
+	function newTable() {
+		let table = _newTable.apply(null, arguments);
+		table.map = mapTable.bind(null, table);
+		return table;
+	}
+}
+
+function mapTable(table, fn) {
+	let next = fn({ column: table.column, primaryColumn: table.primaryColumn, references: table.join, hasMany, hasOne });
+	for (let name in next) {
+		if (next[name].as)
+			next[name] = next[name].as(name);
+	}
+
+	function hasMany(to) {
+		if (!to)
+			throw new Error('Missing \'to\' table');
+		return { by };
+
+		function by() {
+			const join = to.join(table).by.apply(null, arguments);
+			return table.hasMany(join);
+		}
+	}
+
+	function hasOne(to) {
+		if (!to)
+			throw new Error('Missing \'to\' table');
+		return { by };
+
+		function by() {
+			const join = to.join(table).by.apply(null, arguments);
+			return table.hasOne(join);
+		}
+	}
+
+	return table;
+
+}
+
+module.exports = mapRoot;

package/src/client/merge.js

@@ -0,0 +1,9 @@
+const fs = require('fs').promises;
+
+async function merge() {
+	let data1 = await fs.readFile('./src/client/self.js', 'utf8');
+	let data2 = await fs.readFile('./src/client/index.mjs', 'utf8');
+	await fs.writeFile('./src/client/index.mjs', data1 + data2);
+}
+
+merge();

package/src/client/netAdapter.js

@@ -0,0 +1,133 @@
+const _axios = require('axios');
+
+function httpAdapter(baseURL, path, axiosInterceptor) {
+	//@ts-ignore
+	const axios = _axios.default ? _axios.default.create({ baseURL }) : _axios.create({ baseURL });
+	axiosInterceptor.applyTo(axios);
+
+	let c = {
+		get,
+		post,
+		patch,
+		query,
+		express
+	};
+
+	return c;
+
+	async function get() {
+		try {
+			const headers = { 'Content-Type': 'application/json', 'Accept': 'application/json' };
+			const res = await axios.request(path, { headers, method: 'get' });
+			return res.data;
+		}
+		catch (e) {
+			if (e.response?.data)
+				throw new Error(e.response?.data.replace(/^Error: /, ''));
+			else
+				throw e;
+		}
+
+	}
+
+	async function patch(body) {
+		try {
+
+			const headers = { 'Content-Type': 'application/json' };
+			const res = await axios.request(path, { headers, method: 'patch', data: body });
+			return res.data;
+		}
+		catch (e) {
+			if (e.response?.data)
+				throw new Error(e.response?.data.replace(/^Error: /, ''));
+			else
+				throw e;
+		}
+
+
+	}
+
+	async function post(body) {
+		try {
+			const headers = { 'Content-Type': 'application/json' };
+			const res = await axios.request(path, { headers, method: 'post', data: body });
+			return res.data;
+		}
+		catch (e) {
+			if (e.response?.data)
+				throw new Error(e.response?.data.replace(/^Error: /, ''));
+			else throw e;
+		}
+	}
+
+
+	function query() {
+		throw new Error('Queries are not supported through http');
+	}
+
+	function express() {
+		throw new Error('Hosting in express is not supported on the client side');
+	}
+}
+
+function netAdapter(url, tableName, { axios, tableOptions }) {
+
+	let c = {
+		get,
+		post,
+		patch,
+		query
+	};
+
+	return c;
+
+	async function get() {
+		const adapter = await getInnerAdapter();
+		return adapter.get.apply(null, arguments);
+	}
+
+	async function patch(_body) {
+		const adapter = await getInnerAdapter();
+		return adapter.patch.apply(null, arguments);
+	}
+
+	async function post(_body) {
+		const adapter = await getInnerAdapter();
+		return adapter.post.apply(null, arguments);
+	}
+
+	async function query() {
+		const adapter = await getInnerAdapter();
+		return adapter.query.apply(null, arguments);
+	}
+
+	async function getInnerAdapter() {
+		const db = await getDb();
+		if (typeof db === 'string') {
+			return httpAdapter(db, `?table=${tableName}`, axios);
+		}
+		else if (db && db.transaction) {
+			return db.hostLocal({ ...tableOptions, db, table: url });
+		}
+		else
+			throw new Error('Invalid arguments');
+	}
+
+	async function getDb() {
+		let db = tableOptions.db;
+		if (db.transaction)
+			return db;
+		if (typeof db === 'function') {
+			let dbPromise = db();
+			if (dbPromise.then)
+				db = await dbPromise;
+			else
+				db = dbPromise;
+		}
+
+		return db;
+	}
+
+}
+
+module.exports = netAdapter;

package/src/client/rollup.config.js

@@ -0,0 +1,12 @@
+import commonjs from '@rollup/plugin-commonjs';
+import nodeResolve from '@rollup/plugin-node-resolve';
+
+export default {
+	input: './src/client/index.js',
+	output: {
+		file: './src/client/index.mjs',
+		format: 'esm'
+	},
+	plugins: [commonjs(), nodeResolve({browser: true})],
+	external: ['vue']
+};

package/src/client/self.js

@@ -0,0 +1,4 @@
+void !function() {
+	typeof self === 'undefined' && typeof global === 'object'
+		? global.self = global : null;
+}();

package/src/client/stringify.js

@@ -0,0 +1,22 @@
+let dateToISOString = require('../dateToISOString');
+const isNode = (typeof window === 'undefined');
+
+function stringify(value) {
+	return JSON.stringify(value, replacer);
+}
+
+function replacer(key, value) {
+	if (isNode && isNodeBuffer(value))
+		return value.toString('base64');
+	// @ts-ignore
+	else if (value instanceof Date  && !isNaN(value))
+		return dateToISOString(value);
+	else
+		return value;
+}
+
+function isNodeBuffer(object) {
+	return Buffer.isBuffer(object);
+}
+
+module.exports = stringify;

package/src/client/toKeyPositionMap.js

@@ -0,0 +1,30 @@
+const stringify = require('./stringify');
+const { v4: uuid } = require('uuid');
+
+function toKeyPositionMap(rows, options) {
+	return rows.reduce((map, element, i) => {
+		if (options && options.keys && element === Object(element)) {
+			let key = [];
+			for (let i = 0; i < options.keys.length; i++) {
+				let keyName = options.keys[i].name;
+				key.push(negotiateTempKey(element[keyName]));
+			}
+			map[stringify(key)] = i;
+		}
+		else if ('id' in element)
+			map[stringify(element.id)] = i;
+		else
+			map[i] = i;
+		return map;
+	}, {});
+
+}
+
+function negotiateTempKey(value) {
+	if (value === undefined)
+		return `~${uuid()}`;
+	else
+		return value;
+}
+
+module.exports = toKeyPositionMap;

package/src/clsTest.js

@@ -0,0 +1,79 @@
+let cls = require('node-cls');
+const fs = require('fs');
+const log = (str) => fs.writeSync(1, `${str}\n`);
+
+function begin(id) {
+	return new Promise((resolve) => {
+		let context = cls.get();
+		context.id = id;
+		resolve();
+	});
+}
+
+function getById() {
+	return new Promise((resolve) => {
+		let context = cls.get();
+		context.id;
+		resolve(context.id);
+	});
+}
+
+async function getFromDb() {
+	let c = cls.create();
+	await c.start();
+	await begin(1);
+	await new Promise((resolve) => {
+		setTimeout(resolve(), 500);
+	});
+	await getFromDb2();
+
+	let c3 = cls.create();
+	await c3.start();
+	await begin(3);
+	let id3 = await getById();
+	if (id3 !== 3)
+		throw new Error('3 Unexpected context id : ' + id3);
+	cls.exit();
+
+	await getFromDb3();
+
+	let id = await getById();
+	if (id !== 1)
+		throw new Error('1 Unexpected context id : ' + id);
+	cls.exit();
+}
+
+function getFromDb2() {
+	return new Promise((resolve) => {
+		setTimeout(async () => {
+			let c2 = cls.create();
+			await c2.start();
+			await begin(2);
+			let id2 = await getById();
+			if (id2 !== 2)
+				throw new Error('2 Unexpected context id : ' + id2);
+			id2 = cls.active.id;
+			if (id2 !== 2)
+				throw new Error('2 Unexpected context id : ' + id2);
+			cls.exit();
+			resolve();
+		}, 500);
+	});
+}
+
+async function getFromDb3() {
+	let c3 = cls.create();
+	await c3.start();
+	await begin(3);
+	let id3 = await getById();
+	if (id3 !== 3)
+		throw new Error('3 Unexpected context id : ' + id3);
+	cls.exit();
+}
+
+
+async function testStart() {
+	await getFromDb();
+}
+
+testStart().then(() => log('done'), (e) => log(e.stack));

package/src/createDomain/negotiateForwardProperty.js

@@ -0,0 +1,23 @@
+function negotiateForwardProperty(oldDomain, newDomain, propertyName) {
+	if(newDomain[propertyName]) return;
+	if (propertyName === 'rdb') return;
+	Object.defineProperty(newDomain, propertyName, {
+		enumerable: true,
+		get: createGetter(oldDomain, propertyName),
+		set: createSetter(oldDomain, propertyName)
+	});
+}
+
+function createGetter(oldDomain, propName) {
+	return function() {
+		return oldDomain[propName];
+	};
+}
+
+function createSetter(oldDomain, propName) {
+	return function(value) {
+		oldDomain[propName] = value;
+	};
+}
+
+module.exports = negotiateForwardProperty;

package/src/createDomain.js

@@ -0,0 +1,31 @@
+let useHook = require('./useHook');
+let cls;
+var Domain = require('domain');
+var negotiateForwardProperty = require('./createDomain/negotiateForwardProperty');
+
+function createDomain() {
+	var oldDomain = Domain.active || {};
+	var domain = Domain.create();
+	var ownProperties = Object.getOwnPropertyNames(oldDomain);
+	ownProperties.forEach(function(propName) {
+		negotiateForwardProperty(oldDomain, domain, propName);
+	});
+	return domain;
+}
+
+function createOnContext() {
+	if (!cls)
+		cls = require('node-cls');
+	return cls.create('rdb');
+}
+
+
+function _createDomain() {
+	if (useHook())
+		return createOnContext();
+	else
+		return createDomain();
+
+}
+
+module.exports = _createDomain;

package/src/dateToISOString.js

@@ -0,0 +1,25 @@
+function dateToISOString(date) {
+	let tzo = -date.getTimezoneOffset();
+	let dif = tzo >= 0 ? '+' : '-';
+
+	function pad(num) {
+		let norm = Math.floor(Math.abs(num));
+		return (norm < 10 ? '0' : '') + norm;
+	}
+
+	function padMilli(d) {
+		return (d.getMilliseconds() + '').padStart(3, '0');
+	}
+
+	return date.getFullYear() +
+		'-' + pad(date.getMonth() + 1) +
+		'-' + pad(date.getDate()) +
+		'T' + pad(date.getHours()) +
+		':' + pad(date.getMinutes()) +
+		':' + pad(date.getSeconds()) +
+		'.' + padMilli(date) +
+		dif + pad(tzo / 60) +
+		':' + pad(tzo % 60);
+}
+
+module.exports = dateToISOString;

package/src/emitEvent.js

@@ -0,0 +1,46 @@
+function emitEvent() {
+	var callbacks = [];
+	var emit = function() {
+
+		var copy = callbacks.slice(0, callbacks.length);
+		var result = [];
+		for (var i = 0; i < copy.length; i++) {
+			var callback = copy[i];
+			result.push(callback.apply(null,arguments));
+		}
+		return result;
+	};
+
+	emit.add = function(callback) {
+		callbacks.push(callback);
+	};
+
+	emit.tryAdd = function(callback) {
+		if (callback)
+			emit.add(callback);
+	};
+
+	emit.remove = function(callback) {
+		for (var i = 0; i < callbacks.length; i++) {
+			if(callbacks[i] === callback){
+				callbacks.splice(i,1);
+				return;
+			}
+		}
+	};
+
+	emit.tryRemove = function(callback) {
+		if(callback)
+			emit.remove(callback);
+	};
+
+	emit.clear = function() {
+		callbacks.splice(0, callbacks.length);
+	};
+
+	emit.callbacks = callbacks;
+
+	return emit;
+}
+
+module.exports = emitEvent;

package/src/emptyFilter.js

@@ -0,0 +1,35 @@
+var negotiateRawSqlFilter = require('./table/column/negotiateRawSqlFilter');
+var parameterized = require('./table/query/newParameterized')('');
+function emptyFilter() {
+	return emptyFilter.and.apply(null, arguments);
+}
+
+emptyFilter.sql = parameterized.sql;
+emptyFilter.parameters = parameterized.parameters;
+
+emptyFilter.and = function(other) {
+	other = negotiateRawSqlFilter(other);
+	for (var i = 1; i < arguments.length; i++) {
+		other = other.and(arguments[i]);
+	}
+	return other;
+};
+
+emptyFilter.or = function(other) {
+	other = negotiateRawSqlFilter(other);
+	for (var i = 1; i < arguments.length; i++) {
+		other = other.or(arguments[i]);
+	}
+	return other;
+};
+
+emptyFilter.not = function(other) {
+	other = negotiateRawSqlFilter(other).not();
+	for (var i = 1; i < arguments.length; i++) {
+		other = other.and(arguments[i]);
+	}
+	return other;
+
+};
+
+module.exports = emptyFilter;

package/src/flags.js

@@ -0,0 +1,6 @@
+let flags = {
+	useProxy: true,
+	useLazyDefaults: true
+};
+
+module.exports = flags;

package/src/fromCompareObject.js

@@ -0,0 +1,24 @@
+function fromCompareObject(object) {
+	if (object === null || object === undefined) return object;
+	if (object.__patchType === 'Array') {
+		let copy = [];
+		let i = 0;
+		for (let id in object) {
+			if (id !== '__patchType') {
+				copy[i] = fromCompareObject(object[id]);
+				i++;
+			}
+		}
+		return copy;
+	} else if (object === Object(object)) {
+		let copy = {};
+		for (let name in object) {
+			if (name !== '__patchType')
+				copy[name] = fromCompareObject(object[name]);
+		}
+		return copy;
+	}
+	return object;
+}
+
+module.exports = fromCompareObject;