nodester 0.0.1 → 0.0.6

package/lib/middlewares/ql/sequelize/interpreter/QueryLexer.js

@@ -0,0 +1,456 @@
+const Enum = require('../../../../enums/Enum');
+const { ModelsTree, ModelsTreeNode } = require('./ModelsTree');
+const util = require('util');
+const debug = require('debug')('nodester:interpreter:QueryLexer');
+
+const OP_TOKENS = new Enum({
+	AND: 'and',
+	BETWEEN: 'between',
+	NOT_BETWEEN: 'notBetween',
+	BETWEEN_MARK: '~',
+	OR: 'or',
+	OR_MARK: '|',
+	XOR: 'xor',
+	NOT: 'not',
+	NOT_MARK: '!',
+	NOT_IN: 'notIn',
+	LIKE: 'like',
+	GREATER: 'gt',
+	GREATER_OR_EQUAL: 'gte',
+	LOWER: 'lt',
+	LOWER_OR_EQUAL: 'lte'
+});
+
+
+module.exports = class QueryLexer {
+	constructor(queryString='') {
+		this.tree = new ModelsTree();
+		this.query = !!queryString ?
+									this.parse(queryString).toObject()
+									:
+									{};
+	}
+
+	parse(queryString='', tree=this.tree) {
+		if (typeof queryString !== 'string') {
+			const err = new TypeError(`Invalid 'queryString'.`);
+			throw err;
+		}
+
+		// You never know if it's encoded or not.
+		const decoded = decodeURI(queryString);
+
+		this.parseIsolatedQuery(decoded, 0, this.tree);
+
+		return this.tree.root;
+	}
+
+	parseIsolatedQuery(queryString='', startAt=0, tree) {
+		const isSubQuery = tree.node.model !== 'root';
+		debug({ isSubQuery, startAt });
+
+		// Token is accumulated char-by-char.
+		let token = '';
+		// Value of param ('id=10' OR 'fields=id,text').
+		let value = [];
+		// Model, that was active before cursor went up in the tree.
+		let previousActive = null;
+
+		for (let i=startAt; i < queryString.length; i++) {
+			const char = queryString[i];
+
+			// ( can mean params of OP token,
+			// or subquery of a model:
+			if (char === '(') {
+				debug('char', char, { token, node: tree.node });
+
+				// If OP token:
+				if (OP_TOKENS.asArray.indexOf(token) > -1) {
+					// Set operation token.
+					tree.node.op = this.parseOP(token);
+					token = '';
+					continue;
+				}
+				// If model subquery:
+				else {
+					const model = token;
+					tree.use(model) ?? tree.include(model).use(model);
+					token = '';
+
+					// Process subquery:
+					i++;
+					const [ charsCount ] = this.parseIsolatedQuery(queryString, i, tree);
+					i += charsCount;
+
+					previousActive = model;
+					tree.up();
+
+					continue;
+				}
+			}
+
+			// ) can mean end of OP token params,
+			// or end of subquery:
+			if (char === ')') {
+				debug('char', char, { token, node: tree.node });
+
+				// If end of OP token:
+				if (!!tree.node.op) {
+
+					// If token is empty, error:
+					if (token === '') {
+						const err = UnexpectedCharError(i, char);
+						throw err;
+					}
+
+					// Structure of a value depends on OP:
+					let fullOp = {};
+					switch (tree.node.op) {
+						case 'not':
+						case 'like':
+							fullOp = { [tree.node.activeParam]: { [tree.node.op]: [token] } };
+							break;
+						default:
+							value.push({ [tree.node.activeParam]: [token] });
+							fullOp = { [tree.node.op]: value };
+							break;
+					}
+
+					tree.node.addWhere(fullOp);
+
+					// Reset:
+					tree.node.resetOP();
+					tree.node.activeParam = 'includes';
+					token = '';
+					value = [];
+					continue;
+				}
+
+				// If end of subquery:
+				if (!!tree.node.activeParam && tree.node.activeParam !== 'includes') {
+					// Set value.
+					this.setNodeParam(tree.node, token, value);
+					// Reset:
+					tree.node.resetActiveParam();
+					tree.node.resetOP();
+				}
+				const numberOfProcessedChars = i - startAt;
+				return [ numberOfProcessedChars ];
+			}
+
+			// , can mean n-th value in value array,
+			// or horizontal include:
+			if (char === ',') {
+				debug('char', char, { token, node: tree.node });
+
+				// If OP token:
+				if (!!tree.node.op) {
+					value.push({
+						[tree.node.activeParam]: [token]
+					});
+					token = '';
+					continue;
+				}
+
+				// If param value:
+				if (tree.node.activeParam !== 'includes') {
+					value.push(token);
+					token = '';
+					continue;
+				}
+
+				// Just quit from subquery:
+				if (token.length === 0) {
+					continue;
+				}
+
+				// Horizontal include:
+				if (tree.node.activeParam === 'includes') {
+					const model = token;
+					tree.use(model) ?? tree.include(model);
+
+					token = '';
+					continue;
+				}
+
+				const err = UnexpectedCharError(i, char);
+				throw err;
+			}
+
+			// . can mean vertical include
+			// or it can be a part of param for "where":
+			if (char === '.') {
+				debug('char', char, { token, node: tree.node });
+
+				// Vertical include:
+				if (!!previousActive) {
+					tree.use(previousActive);
+					tree.node.activeParam = 'includes';
+					token = '';
+					continue;
+				}
+
+				// If include of new model:
+				if (token.length > 0) {
+					const model = token;
+					tree.use(model) ?? tree.include(model).use(model);
+
+					// Prepare for more includes:
+					tree.node.activeParam = 'includes';
+
+					token = '';
+					continue;
+				}
+
+				const err = UnexpectedCharError(i, char);
+				throw err;
+			}
+
+			// + can only mean horizontal include:
+			if (char === '+') {
+				debug('char', char, { token, node: tree.node });
+
+				// If include of new model:
+				if (token.length > 0) {
+					const model = token;
+					// Include, but do not use:
+					tree.use(model) ?? tree.include(model).use(model);
+					tree.up();
+
+					// Prepare for more includes:
+					tree.node.activeParam = 'includes';
+
+					token = '';
+					continue;
+				}
+
+				if (tree.node.hasParent === false) {
+					const err = UnexpectedCharError(i, char);
+					throw err;
+				}
+
+				tree.up();
+				tree.node.activeParam = 'includes';
+
+				continue;
+			}
+
+			// & can mean the end of key=value pair,
+			// or the end of subincludes:
+			if (char === '&') {
+				debug('char', char, { token, node: tree.node });
+
+				// If any OP at all:
+				if (!!tree.node.op) {
+					const err = MissingCharError(i+1, ')');
+					throw err;
+				}
+
+				// If end of key=value pair:
+				if (!!tree.node.activeParam && tree.node.activeParam !== 'includes') {
+					// Set value.
+					this.setNodeParam(tree.node, token, value);
+					// Reset:
+					tree.node.resetActiveParam();
+					token = '';
+					value = [];
+					continue;
+				}
+				else if (tree.node.activeParam === 'includes') {
+					// If include of new model:
+					if (token.length > 0) {
+						const model = token;
+						// Just include, no use.
+						tree.include(model);
+					}
+
+					// Then jump to root.
+					tree.upToRoot();
+
+					// Reset:
+					token = '';
+					value = [];
+					continue;	
+				}
+
+				// If end of subquery:
+				if (tree.node.hasParent === true) {
+					tree.up();
+					continue;
+				}
+				// If root:
+				else {
+					// Reset:
+					tree.node.resetActiveParam();
+					token = '';
+					value = [];
+					continue;
+				}
+
+				// Unknown case:
+				const err = UnexpectedCharError(i, char);
+				throw err;
+			}
+			
+			// [ can only mean start of 'in':
+			if (char === '[') {
+				tree.node.op = 'in';
+				continue;
+			}
+
+			// ] can only mean end if 'in':
+			if (char === ']') {
+				// User missed first '[' :
+				if (tree.node.op !== 'in') {
+					const err = UnexpectedCharError(i, char);
+					throw err;
+				}
+
+				tree.node.addWhere({
+					[tree.node.activeParam]: {
+						[tree.node.op]: value
+					}
+				});
+				// Reset:
+				tree.node.resetOP();
+				value = [];
+				token = '';
+				continue;
+			}
+			
+			// = can only mean the end of param name:
+			if (char === '=') {
+				const param = this.parseParamFromToken(token);
+
+				if (isSubQuery === true && param === 'includes') {
+					const err = new TypeError(`'include' is forbidden inside subquery (position ${ i }). Use: 'model.model' or 'model.model+model'.`);
+					throw err;
+				}
+
+				tree.node.activeParam = param;
+				token = '';
+				continue;
+			}
+
+			// Continue accumulating token.
+			token += char;
+			
+			// If last char:
+			if (i === queryString.length-1) {
+				debug('last char', { token, node: tree.node });
+				
+				// haven't up from 'in':
+				if (tree.node.op === 'in') {
+					const err = MissingCharError(i+1, ']');
+					throw err;
+				}
+
+				// If any OP at all:
+				if (!!tree.node.op) {
+					const err = MissingCharError(i+1, ')');
+					throw err;
+				}
+
+				this.setNodeParam(tree.node, token, value);
+
+				// If end of subquery:
+				if (isSubQuery === true) {
+					const numberOfProcessedChars = i+1 - startAt;
+					return [ numberOfProcessedChars ];
+				}
+			}
+		}
+
+		return [ queryString.length - startAt ];
+	}
+
+	parseParamFromToken(token) {
+		switch(token) {
+			case 'limit':
+			case 'l':
+				return 'limit';
+			case 'skip':
+			case 's':
+			case 'offset':
+				return 'skip';
+			case 'order':
+			case 'o':
+				return 'order';
+			case 'order_by':
+			case 'o_by':
+				return 'orderBy';
+			case 'fields':
+			case 'f':
+				return 'fields';
+			case 'includes':
+			case 'in':
+				return 'includes';
+			default:
+				return token;
+		}
+	}
+
+	setNodeParam(treeNode, token, value) {
+		const param = treeNode.activeParam;
+
+		debug(`set param ${ param }`, { token, value });
+
+		switch(param) {
+			case 'limit':
+				treeNode.limit = parseInt(token);
+				break;
+			case 'skip':
+			case 'offset':
+				treeNode.skip = parseInt(token);
+				break;
+			case 'order':
+				treeNode.order = token;
+				break;
+			case 'orderBy':
+				treeNode.orderBy = token;
+				break;
+			case 'fields':
+				if (token)
+					value.push(token);
+				treeNode.fields = value;
+				break;
+			case 'includes':
+				const node = new ModelsTreeNode(token);
+				treeNode.include(node);
+				break;
+			default:
+				if (token)
+					value.push(token);
+				treeNode.addWhere({ [param]: value });
+				break;
+		}
+	}
+
+	parseOP(opToken) {
+		switch(opToken) {
+			case '|':
+			case 'or':
+				return 'or';
+			case 'not':
+			case '!':
+				return 'not';
+			default:
+				return opToken;
+		}
+	}
+
+	[util.inspect.custom](depth, opts) {
+		return this.tree.root;
+	}
+}
+
+
+function UnexpectedCharError(index, char) {
+	const err = new TypeError(`Unexpected ${ char } at position ${ index }`);
+	return err;
+}
+
+function MissingCharError(index, char) {
+	const err = new TypeError(`Missing ${ char } at position ${ index }`);
+	return err;
+}

