orange-orm 5.1.0 → 5.2.0

package/src/client/index.js

@@ -212,6 +212,7 @@ function rdbClient(options = {}) {
 			count,
 			getMany,
 			aggregate: groupBy,
+			distinct,
 			getAll,
 			getOne,
 			getById,
@@ -267,9 +268,17 @@ function rdbClient(options = {}) {
 		}
 
 		async function groupBy(strategy) {
+			return executeGroupBy('aggregate', strategy);
+		}
+
+		async function distinct(strategy) {
+			return executeGroupBy('distinct', strategy);
+		}
+
+		async function executeGroupBy(path, strategy) {
 			let args = negotiateGroupBy(null, strategy);
 			let body = stringify({
-				path: 'aggregate',
+				path,
 				args
 			});
 			let adapter = netAdapter(url, tableName, { axios: axiosInterceptor, tableOptions });
@@ -1064,12 +1073,20 @@ function groupByAggregate(path, arg) {
 	}
 }
 
+const isColumnProxyKey = '__isColumnProxy';
+const columnPathKey = '__columnPath';
+const columnRefKey = '__columnRef';
+
 function column(path, ...previous) {
 	function c() {
 		let args = [];
 		for (let i = 0; i < arguments.length; i++) {
-			if (typeof arguments[i] === 'function')
-				args[i] = arguments[i](tableProxy(path.split('.').slice(0, -1).join('.')));
+			if (typeof arguments[i] === 'function') {
+				if (arguments[i][isColumnProxyKey])
+					args[i] = { [columnRefKey]: arguments[i][columnPathKey] };
+				else
+					args[i] = arguments[i](tableProxy(path.split('.').slice(0, -1).join('.')));
+			}
 			else
 				args[i] = arguments[i];
 		}
@@ -1092,6 +1109,10 @@ function column(path, ...previous) {
 	}
 	let handler = {
 		get(_target, property) {
+			if (property === isColumnProxyKey)
+				return true;
+			if (property === columnPathKey)
+				return path;
 			if (property === 'toJSON')
 				return Reflect.get(...arguments);
 			else if (property === 'then')

package/src/getManyDto/query/newSingleQuery.js

@@ -4,7 +4,7 @@ var newJoinSql = require('../../table/query/singleQuery/newJoinSql');
 var newParameterized = require('../../table/query/newParameterized');
 var getSessionSingleton = require('../../table/getSessionSingleton');
 
-function _new(context,table,filter,span, alias,orderBy,limit,offset) {
+function _new(context,table,filter,span, alias,orderBy,limit,offset,distinct = false) {
 	var quote = getSessionSingleton(context, 'quote');
 	var name = quote(table._dbName);
 	var columnSql = newColumnSql(context,table,span,alias,true);
@@ -12,9 +12,10 @@ function _new(context,table,filter,span, alias,orderBy,limit,offset) {
 	var whereSql = newWhereSql(context,table,filter,alias);
 	if (limit)
 		limit = limit + ' ';
+	const selectClause = distinct ? 'select distinct ' : 'select ';
 
-	return newParameterized('select ' + limit + columnSql + ' from ' + name + ' ' + quote(alias)).append(joinSql).append(whereSql).append(orderBy + offset);
+	return newParameterized(selectClause + limit + columnSql + ' from ' + name + ' ' + quote(alias)).append(joinSql).append(whereSql).append(orderBy + offset);
 
 }
 
-module.exports = _new;
+module.exports = _new;

package/src/hostExpress/executePath.js

@@ -76,7 +76,7 @@ function _executePath(context, ...rest) {
 
 	async function executePath({ table, JSONFilter, baseFilter, customFilters = {}, request, response, readonly, disableBulkDeletes, isHttp, client }) {
 		let allowedOps = { ..._allowedOps, insert: !readonly, ...extractRelations(getMeta(table)) };
-		let ops = { ..._ops, ...getCustomFilterPaths(customFilters), getManyDto, getMany, aggregate, count, delete: _delete, cascadeDelete, update, replace };
+		let ops = { ..._ops, ...getCustomFilterPaths(customFilters), getManyDto, getMany, aggregate, distinct, count, delete: _delete, cascadeDelete, update, replace };
 
 		let res = await parseFilter(JSONFilter, table);
 		if (res === undefined)
@@ -90,9 +90,12 @@ function _executePath(context, ...rest) {
 
 				let anyAllNone = tryGetAnyAllNone(json.path, table);
 				if (anyAllNone) {
-					if (isHttp)
-						validateArgs(json.args[0]);
-					const f = anyAllNone(context, x => parseFilter(json.args[0], x));
+					const arg0 = json.args[0];
+					if (isHttp && arg0 !== undefined)
+						validateArgs(arg0);
+					const f = arg0 === undefined
+						? anyAllNone(context)
+						: anyAllNone(context, x => parseFilter(arg0, x));
 					if(!('isSafe' in f))
 						f.isSafe = isSafe;
 					return f;
@@ -111,17 +114,22 @@ function _executePath(context, ...rest) {
 				}
 				return result;
 			}
+			else if (isColumnRef(json)) {
+				return resolveColumnRef(table, json.__columnRef);
+			}
 			return json;
 
 			function tryGetAnyAllNone(path, table) {
-				path = path.split('.');
-				for (let i = 0; i < path.length; i++) {
-					table = table[path[i]];
+				const parts = path.split('.');
+				for (let i = 0; i < parts.length; i++) {
+					table = table[parts[i]];
 				}
 
 				let ops = new Set(['all', 'any', 'none', 'where', '_aggregate']);
 				// let ops = new Set(['all', 'any', 'none', 'where']);
-				let last = path.slice(-1)[0];
+				let last = parts[parts.length - 1];
+				if (last === 'count' && parts.length > 1)
+					ops.add('count');
 				if (ops.has(last) || (table && (table._primaryColumns || (table.any && table.all))))
 					return table;
 			}
@@ -154,8 +162,21 @@ function _executePath(context, ...rest) {
 					target = target[pathArray[i]];
 				}
 
-				if (!target)
+				if (!target) {
+					const left = args && args[0];
+					if (left) {
+						target = left;
+						for (let i = 0; i < pathArray.length; i++) {
+							target = target[pathArray[i]];
+						}
+						if (target) {
+							let res = target.apply(null, [context].concat(args.slice(1)));
+							setSafe(res);
+							return res;
+						}
+					}
 					throw new Error(`Method '${path}' does not exist`);
+				}
 				let res = target.apply(null, [context, ...args]);
 				setSafe(res);
 				return res;
@@ -201,7 +222,7 @@ function _executePath(context, ...rest) {
 
 		function nextTable(path, table) {
 			path = path.split('.');
-			let ops = new Set(['all', 'any', 'none']);
+			let ops = new Set(['all', 'any', 'none', 'count']);
 			let last = path.slice(-1)[0];
 			if (ops.has(last)) {
 				for (let i = 0; i < path.length - 1; i++) {
@@ -351,6 +372,17 @@ function _executePath(context, ...rest) {
 			return table.aggregate.apply(null, args);
 		}
 
+		async function distinct(filter, strategy) {
+			validateStrategy(table, strategy);
+			filter = negotiateFilter(filter);
+			const _baseFilter = await invokeBaseFilter();
+			if (_baseFilter)
+				filter = filter.and(context, _baseFilter);
+			let args = [context, filter].concat(Array.prototype.slice.call(arguments).slice(1));
+			await negotiateWhereAndAggregate(strategy);
+			return table.distinct.apply(null, args);
+		}
+
 
 
 		async function negotiateWhereAndAggregate(strategy) {
@@ -460,6 +492,27 @@ function _executePath(context, ...rest) {
 		return json instanceof Object && 'path' in json && 'args' in json;
 	}
 
+	function isColumnRef(json) {
+		return json instanceof Object && typeof json.__columnRef === 'string';
+	}
+
+	function resolveColumnRef(table, path) {
+		let current = table;
+		const parts = path.split('.');
+		for (let i = 0; i < parts.length; i++) {
+			if (current)
+				current = current[parts[i]];
+		}
+
+		if (!current || typeof current._toFilterArg !== 'function') {
+			let e = new Error(`Column reference '${path}' is invalid`);
+			// @ts-ignore
+			e.status = 400;
+			throw e;
+		}
+		return current;
+	}
+
 	function setSafe(o) {
 		if (o instanceof Object)
 			Object.defineProperty(o, 'isSafe', {
@@ -500,4 +553,4 @@ function _executePath(context, ...rest) {
 
 	}
 }
-module.exports = _executePath;
+module.exports = _executePath;

package/src/hostLocal.js

@@ -5,7 +5,7 @@ let executeQuery = require('./query');
 let executeSqliteFunction = require('./sqliteFunction');
 let hostExpress = require('./hostExpress');
 let hostHono = require('./hostHono');
-const readonlyOps = ['getManyDto', 'getMany', 'aggregate', 'count'];
+const readonlyOps = ['getManyDto', 'getMany', 'aggregate', 'distinct', 'count'];
 // { db, table, defaultConcurrency,
 // 	concurrency,
 // 	customFilters,

package/src/map2.d.ts

@@ -75,34 +75,40 @@ export interface Filter extends RawFilter {
   not(): Filter;
 }
 
-type StringOnlyMethods = {
-  startsWith(value: string | null | undefined): Filter;
-  iStartsWith(value: string | null | undefined): Filter;
-  endsWith(value: string | null | undefined): Filter;
-  iEndsWith(value: string | null | undefined): Filter;
-  contains(value: string | null | undefined): Filter;
-  iContains(value: string | null | undefined): Filter;
-  iEqual(value: string | null | undefined): Filter;
-  ieq(value: string | null | undefined): Filter;
+type ComparableValue<Val, ColumnType = any> =
+  | Val
+  | null
+  | undefined
+  | ColumnFilterType<any, ColumnType>;
+
+type StringOnlyMethods<ColumnType = 'string'> = {
+  startsWith(value: ComparableValue<string, ColumnType>): Filter;
+  iStartsWith(value: ComparableValue<string, ColumnType>): Filter;
+  endsWith(value: ComparableValue<string, ColumnType>): Filter;
+  iEndsWith(value: ComparableValue<string, ColumnType>): Filter;
+  contains(value: ComparableValue<string, ColumnType>): Filter;
+  iContains(value: ComparableValue<string, ColumnType>): Filter;
+  iEqual(value: ComparableValue<string, ColumnType>): Filter;
+  ieq(value: ComparableValue<string, ColumnType>): Filter;
 };
 
 export type ColumnFilterType<Val, ColumnType = any> = {
-  equal(value: Val | null | undefined): Filter;
-  eq(value: Val | null | undefined): Filter;
-  notEqual(value: Val | null | undefined): Filter;
-  ne(value: Val | null | undefined): Filter;
-  lessThan(value: Val | null | undefined): Filter;
-  lt(value: Val | null | undefined): Filter;
-  lessThanOrEqual(value: Val | null | undefined): Filter;
-  le(value: Val | null | undefined): Filter;
-  greaterThan(value: Val | null | undefined): Filter;
-  gt(value: Val | null | undefined): Filter;
-  greaterThanOrEqual(value: Val | null | undefined): Filter;
-  ge(value: Val | null | undefined): Filter;
-  in(values: readonly (Val | null | undefined)[]): Filter;
-  between(from: Val | null | undefined, to: Val | null | undefined): Filter;
-  notIn(values: readonly (Val | null | undefined)[]): Filter;
-} & (ColumnType extends 'string' ? StringOnlyMethods : {});
+  equal(value: ComparableValue<Val, ColumnType>): Filter;
+  eq(value: ComparableValue<Val, ColumnType>): Filter;
+  notEqual(value: ComparableValue<Val, ColumnType>): Filter;
+  ne(value: ComparableValue<Val, ColumnType>): Filter;
+  lessThan(value: ComparableValue<Val, ColumnType>): Filter;
+  lt(value: ComparableValue<Val, ColumnType>): Filter;
+  lessThanOrEqual(value: ComparableValue<Val, ColumnType>): Filter;
+  le(value: ComparableValue<Val, ColumnType>): Filter;
+  greaterThan(value: ComparableValue<Val, ColumnType>): Filter;
+  gt(value: ComparableValue<Val, ColumnType>): Filter;
+  greaterThanOrEqual(value: ComparableValue<Val, ColumnType>): Filter;
+  ge(value: ComparableValue<Val, ColumnType>): Filter;
+  in(values: readonly ComparableValue<Val, ColumnType>[]): Filter;
+  between(from: ComparableValue<Val, ColumnType>, to: ComparableValue<Val, ColumnType>): Filter;
+  notIn(values: readonly ComparableValue<Val, ColumnType>[]): Filter;
+} & (ColumnType extends 'string' ? StringOnlyMethods<ColumnType> : {});
 
 export type JsonArray = Array<JsonValue>;
 export type JsonObject = { [key: string]: JsonValue };
@@ -128,6 +134,8 @@ export type HasManyRelationFilter<M extends Record<string, TableDefinition<M>>,
   all(predicate: (row: RelationTableRefs<M, Target>) => Filter): Filter;
   none(predicate: (row: RelationTableRefs<M, Target>) => Filter): Filter;
   exists(): Filter;
+  count(): ColumnFilterType<number, 'numeric'>;
+  count(predicate: (row: RelationTableRefs<M, Target>) => Filter): ColumnFilterType<number, 'numeric'>;
 };
 
 export type FilterableSingleRelation<M extends Record<string, TableDefinition<M>>, Target extends keyof M> =
@@ -688,6 +696,7 @@ export type TableClient<M extends Record<string, TableDefinition<M>>, K extends
 
   // Aggregate methods - return plain objects (no active record methods)
   aggregate<strategy extends AggregateStrategy<M, K>>(strategy: strategy): Promise<Array<DeepExpand<AggregateCustomSelectorProperties<M, K, strategy>>>>;
+  distinct<strategy extends AggregateStrategy<M, K>>(strategy: strategy): Promise<Array<DeepExpand<AggregateCustomSelectorProperties<M, K, strategy>>>>;
 
   // Single item methods - return individual objects with individual active record methods
   getOne<strategy extends FetchStrategy<M, K>>(

package/src/table/column/encodeFilterArg.js

@@ -1,8 +1,10 @@
 function encodeFilterArg(context, column, arg) {
+	if (arg && typeof arg._toFilterArg === 'function')
+		return arg._toFilterArg(context);
 	if (column.encode.safe)
 		return column.encode.safe(context, arg);
 	else
 		return column.encode(context, arg);
 }
 
-module.exports = encodeFilterArg;
+module.exports = encodeFilterArg;

package/src/table/column/newColumn.js

@@ -9,6 +9,7 @@ const _extractAlias = require('./extractAlias');
 const quote = require('../../table/quote');
 const aggregate = require('./columnAggregate');
 const aggregateGroup = require('./columnAggregateGroup');
+const newParameterized = require('../query/newParameterized');
 
 module.exports = function(table, name) {
 	var c = {};
@@ -16,6 +17,16 @@ module.exports = function(table, name) {
 	c._dbName = name;
 	c.alias = name;
 	table._aliases.add(name);
+	Object.defineProperty(c, '_table', {
+		value: table,
+		enumerable: false,
+		writable: false
+	});
+	Object.defineProperty(c, '_toFilterArg', {
+		value: toFilterArg,
+		enumerable: false,
+		writable: false
+	});
 
 	c.dbNull = null;
 	table._columns.push(c);
@@ -101,5 +112,11 @@ module.exports = function(table, name) {
 		};
 	}
 
+	function toFilterArg(context) {
+		const tableAlias = quote(context, table._rootAlias || table._dbName);
+		const columnName = quote(context, c._dbName);
+		return newParameterized(`${tableAlias}.${columnName}`);
+	}
+
 	return c;
 };

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

@@ -1,13 +1,17 @@
 const quote = require('../../quote');
 var newBoolean = require('../newBoolean');
 var nullOperator = ' is ';
+var encodeFilterArg = require('../encodeFilterArg');
+var newLikeColumnArg = require('./newLikeColumnArg');
 
-function endsWithCore(context, operator, column,arg,alias) {
+function containsCore(context, operator, column,arg,alias) {
 	alias = quote(context, alias);
 	operator = ' ' + operator + ' ';
-	var encoded = column.encode(context, arg);
+	var encoded = encodeFilterArg(context, column, arg);
 	if (encoded.sql() == 'null')
 		operator = nullOperator;
+	else if (arg && typeof arg._toFilterArg === 'function')
+		encoded = newLikeColumnArg(context, column, encoded, '%', '%');
 	else
 		encoded = column.encode(context, '%' + arg + '%');
 	var firstPart = alias + '.' + quote(context, column._dbName) + operator;
@@ -15,4 +19,4 @@ function endsWithCore(context, operator, column,arg,alias) {
 	return newBoolean(filter);
 }
 
-module.exports = endsWithCore;
+module.exports = containsCore;

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

@@ -1,13 +1,17 @@
 const quote = require('../../quote');
 var newBoolean = require('../newBoolean');
 var nullOperator = ' is ';
+var encodeFilterArg = require('../encodeFilterArg');
+var newLikeColumnArg = require('./newLikeColumnArg');
 
 function endsWithCore(context, operator, column,arg,alias) {
 	alias = quote(context, alias);
 	operator = ' ' + operator + ' ';
-	var encoded = column.encode(context, arg);
+	var encoded = encodeFilterArg(context, column, arg);
 	if (encoded.sql() == 'null')
 		operator = nullOperator;
+	else if (arg && typeof arg._toFilterArg === 'function')
+		encoded = newLikeColumnArg(context, column, encoded, '%', null);
 	else
 		encoded = column.encode(context, '%' + arg);
 	var firstPart = alias + '.' + quote(context, column._dbName) + operator;
@@ -15,4 +19,4 @@ function endsWithCore(context, operator, column,arg,alias) {
 	return newBoolean(filter);
 }
 
-module.exports = endsWithCore;
+module.exports = endsWithCore;

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

@@ -0,0 +1,38 @@
+var getSessionSingleton = require('../../getSessionSingleton');
+var newParameterized = require('../../query/newParameterized');
+
+function newLikeColumnArg(context, column, encodedArg, prefix, suffix) {
+	var encodedPrefix = prefix ? column.encode(context, prefix) : null;
+	var encodedSuffix = suffix ? column.encode(context, suffix) : null;
+	var engine = getSessionSingleton(context, 'engine');
+
+	if (engine === 'mysql')
+		return concatWithFunction(encodedPrefix, encodedArg, encodedSuffix);
+	if (engine === 'mssql' || engine === 'mssqlNative')
+		return concatWithOperator('+', encodedPrefix, encodedArg, encodedSuffix);
+	return concatWithOperator('||', encodedPrefix, encodedArg, encodedSuffix);
+}
+
+function concatWithFunction(prefix, value, suffix) {
+	var args = [prefix, value, suffix].filter(Boolean);
+	var sql = 'CONCAT(' + args.map(x => x.sql()).join(',') + ')';
+	var parameters = [];
+	for (var i = 0; i < args.length; i++)
+		parameters = parameters.concat(args[i].parameters);
+	return newParameterized(sql, parameters);
+}
+
+function concatWithOperator(operator, prefix, value, suffix) {
+	var args = [prefix, value, suffix].filter(Boolean);
+	var sql = '';
+	var parameters = [];
+	for (var i = 0; i < args.length; i++) {
+		if (i > 0)
+			sql += ' ' + operator + ' ';
+		sql += args[i].sql();
+		parameters = parameters.concat(args[i].parameters);
+	}
+	return newParameterized(sql, parameters);
+}
+
+module.exports = newLikeColumnArg;

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

@@ -1,12 +1,16 @@
 var newBoolean = require('../newBoolean');
 var nullOperator = ' is ';
 var quote = require('../../quote');
+var encodeFilterArg = require('../encodeFilterArg');
+var newLikeColumnArg = require('./newLikeColumnArg');
 
 function startsWithCore(context, operator, column,arg,alias) {
 	operator = ' ' + operator + ' ';
-	var encoded = column.encode(context, arg);
+	var encoded = encodeFilterArg(context, column, arg);
 	if (encoded.sql() == 'null')
 		operator = nullOperator;
+	else if (arg && typeof arg._toFilterArg === 'function')
+		encoded = newLikeColumnArg(context, column, encoded, null, '%');
 	else
 		encoded = column.encode(context, arg + '%');
 	var firstPart = quote(context, alias) + '.' + quote(context, column._dbName) + operator;
@@ -14,4 +18,4 @@ function startsWithCore(context, operator, column,arg,alias) {
 	return newBoolean(filter);
 }
 
-module.exports = startsWithCore;
+module.exports = startsWithCore;

package/src/table/groupBy/newQuery.js

@@ -4,13 +4,17 @@ var extractLimit = require('../query/extractLimit');
 var newParameterized = require('../query/newParameterized');
 var extractOffset = require('../query/extractOffset');
 
-function newQuery(context, table,filter,span,alias) {
+function newQuery(context, table,filter,span,alias,options = {}) {
 	filter = extractFilter(filter);
 	var orderBy = '';
 	var limit = extractLimit(context, span);
 	var offset = extractOffset(context, span);
+	const useDistinct = options.distinct && canUseDistinct(span);
+
+	var query = newSingleQuery(context, table,filter,span,alias,orderBy,limit,offset,useDistinct);
+	if (useDistinct)
+		return query;
 
-	var query = newSingleQuery(context, table,filter,span,alias,orderBy,limit,offset);
 	const groupClause = groupBy(span);
 	return newParameterized(query.sql(), query.parameters).append(groupClause);
 }
@@ -22,4 +26,9 @@ function groupBy(span) {
 	return ' GROUP BY ' + keys.map(key => span.aggregates[key].groupBy).join(',');
 }
 
-module.exports = newQuery;
+function canUseDistinct(span) {
+	const keys = Object.keys(span.aggregates);
+	return keys.every(key => !!span.aggregates[key].column);
+}
+
+module.exports = newQuery;

package/src/table/groupBy.js

@@ -3,7 +3,7 @@ const negotiateRawSqlFilter = require('./column/negotiateRawSqlFilter');
 const strategyToSpan = require('./strategyToSpan');
 const executeQueries = require('./executeQueries');
 
-async function groupBy(context, table, filter, strategy) {
+async function groupBy(context, table, filter, strategy, options) {
 	filter = negotiateRawSqlFilter(context, filter, table);
 	if (strategy && strategy.where) {
 		let arg = typeof strategy.where === 'function' ? strategy.where(table) : strategy.where;
@@ -15,7 +15,7 @@ async function groupBy(context, table, filter, strategy) {
 
 	let alias = table._dbName;
 
-	const query = newQuery(context, table, filter, span, alias);
+	const query = newQuery(context, table, filter, span, alias, options);
 	const res = await executeQueries(context, [query]);
 	return decode(context, span, await res[0]);
 }
@@ -62,4 +62,4 @@ async function decode(context, span, rows, keys = rows.length > 0 ? Object.keys(
 	return outRows;
 }
 
-module.exports = groupBy;
+module.exports = groupBy;

package/src/table/newRelatedTable.js

@@ -5,6 +5,7 @@ var all = require('./relatedTable/all');
 var where = require('./relatedTable/where');
 var aggregate = require('./relatedTable/aggregate');
 var none = require('./relatedTable/none');
+var count = require('./relatedTable/count');
 
 function newRelatedTable(relations, isShallow, depth = 0) {
 	var table = relations[relations.length - 1].childTable;
@@ -26,6 +27,9 @@ function newRelatedTable(relations, isShallow, depth = 0) {
 	// @ts-ignore
 	c.where =  where(relations, depth);
 
+	// @ts-ignore
+	c.count = count(newRelatedTable, relations, depth);
+
 	// @ts-ignore
 	c._aggregate = aggregate(relations);
 
@@ -90,4 +94,4 @@ function newRelatedTable(relations, isShallow, depth = 0) {
 	return cProxy;
 }
 
-module.exports = newRelatedTable;
+module.exports = newRelatedTable;