nodester 0.1.5 → 0.2.1

package/lib/stacks/MiddlewaresStack.js

@@ -0,0 +1,200 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+
+'use strict';
+
+const finalhandler = require('finalhandler');
+
+// Arguments validator.
+const { ensure } = require('../validators/arguments');
+
+// Console:
+const consl = require('nodester/loggers/console');
+const debug = require('debug')('nodester:MiddlewaresStack');
+
+
+/*
+ * Creates new MiddlewaresStack.
+ *
+ * @param {Object}  [opts]
+ * @param {Boolean} opts.finalhandlerEnabled
+ *
+ * @return {MiddlewaresStack}
+ *
+ */
+module.exports = class MiddlewaresStack {
+	constructor(opts={}) {
+		// This array MUST stay flat!
+		this._middlewares = [];
+
+		// Indicates whether we can add more middlewares or no.
+		this._isLocked = false;
+		this.finalhandlerEnabled = !!opts.finalhandlerEnabled;
+
+
+		const env = process.env.NODE_ENV || 'development';
+		// Final middleware & error handler.
+		this.finalhandler = (req, res) => finalhandler(req, res, {
+			env: env,
+			onerror: consl.error.bind(this)
+		});
+	}
+
+	// Getters:
+	get middlewares() {
+		return this._middlewares;
+	}
+
+	get length() {
+		return this._middlewares.length;
+	}
+
+	/**
+	 * Indicates whether user can add more middlewares or not.
+	 *
+	 * @return {Boolean} isLocked
+	 *
+	 * @api public
+	 */
+	get isLocked() {
+		return this._isLocked === true;
+	}
+	// Getters\
+
+
+	/**
+	 * Add the given middleware `fn` to the stack.
+	 *
+	 * @param {Function} fn
+	 * @param {Integer} index (0 or undefined)
+	 *
+	 * @return {Integer} index of the new middleware
+	 *
+	 * @api public
+	 */
+	add(fn, index) {
+		try {
+			ensure(fn, 'function,required', 'fn');
+			ensure(index, 'number', 'index');
+
+			if (this._isLocked) {
+				const err = new Error(`Can't add more middlewares while stack is locked.`);
+				throw err;
+			}
+
+			let pushedIndex = -1;
+
+			if (index === 0) {
+				this._middlewares.unshift(fn);
+				pushedIndex = 0;
+			}
+			else {
+				pushedIndex = this.middlewares.push(fn);
+			}
+
+			debug(`added middleware (${ pushedIndex })`);
+			return pushedIndex;
+		}
+		catch(error) {
+			Error.captureStackTrace(error, this.add);
+			throw error;
+		}
+	}
+
+
+	/**
+	 * Removes middleware at index.
+	 *
+	 * @param {Integer} index
+	 *
+	 * @return {MiddlewaresStack} self
+	 *
+	 * @api public
+	 */
+	remove(index=-1) {
+		try {
+			ensure(index, 'number,required', 'index');
+
+			if (this._isLocked) {
+				const err = new Error(`Can't remove middlewares while stack is locked.`);
+				throw err;
+			}
+
+			this._middlewares.splice(index, 1);
+			debug(`removed middleware (${ index })`);
+			return this;
+		}
+		catch(error) {
+			Error.captureStackTrace(error, this.remove);
+			throw error;
+		}
+	}
+
+
+	/*
+	 * Prepare stack for processing.
+	 *
+	 * @api public
+	 */
+	lock() {
+		if (this.finalhandlerEnabled) {
+			// Add final handler to the stack.
+			this.add((req, res)=>this.finalhandler(req, res)());
+		}
+
+		// Stack is ready.
+		this._isLocked = true;
+
+		debug(`stack is locked`);
+	}
+
+
+	/*
+	 * Unlocks stack.
+	 *
+	 * @api public
+	 */
+	unlock() {
+		this._isLocked = false;
+		
+		if (this.finalhandlerEnabled) {
+			this._middlewares.pop();
+		}
+
+		debug(`stack is unlocked`);
+	}
+
+
+	/*
+	 * Start chain.
+	 *
+	 * @api public
+	 */
+	process(req, res, next) {
+		let middlewareOffset = -1;
+
+		const _next = (...args) => {
+			middlewareOffset += 1;
+			const fn = this._middlewares[middlewareOffset];
+
+			try {
+				if (!fn && !!next) {
+					// Middleware stack is finished:
+					return next.call(null, req, res, next, ...args);
+				}
+				else if (!!fn) {
+					return fn.call(null, req, res, _next, ...args);
+				}
+			}
+			catch(error) {
+				return this.finalhandler(req, res)(error);
+			}
+		}
+
+		// Initial start:
+		return _next();
+	}
+
+}

