orange-orm 3.10.2

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

@@ -0,0 +1,25 @@
+var purify = require('./purify');
+var newParam = require('../../query/newParameterized');
+
+module.exports = function(column) {
+
+	function encode(value) {
+		value = purify(value);
+		if (value == null) {
+			var dbNull = column.dbNull;
+			return newParam('' + dbNull + '');
+		}
+		return newParam('' + value);
+	}
+
+	encode.unsafe = function(value) {
+		value = purify(value);
+		if (value == null) {
+			var dbNull = column.dbNull;
+			return '' + dbNull + '';
+		}
+		return '' + value;
+
+	};
+	return encode;
+};

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

@@ -0,0 +1,12 @@
+function purify(value) {
+	if(value == null)
+		return null;
+	const parsedFloat = Number.parseFloat(value);
+	if (!isNaN(parsedFloat))
+		return parsedFloat;
+	if (typeof(value) !== 'number')
+		throw new Error('\'' + value + '\'' + ' is not a number');
+	return value;
+}
+
+module.exports = purify;

package/src/table/column/numeric.js

@@ -0,0 +1,15 @@
+var newEncode = require('./numeric/newEncode');
+var newDecode = require('./numeric/newDecode');
+var purify = require('./numeric/purify');
+
+function _new(column) {
+	column.tsType = 'NumberColumn';
+	// if (!column.isPrimary)
+	// 	column.default = 0;
+	column.lazyDefault = 0;
+	column.purify = purify;
+	column.encode = newEncode(column);
+	column.decode = newDecode(column);
+}
+
+module.exports = _new;

package/src/table/column/string/contains.js

@@ -0,0 +1,3 @@
+var containsCore = require('./containsCore');
+
+module.exports = containsCore.bind(null, 'LIKE');

package/src/table/column/string/containsCore.js

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

package/src/table/column/string/endsWith.js

@@ -0,0 +1,3 @@
+var endsWithCore = require('./endsWithCore');
+
+module.exports = endsWithCore.bind(null, 'LIKE');

package/src/table/column/string/endsWithCore.js

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

package/src/table/column/string/iContains.js

@@ -0,0 +1,3 @@
+var containsCore = require('./containsCore');
+
+module.exports = containsCore.bind(null, 'ILIKE');

package/src/table/column/string/iEndsWith.js

@@ -0,0 +1,3 @@
+var endsWithCore = require('./endsWithCore');
+
+module.exports = endsWithCore.bind(null, 'ILIKE');

package/src/table/column/string/iEqual.js

@@ -0,0 +1,15 @@
+var newBoolean = require('../newBoolean');
+var nullOperator = ' is ';
+var encodeFilterArg = require('../encodeFilterArg');
+
+function iEqual(column,arg,alias) {
+	var operator = ' ILIKE ';
+	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 = iEqual;

package/src/table/column/string/iStartsWith.js

@@ -0,0 +1,3 @@
+var startsWithCore = require('./startsWithCore');
+
+module.exports = startsWithCore.bind(null, 'ILIKE');

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

@@ -0,0 +1,31 @@
+var newPara = require('../../query/newParameterized');
+var purify = require('./purify');
+
+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('?', [value]);
+	};
+
+	encode.unsafe = function(value) {
+		value = purify(value);
+		value = purify(value);
+		if (value == null) {
+			if (column.dbNull === null)
+				return 'null';
+			return '\'' + column.dbNull + '\'';
+		}
+		return '\'' + value + '\'';
+	};
+
+	return encode;
+
+}
+
+module.exports = _new;

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

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

package/src/table/column/string/startsWith.js

@@ -0,0 +1,3 @@
+var startsWithCore = require('./startsWithCore');
+
+module.exports = startsWithCore.bind(null, 'LIKE');

package/src/table/column/string/startsWithCore.js

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

package/src/table/column/string.js

