nodester 0.1.5 → 0.2.1

package/lib/query/traverse.js

@@ -2,20 +2,40 @@
  * /nodester
  * MIT Licensed
  */
+ 
 'use strict';
 
+const BOUNDS = require('../constants/Bounds');
+
 const { Op } = require('sequelize');
 const NQueryError = require('../factories/errors/NodesterQueryError');
 const httpCodes = require('nodester/http/codes');
 
+const { ensure } = require('../validators/arguments');
+
 
 module.exports = traverse;
 
-function traverse(queryNode, filter=null, model) {
+function traverse(queryNode, filter=null, model=null) {
+	const _model = model ?? filter.model;
 
-	const sequelize = model.sequelize;
-	const fieldsAvailable = Object.keys(model.tableAttributes);
-	const includesAvailable = model.getIncludesList();
+	try {
+		ensure(queryNode, 'object,required', 'queryNode');
+		ensure(filter, 'object,required', 'filter');
+		if (!_model) {
+			const err = new TypeError(`'model' must be provided either in 'filter.model' or as a third argument.`);
+			throw err;
+		}
+	}
+	catch(error) {
+		Error.captureStackTrace(error, traverse);
+		throw error;
+	}
+
+	const rootModelName = _model.options.name;
+	const rootModelAssociations = _model.associations;
+	const { sequelize } = _model;
+	const fieldsAvailable = Object.keys(_model.tableAttributes);
 
 	const newQuery = {
 		attributes: [],
@@ -87,10 +107,9 @@ function traverse(queryNode, filter=null, model) {
 			const countParams = fnParams.args;
 
 			const [ countTarget ] = countParams;
-			const RootModelName = model.options.name;
 			// Count can be requested for this model,
 			// or for any of the available uncludes.
-			const isForRootModel = countTarget === RootModelName.plural.toLowerCase();
+			const isForRootModel = countTarget === rootModelName.plural.toLowerCase();
 
 			// Compile request:
 			//	Example:
@@ -108,7 +127,7 @@ function traverse(queryNode, filter=null, model) {
 						||
 						!filter?.includes[countTarget]
 						||
-						model.associations[countTarget] === undefined
+						rootModelAssociations[countTarget] === undefined
 					) {
 					const err = new NQueryError(`Count for '${ countTarget }' is not available.`);
 					err.status = httpCodes.NOT_ACCEPTABLE;
@@ -118,8 +137,8 @@ function traverse(queryNode, filter=null, model) {
 				const {
 					foreignKey,
 					sourceKey
-				} = model.associations[countTarget];
-				rawSQL += `${ countTarget } where ${ countTarget }.${ foreignKey }=${ RootModelName.singular }.${ sourceKey })`;
+				} = rootModelAssociations[countTarget];
+				rawSQL += `${ countTarget } where ${ countTarget }.${ foreignKey }=${ rootModelName.singular }.${ sourceKey })`;
 				countAttribute = `${ countTarget }_count`;
 			}
 
@@ -142,22 +161,26 @@ function traverse(queryNode, filter=null, model) {
 		}
 
 		switch(clauseName) {
-			case 'limit':
+			case 'limit': {
+				const _value = _setValueWithBounds(value, 'number', filter.bounds.clauses.limit);
+				
 				// Do not set if -1:
-				if (value === -1) 
+				if (_value === -1) 
 					continue;
 
-				newQuery.limit = value;
+				newQuery.limit = _value;
 				continue;
+			}
+			case 'skip': {
+				const _value = _setValueWithBounds(value, 'number', filter.bounds.clauses.skip);
 
-			case 'skip':
 				// Do not set if 0:
-				if (value === 0)
+				if (_value === 0)
 					continue;
 
-				newQuery.offset = value;
+				newQuery.offset = _value;
 				continue;
-
+			}
 			case 'order':
 				order.order = value;
 				continue;
@@ -171,7 +194,7 @@ function traverse(queryNode, filter=null, model) {
 		}
 	}
 
-	//	"statics" override or set any query Clause:
+	//	"statics" override or set any query in clauses:
 	if (filter !== null) {
 		const staticClausesEntries = Object.entries(filter.statics.clauses);
 
@@ -196,6 +219,11 @@ function traverse(queryNode, filter=null, model) {
 			}
 		}
 	}
+
+	// Check for undefined clauses:
+	if (newQuery.limit === undefined && typeof filter.bounds.clauses.limit === 'object') {
+		newQuery.limit = filter.bounds.clauses.limit.max ?? BOUNDS.limit.max;
+	}
 	// Clauses\
 
 
@@ -233,22 +261,19 @@ function traverse(queryNode, filter=null, model) {
 
 
 	// Includes:
-	// 	If requested includes are not available:
-	const leftIncludes = includesAvailable.map(i => i.association);
+	// 	Validate, if requested includes are available:
 	for (let include of includes) {
 		const includeName = include.model;
 
-		const includeIndex = leftIncludes.indexOf(includeName);
-		if (includeIndex === -1) {
-			const err = new TypeError(`No include named '${ includeName }'`);
+		if (rootModelAssociations[includeName] === undefined) {
+			const err = new NQueryError(`No include named '${ includeName }'`);
 			err.status = httpCodes.NOT_ACCEPTABLE;
+			Error.captureStackTrace(err, traverse);
 			throw err;
 		}
-
-		leftIncludes.splice(includeIndex, 1);
 	}
 
-	_traverseIncludes(includes, model, filter, newQuery)
+	_traverseIncludes(includes, _model, filter, newQuery)
 	// Includes\
 
 
@@ -268,50 +293,30 @@ function traverse(queryNode, filter=null, model) {
 }
 
 
-function _traverseIncludes(includes, model, filter=null, resultQuery) {
-	// If no Filter:
-	if (filter === null) {
-		for (let include of includes) {
-			const includeName = include.model;
-			const association = model.associations[includeName];
+function _traverseIncludes(includes, model, filter, resultQuery) {
+	const filterIncludesEntries = Object.entries(filter.includes);
+	for (let [ includeName, includeFilter ] of filterIncludesEntries) {
 
-			// If no such association:
-			if (!association) {
-				const err = new TypeError(`No include '${ includeName }'`);
-				err.status = httpCodes.NOT_ACCEPTABLE;
-				throw err;
-			}
-
-			const includeModel = association.target;
-			// Build query for this include.
-			const associationQuery = traverse(include, null, includeModel);
+		const association = model.associations[includeName];
 
-			_addAssociationQuery(associationQuery, includeName, resultQuery);
+		// If no such association:
+		if (!association) {
+			const err = new NQueryError(`No include named '${ includeName }'`);
+			err.status = httpCodes.NOT_ACCEPTABLE;
+			Error.captureStackTrace(err, _traverseIncludes);
+			throw err;
 		}
-	}
-	//	Filter is present:
-	else {
-		const filterIncludeEntries = Object.entries(filter.includes);
-		for (let [includeName, includeFilter] of filterIncludeEntries) {			
-			const association = model.associations[includeName];
-			// If no such association:
-			if (!association) {
-				const err = new TypeError(`No include ${ includeName }`);
-				err.status = httpCodes.NOT_ACCEPTABLE;
-				throw err;
-			}
 
-			// If include was not requested:
-			const include = includes.find(({ model }) => model === includeName);
-			if (!include)
-				continue;
+		// If include was not requested:
+		const include = includes.find(({ model }) => model === includeName);
+		if (!include)
+			continue;
 
-			const includeModel = association.target;
-			// Build query for this include.
-			const associationQuery = traverse(include, filter.includes[includeName], includeModel);
+		const includeModel = association.target;
+		// Build query for this include.
+		const associationQuery = traverse(include, filter.includes[includeName], includeModel);
 
-			_addAssociationQuery(associationQuery, includeName, resultQuery);
-		}
+		_addAssociationQuery(associationQuery, includeName, resultQuery);
 	}
 }
 
@@ -387,3 +392,32 @@ function _parseValue(value, attribute) {
 
 	return value;
 }
+
+function _setValueWithBounds(value, type, bounds) {
+	if (typeof bounds === 'object') {
+
+		switch(type) {
+			case 'number': {
+				let _value = value;
+
+				const {
+					min,
+					max
+				} = bounds;
+
+				const _min = isNaN(min) ? 1 : min;
+				_value = _value < _min ? _min : _value;
+
+				const _max = isNaN(max) ? 1 : max;
+				_value = _value > _max ? _max : _value;
+
+				return _value;
+			}
+			default:
+				break;
+		}
+	}
+
+	// If bounds were not set, just use original value.
+	return value;
+}

package/lib/router/handlers.util.js

@@ -2,6 +2,7 @@
  * /nodester
  * MIT Licensed
  */
+ 
 'use strict';
 
 const { typeOf } = require('../utils/types.util');