package/lib/models/define.js

@@ -3,25 +3,18 @@ const { implementsCRUD } = require('./mixins');
 // ORM.
 const { DataTypes } = require('sequelize');
 
-// Utils.
-// const {
-// 	pluralize,
-// 	underscore
-// } = require('../utils/strings.util');
 
-
-module.exports = _defineModel;
+module.exports = defineModel;
 
 /*
- * params:
- * - databaseConnection (Instance of Sequilize)
- * - modelName (String)
- * - definition (function)
- * - options (Object)
+ * @param {SequilizeConnection} databaseConnection
+ * @param {String} modelName
+ * @param {Function} definition
+ * @param {Object} options
  *   - ... Sequilize model options
  *   - noCRUD (Bool)
  */
-function _defineModel(
+function defineModel(
 	databaseConnection,
 	modelName='',
 	definition=()=>{},

package/lib/models/mixins.js

@@ -13,28 +13,41 @@ module.exports = {
 	implementsCRUD: _implementsCRUD
 }
 
-function _implementsCRUD(modelDefinition) {
-	if (!!modelDefinition) {
 
-		// Create.
-		modelDefinition.createWithIncludes = _createWithIncludes.bind(modelDefinition);
+/**
+ * Sets all of CRUD methods to Model.
+ *
+ * @param {Object} controller
+ *
+ *
+ * @api public
+ * @alias implementsCRUD
+ */
+function _implementsCRUD(model) {
+	if (!model) {
+		const err = new TypeError(`'model' argument is not provided.`);
+		throw err;
+	}
 
-		// Read:
-		modelDefinition.findById = _findById.bind(modelDefinition);
-		modelDefinition.findOneWithIncludes = _findOneWithIncludes.bind(modelDefinition);
+	// Create.
+	modelDefinition.createWithIncludes = _createWithIncludes.bind(modelDefinition);
 
-		// Update:
-		modelDefinition.updateOne = _updateOne.bind(modelDefinition);
-		modelDefinition.updateById = _updateById.bind(modelDefinition);
+	// Read:
+	modelDefinition.findById = _findById.bind(modelDefinition);
+	modelDefinition.findOneWithIncludes = _findOneWithIncludes.bind(modelDefinition);
 
-		// Delete.
-		modelDefinition.deleteById = _deleteById.bind(modelDefinition);
+	// Update:
+	modelDefinition.updateOne = _updateOne.bind(modelDefinition);
+	modelDefinition.updateById = _updateById.bind(modelDefinition);
 
-		// Associations:
-		modelDefinition.getIncludesList = _getIncludesList.bind(modelDefinition);
-	}
+	// Delete.
+	modelDefinition.deleteById = _deleteById.bind(modelDefinition);
+
+	// Associations:
+	modelDefinition.getIncludesList = _getIncludesList.bind(modelDefinition);
 }
 
+
 /* Main mixinis: */
 async function _createWithIncludes(
 	data={}

package/lib/params/Params.js

@@ -0,0 +1,34 @@
+
+module.exports = Params;
+
+/**
+ * Extracts only values in second argument
+ * from first argument.
+ * If such values is missing in first atgument,
+ * will fallback to the value in second argument.
+ *
+ * @param {Object} sourceObj
+ * @param {Object} defaultValuesList
+ *
+ * @return {Function|Object} controller
+ *
+ * @api public
+ * @alias withDefaultCRUD
+ */
+function Params(
+	sourceObj={},
+	defaultValuesList={}
+) {
+	const result = {};
+
+	const keys = Object.keys(defaultValuesList);
+	for (const key of keys) {
+		// If value is not set, use default one from 'defaultValuesList'.
+		result[key] = !(key in sourceObj[key]) ?
+										defaultValuesList[key]
+										:
+										sourceObj[key];
+	}
+
+	return result;
+}

package/lib/queries/NodesterQueryParams.js

@@ -0,0 +1,139 @@
+// Dictionary of unsafe characters:
+const NOT_ALLOWED = [
+	'{',
+	'}',
+	// `\`,
+	'^',
+	'~',
+	'[',
+	']',
+	'`'
+];
+
+const util = require('util');
+
+/*
+ * NodesterQueryParams is a ready-to-use replacement for URLSearchParams.
+ * The only difference is that NodesterQueryParams
+ * respects nested "&" during parsing.
+ */
+module.exports = class NodesterQueryParams {
+	constructor(queryString='') {
+		// Type validateion:
+		if (typeof queryString !== 'string') {
+			const err = new TypeError(`'query' must be a String.`);
+			throw err;
+		}
+
+		// You never know if it's encoded or not.
+		const decoded = decodeURI(queryString);
+
+		// Indicates, how deep the char is inside different ().
+		let deep = 0;
+
+		const paramLevels = {};
+
+		// Current query parameter.
+		let param = '';
+
+		// Current query token.
+		let token = '';
+
+		this._map = new Map();
+
+		for (let i=0; i < decoded.length; i++) {
+			const char = decoded[i];
+
+			// Validate char:
+			if (NOT_ALLOWED.indexOf(char) > -1) {
+				const err = new TypeError(`Invalid query token at ${ i }: '${ char }'`);
+				throw err;
+			}
+
+			if (char === '(') {
+				// Error If there is nothing behind:
+				if (param.length === 0) {
+					const err = new TypeError(`Invalid query token at ${ i }: '${ char }'`);
+					throw err;
+				}
+
+				// If not special token, go deeper:
+				if (['and', 'or', 'xor', 'not', '!', '|', 'like'].indexOf(token) === -1) {
+					this.append(param, token);
+					deep++;
+				}
+
+				// will set ( in token later.
+			}
+
+			if (char === ')') {
+				// If sub-level:
+				if (deep > 0) {
+					deep--
+				}
+			}
+
+			// & can mean the end of key=value pair:
+			if (char === '&') {
+				// If top-level:
+				if (deep === 0) {
+					this.append(param, token);
+					param = '';
+					token = '';
+					continue;
+				}
+
+				// If sub-level do nothing.
+			}
+			
+			// = can mean the end of param name:
+			if (char === '=') {
+				// If top-level:
+				if (deep === 0) {
+					param = token;
+					token = '';
+				}
+			}
+			
+			// Continue building token:
+			if (char !== '=' || deep > 0 ) {
+				token += char;
+			}
+
+			// If last char:
+			if (i === decoded.length-1) {
+				// Validate:
+				if (deep > 0) {
+					const err = new TypeError(`Missing ')' at ${ i }`);
+					throw err;
+				}
+
+				this.append(param, token);
+			}
+		}
+	}
+
+	append(...args) {
+		return this._map.set(...args);
+	}
+
+	get(...args) {
+		return this._map.get(...args);
+	}
+
+	delete(...args) {
+		return this._map.delete(...args);
+	}
+
+	entries(...args) {
+		return this._map.entries(...args);
+	}
+
+	toString() {
+		return this._map.toString();
+	}
+
+	[util.inspect.custom](depth, opts) {
+		return this._map;
+	}
+}