@@ -0,0 +1,55 @@
+var newEncode = require('./string/newEncode');
+var newDecode = require('./newDecodeCore');
+var startsWith = require('./string/startsWith');
+var endsWith = require('./string/endsWith');
+var contains = require('./string/contains');
+var iStartsWith = require('./string/iStartsWith');
+var iEndsWith = require('./string/iEndsWith');
+var iContains = require('./string/iContains');
+var iEqual = require('./string/iEqual');
+var purify = require('./string/purify');
+var _extractAlias = require('./extractAlias');
+
+function _new(table, column) {
+	column.tsType = 'StringColumn';
+	column.purify = purify;
+	column.encode = newEncode(column);
+	column.decode = newDecode(column);
+	var extractAlias = _extractAlias.bind(null, table);
+
+	column.startsWith = function(arg, alias) {
+		alias = extractAlias(alias);
+		return startsWith(column, arg, alias);
+	};
+	column.endsWith = function(arg, alias) {
+		alias = extractAlias(alias);
+		return endsWith(column, arg, alias);
+	};
+	column.contains = function(arg, alias) {
+		alias = extractAlias(alias);
+		return contains(column, arg, alias);
+	};
+	column.iStartsWith = function(arg, alias) {
+		alias = extractAlias(alias);
+		return iStartsWith(column, arg, alias);
+	};
+	column.iEndsWith = function(arg, alias) {
+		alias = extractAlias(alias);
+		return iEndsWith(column, arg, alias);
+	};
+	column.iContains = function(arg, alias) {
+		alias = extractAlias(alias);
+		return iContains(column, arg, alias);
+	};
+
+	column.iEqual = function(arg, alias) {
+		alias = extractAlias(alias);
+		return iEqual(column, arg, alias);
+	};
+
+	column.iEq = column.iEqual;
+	column.IEQ = column.iEqual;
+	column.ieq = column.iEqual;
+}
+
+module.exports = _new;

package/src/table/column.js

@@ -0,0 +1,154 @@
+const Ajv = require('ajv');
+const inspect = require('util').inspect;
+
+function defineColumn(column, table) {
+	var c = {};
+
+	c.string = function() {
+		require('./column/string')(table, column);
+		return c;
+	};
+
+	c.json = function() {
+		require('./column/json')(column);
+		return c;
+	};
+
+	c.guid = function() {
+		require('./column/guid')(column);
+		return c;
+	};
+	c.uuid = c.guid;
+
+	c.date = function() {
+		require('./column/date')(column);
+		return c;
+	};
+
+	c.date = function() {
+		require('./column/date')(column);
+		return c;
+	};
+
+	c.dateWithTimeZone = function() {
+		require('./column/dateWithTimeZone')(column);
+		return c;
+	};
+
+	c.numeric = function(optionalPrecision,optionalScale) {
+		require('./column/numeric')(column,optionalPrecision,optionalScale);
+		return c;
+	};
+
+	c.boolean = function() {
+		require('./column/boolean')(column);
+		return c;
+	};
+
+	c.binary = function() {
+		require('./column/binary')(column);
+		return c;
+	};
+
+	c.default = function(value) {
+		column.default = value;
+		return c;
+	};
+
+	c.primary = function() {
+		column.isPrimary = true;
+		table._primaryColumns.push(column);
+		return c;
+	};
+
+	c.as = function(alias) {
+		var oldAlias = column.alias;
+		table._aliases.delete(oldAlias);
+		table._aliases.add(alias);
+		delete table[oldAlias];
+		table[alias] = column;
+		column.alias = alias;
+		return c;
+	};
+
+	c.dbNull = function(value) {
+		column.dbNull = value;
+		return c;
+	};
+
+	c.serializable = function(value) {
+		column.serializable = value;
+		return c;
+	};
+
+	c.notNull = function() {
+		column._notNull = true;
+		function validate(value) {
+			if (value === undefined || value === null) {
+				const error =  new Error(`Column ${column.alias} cannot be null or undefined`);
+				error.status = 400;
+				throw error;
+			}
+		}
+
+		return c.validate(validate);
+	};
+
+	c.notNullExceptInsert = function() {
+		column._notNullExceptInsert = true;
+		function validate(value, _row, isInsert) {
+			if (isInsert)
+				return;
+			if (value === undefined || value === null)
+				throw new Error(`Column ${column.alias} cannot be null or undefined`);
+		}
+
+		return c.validate(validate);
+	};
+
+	c.validate = function(value) {
+		let previousValue = column.validate;
+		if (previousValue)
+			column.validate = nestedValidate;
+		else
+			column.validate = value;
+
+		function nestedValidate() {
+			try {
+				previousValue.apply(null, arguments);
+				value.apply(null, arguments);
+			}
+			catch (e) {
+				const error = new Error(e.message || e);
+				// @ts-ignore
+				error.status = 400;
+				throw error;
+			}
+		}
+		return c;
+	};
+
+	c.JSONSchema = function(schema, options) {
+		let previousValidate = column.validate;
+		let ajv = new Ajv(options);
+		let validate = ajv.compile(schema);
+		column.validate = _validate;
+
+		function _validate() {
+			if (previousValidate)
+				previousValidate.apply(null, arguments);
+			let valid = validate.apply(null, arguments);
+			if (!valid) {
+				let e = new Error(`Column ${table._dbName}.${column._dbName} violates JSON Schema: ${inspect(validate.errors, false, 10)}`);
+				e.errors = validate.errors;
+				e.status = 400;
+				throw e;
+			}
+		}
+		return c;
+	};
+
+	return c;
+}
+
+module.exports = defineColumn;

package/src/table/commands/beginCommand.js

