nodester 0.0.1 → 0.0.5

package/lib/application/index.js

@@ -6,13 +6,18 @@
 'use strict';
 
 const Emitter = require('events');
-const MiddlewareStack = require('./MiddlewareStack');
+const DefaultRouter = require('../router');
 // Server:
 const http = require('http');
-const request = require('./http/request');
-const response = require('./http/response');
+const request = require('../http/request');
+const response = require('../http/response');
+// Middlewares:
+const nodesterQL = require('../middlewares/ql/sequelize');
 // Utils:
-const { typeOf } = require('../utils/types.util');
+const {
+	typeOf,
+	isConstructor
+} = require('../utils/types.util');
 const { merge } = require('../utils/objects.util');
 const consl = require('../logger/console');
 const debug = require('debug')('nodester:application');
@@ -31,11 +36,14 @@ module.exports = class Application extends Emitter {
 		// Fallback port.
 		this.port = opts?.port ?? 8080;
 
-		// Reference to middlewares stack.
-		this._middlewares = new MiddlewareStack();
+		// Reference to router.
+		this._router = new DefaultRouter({ finalhandlerEnabled: true });
 
 		// Reference to the database connection.
-		this.database = null;
+		this._database = null;
+
+		// Reference to the Query parser.
+		this._queryParser = nodesterQL;
 
 		// Reference to the http(s) server,
 		this.server = null;
@@ -55,7 +63,7 @@ module.exports = class Application extends Emitter {
 	 */
 	get request() {
 		return Object.create(request, {
-			app: { configurable: true, enumerable: true, writable: true, value: app }
+			app: { configurable: true, enumerable: true, writable: true, value: this }
 		})
 	}
 
@@ -67,7 +75,7 @@ module.exports = class Application extends Emitter {
 	 */
 	get response() {
 		return Object.create(response, {
-			app: { configurable: true, enumerable: true, writable: true, value: app }
+			app: { configurable: true, enumerable: true, writable: true, value: this }
 		})
 	}
 
@@ -89,6 +97,7 @@ module.exports = class Application extends Emitter {
 
 	/**
 	 * Sets (or overrides) main database of the application and tries to make connection.
+	 *
 	 * @param {Sequilize} sequilizeConnection
 	 * @param {Boolean} crashOnError
 	 * @return {sequilizeConnection.authenticate}
@@ -98,12 +107,17 @@ module.exports = class Application extends Emitter {
 	setDatabase(sequilizeConnection, crashOnError=true) {
 		try {
 			if (!sequilizeConnection) {
-				const err = new Error('Connection to database (Sequilize) can not be null or undefined.');
+				const err = new TypeError('Connection to database (Sequilize) can not be null or undefined.');
+				throw err;
+			}
+
+			if (this.isListening === true) {
+				const err = new Error(`Can't set database after application start.`);
 				throw err;
 			}
 
 			const result = sequilizeConnection.authenticate();
-			this.database = sequilizeConnection;
+			this._database = sequilizeConnection;
 
 			return result;
 		}
@@ -118,13 +132,42 @@ module.exports = class Application extends Emitter {
 	}
 
 
+	/*
+	 * Returns main database of the application.
+	 *
+	 * @return {SequilizeConnection}
+	 *
+	 * @public
+	 */
+	get database() {
+		return this._database;
+	}
+
+
 	/**
 	 * Overrides default Router.
 	 *
 	 * @public
 	 */
 	setRouter(newRouter) {
-		this.router = newRouter.init(this);
+		if (isConstructor(newRouter)) {
+			this._router = new newRouter();
+		}
+		else {
+			this._router = newRouter;
+		}
+	}
+
+
+	/*
+	 * Returns NodesterRouter object.
+	 *
+	 * @return {NodesterRouter}
+	 *
+	 * @public
+	 */
+	get router() {
+		return this._router;
 	}
 
 
@@ -136,40 +179,39 @@ module.exports = class Application extends Emitter {
 	 */
 	get add() {
 		return {
-			middleware: this.addMiddleware.bind(this)
+			controller: this._router.add.controller,
+			middleware: this._router.add.middleware,
+			marker: this._router.add.marker,
+			route: this._router.add.route,
 		}
 	}
 
 
 	/*
-	 * Adds new middleware to the stack.
+	 * Proxy to .add.middleware()
+	 *
+	 * @param {Function} fn
 	 *
 	 * @api public
 	 */
-	addMiddleware(fn) {
-		if (this._middlewares.isLocked === true) {
-			const err = new Error(`Can't add more middlewares after application has been started.`);
-			throw err;
-		}
-
-		this._middlewares.add(fn);
+	use(fn) {
+		return this._router.add.middleware(fn);
 	}
 
 
 	/*
-	 * Proxy to .add().
 	 *
-	 * @param {Function} fn
+	 * @param {String} markerName
 	 *
 	 * @api public
 	 */
-	use(fn) {
-		return this.add(fn);
+	only(markerName='') {
+		return this._router.only(markerName);
 	}
 
 
 	/**
-	 * Adds to hooks stack (beforeStart).
+	 * Sets beforeStart hook.
 	 *
 	 * @api public
 	 */
@@ -192,20 +234,24 @@ module.exports = class Application extends Emitter {
 	 *
 	 * @api public
 	 */
-	start() {
+	async start() {
 		try {
-			this._hooks.beforeStart.call(this);
+			await this._hooks.beforeStart.call(this);
 		}
 		catch(error) {
 			console.error('Application did not start due to error.');
 			consl.error(error);
-			return;
+			return Promise.reject(error);
 		}
 
-		// Lock middlewares stack.
-		this._middlewares.lock();
+		// Add query parser.
+		this._router.add.middleware(this._queryParser, 0);
 
-		return this.handle.bind(this);
+		// Prepare router for processing.
+		this._router.lock();
+
+		const handler = this.handle.bind(this);
+		return handler;
 	}
 
 
@@ -220,7 +266,7 @@ module.exports = class Application extends Emitter {
 	 *
 	 * @api public
 	 */
-	listen(port, ...args) {
+	async listen(port, ...args) {
 		// Remember port:
 		const _port = port ?? this.port;
 		this.port = _port;
@@ -228,7 +274,8 @@ module.exports = class Application extends Emitter {
 		debug(`listen on port ${ this.port }`);
 
 		if (!this.server) {
-			this.server = http.createServer(this.start());
+			const handler = await this.start();
+			this.server = http.createServer(handler);
 		}
 
 		this.isListening = true;
@@ -250,7 +297,7 @@ module.exports = class Application extends Emitter {
 		req.res = res;
 		res.req = req;
 
-		return this._middlewares.process(req, res)
+		return this._router.handle(req, res);
 	}
 
 
@@ -288,5 +335,9 @@ module.exports = class Application extends Emitter {
 
 		this.server.close();
 		this.isListening = false;
+
+		this._router.unlock();
+		// Remove query parser.
+		this._router.remove.middleware(0);
 	}
 }

package/lib/constants/Operations.js

@@ -0,0 +1,23 @@
+const Enum = require('../enums/Enum');
+
+
+module.exports = new Enum({
+	and: Symbol.for('and'),
+	between: Symbol.for('between'),
+	contains: Symbol.for('contains'),
+	eq: Symbol.for('eq'),
+	ne: Symbol.for('ne'),
+	gte: Symbol.for('gte'),
+	gt: Symbol.for('gt'),
+	lte: Symbol.for('lte'),
+	lt: Symbol.for('lt'),
+	not: Symbol.for('not'),
+	is: Symbol.for('is'),
+	in: Symbol.for('in'),
+	notIn: Symbol.for('notIn'),
+	like: Symbol.for('like'),
+	notLike: Symbol.for('notLike'),
+	notBetween: Symbol.for('notBetween'),
+	or: Symbol.for('or'),
+	xor: Symbol.for('xor'),
+});

package/lib/controllers/methods/index.js

@@ -0,0 +1,170 @@
+
+module.exports = {
+	getOne: _getOne,
+	getMany: _getMany,
+	createOne: _createOne,
+	updateOne: _updateOne,
+	deleteOne: _deleteOne
+}
+
+
+/*
+ * @alias getOne
+ * @api public
+ */
+async function _getOne(req, res) {
+	try {
+
+		const result = await this.facade.getOne();
+
+		if (this.afterGetOne) {
+			await this.afterGetOne(req, res, result);
+		}
+
+		return this.respondOk(res, {
+			content: { ...result }
+		});
+	}
+	catch(error) {
+		console.error('getOne', error);
+		if (this.processError) {
+			return this.processError(error, req, res);
+		}
+		else {
+			res.status(500);
+			res.json({ error: error.toString() });
+		}
+	}
+	finally {
+		return Promise.resolve();
+	}
+}
+
+
+/*
+ * @alias getMany
+ * @api public
+ */
+async function _getMany(req, res) {
+	try {
+		const result = await this.facade.getMany();
+
+		if (this.afterGetMany) {
+			await this.afterGetMany(req, res, result);
+		}
+
+		return this.respondOk(res, {
+			content: { ...result }
+		});
+	}
+	catch(error) {
+		if (this.processError) {
+			return this.processError(error, req, res);
+		}
+		else {
+			res.status(500);
+			res.json({ error: error.toString() });
+		}
+	}
+	finally {
+		return Promise.resolve();
+	}
+}
+
+
+/*
+ * @alias createOne
+ * @api public
+ */
+async function _createOne(req, res) {
+	try {
+
+		const result = await this.facade.createOne();
+
+		if (this.afterCreateOne) {
+			await this.afterCreateOne(req, res, result);
+		}
+
+		return this.respondOk(res, {
+			content: { ...result }
+		});
+	}
+	catch(error) {
+		if (this.processError) {
+			return this.processError(error, req, res);
+		}
+		else {
+			res.status(500);
+			res.json({ error: error.toString() });
+		}
+	}
+	finally {
+		return Promise.resolve();
+	}
+}
+
+
+/*
+ * @alias updateOne
+ * @api public
+ */
+async function _updateOne(req, res) {
+	try {
+
+		const result = await this.facade.updateOne();
+
+		if (this.afterUpdateOne) {
+			await this.afterUpdateOne(req, res, result);
+		}
+
+		return this.respondOk(res, {
+			content: { ...result }
+		});
+	}
+	catch(error) {
+		if (this.processError) {
+			return this.processError(error, req, res);
+		}
+		else {
+			res.status(500);
+			res.json({ error: error.toString() });
+		}
+	}
+	finally {
+		return Promise.resolve();
+	}
+}
+
+
+/*
+ * @alias deleteOne
+ * @api public
+ */
+async function _deleteOne(req, res) {
+	try {
+
+		const result = await this.facade.deleteOne();
+
+		if (this.afterDeleteOn) {
+			await this.afterDeleteOne(req, res, result);
+		}
+
+		return this.respondOk(res, {
+			content: { ...result }
+		});
+	}
+	catch(error) {
+		if (this.processError) {
+			return this.processError(error, req, res);
+		}
+		else {
+			res.status(500);
+			res.json({ error: error.toString() });
+		}
+	}
+	finally {
+		return Promise.resolve();
+	}
+}
+
+

package/lib/controllers/mixins/index.js

@@ -0,0 +1,213 @@
+const {
+	getOne,
+	getMany,
+	createOne,
+	updateOne,
+	deleteOne
+} = require('../methods');
+
+
+module.exports = {
+	withDefaultCRUD: _withDefaultCRUD,
+	withDefaultErrorProcessing: _withDefaultErrorProcessing,
+	setMethod: _setMethod
+}
+
+
+/**
+ * Sets one of or all of CRUD methods to Controller.
+ *
+ * @param {Function|Object} controller
+ * @param {Object} opts
+ * - @param {Function|Object} facade
+ * - @param {String} name
+ * - @param {Array} only
+ *
+ * @return {Function|Object} controller
+ *
+ * @api public
+ * @alias withDefaultCRUD
+ */
+function _withDefaultCRUD(controller, opts={}) {
+	const {
+		facade,
+
+		// Optional:
+		name,
+		only
+	} = opts;
+
+	if (!controller) {
+		const err = new TypeError(`'controller' argument is not provided.`);
+		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;
+	}
+
+	// Set model info:
+	const model = facade.model;
+	// Extract plural name of this model.
+	const modelPluralName = model?.options?.name?.plural;
+	// Set name of this controller:
+	Object.defineProperty(controller, 'name', {
+		value: name ?? `${ modelPluralName ?? controller.name }Controller`,
+		writable: false
+	});
+
+
+	// If only certain methods should be set:
+	if (!!only) {
+		for (const selectedMethod of only) {
+			switch(selectedMethod) {
+				case 'getOne':
+					controller.getOne    = getOne.bind(controller);
+					break;
+				case 'getMany':
+					controller.getMany   = getMany.bind(controller);
+					break;
+				case 'createOne':
+					controller.createOne = createOne.bind(controller);
+					break;
+				case 'updateOne':
+					controller.updateOne = updateOne.bind(controller);
+					break;
+				case 'deleteOne':
+					controller.deleteOne = deleteOne.bind(controller);
+					break;
+
+				default:
+					break;
+			}
+		}
+	}
+	// Or set all methods:
+	else {
+		controller.getOne    = getOne.bind(controller);
+		controller.getMany   = getMany.bind(controller);
+		controller.createOne = createOne.bind(controller);
+		controller.updateOne = updateOne.bind(controller);
+		controller.deleteOne = deleteOne.bind(controller);
+
+		// Set empty hooks:
+		controller.afterGetOne    = async () => {};
+		controller.afterGetMany   = async () => {};
+		controller.afterCreateOne = async () => {};
+		controller.afterUpdateOne = async () => {};
+		controller.afterDeleteOe  = async () => {};
+	}
+
+	// TODO: remove.
+	controller.respondOk = (res, data) => res.json(data);
+	controller.respondNotOk = (res, data) => { res.status(data.status); res.json(data); };
+
+	return controller;
+}
+
+
+/**
+ * Sets default error responses to Controller.
+ *
+ * @param {Function|Object} controller
+ * @param {Object} opts
+ *
+ * @return {Function|Object} controller
+ *
+ * @api public
+ * @alias withDefaultErrorProcessing
+ */
+function _withDefaultErrorProcessing(controller, opts={}) {
+	if (!controller) {
+		const err = new TypeError(`'controller' argument is not provided.`);
+		throw err;
+	}
+
+	// Set processError:
+	controller.processError = function (error, req, res) {
+		// Default error message.
+		let errorMessage = error?.message ?? 'Internal server error';
+		// Default HTTP status code.
+		let statusCode = error?.status ?? error?.statusCode ?? 500;
+		// Error response object.
+		let errorResponse = {};
+
+		switch(error.name) {
+			case('Unauthorized'): {
+				statusCode = 401;
+				errorResponse.details = { message: 'Unauthorized' };
+				break;
+			}
+			case('NotFound'): {
+				statusCode = 404;
+				errorResponse.details = { message: errorMessage };
+				break;
+			}
+			case('ValidationError'): {
+				statusCode = 406;
+				errorResponse.details = error?.details;
+				break;
+			}
+			case('ConflictError'): {
+				statusCode = 409;
+				errorResponse.details = error?.details ?? error?.message;
+				break;
+			}
+			case('SequelizeUniqueConstraintError'): {
+				statusCode = 409;
+				errorResponse.details = error?.errors;
+				break;
+			}
+			case('InternalValidationError'): {
+				statusCode = 500;
+				errorResponse.details = { message:'Error' };
+				break;
+			}
+			default: {
+				errorResponse.details = { message:errorMessage };
+				break;
+			}
+		}
+
+		// Send error response with provided status code.
+		return this.respondNotOk(res, {
+			error: {
+				...errorResponse,
+				code: statusCode
+			},
+			status: statusCode
+		});
+	}
+
+	return controller;
+}
+
+
+/**
+ * Sets one of CRUD methods to Controller.
+ *
+ * @param {Function|Object} controller
+ * @param {Object} opts
+ *
+ * @return {Function|Object} controller
+ *
+ * @api public
+ * @alias withDefaultCRUD
+ */
+function _setMethod(controller,) {
+	if (!controller) {
+		const err = new TypeError(`'controller' argument is not provided.`);
+		throw err;
+	}
+
+
+}

package/lib/enums/Enum.js

@@ -0,0 +1,16 @@
+
+module.exports = Enum;
+
+function Enum(constantsList = {}, writable=false) {
+	const def = (key, value) => Object.defineProperty(this, key, { value, writable: !!writable });
+
+	// Set list.
+	def('list', constantsList);
+
+	// Set getters:
+	Object.keys(constantsList)
+				.forEach(key => def(key, constantsList[key]) );
+
+	// Set constants in static array.
+	def('asArray', Object.values(constantsList) );
+}

package/lib/factories/errors/CustomError.js

@@ -1,6 +1,8 @@
-class CustomError extends Error {
+
+module.exports = class CustomError extends Error {
 	constructor(message) {
 		super(message);
+
 		this.name = this.constructor.name;
 		this.status = 500;
 
@@ -14,9 +16,9 @@ class CustomError extends Error {
 		this.status = originalError?.status ?? this.status;
 
 		// Append stack from original error.
-		const messageLines = (this.message.match(/\n/g)||[]).length + 1
-		this.stack = this.stack.split('\n').slice(0, messageLines+1).join('\n') + '\n' + originalError.stack;
+		const linesCount = (this.message.match(/\n/g)||[]).length + 1;
+		this.stack = this.stack.split('\n')
+													 .slice(0, linesCount+1)
+													 .join('\n') + '\n' + originalError.stack;
 	}
 }
-
-module.exports = CustomError;

package/lib/factories/responses/html.js

@@ -1,7 +1,12 @@
-const Params = require('nodester/facades/FacadeParams');
+/*
+ * WARNING: Unfinihsed. Do not use!
+ *
+ */
 
+const Params = require('../../params/Params');
 
-module.exports = class WebResponseFactory {
+
+module.exports = class HtmlResponseFactory {
 	constructor() {}
 
 	/**