nodester 0.1.4 → 0.2.0

package/lib/middlewares/render/index.js

@@ -0,0 +1,62 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+ 
+'use strict';
+
+
+module.exports = function initRenderMiddleware() {
+	return handle;
+}
+
+
+function handle(req, res, next) {
+	const context = { req, res, next };
+	res.render = _render.bind(context);
+	next();
+}
+
+
+/**
+ * Render `view` with the given `options` and optional callback `fn`.
+ * When a callback function is given a response will _not_ be made
+ * automatically, otherwise a response of _200_ and _text/html_ is given.
+ *
+ * Options:
+ *
+ *  - `cache`     boolean hinting to the engine it should cache
+ *  - `filename`  filename of the view being rendered
+ *
+ * @alias render
+ * @api public
+ */
+function _render(view, options, callback) {
+	const app = this.req.app;
+	let done = callback;
+	let opts = options || {};
+	
+	const req = this.req;
+	const res = this.res;
+	const next = this.next;
+
+	// support callback function as second arg
+	if (typeof options === 'function') {
+		done = options;
+		opts = {};
+	}
+
+	// merge res.locals
+	opts._locals = res.locals;
+
+	// default callback to respond
+	done = done || function (err, str) {
+		if (err)
+			return next(err);
+		
+		res.send(str);
+	};
+
+	// render
+	app.render(view, opts, done);
+};

package/lib/models/associate.js

@@ -1,5 +1,17 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+ 
+'use strict';
 