@@ -0,0 +1,13 @@
+let newParameterized = require('../query/newParameterized');
+let getSessionContext = require('../getSessionContext');
+
+module.exports = function() {
+	let command = newParameterized(getSessionContext().begin || 'BEGIN');
+	command.endEdit = empty;
+	command.matches = empty;
+
+	function empty() {}
+
+	return command;
+
+};

package/src/table/commands/commitCommand.js

@@ -0,0 +1,9 @@
+var newParameterized = require('../query/newParameterized');
+
+var command = newParameterized('COMMIT');
+function empty() {}
+
+command.endEdit = empty;
+command.matches = empty;
+
+module.exports = command;

package/src/table/commands/compressChanges.js

@@ -0,0 +1,25 @@
+var newParameterized = require('../query/newParameterized');
+var getSessionSingleton = require('../getSessionSingleton');
+
+function compress(queries) {
+	var multipleStatements = getSessionSingleton('multipleStatements');
+	var compressed = [];
+	var queryCount = queries.length;
+
+	for (var i = 0; i < queryCount; i++) {
+		var current = queries[i];
+		if (multipleStatements && current.parameters.length === 0 && !current.disallowCompress) {
+			for (var i2 = i+1; i2 < queryCount; i2++) {
+				var next = queries[i2];
+				if (next.parameters.length > 0 || ! next.disallowCompress)
+					break;
+				current = newParameterized(current.sql() + ';' + next.sql());
+				i++;
+			}
+		}
+		compressed.push(current);
+	}
+	return compressed;
+}
+
+module.exports = compress;

package/src/table/commands/delete/createAlias.js

@@ -0,0 +1,6 @@
+function createAlias(table, depth) {
+	if (depth === 0)
+		return table._dbName;
+	return 'x' + depth;
+}
+module.exports = createAlias;

package/src/table/commands/delete/newSingleCommand.js

@@ -0,0 +1,17 @@
+var newSubFilter = require('./singleCommand/subFilter');
+var newDiscriminatorSql = require('../../query/singleQuery/newDiscriminatorSql');
+var extractFilter = require('../../query/extractFilter');
+var newSingleCommandCore = require('./singleCommand/newSingleCommandCore');
+var createAlias = require('./createAlias');
+
+function _new(table,filter,relations) {
+	var alias = createAlias(table, relations.length);
+	filter = extractFilter(filter);
+	filter = newSubFilter(relations, filter);
+	var discriminator = newDiscriminatorSql(table, alias);
+	if (discriminator !== '')
+		filter = filter.and(discriminator);
+	return newSingleCommandCore(table, filter, alias);
+}
+
+module.exports = _new;

package/src/table/commands/delete/singleCommand/joinSql.js

@@ -0,0 +1,26 @@
+var newShallowJoinSql = require('../../../query/singleQuery/joinSql/newShallowJoinSql');
+var createAlias = require('../createAlias');
+
+function newJoinSql(relations) {
+	var length = relations.length;
+	var leftAlias,
+		rightAlias;
+	var sql = '';
+
+	function addSql(relation) {
+		var rightColumns = relation.childTable._primaryColumns;
+		var leftColumns = relation.columns;
+		sql += ' INNER' + newShallowJoinSql(relation.childTable,leftColumns,rightColumns,leftAlias,rightAlias).sql();
+	}
+
+	relations.forEach(function(relation, i){
+		leftAlias = 'x' + (length-i);
+		rightAlias = createAlias(relation.childTable, length-i-1);
+		addSql(relation);
+
+	});
+
+	return sql;
+}
+
+module.exports = newJoinSql;

package/src/table/commands/delete/singleCommand/newSingleCommandCore.js

@@ -0,0 +1,19 @@
+var getSessionSingleton = require('../../../getSessionSingleton');
+
+function newSingleCommandCore(table,filter,alias) {
+	var c = {};
+
+	c.sql = function() {
+		var whereSql = filter.sql();
+		if (whereSql)
+			whereSql = ' where ' + whereSql;
+		var deleteFromSql = getSessionSingleton('deleteFromSql');
+		return deleteFromSql(table, alias, whereSql);
+	};
+
+	c.parameters = filter.parameters;
+
+	return c;
+}
+
+module.exports = newSingleCommandCore;

package/src/table/commands/delete/singleCommand/selectSql.js

@@ -0,0 +1,11 @@
+var newParameterized = require('../../../query/newParameterized');
+var newBoolean = require('../../../column/newBoolean');
+
+function newSelectSql(table, alias) {
+	var colName = table._primaryColumns[0]._dbName;
+	var sql = 'SELECT ' + alias + '.' + colName + ' FROM ' + table._dbName + ' ' + alias;
+	sql = newParameterized(sql);
+	return newBoolean(sql);
+}
+
+module.exports = newSelectSql;

package/src/table/commands/delete/singleCommand/subFilter.js

