orange-orm 3.10.2

package/src/hostExpress/executePath.js

@@ -0,0 +1,433 @@
+let 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,
+	or: true,
+	not: true,
+	AND: true,
+	OR: true,
+	NOT: true,
+	equal: true,
+	eq: true,
+	EQ: true,
+	notEqual: true,
+	ne: true,
+	NE: true,
+	lessThan: true,
+	lt: true,
+	LT: true,
+	lessThanOrEqual: true,
+	le: true,
+	LE: true,
+	greaterThan: true,
+	gt: true,
+	GT: true,
+	greaterThanOrEqual: true,
+	ge: true,
+	GE: true,
+	between: true,
+	in: true,
+	IN: true,
+	startsWith: true,
+	iStartsWith: true,
+	endsWith: true,
+	iEndsWith: true,
+	contains: true,
+	iContains: true,
+	iEqual: true,
+	iEq: true,
+	ieq: true,
+	IEQ: true,
+	exists: true,
+	all: true,
+	any: true,
+	none: true,
+	where: true,
+	sum: true,
+	avg: true,
+	max: true,
+	min: true,
+	count: true,
+	groupSum: true,
+	groupAvg: true,
+	groupMax: true,
+	groupMin: true,
+	groupCount: true,
+	_aggregate: true,
+	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 };
+	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;
+			}
+			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 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]];
+			}
+
+			let res = target.apply(null, args);
+			setSafe(res);
+			return res;
+		}
+	}
+
+
+
+	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 });
+		}
+		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 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 });
+		}
+	}
+
+	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;
+		}
+		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;
+		}
+	}
+
+	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;
+		}
+		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;
+
+		}
+		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 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')
+			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]);
+		}
+
+	}
+
+	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 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 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 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;
+		}
+		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 setSafe(o) {
+	if (o instanceof Object)
+		Object.defineProperty(o, 'isSafe', {
+			value: isSafe,
+			enumerable: false
+
+		});
+}
+
+function extractRelations(obj) {
+	let flattened = {};
+
+	function helper(relations) {
+		Object.keys(relations).forEach(key => {
+
+			flattened[key] = true;
+
+			if (typeof relations[key] === 'object' && Object.keys(relations[key]?.relations)?.length > 0) {
+				helper(relations[key].relations);
+			}
+		});
+	}
+
+	helper(obj.relations);
+
+	return flattened;
+}
+
+function bindDb(client) {
+	// @ts-ignore
+	var domain = process.domain;
+	let p = domain.run(() => true);
+
+	function run(fn) {
+		return p.then(domain.run.bind(domain, fn));
+	}
+
+	return client({ transaction: run });
+
+}
+module.exports = executePath;

package/src/hostExpress/getMeta.js

@@ -0,0 +1,49 @@
+let extractSubStrategy = _extractSubStrategy;
+
+function _extractSubStrategy(table, map) {
+	extractSubStrategy = require('./getMeta');
+	return extractSubStrategy(table, map);
+}
+
+function getMeta(table, map = new Map()) {
+	if (map.has(table))
+		return map.get(table).id;
+	let strategy = {
+		keys: table._primaryColumns.map(x => ({name: x.alias, type: x.tsType})),
+		columns: {},
+		relations: {},
+		id: map.size
+	};
+	map.set(table, strategy);
+
+	for (let i = 0; i < table._columns.length; i++) {
+		const column = table._columns[i];
+		strategy.columns[column.alias] = {};
+		if ('serializable' in column && !column.serializable)
+			strategy.columns[column.alias].serializable = false;
+		else
+			strategy.columns[column.alias].serializable = true;
+	}
+
+	let relations = table._relations;
+	let relationName;
+
+	let visitor = {};
+	visitor.visitJoin = function(relation) {
+		strategy.relations[relationName] = extractSubStrategy(relation.childTable, map);
+	};
+
+	visitor.visitMany = function(relation) {
+		strategy.relations[relationName] = extractSubStrategy(relation.childTable, map);
+	};
+
+	visitor.visitOne = visitor.visitMany;
+
+	for (relationName in relations) {
+		let relation = relations[relationName];
+		relation.accept(visitor);
+	}
+	return strategy;
+}
+
+module.exports = getMeta;

package/src/hostExpress.js

