orange-orm 3.10.2

package/src/table/column/date/tryParseISO.js

@@ -0,0 +1,14 @@
+var pattern = /(\d{4}-[01]\d-[0-3]\d(T| )[0-2]\d:[0-5]\d:[0-5]\d\.\d+)|(\d{4}-[01]\d-[0-3]\d(T| )[0-2]\d:[0-5]\d:[0-5]\d)|(\d{4}-[01]\d-[0-3]\d(T| )[0-2]\d:[0-5]\d)/;
+
+function tryParseISO(iso) {
+	if (pattern.test(iso))
+		return iso;
+	else
+		throw new TypeError(iso +  ' is not a valid Date');
+
+
+
+
+}
+
+module.exports = tryParseISO;

package/src/table/column/date.js

@@ -0,0 +1,14 @@
+var newEncode = require('./date/newEncode');
+var newDecode = require('./date/newDecode');
+var formatOut = require('./date/formatOut');
+var purify = require('./date/purify');
+
+function _new(column) {
+	column.tsType = 'DateColumn';
+	column.purify = purify;
+	column.encode = newEncode(column);
+	column.decode = newDecode(column);
+	column.formatOut = formatOut.bind(null, column);
+}
+
+module.exports = _new;

package/src/table/column/dateWithTimeZone/newEncode.js

@@ -0,0 +1,41 @@
+var newPara = require('../../query/newParameterized');
+var purify = require('../date/purify');
+// var getSessionSingleton = require('../../getSessionSingleton');
+
+function _new(column) {
+	var encode = function(value) {
+		value = purify(value);
+		if (value == null) {
+			if (column.dbNull === null)
+				return newPara('null');
+			return newPara('\'' + column.dbNull + '\'');
+		}
+		return newPara('?', [encodeDate(value)]);
+	};
+
+	encode.unsafe = function(value) {
+		value = purify(value);
+		if (value == null) {
+			if (column.dbNull === null)
+				return 'null';
+			return '\'' + column.dbNull + '\'';
+		}
+		return encodeDate(value);
+	};
+
+	return encode;
+
+
+}
+function encodeDate(date) {
+	if (date.toISOString)
+		return truncate(date.toISOString(date));
+	return truncate(date);
+}
+
+function truncate(date) {
+	return date;
+}
+
+
+module.exports = _new;

package/src/table/column/dateWithTimeZone.js

@@ -0,0 +1,14 @@
+var newEncode = require('./dateWithTimeZone/newEncode');
+var newDecode = require('./date/newDecode');
+var formatOut = require('./date/formatOut');
+var purify = require('./date/purify');
+
+function _new(column) {
+	column.tsType = 'DateColumn';
+	column.purify = purify;
+	column.encode = newEncode(column);
+	column.decode = newDecode(column);
+	column.formatOut = formatOut.bind(null, column);
+}
+
+module.exports = _new;

package/src/table/column/encodeFilterArg.js

@@ -0,0 +1,8 @@
+function encodeFilterArg(column, arg) {
+	if (column.encode.safe)
+		return column.encode.safe(arg);
+	else
+		return column.encode(arg);
+}
+
+module.exports = encodeFilterArg;

package/src/table/column/equal.js

@@ -0,0 +1,15 @@
+var newBoolean = require('./newBoolean');
+var nullOperator = ' is ';
+var encodeFilterArg = require('./encodeFilterArg');
+
+function equal(column,arg,alias) {
+	var operator = '=';
+	var encoded = encodeFilterArg(column, arg);
+	if (encoded.sql() == 'null')
+		operator = nullOperator;
+	var firstPart = alias + '.' + column._dbName + operator;
+	var filter =  encoded.prepend(firstPart);
+	return newBoolean(filter);
+}
+
+module.exports = equal;

package/src/table/column/extractAlias.js

@@ -0,0 +1,7 @@
+function extract(table, optionalAlias) {
+	if (optionalAlias)
+		return optionalAlias;
+	return table._rootAlias || table._dbName;
+}
+
+module.exports = extract;

package/src/table/column/greaterThan.js