@@ -0,0 +1,19 @@
+var newSelect = require('./selectSql');
+var newJoin = require('./joinSql');
+var newWhere = require('./whereSql');
+var createAlias = require('../createAlias');
+
+function newSubFilter(relations, shallowFilter) {
+	var relationCount = relations.length;
+	if (relationCount === 0)
+		return shallowFilter;
+	var table = relations[0].childTable;
+	var alias = createAlias(table, relationCount -1);
+	var filter = newSelect(table,alias).prepend('EXISTS (');
+	var join = newJoin(relations.slice(1));
+	var where = newWhere(relations,shallowFilter,alias);
+	return filter.append(join).append(where).append(')');
+
+}
+
+module.exports = newSubFilter;

package/src/table/commands/delete/singleCommand/whereSql.js

@@ -0,0 +1,25 @@
+var newShallowJoinSql = require('../../../query/singleQuery/joinSql/newShallowJoinSqlCore');
+
+function newWhereSql(relations, shallowFilter, rightAlias) {
+	var sql;
+	var relationCount = relations.length;
+	var relation = relations[0];
+	var leftAlias = 'x' + relationCount;
+	var table = relation.childTable;
+	var leftColumns = relation.columns;
+	var rightColumns = table._primaryColumns;
+	where();
+
+	function where() {
+		var table = relation.childTable;
+		var joinCore = newShallowJoinSql(table, leftColumns, rightColumns, leftAlias, rightAlias);
+		if (shallowFilter.sql())
+			sql = shallowFilter.prepend(' AND ').prepend(joinCore).prepend(' WHERE ');
+		else
+			sql = joinCore.prepend(' WHERE ');
+	}
+
+	return sql;
+}
+
+module.exports = newWhereSql;

package/src/table/commands/getChangeSet.js

@@ -0,0 +1,6 @@
+var getSessionSingleton = require('../getSessionSingleton');
+function getChangeSet() {
+	return getSessionSingleton('changes');
+}
+
+module.exports = getChangeSet;

package/src/table/commands/insert/getSqlTemplate.js

@@ -0,0 +1,68 @@
+let getSessionContext = require('../../getSessionContext');
+
+function getSqlTemplate(_table, _row) {
+	let context = getSessionContext();
+	if (context.insertSql)
+		return context.insertSql.apply(null, arguments);
+	else
+		return getSqlTemplateDefault.apply(null, arguments);
+
+}
+
+function getSqlTemplateDefault(table, row) {
+	let columnNames = [];
+	let regularColumnNames = [];
+	let values = [];
+	let sql = 'INSERT INTO ' + table._dbName + ' ';
+	addDiscriminators();
+	addColumns();
+	if (columnNames.length === 0)
+		sql += `${outputInserted()}${defaultValues()}${lastInserted()}`;
+	else
+		sql = sql + '('+ columnNames.join(',') + ') ' + outputInserted() +  'VALUES (' + values.join(',') + ')' + lastInserted() ;
+	return sql;
+
+	function addDiscriminators() {
+		let discriminators = table._columnDiscriminators;
+		for (let i = 0; i < discriminators.length; i++) {
+			let parts = discriminators[i].split('=');
+			columnNames.push(parts[0]);
+			values.push(parts[1]);
+		}
+	}
+
+	function addColumns() {
+		let columns = table._columns;
+		for (let i = 0; i < columns.length; i++) {
+			let column = columns[i];
+			regularColumnNames.push(column._dbName);
+			if (row['__' + column.alias] !== undefined) {
+				columnNames.push(column._dbName);
+				values.push('%s');
+			}
+		}
+	}
+
+	function lastInserted() {
+		let context = getSessionContext();
+		if (!context.lastInsertedIsSeparate && context.lastInsertedSql)
+			return ' ' + context.lastInsertedSql(table);
+		return '';
+	}
+
+	function outputInserted() {
+		let context = getSessionContext();
+		if (!context.lastInsertedIsSeparate && context.outputInsertedSql)
+			return ' ' + context.outputInsertedSql(table) + ' ';
+		return '';
+	}
+
+	function defaultValues() {
+		let context = getSessionContext();
+		let _default = context.insertDefault || 'DEFAULT VALUES';
+		return `${_default}${lastInserted()}`;
+
+	}
+}
+
+module.exports = getSqlTemplate;

package/src/table/commands/lastCommandMatches.js

@@ -0,0 +1,11 @@
+var getChangeSet = require('./getChangeSet');
+
+function lastCommandMatches(row) {
+	var changeSet = getChangeSet();
+	var lastIndex = changeSet.length-1;
+	if (lastIndex >= 0 && changeSet[lastIndex].matches)
+		return changeSet[lastIndex].matches(row);
+	return false;
+}
+
+module.exports = lastCommandMatches;