nodester 0.1.0 → 0.1.5

package/Readme.md

@@ -30,12 +30,13 @@ app.listen(8080, function() {
 
 
 ### Core concepts
-[Go to core concepts documentaion](docs/CoreConcepts.md)
+[Core concepts documentation ➡️](docs/CoreConcepts.md)
+
 
 ### Queries & Querying - Nodester Query Language (NQR)
 One of the main power points of nodester is it's query language. It's an extension of a REST API syntaxis for a broader integration with a database SQL. Read more about it in the documentation:
 
-[Go to NQR documentaion](docs/Queries.md)
+[NQR documentaion ➡️](docs/Queries.md)
 
 
 ### Database

package/lib/application/index.js

@@ -27,7 +27,7 @@ const {
 } = require('../database/utils');
 
 const { merge } = require('../utils/objects.util');
-const consl = require('../logger/console');
+const consl = require('nodester/loggers/console');
 const debug = require('debug')('nodester:application');
 
 

package/lib/body/extract.js

@@ -0,0 +1,78 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+'use strict';
+
+const httpCodes = require('nodester/http/codes');
+
+const Sanitizations = require('nodester/utils/sanitizations');
+
+
+module.exports = extract;
+
+function extract(body, filter=null, model) {
+
+	const sequelize = model.sequelize;
+	const modelFields = Object.keys(model.tableAttributes);
+	const availableIncludes = Object.keys(model.associations);
+
+	const bodyEntries = Object.entries(body);
+
+	const { statics } = filter;
+
+
+	// Result object.
+	const newBody = {};
+
+	for (const [key, value] of bodyEntries) {
+		const isInclude = availableIncludes.indexOf(key) > -1;
+		const isField = modelFields.indexOf(key) > -1;
+
+		if ((!isField || filter.fields.indexOf(key) === -1) && !isInclude) {
+			const err = new Error(`Field '${ key }' is not available.`);
+			err.status = httpCodes.NOT_ACCEPTABLE;
+			throw err;
+		}
+
+		if (isField) {
+			const column = model.rawAttributes[key];
+			const typeName = column.type.constructor.name;
+			// Optional validation.
+			const { validation } = column;
+			
+			const sanitizationOptions = {
+				fallback: column.defaultValue ?? undefined,
+				min: validation?.min ?? undefined,
+				max: validation?.max ?? undefined
+			}
+			const sanitized = Sanitizations[typeName](value, sanitizationOptions);
+
+			newBody[key] = sanitized;
+
+			continue;
+		}
+
+		if (isInclude) {
+			const filterIncludes = Object.keys(filter.includes);
+
+			if (filterIncludes.indexOf(key) === -1) {
+				const err = new Error(`Include '${ key }' is not available.`);
+				err.status = httpCodes.NOT_ACCEPTABLE;
+				throw err;
+			}
+
+			const association = model.associations[key];
+	
+			newBody[key] = extract(value[0], filter.includes[key], association.target);
+
+			continue;
+		}
+
+		const err = new Error(`Unknown field '${ key }'.`);
+		err.status = httpCodes.NOT_ACCEPTABLE;
+		throw err;
+	}
+	
+	return newBody;
+}

package/lib/constants/ErrorCodes.js

@@ -0,0 +1,19 @@
+const Enum = require('nodester/enum');
+
+const NODESTER_QUERY_ERROR = 'NodesterQueryError';
+const UNAUTHORIZED_ERROR = 'Unauthorized';
+const NOT_FOUND_ERROR = 'NotFound';
+const VALIDATION_ERROR = 'ValidationError';
+const CONFLICT_ERROR = 'ConflictError';
+const SEQUELIZE_UNIQUE_CONSTRAINT_ERROR = 'SequelizeUniqueConstraintError';
+const INTERNAL_VALIDATION_ERROR = 'InternalValidationError';
+
+module.exports = new Enum({
+	NODESTER_QUERY_ERROR,
+	UNAUTHORIZED_ERROR,
+	NOT_FOUND_ERROR,
+	VALIDATION_ERROR,
+	CONFLICT_ERROR,
+	SEQUELIZE_UNIQUE_CONSTRAINT_ERROR,
+	INTERNAL_VALIDATION_ERROR,
+});

package/lib/constants/Operations.js

@@ -1,4 +1,4 @@
-const Enum = require('../enums/Enum');
+const Enum = require('nodester/enum');
 
 
 module.exports = new Enum({

package/lib/controllers/mixins/index.js

@@ -1,3 +1,13 @@
+const {
+	NODESTER_QUERY_ERROR,
+	UNAUTHORIZED_ERROR,
+	NOT_FOUND_ERROR,
+	VALIDATION_ERROR,
+	CONFLICT_ERROR,
+	SEQUELIZE_UNIQUE_CONSTRAINT_ERROR,
+	INTERNAL_VALIDATION_ERROR
+} = require('nodester/constants/ErrorCodes');
+
 const {
 	getOne,
 	getMany,
@@ -10,6 +20,8 @@ const {
 module.exports = {
 	withDefaultCRUD: _withDefaultCRUD,
 	withDefaultErrorProcessing: _withDefaultErrorProcessing,
+
+	setFacade: _setFacade,
 	setMethod: _setMethod
 }
 
@@ -42,18 +54,7 @@ function _withDefaultCRUD(controller, opts={}) {
 		throw err;
 	}
 
-	if (!facade) {
-		const err = new TypeError(`'opts.facade' argument is invalid.`);
-		throw err;
-	}
-
-	// Set main facade:
-	if (facade.constructor.name === 'Function') {
-		controller.facade = new facade();
-	}
-	else {
-		controller.facade = facade;
-	}
+	_setFacade(controller, facade);
 
 	// Set model info:
 	const model = facade.model;
@@ -143,34 +144,39 @@ function _withDefaultErrorProcessing(controller, opts={}) {
 		let errorResponse = {};
 
 		switch(error.name) {
-			case('Unauthorized'): {
+			case UNAUTHORIZED_ERROR: {
 				statusCode = 401;
 				errorResponse.details = { message: 'Unauthorized' };
 				break;
 			}
-			case('NotFound'): {
+			case NOT_FOUND_ERROR: {
 				statusCode = 404;
 				errorResponse.details = { message: errorMessage };
 				break;
 			}
-			case('ValidationError'): {
-				statusCode = 406;
+			case NODESTER_QUERY_ERROR: {
+				statusCode = 422;
+				errorResponse.details = { message: errorMessage };
+				break;
+			}
+			case VALIDATION_ERROR: {
+				statusCode = 422;
 				errorResponse.details = error?.details;
 				break;
 			}
-			case('ConflictError'): {
+			case CONFLICT_ERROR: {
 				statusCode = 409;
 				errorResponse.details = error?.details ?? error?.message;
 				break;
 			}
-			case('SequelizeUniqueConstraintError'): {
+			case SEQUELIZE_UNIQUE_CONSTRAINT_ERROR: {
 				statusCode = 409;
 				errorResponse.details = error?.errors;
 				break;
 			}
-			case('InternalValidationError'): {
+			case INTERNAL_VALIDATION_ERROR: {
 				statusCode = 500;
-				errorResponse.details = { message: 'Error' };
+				errorResponse.details = { message: errorMessage };
 				break;
 			}
 			default: {
@@ -201,6 +207,39 @@ function _withDefaultErrorProcessing(controller, opts={}) {
 }
 
 
+/**
+ * Sets one of or all of CRUD methods to Controller.
+ *
+ * @param {Function|Object} controller
+ * @param {Function|Object} facade
+ * @param {String} facadeName
+ *
+ * @return {Function|Object} controller
+ *
+ * @api public
+ * @alias setFacade
+ */
+function _setFacade(controller, facade, facadeName=null) {
+	if (!controller) {
+		const err = new TypeError(`'controller' argument is not provided.`);
+		throw err;
+	}
+
+	if (!facade) {
+		const err = new TypeError(`'facade' argument is invalid.`);
+		throw err;
+	}
+
+	// Set main facade:
+	if (facade.constructor.name === 'Function') {
+		controller[facadeName ?? 'facade'] = new facade();
+	}
+	else {
+		controller[facadeName ?? 'facade'] = facade;
+	}
+}
+
+
 /**
  * Sets one of CRUD methods to Controller.
  *

package/lib/facades/methods/index.js

@@ -1,5 +1,13 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+'use strict';
+
 const Params = require('nodester/params');
 
+const log = require('nodester/loggers/dev');
+
 
 module.exports = {
 	getOne: _getOne,
@@ -29,11 +37,12 @@ async function _getOne(params) {
 
 		const result = {
 			[this.modelName.singular]: instance,
-			count: 0 + instance !== null
+			count: 0 + (instance !== null)
 		}
 		return Promise.resolve(result);
 	}
 	catch(error) {
+		log.error(`${ [this.modelName.singular] }Facade.getOne error:`, error);
 		return Promise.reject(error);
 	}
 }
@@ -63,6 +72,7 @@ async function _getMany(params) {
 		return Promise.resolve(result);
 	}
 	catch(error) {
+		log.error(`${ [this.modelName.singular] }Facade.getMany error:`, error);
 		return Promise.reject(error);
 	}
 }
@@ -79,24 +89,17 @@ async function _createOne(params) {
 	try {
 		const {
 			data,
-			includes,
 		} = Params(params, {
 			data: null,
-			includes: null,
 		});
 
 		const instance = await this.model.create({ ...data }, {
 			include: this.model.getIncludesList(data)
 		});
 
-		// If includes are set, "find" this record with includes:
-		if (!!includes && includes?.length > 0) {
-			await instance.reload({ include: includes });
-		}
-
 		const result = {
 			[this.modelName.singular]: instance,
-			count: instance === null ? 0 : 1
+			count: 0 + (instance !== null)
 		}
 
 		// Call after create.
@@ -105,6 +108,7 @@ async function _createOne(params) {
 		return Promise.resolve(result);
 	}
 	catch(error) {
+		log.error(`${ [this.modelName.singular] }Facade.createOne error:`, error);
 		return Promise.reject(error);
 	}
 }
@@ -134,11 +138,12 @@ async function _updateOne(params) {
 		const result = {
 			success: isNewRecord === false,
 			[this.modelName.singular]: instance,
-			count: !!instance ? 1 : 0
+			count: 0 + (instance !== null)
 		}
 		return Promise.resolve(result);
 	}
 	catch(error) {
+		log.error(`${ [this.modelName.singular] }Facade.updateOne error:`, error);
 		return Promise.reject(error);
 	}
 }
@@ -168,6 +173,7 @@ async function _deleteOne(params) {
 		return Promise.resolve(result);
 	}
 	catch(error) {
+		log.error(`${ [this.modelName.singular] }Facade.deleteOne error:`, error);
 		return Promise.reject(error);
 	}
 }

package/lib/factories/errors/CustomError.js

@@ -1,3 +1,10 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+
+'use strict';
+
 
 module.exports = class CustomError extends Error {
 	constructor(message) {

package/lib/factories/errors/NodesterQueryError.js

@@ -0,0 +1,23 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+
+'use strict';
+
+const {
+	NODESTER_QUERY_ERROR,
+} = require('nodester/constants/ErrorCodes');
+
+
+module.exports = class NodesterQueryError extends Error {
+	constructor(message) {
+		super(message);
+
+		this.name = NODESTER_QUERY_ERROR;
+		this.status = 422;
+
+		// Remove constructor info from stack.
+		Error.captureStackTrace(this, this.constructor);
+	}
+}

package/lib/factories/errors/index.js

@@ -1,9 +1,16 @@
-/*
- * Add all your custom errors in this file.
+/*!
+ * /nodester
+ * MIT Licensed
  */
+
+'use strict';
+
+
 const Err = require('./CustomError');
+const NodesterQueryError = require('./NodesterQueryError');
 
 
 module.exports = {
-	Err
+	Err,
+	NodesterQueryError
 }

package/lib/{queries/Colander.js → filters/Filter.js}

@@ -1,11 +1,20 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+'use strict';
+
 const CLAUSES = ['limit', 'skip', 'order', 'order_by'];
 
+const { isModel } = require('../utils/models');
+
 
-module.exports = class Colander {
+module.exports = class Filter {
 
 	/*
 	 *
-	 * @param {Object|Model} optsOrModelDefinition
+	 * @param {Model} model
+	 * @param {Object} opts
 	 * - @param {Array} fields
 	 * - @param {Array} clauses
 	 * - @param {Object} includes
@@ -13,33 +22,49 @@ module.exports = class Colander {
 	 * -- @param {Object} attributes
 	 * -- @param {Object} clauses
 	 *
+	 * @param {Boolean} noLimit
+	 *
 	 */
-	constructor(optsOrModelDefinition) {
+	constructor(model=null, opts=null) {
+		this._model = model;
+
 		this._fields = [];
 		this._clauses = [];
 		this._includes = {};
 		
 		this._statics = {
 			attributes: {},
-			clauses: {
-				limit: 3
-			}
+			clauses: {}
 		}
 
-		// If model:
-		if (!!optsOrModelDefinition.tableName && typeof optsOrModelDefinition._schema === 'object') {
-			this._fields = Object.keys(optsOrModelDefinition.tableAttributes);
+		// noLimit=false
+		// if (noLimit === true) {
+		// 	delete this._statics.clauses.limit;
+		// }
+
+		// If model is present:
+		if (isModel(this._model)) {
+			this._fields = Object.keys(this._model.tableAttributes);
 			this._clauses = CLAUSES;
+
+			// ...and no options are provided,
+			// set default statics:
+			if (!opts) {
+				this.statics.clauses.limit = 3;
+			}
 		}
-		// If options:
-		else {
+		
+		// If options are defined:
+		if (!!opts) {
 			const {
 				fields,
 				clauses,
 				includes,
 				statics,
-			} = optsOrModelDefinition;
+			} = opts;
+
 
+			// If fields are array:
 			if (Array.isArray(fields)) {
 				this._fields = fields;
 			}

package/lib/http/codes/descriptions.js

@@ -0,0 +1,82 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+'use strict';
+
+const Enum = require('nodester/enum');
+
+
+module.exports = new Enum({
+	// Informational:
+	100: 'Continue',
+	101: 'Switching Protocols',
+	102: 'Processing',
+	103: 'Early Hints',
+
+	// Success:
+	200: 'OK',
+	201: 'Created',
+	202: 'Accepted',
+	203: 'Non-Authoritative Information',
+	204: 'No Content',
+	205: 'Reset Content',
+	206: 'Partial Content',
+	207: 'Multi-Status',
+	208: 'Already Reported',
+	226: 'IM Used',
+
+	// Redirections:
+	300: 'Multiple Choices',
+	301: 'Moved Permanently',
+	302: 'Found',
+	303: 'See Other',
+	304: 'Not Modified',
+	305: 'Use Proxy',
+	307: 'Temporary Redirect',
+	308: 'Permanent Redirect',
+
+	// Client Errors:
+	400: 'Bad Request',
+	401: 'Unauthorized',
+	402: 'Payment Required',
+	403: 'Forbidden',
+	404: 'Not Found',
+	405: 'Method Not Allowed',
+	406: 'Not Acceptable',
+	407: 'Proxy Authentication Required',
+	408: 'Request Timeout',
+	409: 'Conflict',
+	410: 'Gone',
+	411: 'Length Required',
+	412: 'Precondition Failed',
+	413: 'Payload Too Large',
+	414: 'URI Too Long',
+	415: 'Unsupported Media Type',
+	416: 'Range Not Satisfiable',
+	417: 'Expectation Failed',
+	418: 'I\'m a teapot',
+	421: 'Misdirected Request',
+	422: 'Unprocessable Entity',
+	423: 'Locked',
+	424: 'Failed Dependency',
+	425: 'Too Early',
+	426: 'Upgrade Required',
+	428: 'Precondition Required',
+	429: 'Too Many Requests',
+	431: 'Request Header Fields Too Large',
+	451: 'Unavailable For Legal Reasons',
+
+	// Server Errors:
+	500: 'Internal Server Error',
+	501: 'Not Implemented',
+	502: 'Bad Gateway',
+	503: 'Service Unavailable',
+	504: 'Gateway Timeout',
+	505: 'HTTP Version Not Supported',
+	506: 'Variant Also Negotiates',
+	507: 'Insufficient Storage',
+	508: 'Loop Detected',
+	510: 'Not Extended',
+	511: 'Network Authentication Required'
+});