package/lib/structures/Enum.js

@@ -0,0 +1,46 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+ 
+'use strict';
+
+
+module.exports = function Enum(constantsList={}) {
+	_setGetters(this, constantsList);
+
+	this.withValuePrefix = _withValuePrefix.bind(this);
+	this.withKeyPrefix = _withKeyPrefix.bind(this);
+}
+
+function _setGetters(enumTarget, constantsList) {
+	enumTarget.list = constantsList;
+
+	Object.keys(constantsList).forEach(key => {
+		enumTarget[key] = constantsList[key];
+	});
+
+	// Set constants in static array.
+	enumTarget.asArray = Object.values(constantsList);
+}
+
+
+function _withValuePrefix(prefix='') {
+	const constantsList = {};
+
+	for (const [ key, value ] of Object.entries(this.list)) {
+		constantsList[key] = `${ prefix }${ value }`;
+	}
+
+	_setGetters(this, constantsList);
+
+	return this;
+}
+
+function _withKeyPrefix(prefix='') {
+	Object.keys(this.list).forEach(key => {
+		this[`${ prefix }${ key }`] = this.list[key];
+	});
+
+	return this;
+}

package/lib/structures/Filter.js

@@ -0,0 +1,157 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+ 
+'use strict';
+
+const BOUNDS = require('../constants/Bounds');
+const CLAUSES = require('../constants/Clauses');
+
+const { isModel } = require('../utils/models');
+const { ensure } = require('../validators/arguments');
+
+
+module.exports = class NodesterFilter {
+
+	/*
+	 *
+	 * @param {Model} model
+	 * @param {Object} options
+	 * @param {Array}  options.fields
+	 * @param {Array}  options.clauses
+	 * @param {Object} options.includes
+	 *
+	 * @param {Object} options.bounds
+	 * @param {Object} options.bounds.fields
+	 * @param {Object} options.bounds.clauses
+	 *
+	 * @param {Object} options.statics
+	 * @param {Object} options.statics.attributes
+	 * @param {Object} options.statics.clauses
+	 *
+	 *
+	 */
+	constructor(model=null, options={}) {
+		ensure(options, 'object,required', 'options');
+		
+		this._model = model;
+
+		this._fields = [];
+		this._clauses = [];
+		this._includes = {};
+
+		this._bounds = {
+			fields: {},
+			clauses: {}
+		}
+		
+		this._statics = {
+			attributes: {},
+			clauses: {}
+		}
+
+		// If model is present:
+		if (isModel(this.model)) {
+			this._fields = Object.keys(this.model.tableAttributes);
+			this._clauses = CLAUSES.asArray;
+
+			// ...and no 'bounds' and 'statics' are provided,
+			// set defaults:
+			if (!options.bounds && !options.statics) {
+				this._bounds.clauses.limit = {
+					min: BOUNDS.limit.min,
+					max: BOUNDS.limit.max
+				}
+			}
+		}
+		
+		const {
+			fields,
+			clauses,
+			includes,
+			bounds,
+			statics,
+		} = options;
+
+
+		// If fields are array:
+		if (Array.isArray(fields)) {
+			this._fields = fields;
+		}
+
+		if (Array.isArray(clauses)) {
+			this._clauses = clauses;
+		}
+
+		// Includes:
+		if (typeof includes === 'object') {
+			const { associations } = this.model;
+			for (const [ includeName, includeFilter ] of Object.entries(includes)) {
+				const association = associations[includeName];
+				// Validate association by name:
+				if (association === undefined) {
+					const error = new TypeError(`No include named '${ includeName }'.`);
+					Error.captureStackTrace(error, this.constructor);
+					throw error;
+				}
+
+				// If singular association:
+				// Fix of "Only HasMany associations support include.separate"
+				if ('HasMany' !== association.associationType) {
+					// Empty bounds.
+					includeFilter.noBounds = true;
+				}
+
+				this._includes[includeName] = includeFilter;
+			}
+		}
+		// Includes\
+
+		if (typeof bounds === 'object') {
+			this._bounds = bounds;
+		}
+
+		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 bounds() {
+		return this._bounds;
+	}
+
+	get statics() {
+		return this._statics;
+	}
+
+	get model() {
+		return this._model;
+	}
+	// Getters\
+
+	set noBounds(value) {
+		if (value === true) {
+			this._bounds.clauses = {};
+		}
+	}
+}

package/lib/structures/Params.js

@@ -0,0 +1,55 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+ 
+'use strict';
+
+const {
+	BOOLEAN
+} = require('nodester/utils/sanitizations');
+
+
+module.exports = Params;
+
+/**
+ * Extracts only values set in the second argument from the first argument.
+ * If such values is missing in the first argument, will fallback to the value in the second argument.
+ *
+ * @param {Object} sourceObj
+ * @param {Object} defaultValuesList
+ *
+ * @return {Object} result
+ *
+ * @api public
+ */
+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':
+		if (sourceObj[key] === undefined) {
+			result[key] = defaultValuesList[key];
+			continue;
+		}
+
+		// If String:
+		if (typeof defaultValuesList[key] === 'string') {
+			result[key] = `${ sourceObj[key] }`;
+			continue;
+		}
+
+		const isBoolean = toString.call(defaultValuesList[key]) === '[object Boolean]';
+		const isNumber = !isNaN(`${ defaultValuesList[key] }`);
+
+		result[key] = isBoolean ? BOOLEAN(sourceObj[key]) : (isNumber ? parseFloat(sourceObj[key]) : sourceObj[key]);
+	}
+
+	return result;
+}

