nodester 0.0.9 → 0.1.4

package/lib/params/Params.js

@@ -10,10 +10,9 @@ module.exports = Params;
  * @param {Object} sourceObj
  * @param {Object} defaultValuesList
  *
- * @return {Function|Object} controller
+ * @return {Object} result
  *
  * @api public
- * @alias withDefaultCRUD
  */
 function Params(
 	sourceObj={},
@@ -23,11 +22,15 @@ function Params(
 
 	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];
+
+		// If value is not set,
+		// use default one from 'defaultValuesList':
+		if (sourceObj[key] === undefined) {
+			result[key] = defaultValuesList[key];
+			continue;
+		}
+
+		result[key] = sourceObj[key];
 	}
 
 	return result;

package/lib/queries/Colander.js

@@ -0,0 +1,107 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+'use strict';
+
+const CLAUSES = ['limit', 'skip', 'order', 'order_by'];
+
+const { isModel } = require('../utils/models');
+
+
+module.exports = class Colander {
+
+	/*
+	 *
+	 * @param {Object|Model} optsOrModelDefinition
+	 @ - @param {Model} model
+	 * - @param {Array} fields
+	 * - @param {Array} clauses
+	 * - @param {Object} includes
+	 * - @param {Object} statics
+	 * -- @param {Object} attributes
+	 * -- @param {Object} clauses
+	 *
+	 * @param {Boolean} noLimit
+	 *
+	 */
+	constructor(optsOrModelDefinition, noLimit=false) {
+		this._fields = [];
+		this._clauses = [];
+		this._includes = {};
+		
+		this._statics = {
+			attributes: {},
+			clauses: {
+				limit: 3
+			}
+		}
+		if (noLimit === true) {
+			delete this._statics.clauses.limit;
+		}
+
+		// If model:
+		if (isModel(optsOrModelDefinition)) {
+			this._fields = Object.keys(optsOrModelDefinition.tableAttributes);
+			this._clauses = CLAUSES;
+		}
+		// If options:
+		else {
+			const {
+				model,
+				fields,
+				clauses,
+				includes,
+				statics,
+			} = optsOrModelDefinition;
+
+
+			// If fields are array:
+			if (Array.isArray(fields)) {
+				this._fields = fields;
+			}
+			// If fields were not provided,
+			// but we have full model definition:
+			else if (isModel(model)) {
+				this._fields = Object.keys(model.tableAttributes);
+			}
+
+
+			if (Array.isArray(clauses)) {
+				this._clauses = clauses;
+			}
+
+			if (typeof includes === 'object') {
+				this._includes = includes;
+			}
+
+			if (typeof statics === 'object') {
+				if (typeof statics.attributes === 'object') {
+					this._statics.attributes = statics.attributes;
+				}
+
+				if (typeof statics.clauses === 'object') {
+					this._statics.clauses = statics.clauses;
+				}
+			}
+		}
+	}
+
+	// Getters:
+	get fields() {
+		return this._fields;
+	}
+
+	get clauses() {
+		return this._clauses;
+	}
+
+	get includes() {
+		return this._includes;
+	}
+
+	get statics() {
+		return this._statics;
+	}
+	// Getters\
+}

package/lib/queries/NodesterQueryParams.js