-module.exports = async function associateModels(databaseConnection) {
+
+module.exports = {
+	associateModels: _associateModels,
+	associateModelsSync: _associateModelsSync
+}
+
+async function _associateModels(databaseConnection) {
 	try {
 		const models = databaseConnection.models;
 
@@ -15,3 +27,15 @@ module.exports = async function associateModels(databaseConnection) {
 		return Promise.reject(error);
 	}
 }
+
+function _associateModelsSync(databaseConnection) {
+	const models = databaseConnection.models;
+
+	const modelNames = Object.keys(models);
+
+	for (let modelName of modelNames) {
+		models[modelName].associate(models);
+	}
+
+	return models;
+}

package/lib/models/define.js

@@ -1,9 +1,14 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+ 
+'use strict';
+
 // CRUD mixins.
 const { implementsCRUD } = require('./mixins');
 // ORM.
 const { DataTypes } = require('sequelize');
-// NQL.
-const Colander = require('../queries/Colander');
 
 
 module.exports = defineModel;
@@ -14,7 +19,7 @@ module.exports = defineModel;
  * @param {Function} definition
  * @param {Object} options
  *   - ... Sequilize model options
- *   - noCRUD (Bool)
+ *   - @param {Boolean} noCRUD
  */
 function defineModel(
 	databaseConnection,
@@ -26,16 +31,24 @@ function defineModel(
 	const _options = {
 		// Set snake-cased table name.
 		// tableName: underscore( pluralize(modelName) ),
+		
 		// Set snake-case.
 		underscored: true,
+		
 		// Enable automatic 'created_at' and 'updated_at' fields.
 		timestamps: true,
 
-		// The only way to get snake-cased timestamps (issue: https://github.com/sequelize/sequelize/issues/10857)
+		// The only way to get snake-cased timestamps:
+		// (issue: https://github.com/sequelize/sequelize/issues/10857)
 		createdAt: 'created_at',
 		updatedAt: 'updated_at',
 		deletedAt: 'deleted_at',
 
+		// Configs related to nodester:
+		nodester: {
+			output: 'underscored'
+		},
+
 		// Add user-defined options (they can override upper ones).
 		...options
 	};
@@ -52,7 +65,7 @@ function defineModel(
 		implementsCRUD(model);
 	}
 
-	// Association helpers:
+	// Associations:
 	model.associate = (models) => {};
 	model.getIncludesList = _getIncludesList.bind(model);
 
@@ -61,7 +74,6 @@ function defineModel(
 		const values = { ...this.get() };
 		return values;
 	}
-	// Instance methods\
 
 	return model;
 }
@@ -73,11 +85,8 @@ function _getIncludesList(facadeData=null) {
 	const associations = this.associations;
 	const associationEntries = Object.entries(associations);
 
-	associationEntries.forEach(([
-		associationName,
-		associationDefinition
-	]) => {
-		const a = { association: associationName };
+	for (const [ associationName, associationDefinition ] of associationEntries) {
+		const formatted = { association: associationName };
 
 		if (!!facadeData) {
 			// If facade data is set, go deeper:
@@ -85,19 +94,17 @@ function _getIncludesList(facadeData=null) {
 			if (keys.indexOf(associationName) > 0) {
 				const associationModel = associationDefinition.target;
 
-				const a = { association: associationName };
 				if (Object.entries(associationModel.associations).length > 0) {
 					const deepData = facadeData[ associationName ];
-					a.include = associationModel.getIncludesList(Array.isArray(deepData) ? deepData[0] : deepData);
+					formatted.include = associationModel.getIncludesList(
+												Array.isArray(deepData) ? deepData[0] : deepData
+											);
 				}
-
-				result.push( a );
 			}
 		}
-		else {
-			result.push( a );
-		}
-	});
+
+		result.push( formatted );
+	}
 
 	return result;
 }

package/lib/models/mixins.js

@@ -1,3 +1,10 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+ 
+'use strict';
+
 /*
  *	CRUD mixins for any model:
  */
@@ -10,7 +17,7 @@ const {
 
 // Nodester query:
 const NQLexer = require('../middlewares/ql/sequelize/interpreter/QueryLexer');
-const traverseNQuery = require('../queries/traverse');
+const traverseNQuery = require('nodester/query/traverse');
 
 
 module.exports = {

package/lib/{queries → query}/traverse.js

@@ -2,19 +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, colander=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: [],
@@ -33,9 +54,9 @@ function traverse(queryNode, colander=null, model) {
 
 	// Fields:
 	//
-	//	If Colander is not set,
+	//	If Filter is not set,
 	//	use every available field:
-	if (colander === null) {
+	if (filter === null) {
 		for (let field of fieldsAvailable) {
 			// If no query filter or field is requested:
 			if (fields.length === 0 || fields.indexOf(field) > -1) {
@@ -44,20 +65,21 @@ function traverse(queryNode, colander=null, model) {
 			}
 		}
 	}
-	//	Colander is present:
+	//	Filter is present:
 	else {
 		// If no query fields were set,
-		//	use the ones from Colander,
+		//	use the ones from Filter,
 		// If query fields were set,
-		//	put them through Colander:
-		for (let field of colander.fields) {
+		//	put them through Filter:
+		for (let field of filter.fields) {
 			if (fieldsAvailable.indexOf(field) === -1) {
-				const err = new TypeError(`field ${ field } is not present in model.`);
+				const err = new TypeError(`Field '${ field }' is not present in model.`);
+				err.status = httpCodes.NOT_ACCEPTABLE;
 				throw err;
 			}
 
 			// If field is not in available set:
-			// if (colander.fields.indexOf(field) === -1) {
+			// if (filter.fields.indexOf(field) === -1) {
 			// 	continue;
 			// }
 
@@ -72,6 +94,7 @@ function traverse(queryNode, colander=null, model) {
 	//	At least 1 field is mandatory:
 	if (newQuery.attributes.length === 0) {
 		const err = new TypeError(`No fields were selected.`);
+		err.status = httpCodes.NOT_ACCEPTABLE;
 		throw err;
 	}
 	// Fields\
@@ -84,10 +107,9 @@ function traverse(queryNode, colander=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:
@@ -101,21 +123,22 @@ function traverse(queryNode, colander=null, model) {
 			if (!isForRootModel) {
 				// Check if it's available:
 				if (
-						!colander
+						!filter
 						||
-						!colander?.includes[countTarget]
+						!filter?.includes[countTarget]
 						||
-						model.associations[countTarget] === undefined
+						rootModelAssociations[countTarget] === undefined
 					) {
-					const err = new NQueryError(`Count for ${ countTarget } is not available.`);
+					const err = new NQueryError(`Count for '${ countTarget }' is not available.`);
+					err.status = httpCodes.NOT_ACCEPTABLE;
 					throw err;
 				}
 
 				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`;
 			}
 
@@ -132,28 +155,32 @@ function traverse(queryNode, colander=null, model) {
 	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)
+		if (filter != null) {
+			if (filter.clauses.indexOf(clauseName) === -1)
 				continue;
 		}
 
 		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;
@@ -167,9 +194,10 @@ function traverse(queryNode, colander=null, model) {
 		}
 	}
 
-	//	"statics" override or set any query Clause:
-	if (colander !== null) {
-		const staticClausesEntries = Object.entries(colander.statics.clauses);
+	//	"statics" override or set any query in clauses:
+	if (filter !== null) {
+		const staticClausesEntries = Object.entries(filter.statics.clauses);
+
 		for (let entry of staticClausesEntries) {
 			const [clauseName, staticClauseValue] = entry;
 
@@ -191,6 +219,11 @@ function traverse(queryNode, colander=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\
 
 
@@ -229,27 +262,24 @@ function traverse(queryNode, colander=null, model) {
 
 	// 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 }`);
+		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, colander, newQuery)
+	_traverseIncludes(includes, _model, filter, newQuery)
 	// Includes\
 
 
 	// Where:
 	const whereEntries = Object.entries(where);
 	for (let [attribute, value] of whereEntries) {
-		_parseWhereEntry(attribute, value, newQuery.where, colander.statics.attributes);
+		_parseWhereEntry(attribute, value, newQuery.where, filter.statics.attributes);
 	}
 
 	// If "where" was not set:
@@ -262,48 +292,30 @@ function traverse(queryNode, colander=null, model) {
 }
 
 
-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];
+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 }`);
-				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;
 		}
-	}
-	//	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;
+		// 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);
+		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);
 	}
 }
 
@@ -379,3 +391,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');