@@ -0,0 +1,12 @@
+var newBoolean = require('./newBoolean');
+var encodeFilterArg = require('./encodeFilterArg');
+
+function greaterThan(column,arg,alias) {
+	var operator = '>';
+	var encoded = encodeFilterArg(column, arg);
+	var firstPart = alias + '.' + column._dbName + operator;
+	var filter =  encoded.prepend(firstPart);
+	return newBoolean(filter);
+}
+
+module.exports = greaterThan;

package/src/table/column/greaterThanOrEqual.js

@@ -0,0 +1,12 @@
+var newBoolean = require('./newBoolean');
+var encodeFilterArg = require('./encodeFilterArg');
+
+function greaterThanOrEqual(column,arg,alias) {
+	var operator = '>=';
+	var encoded = encodeFilterArg(column, arg);
+	var firstPart = alias + '.' + column._dbName + operator;
+	var filter =  encoded.prepend(firstPart);
+	return newBoolean(filter);
+}
+
+module.exports = greaterThanOrEqual;

package/src/table/column/guid/newDecode.js

@@ -0,0 +1,10 @@
+function _new(column) {
+
+	return function(value) {
+		if (value == column.dbNull)
+			return null;
+		return value.toLowerCase();
+	};
+}
+
+module.exports = _new;

package/src/table/column/guid/newEncode.js

@@ -0,0 +1,30 @@
+var newPara = require('../../query/newParameterized');
+var purify = require('./purify');
+
+function _new(column) {
+
+	const encode = function(candidate) {
+		var value = purify(candidate);
+		if (value == null) {
+			if (column.dbNull === null)
+				return newPara('null');
+			return newPara('\'' + column.dbNull + '\'');
+		}
+		return newPara('\'' + value + '\'');
+	};
+
+	encode.unsafe = function(candidate) {
+		var value = purify(candidate);
+		if (value == null) {
+			if (column.dbNull === null)
+				return 'null';
+			return '\'' + column.dbNull + '\'';
+		}
+		return '\'' + value + '\'';
+	};
+
+
+	return encode;
+}
+
+module.exports = _new;

package/src/table/column/guid/purify.js

@@ -0,0 +1,10 @@
+function negotiateGuidFormat(candidate) {
+	if(candidate == null)
+		return null;
+	var pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+	if(!pattern.test(candidate))
+		throw new TypeError(candidate +  ' is not a valid UUID');
+	return candidate;
+}
+
+module.exports = negotiateGuidFormat;

package/src/table/column/guid.js

@@ -0,0 +1,12 @@
+var newEncode = require('./guid/newEncode');
+var newDecode = require('./guid/newDecode');
+var purify = require('./guid/purify');
+
+function _new(column) {
+	column.tsType = 'UUIDColumn';
+	column.purify = purify;
+	column.encode = newEncode(column);
+	column.decode = newDecode(column);
+}
+
+module.exports = _new;

package/src/table/column/in.js

@@ -0,0 +1,24 @@
+var newParameterized = require('../query/newParameterized');
+var newBoolean = require('./newBoolean');
+var encodeFilterArg = require('./encodeFilterArg');
+
+function _in(column,values,alias) {
+	var filter;
+	if (values.length === 0) {
+		filter =  newParameterized('1=2');
+		return newBoolean(filter);
+	}
+	var firstPart = alias + '.' + column._dbName + ' in ';
+	var parameterized = newParameterized(firstPart);
+	var separator = '(';
+
+	for (var i = 0; i < values.length; i++) {
+		var encoded = encodeFilterArg(column, values[i]);
+		parameterized = parameterized.append(separator).append(encoded);
+		separator = ',';
+	}
+	filter =  parameterized.append(')');
+	return newBoolean(filter);
+}
+
+module.exports = _in;

package/src/table/column/json/formatOut.js

@@ -0,0 +1,11 @@
+var getSessionSingleton = require('../../getSessionSingleton');
+
+function formatOut(column, alias) {
+	var formatColumn = getSessionSingleton('formatJSONOut');
+	if (formatColumn)
+		return formatColumn(column, alias);
+	else
+		return `${alias}.${column._dbName}`;
+}
+
+module.exports = formatOut;

package/src/table/column/json/newDecode.js