@@ -0,0 +1,125 @@
+const getTSDefinition = require('./getTSDefinition');
+let hostLocal = _hostLocal;
+const getMeta = require('./hostExpress/getMeta');
+
+function hostExpress(client, options = {}) {
+	if ('db' in options && (options.db ?? undefined) === undefined || !client.db)
+		throw new Error('No db specified');
+	const dbOptions = { db: options.db || client.db };
+	let c = {};
+	const readonly = { readonly: options.readonly};
+	for (let tableName in client.tables) {
+		c[tableName] = hostLocal({
+			...dbOptions,
+			...readonly,
+			...options[tableName],
+			table: client.tables[tableName],
+			isHttp: true, client
+
+		});
+	}
+
+	async function handler(req, res) {
+		if (req.method === 'POST')
+			return post.apply(null, arguments);
+		if (req.method === 'PATCH')
+			return patch.apply(null, arguments);
+		if (req.method === 'GET')
+			return get.apply(null, arguments);
+		if (req.method === 'OPTIONS')
+			return handleOptions(req, res); // assuming the second argument is `response`
+
+		else
+			res.status(405).set('Allow', 'GET, POST, PATCH, OPTIONS').send('Method Not Allowed');
+	}
+
+	handler.db = handler;
+	handler.dts = get;
+
+	function get(request, response) {
+		try {
+			if (request.query.table) {
+				if (!(request.query.table in c)) {
+					let e = new Error('Table is not exposed or does not exist');
+					// @ts-ignore
+					e.status = 400;
+					throw e;
+				}
+
+				const result = getMeta(client.tables[request.query.table]);
+				response.setHeader('content-type', 'text/plain');
+				response.status(200).send(result);
+			}
+			else {
+				const isNamespace = request.query.isNamespace === 'true';
+				let tsArg = Object.keys(c).map(x => {
+					return { table: client.tables[x], customFilters: options?.tables?.[x].customFilters, name: x };
+				});
+				response.setHeader('content-type', 'text/plain');
+				response.status(200).send(getTSDefinition(tsArg, { isNamespace, isHttp: true }));
+			}
+		}
+		catch (e) {
+			if (e.status === undefined)
+				response.status(500).send(e.message || e);
+			else
+				response.status(e.status).send(e.message);
+		}
+	}
+
+	async function patch(request, response) {
+		try {
+			response.json(await c[request.query.table].patch(request.body, request, response));
+		}
+		catch (e) {
+			if (e.status === undefined)
+				response.status(500).send(e.message || e);
+			else
+				response.status(e.status).send(e.message);
+
+		}
+	}
+
+	async function post(request, response) {
+		try {
+			if (!request.query.table) {
+				let e = new Error('Table not defined');
+				// @ts-ignore
+				e.status = 400;
+				throw e;
+			}
+			else if (!(request.query.table in c)) {
+				let e = new Error('Table is not exposed or does not exist');
+				// @ts-ignore
+				e.status = 400;
+				throw e;
+			}
+
+			response.json(await c[request.query.table].post(request.body, request, response));
+		}
+		catch (e) {
+			if (e.status === undefined)
+				response.status(500).send(e.message || e);
+			else
+				response.status(e.status).send(e.message);
+		}
+
+	}
+
+	function handleOptions(req, response) {
+		response.setHeader('Access-Control-Allow-Origin', '*'); // Adjust this as per your CORS needs
+		response.setHeader('Access-Control-Allow-Methods', 'GET, POST, PATCH, OPTIONS'); // And any other methods you support
+		response.setHeader('Access-Control-Allow-Headers', 'Content-Type'); // And any other headers you expect in requests
+		response.setHeader('Access-Control-Max-Age', '86400'); // Cache preflight request for a day. Adjust as you see fit
+		response.status(204).send(); // 204 No Content response for successful OPTIONS requests
+	}
+
+	return handler;
+}
+
+function _hostLocal() {
+	hostLocal = require('./hostLocal');
+	return hostLocal.apply(null, arguments);
+}
+
+module.exports = hostExpress;

package/src/hostLocal.js

@@ -0,0 +1,110 @@
+let executePath = require('./hostExpress/executePath');
+let getMeta = require('./hostExpress/getMeta');
+let setSessionSingleton = require('./table/setSessionSingleton');
+let executeQuery = require('./query');
+let hostExpress = require('./hostExpress');
+
+// { db, table, defaultConcurrency,
+// 	concurrency,
+// 	customFilters,
+// 	baseFilter, strategy, transaction,
+// 	readonly,
+// 	disableBulkDeletes, isBrowser }
+function hostLocal() {
+	const _options = arguments[0];
+	let { table, transaction, db, isHttp } = _options;
+
+	let c = { get, post, patch, query, express };
+
+	function get() {
+		return getMeta(table);
+
+	}
+	async function patch(body,_req, _res) {
+		if (!table) {
+			const error = new Error('Table is not exposed');
+			// @ts-ignore
+			error.status = 400;
+			throw error;
+		}
+		body = typeof body === 'string' ? JSON.parse(body) : body;
+		let result;
+
+		if (transaction)
+			await transaction(fn);
+		else {
+			if (typeof db === 'function') {
+				let dbPromise = db();
+				if (dbPromise.then)
+					db = await dbPromise;
+				else
+					db = dbPromise;
+			}
+			await db.transaction(fn);
+		}
+		return result;
+
+		async function fn() {
+			setSessionSingleton('ignoreSerializable', true);
+			let patch = body.patch;
+			result = await table.patch(patch, { ..._options, ...body.options, isHttp });
+		}
+	}
+
+	async function post(body, request, response) {
+		body = typeof body === 'string' ? JSON.parse(body) : body;
+		let result;
+
+		if (transaction)
+			await transaction(fn);
+		else {
+			if (typeof db === 'function') {
+				let dbPromise = db();
+				if (dbPromise.then)
+					db = await dbPromise;
+				else
+					db = dbPromise;
+			}
+			await db.transaction(fn);
+		}
+		return result;
+
+		async function fn() {
+			setSessionSingleton('ignoreSerializable', true);
+			const options = { ..._options, ...body.options, JSONFilter: body, request, response, isHttp };
+			result = await executePath(options);
+		}
+	}
+	async function query() {
+		let args = arguments;
+		let result;
+
+		if (transaction)
+			await transaction(fn);
+		else {
+			if (typeof db === 'function') {
+				let dbPromise = db();
+				if (dbPromise.then)
+					db = await dbPromise;
+				else
+					db = dbPromise;
+			}
+			result = await db.query.apply(null, arguments);
+		}
+
+		return result;
+
+		async function fn() {
+			result = await executeQuery.apply(null, args);
+		}
+
+	}
+
+	function express(client, options) {
+		return hostExpress(client, options );
+	}
+
+	return c;
+}
+
+module.exports = hostLocal;