package/lib/tools/sql.tool.js

@@ -1,3 +1,10 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+
+'use strict';
+
 const { QueryTypes } = require('sequelize');
 // Utils:
 const fs = require('fs');

package/lib/utils/objects.util.js

@@ -2,8 +2,12 @@
  * /nodester
  * MIT Licensed
  */
+
 'use strict';
 
+// Arguments validator.
+const { ensure } = require('../validators/arguments');
+
 
 module.exports = {
 	copyWithCertainAttributes: _copyWithCertainAttributes,
@@ -13,57 +17,60 @@ module.exports = {
 /**
  * Copy key-value of target object
  *
- * @param {object} targetObj Object to copy attributes from
- * @param {array} attributes Array of keys
- * @returns {object} New object with attributes of targetObj
+ * @param {object} target - Object to copy attributes from
+ * @param {array} attributes - Array of keys
+ *
+ * @return {object} New object with attributes of target
  *
  * @alias copyWithCertainAttributes
- * @public
+ *
+ * @api public
  */
-function _copyWithCertainAttributes(targetObj={}, attributes=[]) {
+function _copyWithCertainAttributes(target={}, attributes=[]) {
+	ensure(target, 'object,required', 'target');
+	ensure(attributes, 'array,required', 'attributes');
+
 	const result = {};
 
-	attributes.forEach(a => result[a] = targetObj[a]);
+	attributes.forEach(a => result[a] = target[a]);
 
 	return result;
 }
 
 /**
- * Merge the property descriptors of `src` into `dest`
+ * Merge the property descriptors of `src` into `target`
  *
- * @param {object} dest Object to add descriptors to
- * @param {object} src Object to clone descriptors from
- * @param {boolean} [redefine=true] Redefine `dest` properties with `src` properties
- * @returns {object} Reference to dest
+ * @param {object} target - Object to add descriptors to
+ * @param {object} src - Object to clone descriptors from
+ * @param {boolean} [redefine=true] - Redefine `target` properties with `src` properties
+ *
+ * @return {object} Reference to target
  *
  * @alias merge
- * @public
+ *
+ * @api public
  */
-function _merge (dest={}, src={}, redefine=true) {
-	if (!dest) {
-		throw new TypeError('argument dest is required')
-	}
-
-	if (!src) {
-		throw new TypeError('argument src is required')
-	}
+function _merge (target={}, src={}, redefine=true) {
+	ensure(target, 'object,required', 'target');
+	ensure(src, 'object,required', 'src');
+	ensure(redefine, 'boolean', 'redefine');
 
 	if (redefine === true) {
-		dest = Object.assign(dest, src);
+		target = Object.assign(target, src);
 	}
 	else {
 		Object.getOwnPropertyNames(src)
 				.forEach(function forEachOwnPropertyName(name) {
-			if (!redefine && hasOwnProperty.call(dest, name)) {
+			if (!redefine && hasOwnProperty.call(target, name)) {
 				// Skip descriptor.
 				return;
 			}
 
 			// Copy descriptor:
 			const descriptor = Object.getOwnPropertyDescriptor(src, name)
-			Object.defineProperty(dest, name, descriptor)
+			Object.defineProperty(target, name, descriptor)
 		});
 	}
 
-	return dest;
+	return target;
 }

package/lib/utils/sanitizations.util.js

@@ -1,3 +1,9 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+'use strict';
+
 
 module.exports = {
 	NUMBER: _NUMBER,
@@ -44,8 +50,8 @@ function _BOOLEAN(value=undefined, options={ fallback:undefined }) {
 			return value;
 
 		// If string-boolean.
-		if (typeof value === "string")
-			return value === "true";
+		if (typeof value === 'string')
+			return value === 'true';
 
 		throw new Error(`Not a Boolean`);
 	}
@@ -56,7 +62,7 @@ function _BOOLEAN(value=undefined, options={ fallback:undefined }) {
 
 function _STRING(value=undefined, options={ fallback:undefined }) {
 	try {
-		if (typeof value !== "string")
+		if (typeof value !== 'string')
 			throw new Error(`Not a String`);
 			
 		return value;
@@ -97,7 +103,7 @@ function _DATE(value=undefined, options={ fallback:undefined }) {
 
 function _JSON(value=undefined, options={ fallback:undefined }) {
 	try {
-		if (typeof value === "string")
+		if (typeof value === 'string')
 			return JSON.parse(value);
 
 		if (typeof value !== 'object')

package/lib/validators/arguments.js

@@ -0,0 +1,68 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+
+'use strict';
+
+
+module.exports = {
+	ensure: _ensure
+}
+
+/*
+ * Validates given argument against rules.
+ *
+ * @param {Any} argument
+ * @param {String} rules
+ * @param {String} argumentName
+ *
+ * @api private
+ * @alias ensure
+ */
+function _ensure(argument, rules, argumentName) {
+	const name = argumentName ? `'${ argumentName }'` : 'Argument';
+	
+	let rulesArray = rules.split(',');
+
+	let types = [];
+	let isRequired = undefined;
+
+	for (const rule of rulesArray) {
+		// Types:
+		if (rule.indexOf('|') > 0) {
+			types = [
+				...types,
+				...rule.split('|')
+			];
+			continue;
+		}
+
+		if (rule === 'required') {
+			if (argument === undefined || argument === null) {
+				throw new Error(`${ name } is required.`);
+			}
+
+			isRequired = true;
+			continue;
+		}
+
+		types.push(rule);
+	}
+
+	if (types.length === 0)
+		return true;
+
+	let mismatchedTypesCount = 0;
+	for (const type of types) {
+		if (typeof argument !== type) {
+			mismatchedTypesCount++;
+		}
+	}
+
+	if (mismatchedTypesCount === types.length && argument !== undefined) {
+		throw new TypeError(`${ name } must be of type ${ types.join('|') }.`);
+	}
+
+	return true;
+}

package/lib/validators/dates.js

@@ -1,3 +1,10 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+
+'use strict';
+
 
 module.exports = {
 	isValidDate: _isValidDate

package/lib/validators/numbers.js

@@ -1,3 +1,10 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+
+'use strict';
+
 
 module.exports = {
 	isValidNumber: _isValidNumber