@@ -0,0 +1,21 @@
+let newDecodeCore = require('../newDecodeCore');
+let getSessionContext = require('../../getSessionContext');
+
+function _new(column) {
+	let decodeCore = newDecodeCore(column);
+
+	return function(value) {
+		value = decodeCore(value);
+		if (value === null)
+			return value;
+		if (typeof value !== 'object') {
+			let decode = getSessionContext().decodeJSON;
+			if (decode)
+				return decode(value);
+			return value;
+		}
+		return value;
+	};
+}
+
+module.exports = _new;

package/src/table/column/json/newEncode.js

@@ -0,0 +1,41 @@
+var newPara = require('../../query/newParameterized');
+var purify = require('./purify');
+var getSessionSingleton = require('../../getSessionSingleton');
+
+function _new(column) {
+
+	const encode = function(candidate) {
+		var value = purify(candidate);
+		if (value == null) {
+			if(column.dbNull === null)
+				return newPara('null');
+			return newPara('\'' + column.dbNull + '\'');
+		}
+		var encodeCore = getSessionSingleton('encodeJSON');
+
+		if (encodeCore) {
+			value = encodeCore(value);
+		}
+		return newPara('?', [value]);
+
+	};
+
+	encode.unsafe = function(candidate) {
+		var value = purify(candidate);
+		if (value == null) {
+			if(column.dbNull === null)
+				return 'null';
+			return '\'' + column.dbNull + '\'';
+		}
+		var encodeCore = getSessionSingleton('encodeJSON');
+
+		if (encodeCore) {
+			value = encodeCore(value);
+		}
+		return value;
+	};
+
+	return encode;
+}
+
+module.exports = _new;

package/src/table/column/json/purify.js

@@ -0,0 +1,7 @@
+function purify(value) {
+	if(value == null)
+		return null;
+	return value;
+}
+
+module.exports = purify;

package/src/table/column/json.js

@@ -0,0 +1,22 @@
+var newEncode = require('./json/newEncode');
+var newDecode = require('./json/newDecode');
+var formatOut = require('./json/formatOut');
+var purify = require('./json/purify');
+var onChange = require('@lroal/on-change');
+let clone = require('rfdc/default');
+
+function _new(column) {
+	column.tsType = 'JSONColumn';
+	column.purify = purify;
+	column.encode = newEncode(column);
+	column.decode = newDecode(column);
+	column.formatOut = formatOut.bind(null, column);
+	column.onChange = onChange;
+	column.toDto = toDto;
+}
+
+function toDto(value) {
+	return clone(value);
+}
+
+module.exports = _new;

package/src/table/column/lessThan.js

@@ -0,0 +1,12 @@
+var newBoolean = require('./newBoolean');
+var encodeFilterArg = require('./encodeFilterArg');
+
+function lessThanOrEqual(column,arg,alias) {
+	var operator = '<';
+	var encoded = encodeFilterArg(column, arg);
+	var firstPart = alias + '.' + column._dbName + operator;
+	var filter = encoded.prepend(firstPart);
+	return newBoolean(filter);
+}
+
+module.exports = lessThanOrEqual;

package/src/table/column/lessThanOrEqual.js

@@ -0,0 +1,12 @@
+var newBoolean = require('./newBoolean');
+var encodeFilterArg = require('./encodeFilterArg');
+
+function lessThanOrEqual(column,arg,alias) {
+	var operator = '<=';
+	var encoded = encodeFilterArg(column, arg);
+	var firstPart = alias + '.' + column._dbName + operator;
+	var filter = encoded.prepend(firstPart);
+	return newBoolean(filter);
+}
+
+module.exports = lessThanOrEqual;

package/src/table/column/negotiateNextAndFilter.js

@@ -0,0 +1,7 @@
+function negotiateNextAndFilter(filter, other) {
+	if (!other.sql())
+		return filter;
+	return filter.append(' AND ').append(other);
+}
+
+module.exports = negotiateNextAndFilter;

package/src/table/column/negotiateNextOrFilter.js

@@ -0,0 +1,7 @@
+function negotiateNextOrFilter(filter, other) {
+	if (!other.sql())
+		return filter;
+	return filter.prepend('(').append(' OR ').append(other).append(')');
+}
+
+module.exports = negotiateNextOrFilter;

package/src/table/column/negotiateRawSqlFilter.js

