orange-orm 4.5.0-beta.0 → 4.5.0-beta.2

package/src/hostExpress/executePath.js

@@ -3,14 +3,6 @@ const emptyFilter = require('../emptyFilter');
 const negotiateRawSqlFilter = require('../table/column/negotiateRawSqlFilter');
 let getMeta = require('./getMeta');
 let isSafe = Symbol();
-let _ops = {
-	and: emptyFilter.and,
-	or: emptyFilter.or,
-	not: emptyFilter.not,
-	AND: emptyFilter.and,
-	OR: emptyFilter.or,
-	NOT: emptyFilter.not
-};
 
 let _allowedOps = {
 	and: true,
@@ -69,431 +61,443 @@ let _allowedOps = {
 	self: true,
 };
 
-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 res = await parseFilter(JSONFilter, table);
-	if (res === undefined)
-		return {};
-	else
-		return res;
-
-	function parseFilter(json, table) {
-		if (isFilter(json)) {
-			let subFilters = [];
-
-			let anyAllNone = tryGetAnyAllNone(json.path, table);
-			if (anyAllNone) {
-				if (isHttp)
-					validateArgs(json.args[0]);
-				const f = anyAllNone(x => parseFilter(json.args[0], x));
-				f.isSafe = isSafe;
-				return f;
+function _executePath(context, ...rest) {
+
+	const _ops = {
+		and: emptyFilter.and.bind(null, context),
+		or: emptyFilter.or.bind(null, context),
+		not: emptyFilter.not.bind(null, context),
+		AND: emptyFilter.and.bind(null, context),
+		OR: emptyFilter.or.bind(null, context),
+		NOT: emptyFilter.not.bind(null, context),
+	};
+
+	return executePath(...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 res = await parseFilter(JSONFilter, table);
+		if (res === undefined)
+			return {};
+		else
+			return res;
+
+		function parseFilter(json, table) {
+			if (isFilter(json)) {
+				let subFilters = [];
+
+				let anyAllNone = tryGetAnyAllNone(json.path, table);
+				if (anyAllNone) {
+					if (isHttp)
+						validateArgs(json.args[0]);
+					const f = anyAllNone(context, x => parseFilter(json.args[0], x));
+					if(!('isSafe' in f))
+						f.isSafe = isSafe;
+					return f;
+				}
+				else {
+					for (let i = 0; i < json.args.length; i++) {
+						subFilters.push(parseFilter(json.args[i], nextTable(json.path, table)));
+					}
+				}
+				return executePath(json.path, subFilters);
 			}
-			else {
-				for (let i = 0; i < json.args.length; i++) {
-					subFilters.push(parseFilter(json.args[i], nextTable(json.path, table)));
+			else if (Array.isArray(json)) {
+				const result = [];
+				for (let i = 0; i < json.length; i++) {
+					result.push(parseFilter(json[i], table));
+				}
+				return result;
+			}
+			return json;
+
+			function tryGetAnyAllNone(path, table) {
+				path = path.split('.');
+				for (let i = 0; i < path.length; i++) {
+					table = table[path[i]];
+				}
+
+				let ops = new Set(['all', 'any', 'none', 'where', '_aggregate']);
+				// let ops = new Set(['all', 'any', 'none', 'where']);
+				let last = path.slice(-1)[0];
+				if (ops.has(last) || (table && (table._primaryColumns || (table.any && table.all))))
+					return table;
+			}
+
+			function executePath(path, args) {
+				if (path in ops) {
+					if (isHttp)
+						validateArgs(args);
+					let op = ops[path].apply(null, args);
+					if (op.then)
+						return op.then((o) => {
+							setSafe(o);
+							return o;
+						});
+					setSafe(op);
+					return op;
+				}
+				let pathArray = path.split('.');
+				let target = table;
+				let op = pathArray[pathArray.length - 1];
+				if (!allowedOps[op] && isHttp) {
+
+					let e = new Error('Disallowed operator ' + op);
+					// @ts-ignore
+					e.status = 403;
+					throw e;
+
+				}
+				for (let i = 0; i < pathArray.length; i++) {
+					target = target[pathArray[i]];
 				}
+
+				if (!target)
+					throw new Error(`Method '${path}' does not exist`);
+				let res = target.apply(null, [context, ...args]);
+				setSafe(res);
+				return res;
 			}
-			return executePath(json.path, subFilters);
 		}
-		else if (Array.isArray(json)) {
-			const result = [];
-			for (let i = 0; i < json.length; i++) {
-				result.push(parseFilter(json[i], table));
+
+		async function invokeBaseFilter() {
+			if (typeof baseFilter === 'function') {
+				const res = await baseFilter.apply(null, [bindDb(client), request, response]);
+				if (!res)
+					return;
+				const JSONFilter = JSON.parse(JSON.stringify(res));
+				//@ts-ignore
+				return executePath({ table, JSONFilter, request, response });
 			}
-			return result;
+			else
+				return;
 		}
-		return json;
 
-		function tryGetAnyAllNone(path, table) {
-			path = path.split('.');
-			for (let i = 0; i < path.length; i++) {
-				table = table[path[i]];
+		function getCustomFilterPaths(customFilters) {
+			return getLeafNames(customFilters);
+
+			function getLeafNames(obj, result = {}, current = 'customFilters.') {
+				for (let p in obj) {
+					if (typeof obj[p] === 'object' && obj[p] !== null)
+						getLeafNames(obj[p], result, current + p + '.');
+					else
+						result[current + p] = resolveFilter.bind(null, obj[p]);
+				}
+				return result;
+			}
+
+			async function resolveFilter(fn, ...args) {
+				const context = { db: bindDb(client), request, response };
+				let res = fn.apply(null, [context, ...args]);
+				if (res.then)
+					res = await res;
+				const JSONFilter = JSON.parse(JSON.stringify(res));
+				//@ts-ignore
+				return executePath({ table, JSONFilter, request, response });
 			}
+		}
 
-			let ops = new Set(['all', 'any', 'none', 'where', '_aggregate']);
-			// let ops = new Set(['all', 'any', 'none', 'where']);
+		function nextTable(path, table) {
+			path = path.split('.');
+			let ops = new Set(['all', 'any', 'none']);
 			let last = path.slice(-1)[0];
-			if (ops.has(last) || (table && (table._primaryColumns || (table.any && table.all))))
+			if (ops.has(last)) {
+				for (let i = 0; i < path.length - 1; i++) {
+					table = table[path[i]];
+				}
 				return table;
+			}
+			else {
+				let lastObj = table;
+				for (let i = 0; i < path.length; i++) {
+					if (lastObj)
+						lastObj = lastObj[path[i]];
+				}
+				if (lastObj?._shallow)
+					return lastObj._shallow;
+				else return table;
+			}
 		}
 
-		function executePath(path, args) {
-			if (path in ops) {
-				if (isHttp)
-					validateArgs(args);
-				let op = ops[path].apply(null, args);
-				if (op.then)
-					return op.then((o) => {
-						setSafe(o);
-						return o;
-					});
-				setSafe(op);
-				return op;
+		async function _delete(filter) {
+			if (readonly || disableBulkDeletes) {
+				let e = new Error('Bulk deletes are not allowed. Parameter "disableBulkDeletes" must be true.');
+				// @ts-ignore
+				e.status = 403;
+				throw e;
 			}
-			let pathArray = path.split('.');
-			let target = table;
-			let op = pathArray[pathArray.length - 1];
-			if (!allowedOps[op] && isHttp) {
+			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));
+			return table.delete.apply(null, args);
+		}
 
-				let e = new Error('Disallowed operator ' + op);
+		async function cascadeDelete(filter) {
+			if (readonly || disableBulkDeletes) {
+				const e = new Error('Bulk deletes are not allowed. Parameter "disableBulkDeletes" must be true.');
 				// @ts-ignore
 				e.status = 403;
 				throw e;
 
 			}
-			for (let i = 0; i < pathArray.length; i++) {
-				target = target[pathArray[i]];
-			}
-
-			if (!target)
-				throw new Error(`Method '${path}' does not exist`);
-			let res = target.apply(null, args);
-			setSafe(res);
-			return res;
+			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));
+			return table.cascadeDelete.apply(null, args);
 		}
-	}
-
-
 
-	async function invokeBaseFilter() {
-		if (typeof baseFilter === 'function') {
-			const res = await baseFilter.apply(null, [bindDb(client), request, response]);
-			if (!res)
-				return;
-			const JSONFilter = JSON.parse(JSON.stringify(res));
-			//@ts-ignore
-			return executePath({ table, JSONFilter, request, response });
+		function negotiateFilter(filter) {
+			if (filter)
+				return negotiateRawSqlFilter(context, filter, table, true);
+			else
+				return emptyFilter;
 		}
-		else
-			return;
-	}
-
-	function getCustomFilterPaths(customFilters) {
-		return getLeafNames(customFilters);
 
-		function getLeafNames(obj, result = {}, current = 'customFilters.') {
-			for (let p in obj) {
-				if (typeof obj[p] === 'object' && obj[p] !== null)
-					getLeafNames(obj[p], result, current + p + '.');
-				else
-					result[current + p] = resolveFilter.bind(null, obj[p]);
-			}
-			return result;
+		async function count(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));
+			return table.count.apply(null, args);
 		}
 
-		async function resolveFilter(fn, ...args) {
-			const context = { db: bindDb(client), request, response };
-			let res = fn.apply(null, [context, ...args]);
-			if (res.then)
-				res = await res;
-			const JSONFilter = JSON.parse(JSON.stringify(res));
-			//@ts-ignore
-			return executePath({ table, JSONFilter, request, response });
+		async function getManyDto(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.getManyDto.apply(null, args);
 		}
-	}
 
-	function nextTable(path, table) {
-		path = path.split('.');
-		let ops = new Set(['all', 'any', 'none']);
-		let last = path.slice(-1)[0];
-		if (ops.has(last)) {
-			for (let i = 0; i < path.length - 1; i++) {
-				table = table[path[i]];
-			}
-			return table;
+		async function replace(subject, strategy = { insertAndForget: true }) {
+			validateStrategy(table, strategy);
+			const refinedStrategy = objectToStrategy(subject, {}, table);
+			const JSONFilter2 = {
+				path: 'getManyDto',
+				args: [subject, refinedStrategy]
+			};
+			const originals = await executePath({ table, JSONFilter: JSONFilter2, baseFilter, customFilters, request, response, readonly, disableBulkDeletes, isHttp, client });
+			const meta = getMeta(table);
+			const patch = createPatch(originals, Array.isArray(subject) ? subject : [subject], meta);
+			const { changed } = await table.patch(context, patch, { strategy });
+			if (Array.isArray(subject))
+				return changed;
+			else
+				return changed[0];
 		}
-		else {
-			let lastObj = table;
-			for (let i = 0; i < path.length; i++) {
-				if (lastObj)
-					lastObj = lastObj[path[i]];
+
+		async function update(subject, whereStrategy, strategy = { insertAndForget: true }) {
+			validateStrategy(table, strategy);
+			const refinedWhereStrategy = objectToStrategy(subject, whereStrategy, table);
+			const JSONFilter2 = {
+				path: 'getManyDto',
+				args: [null, refinedWhereStrategy]
+			};
+			const rows = await executePath({ table, JSONFilter: JSONFilter2, baseFilter, customFilters, request, response, readonly, disableBulkDeletes, isHttp, client });
+			const originals = new Array(rows.length);
+			for (let i = 0; i < rows.length; i++) {
+				const row = rows[i];
+				originals[i] = { ...row };
+				for (let p in subject) {
+					row[p] = subject[p];
+				}
 			}
-			if (lastObj?._shallow)
-				return lastObj._shallow;
-			else return table;
+			const meta = getMeta(table);
+			const patch = createPatch(originals, rows, meta);
+			const { changed } = await table.patch(context, patch, { strategy });
+			return changed;
 		}
-	}
 
-	async function _delete(filter) {
-		if (readonly || disableBulkDeletes) {
-			let e = new Error('Bulk deletes are not allowed. Parameter "disableBulkDeletes" must be true.');
-			// @ts-ignore
-			e.status = 403;
-			throw e;
+		function objectToStrategy(object, whereStrategy, table, strategy = {}) {
+			strategy = { ...whereStrategy, ...strategy };
+			if (Array.isArray(object)) {
+				for (let i = 0; i < object.length; i++) {
+					objectToStrategy(object[i], table, strategy);
+				}
+				return;
+			}
+			for (let name in object) {
+				const relation = table[name]?._relation;
+				if (relation && !relation.columns) {//notJoin, that is one or many
+					strategy[name] = {};
+					objectToStrategy(object[name], whereStrategy?.[name], table[name], strategy[name]);
+				}
+				else
+					strategy[name] = true;
+			}
+			return strategy;
 		}
-		filter = negotiateFilter(filter);
-		const _baseFilter = await invokeBaseFilter();
-		if (_baseFilter)
-			filter = filter.and(_baseFilter);
-		let args = [filter].concat(Array.prototype.slice.call(arguments).slice(1));
-		return table.delete.apply(null, args);
-	}
 
-	async function cascadeDelete(filter) {
-		if (readonly || disableBulkDeletes) {
-			const e = new Error('Bulk deletes are not allowed. Parameter "disableBulkDeletes" must be true.');
-			// @ts-ignore
-			e.status = 403;
-			throw e;
 
+		async function aggregate(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.aggregate.apply(null, args);
 		}
-		filter = negotiateFilter(filter);
-		const _baseFilter = await invokeBaseFilter();
-		if (_baseFilter)
-			filter = filter.and(_baseFilter);
-		let args = [filter].concat(Array.prototype.slice.call(arguments).slice(1));
-		return table.cascadeDelete.apply(null, args);
-	}
-
-	function negotiateFilter(filter) {
-		if (filter)
-			return negotiateRawSqlFilter(filter, table, true);
-		else
-			return emptyFilter;
-	}
 
-	async function count(filter, strategy) {
-		validateStrategy(table, strategy);
-		filter = negotiateFilter(filter);
-		const _baseFilter = await invokeBaseFilter();
-		if (_baseFilter)
-			filter = filter.and(_baseFilter);
-		let args = [filter].concat(Array.prototype.slice.call(arguments).slice(1));
-		return table.count.apply(null, args);
-	}
 
-	async function getManyDto(filter, strategy) {
-		validateStrategy(table, strategy);
-		filter = negotiateFilter(filter);
-		const _baseFilter = await invokeBaseFilter();
-		if (_baseFilter)
-			filter = filter.and(_baseFilter);
-		let args = [filter].concat(Array.prototype.slice.call(arguments).slice(1));
-		await negotiateWhereAndAggregate(strategy);
-		return table.getManyDto.apply(null, args);
-	}
 
-	async function replace(subject, strategy = { insertAndForget: true }) {
-		validateStrategy(table, strategy);
-		const refinedStrategy = objectToStrategy(subject, {}, table);
-		const JSONFilter2 = {
-			path: 'getManyDto',
-			args: [subject, refinedStrategy]
-		};
-		const originals = await executePath({ table, JSONFilter: JSONFilter2, baseFilter, customFilters, request, response, readonly, disableBulkDeletes, isHttp, client });
-		const meta = getMeta(table);
-		const patch = createPatch(originals, Array.isArray(subject) ? subject : [subject], meta);
-		const { changed } =  await table.patch(patch, { strategy });
-		if (Array.isArray(subject))
-			return changed;
-		else
-			return changed[0];
-	}
+		async function negotiateWhereAndAggregate(strategy) {
+			if (typeof strategy !== 'object')
+				return;
 
-	async function update(subject, whereStrategy, strategy = { insertAndForget: true }) {
-		validateStrategy(table, strategy);
-		const refinedWhereStrategy = objectToStrategy(subject, whereStrategy, table);
-		const JSONFilter2 = {
-			path: 'getManyDto',
-			args: [null, refinedWhereStrategy]
-		};
-		const rows = await executePath({ table, JSONFilter: JSONFilter2, baseFilter, customFilters, request, response, readonly, disableBulkDeletes, isHttp, client });
-		const originals = new Array(rows.length);
-		for (let i = 0; i < rows.length; i++) {
-			const row = rows[i];
-			originals[i] = { ...row };
-			for (let p in subject) {
-				row[p] = subject[p];
+			for (let name in strategy) {
+				const target = strategy[name];
+				if (isFilter(target))
+					strategy[name] = await parseFilter(strategy[name], table);
+				else
+					await negotiateWhereAndAggregate(strategy[name]);
 			}
-		}
-		const meta = getMeta(table);
-		const patch = createPatch(originals, rows, meta);
-		const { changed } =  await table.patch(patch, { strategy });
-		return changed;
-	}
 
-	function objectToStrategy(object, whereStrategy, table, strategy = {}) {
-		strategy = {...whereStrategy, ...strategy};
-		if (Array.isArray(object)) {
-			for (let i = 0; i < object.length; i++) {
-				objectToStrategy(object[i], table, strategy);
-			}
-			return;
-		}
-		for (let name in object) {
-			const relation =  table[name]?._relation;
-			if (relation && !relation.columns) {//notJoin, that is one or many
-				strategy[name] = {};
-				objectToStrategy(object[name], whereStrategy?.[name], table[name], strategy[name]);
-			}
-			else
-				strategy[name] = true;
 		}
-		return strategy;
-	}
 
+		async function getMany(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.getMany.apply(null, args);
+		}
 
-	async function aggregate(filter, strategy) {
-		validateStrategy(table, strategy);
-		filter = negotiateFilter(filter);
-		const _baseFilter = await invokeBaseFilter();
-		if (_baseFilter)
-			filter = filter.and(_baseFilter);
-		let args = [filter].concat(Array.prototype.slice.call(arguments).slice(1));
-		await negotiateWhereAndAggregate(strategy);
-		return table.aggregate.apply(null, args);
 	}
 
-
-
-	async function negotiateWhereAndAggregate(strategy) {
-		if (typeof strategy !== 'object')
+	function validateStrategy(table, strategy) {
+		if (!strategy || !table)
 			return;
 
-		for (let name in strategy) {
-			const target = strategy[name];
-			if (isFilter(target))
-				strategy[name] = await parseFilter(strategy[name], table);
-			else
-				await negotiateWhereAndAggregate(strategy[name]);
+		for (let p in strategy) {
+			validateOffset(strategy);
+			validateLimit(strategy);
+			validateOrderBy(table, strategy);
+			validateStrategy(table[p], strategy[p]);
 		}
-
 	}
 
-	async function getMany(filter, strategy) {
-		validateStrategy(table, strategy);
-		filter = negotiateFilter(filter);
-		const _baseFilter = await invokeBaseFilter();
-		if (_baseFilter)
-			filter = filter.and(_baseFilter);
-		let args = [filter].concat(Array.prototype.slice.call(arguments).slice(1));
-		await negotiateWhereAndAggregate(strategy);
-		return table.getMany.apply(null, args);
+	function validateLimit(strategy) {
+		if (!('limit' in strategy) || Number.isInteger(strategy.limit))
+			return;
+		const e = new Error('Invalid limit: ' + strategy.limit);
+		// @ts-ignore
+		e.status = 400;
 	}
 
-}
-
-function validateStrategy(table, strategy) {
-	if (!strategy || !table)
-		return;
-
-	for (let p in strategy) {
-		validateOffset(strategy);
-		validateLimit(strategy);
-		validateOrderBy(table, strategy);
-		validateStrategy(table[p], strategy[p]);
+	function validateOffset(strategy) {
+		if (!('offset' in strategy) || Number.isInteger(strategy.offset))
+			return;
+		const e = new Error('Invalid offset: ' + strategy.offset);
+		// @ts-ignore
+		e.status = 400;
+		throw e;
 	}
-}
 
-function validateLimit(strategy) {
-	if (!('limit' in strategy) || Number.isInteger(strategy.limit))
-		return;
-	const e = new Error('Invalid limit: ' + strategy.limit);
-	// @ts-ignore
-	e.status = 400;
-}
-
-function validateOffset(strategy) {
-	if (!('offset' in strategy) || Number.isInteger(strategy.offset))
-		return;
-	const e = new Error('Invalid offset: ' + strategy.offset);
-	// @ts-ignore
-	e.status = 400;
-	throw e;
-}
+	function validateOrderBy(table, strategy) {
+		if (!('orderBy' in strategy) || !table)
+			return;
+		let orderBy = strategy.orderBy;
+		if (!Array.isArray(orderBy))
+			orderBy = [orderBy];
+		orderBy.reduce(validate, []);
+
+		function validate(_, element) {
+			let parts = element.split(' ').filter(x => {
+				x = x.toLowerCase();
+				return (!(x === '' || x === 'asc' || x === 'desc'));
+			});
+			for (let p of parts) {
+				let col = table[p];
+				if (!(col && col.equal)) {
+					const e = new Error('Unknown column: ' + p);
+					// @ts-ignore
+					e.status = 400;
+					throw e;
+				}
+			}
+		}
+	}
 
-function validateOrderBy(table, strategy) {
-	if (!('orderBy' in strategy) || !table)
-		return;
-	let orderBy = strategy.orderBy;
-	if (!Array.isArray(orderBy))
-		orderBy = [orderBy];
-	orderBy.reduce(validate, []);
-
-	function validate(_, element) {
-		let parts = element.split(' ').filter(x => {
-			x = x.toLowerCase();
-			return (!(x === '' || x === 'asc' || x === 'desc'));
-		});
-		for (let p of parts) {
-			let col = table[p];
-			if (!(col && col.equal)) {
-				const e = new Error('Unknown column: ' + p);
+	function validateArgs() {
+		for (let i = 0; i < arguments.length; i++) {
+			const filter = arguments[i];
+			if (!filter)
+				continue;
+			if (filter && filter.isSafe === isSafe)
+				continue;
+			if (filter.sql || typeof (filter) === 'string') {
+				const e = new Error('Raw filters are disallowed');
 				// @ts-ignore
-				e.status = 400;
+				e.status = 403;
 				throw e;
 			}
-		}
-	}
-}
+			if (Array.isArray(filter))
+				for (let i = 0; i < filter.length; i++) {
 
-function validateArgs() {
-	for (let i = 0; i < arguments.length; i++) {
-		const filter = arguments[i];
-		if (!filter)
-			continue;
-		if (filter && filter.isSafe === isSafe)
-			continue;
-		if (filter.sql || typeof (filter) === 'string') {
-			const e = new Error('Raw filters are disallowed');
-			// @ts-ignore
-			e.status = 403;
-			throw e;
+					validateArgs(filter[i]);
+				}
 		}
-		if (Array.isArray(filter))
-			for (let i = 0; i < filter.length; i++) {
 
-				validateArgs(filter[i]);
-			}
 	}
 
-}
+	function isFilter(json) {
+		return json instanceof Object && 'path' in json && 'args' in json;
+	}
 
-function isFilter(json) {
-	return json instanceof Object && 'path' in json && 'args' in json;
-}
+	function setSafe(o) {
+		if (o instanceof Object)
+			Object.defineProperty(o, 'isSafe', {
+				value: isSafe,
+				enumerable: false
 
-function setSafe(o) {
-	if (o instanceof Object)
-		Object.defineProperty(o, 'isSafe', {
-			value: isSafe,
-			enumerable: false
+			});
+	}
 
-		});
-}
+	function extractRelations(obj) {
+		let flattened = {};
 
-function extractRelations(obj) {
-	let flattened = {};
+		function helper(relations) {
+			Object.keys(relations).forEach(key => {
 
-	function helper(relations) {
-		Object.keys(relations).forEach(key => {
+				flattened[key] = true;
 
-			flattened[key] = true;
+				if (typeof relations[key] === 'object' && Object.keys(relations[key]?.relations)?.length > 0) {
+					helper(relations[key].relations);
+				}
+			});
+		}
 
-			if (typeof relations[key] === 'object' && Object.keys(relations[key]?.relations)?.length > 0) {
-				helper(relations[key].relations);
-			}
-		});
+		helper(obj.relations);
+
+		return flattened;
 	}
 
-	helper(obj.relations);
+	function bindDb(client) {
+		var domain = context;
+		let p = domain.run(() => true);
 
-	return flattened;
-}
+		function run(fn) {
+			return p.then(domain.run.bind(domain, fn));
+		}
 
-function bindDb(client) {
-	// @ts-ignore
-	var domain = process.domain;
-	let p = domain.run(() => true);
+		return client({ transaction: run });
 
-	function run(fn) {
-		return p.then(domain.run.bind(domain, fn));
 	}
-
-	return client({ transaction: run });
-
 }
-module.exports = executePath;
+module.exports = _executePath;