nodester 0.6.0 → 0.6.1

package/lib/errors/NodesterQueryError.js

@@ -5,15 +5,10 @@
 
 'use strict';
 
-const {
-	NODESTER_QUERY_ERROR,
-} = require('nodester/constants/ErrorCodes');
 const {
 	NOT_ACCEPTABLE
 } = require('nodester/http/codes');
 
-const NodesterError = require('./NodesterError');
-
 
 /**
  * @class
@@ -22,11 +17,12 @@ const NodesterError = require('./NodesterError');
  *
  * @access public
  */
-module.exports = class NodesterQueryError extends NodesterError {
-	constructor(message) {
+module.exports = class NodesterQueryError extends Error {
+	constructor(message, status) {
 		super(message);
 
-		this.status = NOT_ACCEPTABLE;
+		this.name = this.constructor.name;
+		this.status = status ?? NOT_ACCEPTABLE;
 
 		Error.captureStackTrace(this, this.constructor);
 	}

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

@@ -17,21 +17,25 @@ class ModelsTreeNode {
 	constructor(model, parent=null, opts={}) {
 		this.model = model;
 		this.parent = parent;
+
 		this.activeParam = null;
 		this.op = null;
 		this.fn = null;
 
-		// for override:
 		this._attributes = [];
 		this._where = {};
 		this._functions = [];
+
+		// Clauses:
+		this.group_by = opts.group_by ?? undefined;
 		this.skip = 0;
 		this.limit = -1; // No limit
-
-		this._includes = opts.includes ?? [];
-
+		
 		this.order = opts.order ?? undefined;
 		this.order_by = opts.order_by ?? undefined;
+		// Clauses\
+
+		this._includes = opts.includes ?? [];
 	}
 
 	// Getters:
@@ -107,6 +111,7 @@ class ModelsTreeNode {
 
 			where: this.where,
 
+			group_by: this.group_by,
 			skip: this.skip,
 			limit: this.limit,
 			order: this.order,

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

@@ -9,7 +9,7 @@ const Enum = require('nodester/enum');
 
 const { ModelsTree, ModelsTreeNode } = require('./ModelsTree');
 
-const NodesterQueryError = require('./NodesterQueryError');
+const { NodesterQueryError } = require('nodester/errors');
 
 const util = require('util');
 const debug = require('debug')('nodester:interpreter:QueryLexer');
@@ -22,6 +22,7 @@ const PARAM_TOKENS = new Enum({
 	INCLUDES: Symbol('includes'),
 
 	// Clauses:
+	GROUP_BY: Symbol('group_by'),
 	LIMIT: Symbol('limit'),
 	ORDER: Symbol('order'),
 	ORDER_BY: Symbol('order_by'),
@@ -187,12 +188,7 @@ module.exports = class QueryLexer {
 
 				// If end of FN token:
 				if (!!tree.node.fn) {
-					// If token is empty, error:
-					if (token === '') {
-						const err = UnexpectedCharError(i, char);
-						throw err;
-					}
-
+					// Token is the param of this fn:
 					const fnParams = {
 						fn: tree.node.fn
 					};
@@ -547,6 +543,10 @@ module.exports = class QueryLexer {
 			case 'in':
 				return PARAM_TOKENS.INCLUDES;
 
+			// Clauses:
+			case 'group_by':
+				return PARAM_TOKENS.GROUP_BY;
+
 			case 'limit':
 			case 'l':
 				return PARAM_TOKENS.LIMIT;
@@ -562,6 +562,7 @@ module.exports = class QueryLexer {
 			case 'skip':
 			case 's':
 				return PARAM_TOKENS.SKIP;
+			// Clauses\
 
 			default:
 				return token;
@@ -589,6 +590,10 @@ module.exports = class QueryLexer {
 				break;
 
 			// Clauses:
+			case PARAM_TOKENS.GROUP_BY:
+				treeNode.group_by = token;
+				break;
+
 			case PARAM_TOKENS.LIMIT:
 				treeNode.limit = parseInt(token);
 				break;

package/lib/query/traverse/index.js

@@ -12,10 +12,14 @@ const httpCodes = require('nodester/http/codes');
 
 const { ensure } = require('nodester/validators/arguments');
 
+// Mappers & parsers:
+const mapCOUNT = require('./mappers/functions/count');
+
 const {
 	parseValue,
 	parseWhereEntry,
 } = require('./parsers');
+// Mappers & parsers\
 
 const {
 	disassembleQueryNode,
@@ -26,6 +30,8 @@ const {
 	getModelAssociationProps
 } = require('../../utils/modelAssociations.util');
 
+const consl = require('nodester/loggers/console');
+
 
 module.exports = traverse;
 
@@ -114,8 +120,13 @@ function traverse(queryNode, filter=null, model=null, association=null) {
 		}
 	}
 	
-	//	At least 1 attribute is mandatory:
-	if (newQuery.attributes.length === 0) {
+	// At least 1 attribute is mandatory
+	// or "functions" must be set:
+	if (
+		functions.length === 0
+		&&
+		newQuery.attributes.length === 0
+	) {
 		const err = new NodesterQueryError(`No attributes were selected.`);
 		Error.captureStackTrace(err, traverse);
 		throw err;
@@ -124,57 +135,28 @@ function traverse(queryNode, filter=null, model=null, association=null) {
 
 	// Functions:
 	for (const fnParams of functions) {
+		const fnName = fnParams.fn;
+
+		if (typeof filter.functions[fnName] === 'undefined') {
+			const err = new NodesterQueryError(`Function '${ fnName }' is not allowed.`);
+			Error.captureStackTrace(err, traverse);
+			throw err;
+		}
 
-		switch(fnParams.fn) {
+		switch(fnName) {
 			// SQL COUNT():
 			case 'count': {
-				const countParams = fnParams.args;
-
-				const [ countTarget ] = countParams;
-				// Count can be requested for this model,
-				// or for any of the available uncludes.
-				const isForRootModel = countTarget === rootModelName.plural.toLowerCase();
-
-				// Compile request:
-				//	Example of desired SQL:
-				//	`(SELECT COUNT(*) FROM comments WHERE comments.post_id=Post.id)`
-				//
-				let rawSQL = '(SELECT COUNT(*) FROM ';
-				let countAttribute = 'count';
-
-				// If request to count one of the includes:
-				if (!isForRootModel) {
-					// Check if it's available:
-					if (
-						!filter
-						||
-						!filter?.includes[countTarget]
-						||
-						rootModelAssociations[countTarget] === undefined
-					) {
-						const err = new NodesterQueryError(`Count for '${ countTarget }' is not available.`);
-						Error.captureStackTrace(err, traverse);
-						throw err;
-					}
-
-					const {
-						as,
-						target,
-						foreignKey,
-						sourceKey
-					} = rootModelAssociations[countTarget];
-					const { tableName } = target;
-
-					rawSQL += `${ tableName } where ${ tableName }.${ foreignKey }=${ rootModelName.singular }.${ sourceKey })`;
-					countAttribute = `${ as }_count`;
-				}
+				mapCOUNT(
+					fnParams,
+					_model,
+					filter?.includes,
 
-				newQuery.attributes.push(
-					[sequelize.literal(rawSQL), countAttribute]
+					newQuery
 				);
 			}
-			// Unknow function:
+			// Any other function:
 			default:
+				consl.warn(`function ${ fnName }() is not supported`);
 				break;
 		}
 	}
@@ -194,6 +176,22 @@ function traverse(queryNode, filter=null, model=null, association=null) {
 		}
 
 		switch(clauseName) {
+			case 'group_by': {
+				// Check if this value is a valid attribute:
+				if (typeof value === 'undefined') {
+					continue;
+				}
+
+				if (typeof _model.tableAttributes[value] === 'undefined') {
+					const err = new NodesterQueryError(`group_by '${ value }' is not allowed.`);
+					Error.captureStackTrace(err, traverse);
+					throw err;
+				}
+
+				newQuery.group = value;
+				continue;
+			}
+
 			case 'limit': {
 				const _value = _setValueWithBounds(value, 'number', filter.bounds.clauses.limit);
 
@@ -241,6 +239,10 @@ function traverse(queryNode, filter=null, model=null, association=null) {
 			const [ clauseName, staticClauseValue ] = entry;
 
 			switch(clauseName) {
+				case 'group_by':
+					newQuery.group = staticClauseValue;
+					continue;
+
 				case 'limit':
 					newQuery.limit = staticClauseValue;
 					continue;

package/lib/query/traverse/mappers/functions/count.js

@@ -0,0 +1,76 @@
+const { NodesterQueryError } = require('nodester/errors');
+
+
+module.exports = function mapCOUNT(
+	fnParams,
+	rootModel,
+	filterIncludes,
+
+	sequelizeQuery
+) {
+	try {
+
+		const { sequelize } = rootModel;
+		const rootModelName = rootModel.options.name;
+
+		const countParams = fnParams.args;
+		const [ countTarget ] = countParams;
+
+		// COUNT can be requested for this model,
+		// or for any of the available includes.
+		const associations = rootModel.associations;
+
+		const isForAssociation = typeof associations[countTarget] !== 'undefined';
+		const isForRootModel = countTarget === '';
+
+		// If request to count one of the includes:
+		if (isForAssociation) {
+			// Check if it's available:
+			if (!filterIncludes[countTarget]) {
+				const err = new NodesterQueryError(`Count for '${ countTarget }' is not available.`);
+				Error.captureStackTrace(err, mapCOUNT);
+				throw err;
+			}
+
+			// Unwrap desired association info:
+			const {
+				as,
+				target,
+				foreignKey,
+				sourceKey
+			} = associations[countTarget];
+			const { tableName } = target;
+
+			// Compile request:
+			//	Example of desired SQL:
+			//	`(SELECT COUNT(*) FROM comments WHERE comments.post_id=Post.id)`
+			const rawSQL = `(SELECT COUNT(*) FROM ${ tableName } where ${ tableName }.${ foreignKey }=${ rootModelName.singular }.${ sourceKey })`;
+			
+			const countAttributeName = `${ as }_count`;
+			sequelizeQuery.attributes.push(
+				[sequelize.literal(rawSQL), countAttributeName]
+			);
+		}
+
+		// If request to COUNT root model:
+		else if (isForRootModel) {
+			const firstAttribute = Object.keys(rootModel.tableAttributes)[0];
+
+			const countAttributeName = `${ rootModelName.plural.toLowerCase() }_count`;
+			sequelizeQuery.attributes.push(
+				[sequelize.fn('COUNT', firstAttribute), countAttributeName]
+			);
+		}
+
+		// Unknown attribute:
+		else {
+			const err = new NodesterQueryError(`Count for '${ countTarget }' is not available.`);
+			Error.captureStackTrace(err, mapCOUNT);
+			throw err;
+		}
+	}
+	catch(error) {
+		Error.captureStackTrace(error, mapCOUNT);
+		throw error;
+	}
+}

package/lib/structures/Filter.js

@@ -44,6 +44,8 @@ module.exports = class NodesterFilter {
 
 		this._attributes = [];
 		this._clauses = [];
+		this._functions = [];
+
 		this._includes = {};
 
 		this._bounds = {
@@ -74,21 +76,47 @@ module.exports = class NodesterFilter {
 		const {
 			attributes,
 			clauses,
+			functions,
 			includes,
 			bounds,
 			statics,
 		} = options;
 
 
-		// If attributes are array:
-		if (Array.isArray(attributes)) {
+		// Check attributes type:
+		if (!!attributes) {
+			if (!Array.isArray(attributes)) {
+				const err = new TypeError(`[NodesterFilter]: 'attributes' parameter must be an array.`);
+				throw err;
+			}
+
 			this._attributes = attributes;
 		}
 
-		if (Array.isArray(clauses)) {
+		// Check clauses type:
+		if (!!clauses) {
+			if (!Array.isArray(clauses)) {
+				const err = new TypeError(`[NodesterFilter]: 'clauses' parameter must be an array.`);
+				throw err;
+			}
+
 			this._clauses = clauses;
 		}
 
+		// If functions are set:
+		if (!!functions) {
+			if (
+				typeof functions !== 'object'
+				||
+				Array.isArray(functions)
+			) {
+				const err = new TypeError(`[NodesterFilter]: 'functions' parameter must be an object.`);
+				throw err;
+			}
+
+			this._functions = functions;
+		}
+
 		// Includes:
 		if (typeof includes === 'object') {
 			const { associations } = this.model;
@@ -152,6 +180,10 @@ module.exports = class NodesterFilter {
 		return this._clauses;
 	}
 
+	get functions() {
+		return this._functions;
+	}
+
 	get includes() {
 		return this._includes;
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodester",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "A versatile REST framework for Node.js",
   "directories": {
     "docs": "docs",

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

@@ -1,9 +0,0 @@
-
-class NodesterQueryError extends Error {
-	constructor(message) {
-		super(message);
-		this.name = 'NodesterQueryError';
-	}
-}
-
-module.exports = NodesterQueryError;