@@ -0,0 +1,74 @@
+let newParameterized = function() {
+	newParameterized = require('../query/newParameterized');
+	return newParameterized.apply(null, arguments);
+};
+
+let newBoolean = function() {
+	newBoolean = require('./newBoolean');
+	return newBoolean.apply(null, arguments);
+};
+
+function negotiateRawSqlFilter(filter, optionalTable, emptyArrayMeansFalse) {
+	if (Array.isArray(filter) && filter.length === 0) {
+		const sql = emptyArrayMeansFalse ? '1 = 2' : '1 = 1';
+		return newBoolean(newParameterized(sql));
+	}
+	else if (Array.isArray(filter)) {
+		let curFilter;
+		let curObjectFilter;
+		for (let i = 0; i < filter.length; i++) {
+			let nextFilter = negotiateRawSqlFilter(filter[i], optionalTable);
+			if (nextFilter.isObjectFilter)
+				curObjectFilter = curObjectFilter ? curObjectFilter.or(nextFilter) : nextFilter;
+			else
+				curFilter = curFilter ? curFilter.and(nextFilter) : nextFilter;
+		}
+		if (curFilter && curObjectFilter)
+			return curFilter.and(curObjectFilter);
+		else if (curFilter)
+			return curFilter;
+		else
+			return curObjectFilter;
+	}
+	else {
+		let params = [];
+		if (filter) {
+			if (filter.and)
+				return filter;
+			if (filter.sql) {
+				let sql = filter.sql;
+				if (typeof filter.sql === 'function') {
+					sql = filter.sql();
+				}
+				params.push(sql, filter.parameters);
+			}
+			else if (isObjectFilter(filter, optionalTable))
+				return newObjectFilter(filter, optionalTable);
+			else
+				params = [filter];
+		} else {
+			params = [filter];
+		}
+
+		let parameterized = newParameterized.apply(null, params);
+		return newBoolean(parameterized);
+	}
+}
+
+function isObjectFilter(object, optionalTable) {
+	return optionalTable && object;
+}
+
+function newObjectFilter(object, table) {
+	let primaryColumns = table._primaryColumns;
+	let filter;
+	for (let i = 0; i < primaryColumns.length; i++) {
+		let column = primaryColumns[i];
+		let colFilter = column.equal(object[column.alias]);
+		filter = filter  ? filter.and(colFilter) : colFilter ;
+	}
+	filter.isObjectFilter = true;
+	return filter;
+}
+
+module.exports = negotiateRawSqlFilter;

package/src/table/column/newBoolean.js

@@ -0,0 +1,54 @@
+var nextNewBoolean = _nextNewBoolean;
+var negotiateRawSqlFilter = require('./negotiateRawSqlFilter');
+var negotiateNextAndFilter = require('./negotiateNextAndFilter');
+var negotiateNextOrFilter = require('./negotiateNextOrFilter');
+
+function newBoolean(filter) {
+	var c = {};
+	c.sql = filter.sql.bind(filter);
+	c.parameters = filter.parameters;
+
+	c.append = function(other) {
+		var nextFilter = filter.append(other);
+		return nextNewBoolean(nextFilter);
+	};
+
+	c.prepend = function(other) {
+		var nextFilter = filter.prepend(other);
+		return nextNewBoolean(nextFilter);
+	};
+
+	c.and = function(other) {
+		other = negotiateRawSqlFilter(other);
+		var nextFilter = negotiateNextAndFilter(filter, other);
+		var next = nextNewBoolean(nextFilter);
+		for (var i = 1; i < arguments.length; i++) {
+			next = next.and(arguments[i]);
+		}
+		return next;
+	};
+
+	c.or = function(other) {
+		other = negotiateRawSqlFilter(other);
+		var nextFilter = negotiateNextOrFilter(filter, other);
+		var next = nextNewBoolean(nextFilter);
+		for (var i = 1; i < arguments.length; i++) {
+			next = next.or(arguments[i]);
+		}
+		return next;
+	};
+
+	c.not = function() {
+		var nextFilter = filter.prepend('NOT (').append(')');
+		return nextNewBoolean(nextFilter);
+	};
+
+	return c;
+}
+
+function _nextNewBoolean(filter) {
+	nextNewBoolean = require('./newBoolean');
+	return nextNewBoolean(filter);
+}
+
+module.exports = newBoolean;

package/src/table/column/newColumn.js