@@ -1,3 +1,9 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+'use strict';
+
 // Dictionary of unsafe characters:
 const NOT_ALLOWED = [
 	'{',

package/lib/queries/traverse.js

@@ -0,0 +1,381 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+'use strict';
+
+const { Op } = require('sequelize');
+const NQueryError = require('../factories/errors/NodesterQueryError');
+
+
+module.exports = traverse;
+
+function traverse(queryNode, colander=null, model) {
+
+	const sequelize = model.sequelize;
+	const fieldsAvailable = Object.keys(model.tableAttributes);
+	const includesAvailable = model.getIncludesList();
+
+	const newQuery = {
+		attributes: [],
+		where: {},
+		include: []
+	};
+	
+	const {
+		where,
+		includes,
+		fields,
+		functions,
+		clauses,
+	} = _disassembleQueryNode(queryNode);
+
+
+	// Fields:
+	//
+	//	If Colander is not set,
+	//	use every available field:
+	if (colander === null) {
+		for (let field of fieldsAvailable) {
+			// If no query filter or field is requested:
+			if (fields.length === 0 || fields.indexOf(field) > -1) {
+				newQuery.attributes.push(field);
+				continue;
+			}
+		}
+	}
+	//	Colander is present:
+	else {
+		// If no query fields were set,
+		//	use the ones from Colander,
+		// If query fields were set,
+		//	put them through Colander:
+		for (let field of colander.fields) {
+			if (fieldsAvailable.indexOf(field) === -1) {
+				const err = new TypeError(`field ${ field } is not present in model.`);
+				throw err;
+			}
+
+			// If field is not in available set:
+			// if (colander.fields.indexOf(field) === -1) {
+			// 	continue;
+			// }
+
+			// If no query filter or field is requested:
+			if (fields.length === 0 || fields.indexOf(field) > -1) {
+				newQuery.attributes.push(field);
+				continue;
+			}
+		}
+	}
+	
+	//	At least 1 field is mandatory:
+	if (newQuery.attributes.length === 0) {
+		const err = new TypeError(`No fields were selected.`);
+		throw err;
+	}
+	// Fields\
+
+	// Functions:
+	for (const fnParams of functions) {
+
+		// If COUNT() is requested:
+		if (fnParams.fn === 'count') {
+			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();
+
+			// Compile request:
+			//	Example:
+			// `(SELECT COUNT(*) FROM comments WHERE comments.morph_id=Morph.id)`
+
+			// Params for attribute:
+			let rawSQL = '(SELECT COUNT(*) FROM ';
+			let countAttribute = '_count';
+
+			// If request to count one of includes:
+			if (!isForRootModel) {
+				// Check if it's available:
+				if (
+						!colander
+						||
+						!colander?.includes[countTarget]
+						||
+						model.associations[countTarget] === undefined
+					) {
+					const err = new NQueryError(`Count for ${ countTarget } is not available.`);
+					throw err;
+				}
+
+				const {
+					foreignKey,
+					sourceKey
+				} = model.associations[countTarget];
+				rawSQL += `${ countTarget } where ${ countTarget }.${ foreignKey }=${ RootModelName.singular }.${ sourceKey })`;
+				countAttribute = `${ countTarget }_count`;
+			}
+
+			newQuery.attributes.push(
+				[sequelize.literal(rawSQL), countAttribute]
+			);
+		}
+	}
+	// Functions\
+
+	// Clauses:
+	const order = {};
+
+	const clausesEntries = Object.entries(clauses);
+	for (let [clauseName, value] of clausesEntries) {
+		// If clause is not available:
+		if (colander != null) {
+			if (colander.clauses.indexOf(clauseName) === -1)
+				continue;
+		}
+
+		switch(clauseName) {
+			case 'limit':
+				// Do not set if -1:
+				if (value === -1) 
+					continue;
+
+				newQuery.limit = value;
+				continue;
+
+			case 'skip':
+				// Do not set if 0:
+				if (value === 0)
+					continue;
+
+				newQuery.offset = value;
+				continue;
+
+			case 'order':
+				order.order = value;
+				continue;
+
+			case 'order_by':
+				order.by = value;
+				continue;
+				
+			default:
+				continue;
+		}
+	}
+
+	//	"statics" override or set any query Clause:
+	if (colander !== null) {
+		const staticClausesEntries = Object.entries(colander.statics.clauses);
+		for (let entry of staticClausesEntries) {
+			const [clauseName, staticClauseValue] = entry;
+
+			switch(clauseName) {
+				case 'limit':
+					newQuery.limit = staticClauseValue;
+					continue;
+				case 'skip':
+					newQuery.offset = staticClauseValue;
+					continue;
+				case 'order':
+					order.order = staticClauseValue;
+					continue;
+				case 'order_by':
+					order.by = staticClauseValue;
+					continue;
+				default:
+					break;
+			}
+		}
+	}
+	// Clauses\
+
+
+	// Order:
+	if ( ['rand', 'random'].indexOf(order.order) > -1) {
+		newQuery.order = sequelize.random();
+	}
+	else {
+		const column = sequelize.col( order.by );
+		switch (order.order) {
+			// MAX/MIN:
+			case 'max-asc':
+			case 'max':
+			case 'min-desc':
+				newQuery.order = sequelize.fn('max', column);
+				break;
+			case 'min':
+			case 'min-asc':
+			case 'max-desc':
+				newQuery.order = [ sequelize.fn('max', column), 'DESC' ];
+				break;
+			// MAX/MIN\
+
+			case null:
+			case undefined:
+				newQuery.order = [ ['id', 'desc'] ];
+				break;
+
+			default:
+				newQuery.order = [ [order.by, order.order] ];
+				break;
+		}
+	}
+	// Order\
+
+
+	// Includes:
+	// 	If requested includes are not available:
+	const leftIncludes = includesAvailable.map(i => i.association);
+	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 }`);
+			throw err;
+		}
+
+		leftIncludes.splice(includeIndex, 1);
+	}
+
+	_traverseIncludes(includes, model, colander, newQuery)
+	// Includes\
+
+
+	// Where:
+	const whereEntries = Object.entries(where);
+	for (let [attribute, value] of whereEntries) {
+		_parseWhereEntry(attribute, value, newQuery.where, colander.statics.attributes);
+	}
+
+	// If "where" was not set:
+	if (whereEntries.length === 0) {
+		delete newQuery.where;
+	}
+	// Where\
+
+	return newQuery;
+}
+
+
+function _traverseIncludes(includes, model, colander, resultQuery) {
+	// If no Colander:
+	if (colander === null) {
+		for (let include of includes) {
+			const includeName = include.model;
+			const association = model.associations[includeName];
+
+			// If no such association:
+			if (!association) {
+				const err = new TypeError(`No include ${ includeName }`);
+				throw err;
+			}
+
+			const includeModel = association.target;
+			// Build query for this include.
+			const associationQuery = traverse(include, null, includeModel);
+
+			_addAssociationQuery(associationQuery, includeName, resultQuery);
+		}
+	}
+	//	Colander is present:
+	else {
+		const colanderIncludeEntries = Object.entries(colander.includes);
+		for (let [includeName, includeColander] of colanderIncludeEntries) {			
+			const association = model.associations[includeName];
+			// If no such association:
+			if (!association) {
+				const err = new TypeError(`No include ${ includeName }`);
+				throw err;
+			}
+
+			// 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, colander.includes[includeName], includeModel);
+
+			_addAssociationQuery(associationQuery, includeName, resultQuery);
+		}
+	}
+}
+
+
+function _addAssociationQuery(associationQuery, includeName, resultQuery) {
+
+	// Add all association info into query.
+	resultQuery.include.push({
+		association: includeName,
+		...associationQuery
+	});
+}
+
+
+function _parseWhereEntry(attribute, value, whereHolder, staticAttributes) {
+	let _value = value;
+	const staticAttribute = staticAttributes[attribute];
+
+	// If attribute is Op (not, like, or, etc.):
+	if (attribute in Op) {
+		// Parse value:
+		_value = _parseValue(_value, attribute);
+
+		const op = Op[attribute];
+		whereHolder[op] = _value;
+		return;
+	}
+	
+	// Static value overrides any other:
+	if (!!staticAttribute) {
+		whereHolder[attribute] = staticAttribute;
+		return;
+	}
+
+	whereHolder[attribute] = _parseValue(_value, attribute);
+}
+
+function _disassembleQueryNode(queryNode) {
+	// Disassemble current query node:
+	const {
+		where,
+		includes,
+		fields,
+		functions,
+		...clauses
+	} = queryNode;
+	// delete queryNode.model;
+
+	return {
+		where: where ?? {},
+		includes: includes ?? [],
+		fields: fields ?? [],
+		functions: functions ?? [],
+		clauses: clauses ?? []
+	};
+}
+
+function _parseValue(value, attribute) {
+	// If value is Object:
+	if (typeof value === 'object' && Array.isArray(value) === false) {
+		const [opKey, rawValue] = (Object.entries(value))[0];
+
+		// If operation is "in":
+		if (opKey === 'in') {
+			// Unwrap rawValue.
+			return rawValue[0][attribute];
+		}
+		else {
+			const op = Op[opKey];
+			return { [op]: rawValue };
+		}
+	}
+
+	return value;
+}

package/lib/router/handlers.util.js

@@ -26,19 +26,24 @@ function _parseRouteHandler(routeHandler={}) {
 	}
 
 	const result = {
+		actionName: undefined,
 		before: null,
 		controllerName: undefined,
-		actionName: undefined,
+		providerName: undefined
 	};
 
 	const {
+		action,
 		before,
 
 		controller,
 		controlledBy,
-		action
+
+		provider,
+		providedBy,
 	} = routeHandler;
 
+	// Controllers:
 	if (!!controlledBy) {
 		const parts = controlledBy.split('.');
 		const controllerName = parts[0];
@@ -49,6 +54,21 @@ function _parseRouteHandler(routeHandler={}) {
 	else if (!!controller) {
 		result.controllerName = `${ controller }`;
 	}
+	// Controllers\
+
+	// Providers:
+	else if (!!providedBy) {
+		const parts = providedBy.split('.');
+		const providerName = parts[0];
+		const actionName = parts[1];
+		result.providerName = providerName;
+		result.actionName = actionName;
+	}
+	else if (!!provider) {
+		result.providerName = `${ provider }`;
+	}
+	// Providers\
+	
 	else if (!!action) {
 		result.actionName = `${ action }`;
 	}