@@ -0,0 +1,89 @@
+const equal = require('./equal');
+const notEqual = require('./notEqual');
+const lessThan = require('./lessThan');
+const lessThanOrEqual = require('./lessThanOrEqual');
+const greaterThan = require('./greaterThan');
+const greaterThanOrEqual = require('./greaterThanOrEqual');
+const _in = require('./in');
+const _extractAlias = require('./extractAlias');
+
+module.exports = function(table, name) {
+	var c = {};
+	var extractAlias = _extractAlias.bind(null, table);
+	c._dbName = name;
+	c.alias = name;
+	table._aliases.add(name);
+
+	c.dbNull = null;
+	table._columns.push(c);
+	table[name] = c;
+
+	c.equal = function(arg, alias) {
+		alias = extractAlias(alias);
+		return equal(c, arg, alias);
+	};
+
+	c.notEqual = function(arg, alias) {
+		alias = extractAlias(alias);
+		return notEqual(c, arg, alias);
+	};
+
+	c.lessThan = function(arg, alias) {
+		alias = extractAlias(alias);
+		return lessThan(c, arg, alias);
+	};
+
+	c.lessThanOrEqual = function(arg, alias) {
+		alias = extractAlias(alias);
+		return lessThanOrEqual(c, arg, alias);
+	};
+
+	c.greaterThan = function(arg, alias) {
+		alias = extractAlias(alias);
+		return greaterThan(c, arg, alias);
+	};
+
+	c.greaterThanOrEqual = function(arg, alias) {
+		alias = extractAlias(alias);
+		return greaterThanOrEqual(c, arg, alias);
+	};
+
+	c.between = function(from, to, alias) {
+		alias = extractAlias(alias);
+		from = c.greaterThanOrEqual(from, alias);
+		to = c.lessThanOrEqual(to, alias);
+		return from.and(to);
+	};
+
+	c.in = function(arg, alias) {
+		alias = extractAlias(alias);
+		return _in(c, arg, alias);
+	};
+
+	c.eq = c.equal;
+	c.EQ = c.eq;
+	c.ne = c.notEqual;
+	c.NE = c.ne;
+	c.gt = c.greaterThan;
+	c.GT = c.gt;
+	c.ge = c.greaterThanOrEqual;
+	c.GE = c.ge;
+	c.lt = c.lessThan;
+	c.LT = c.lt;
+	c.le = c.lessThanOrEqual;
+	c.LE = c.le;
+	c.IN = c.in;
+	c.self = self;
+
+	function self() {
+		const tableAlias = table._rootAlias || table._dbName;
+		return {
+			expression: (alias) => `${tableAlias}.${c._dbName} ${alias}`,
+			joins: [''],
+			column: c,
+			groupBy: `${tableAlias}.${c._dbName}`
+		};
+	}
+
+	return c;
+};

package/src/table/column/newDecodeCore.js

@@ -0,0 +1,10 @@
+function _new(column) {
+
+	return function(value) {
+		if (value == column.dbNull)
+			return null;
+		return value;
+	};
+}
+
+module.exports = _new;

package/src/table/column/notEqual.js

@@ -0,0 +1,15 @@
+var newBoolean = require('./newBoolean');
+var encodeFilterArg = require('./encodeFilterArg');
+var nullOperator = ' is not ';
+
+function notEqual(column,arg,alias) {
+	var operator = '<>';
+	var encoded = encodeFilterArg(column, arg);
+	if (encoded.sql() == 'null')
+		operator = nullOperator;
+	var firstPart = alias + '.' + column._dbName + operator;
+	var filter =  encoded.prepend(firstPart);
+	return newBoolean(filter);
+}
+
+module.exports = notEqual;

package/src/table/column/numeric/negotiateDefault.js

@@ -0,0 +1,5 @@
+
+module.exports = function(column) {
+	if(!column.hasOwnProperty.call(column,'default'))
+		column.default = 0;
+};

package/src/table/column/numeric/newDecode.js

@@ -0,0 +1,16 @@
+var newDecodeCore = require('../newDecodeCore');
+
+function _new(column) {
+	var decodeCore = newDecodeCore(column);
+
+	return function(value) {
+		value = decodeCore(value);
+		if (value === null)
+			return value;
+		if (typeof(value) !== 'number')
+			return parseFloat(value);
+		return value;
+	};
+}
+
+module.exports = _new;