nodester 0.0.8 → 0.1.0

package/lib/queries/traverse.js

@@ -0,0 +1,311 @@
+const { Op } = require('sequelize');
+
+
+module.exports = traverse;
+
+function traverse(queryNode, colander=null, model) {
+
+	const fieldsAvailable = Object.keys(model.tableAttributes);
+	const includesAvailable = model.getIncludesList();
+
+	const newQuery = {
+		attributes: [],
+		where: {},
+		include: []
+	};
+	
+	const {
+		where,
+		includes,
+		fields,
+		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\
+
+
+	// 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) {
+		for (let [clauseName, staticClauseValue] of Object.entries(colander.statics.clauses)) {
+			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:
+	const sequelize = model.sequelize;
+	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\
+
+			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 static = staticAttributes[attribute];
+
+	// If attribute is Op (like, or, not, 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 (!!static) {
+		whereHolder[attribute] = static;
+		return;
+	}
+
+	whereHolder[attribute] = _parseValue(_value, attribute);
+}
+
+function _disassembleQueryNode(queryNode) {
+	// Disassemble current query node:
+	const {
+		where,
+		includes,
+		fields,
+		...clauses
+	} = queryNode;
+	// delete queryNode.model;
+
+	return {
+		where: where ?? {},
+		includes: includes ?? [],
+		fields: fields ?? [],
+		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 }`;
 	}

package/lib/router/index.js

@@ -6,11 +6,17 @@
 'use strict';
 
 const MiddlewareStack = require('../stacks/MiddlewareStack');
-const MarkersStack = require('../stacks/MarkersStack');
 const Route = require('./route');
+// Markers:
+const MarkersStack = require('../stacks/MarkersStack');
+const MarkerMethods = require('./markers');
 // Utils:
 const { typeOf } = require('../utils/types.util');
-const { wrapRouteHandler } = require('./routes.util');
+const {
+	validateParsedRouteMethood,
+	wrapRouteHandler
+} = require('./routes.util');
+const { parseProviderFileNames } = require('./utils');
 //	File system:
 const Path = require('path');
 const fs = require('fs');
@@ -34,14 +40,17 @@ module.exports = class NodesterRouter {
 	 * @api public
 	 */
 	constructor(opts={}) {
+		// Reference to the controllers stack.
+		this._controllers = new Map();
+
 		// Reference to middlewares stack.
 		this._middlewares = new MiddlewareStack({ finalhandlerEnabled: !!opts.finalhandlerEnabled });
 
 		// Reference to the markers stack.
 		this._markers = new MarkersStack();
 
-		// Reference to the controllers stack.
-		this._controllers = new Map();
+		// Reference to the providers stack.
+		this._providers = new Map();
 
 		this.codeFileExtensions = commonExtensions.code;
 		this.paths = {};
@@ -55,29 +64,20 @@ module.exports = class NodesterRouter {
 			this.codeFileExtensions = [...opts.codeFileExtensions];
 		}
 
-		//	If "controllersPath" was set, cache all controllers in directory:
+		//	If "controllersPath" was set,
+		//	cache all controllers in directory:
 		if (!!opts.controllersPath) {
 			// Save path.
 			this.paths.controllers = opts.controllersPath;
 
-			const availableFileExtensions = this.codeFileExtensions;
 			// Only get files, which have available file extensions:
+			const availableFileExtensions = this.codeFileExtensions;
 			const fileNames = fs.readdirSync(this.paths.controllers);
-			for (const fileName of fileNames) {
-
-				const nameParts = fileName.split('.');
-				const extension = nameParts.pop();
-				if (availableFileExtensions.indexOf(extension) === -1) {
-					continue;
-				}
 
-				// If the name format is <model>.<controller>,
-				// but second part is not "controller":
-				if (nameParts.length > 1 && nameParts[1] !== 'controller')
-					continue;
+			const controllersNames = parseProviderFileNames(fileNames, availableFileExtensions, 'controller');
 
+			for (const { fileName, controllerName } of controllersNames) {
 				const controller = require(Path.join(this.paths.controllers, fileName));
-				const controllerName = nameParts[0];
 				this.addController(controller, controllerName);
 			}
 		}
@@ -94,6 +94,37 @@ module.exports = class NodesterRouter {
 				this.addController(controllerDefinition, controllerName);
 			}
 		}
+
+		//	If "providersPath" was set,
+		//	cache all providers in directory:
+		if (!!opts.providersPath) {
+			// Save path.
+			this.paths.providers = opts.providersPath;
+
+			// Only get files, which have available file extensions:
+			const availableFileExtensions = this.codeFileExtensions;
+			const fileNames = fs.readdirSync(this.paths.providers);
+
+			const providersNames = parseProviderFileNames(fileNames, availableFileExtensions, 'provider');
+
+			for (const { fileName, providerName } of providersNames) {
+				const provider = require(Path.join(this.paths.providers, fileName));
+				this.addProvider(provider, providerName);
+			}
+		}
+
+		//	If "providers" were provided as an Object:
+		if (!!opts.providers) {
+			if (typeOf(opts.providers) !== 'Object') {
+				const err = new TypeError(`"providers" must be an Object.`);
+				throw err;
+			}
+
+			const entities = Object.entities(opts.providers);
+			for (const [providerName, providerDefinition] of entities) {
+				this.addProvider(providerDefinition, providerName);
+			}
+		}
 	}
 
 
@@ -111,6 +142,7 @@ module.exports = class NodesterRouter {
 			controller: this.addController.bind(this),
 			middleware: this.addMiddleware.bind(this),
 			marker: this.addMarker.bind(this),
+			provider: this.addProvider.bind(this),
 			route: this.addRoute.bind(this),
 			routes: this.addRoutes.bind(this),
 		}
@@ -182,6 +214,33 @@ module.exports = class NodesterRouter {
 	}
 
 
+	/*
+	 * Adds new provider to the providers stack.
+	 *
+	 * @param {Function|Object} provider
+	 * @param {String} providerName
+	 *
+	 * @api public
+	 */
+	addProvider(fnOrObject, providerName=null) {
+		const providerType = typeOf(fnOrObject);
+		const name = providerName ?? fnOrObject?.name ?? fnOrObject.constructor.name;
+
+		// If provider was exported as Object:
+		if (providerType === 'Object') {
+			this._providers.set(name, fnOrObject);
+		}
+		// If provider was exported as a constructor function:
+		else if (providerType === 'function') {
+			this._providers.set(name, new fnOrObject());
+		}
+		else {
+			const err = new TypeError(`Please check how you exported ${ name }, it should be either Object or constructor function.`);
+			throw err;
+		}
+	}
+
+
 	/*
 	 * Creates route middleware and adds it to the stack.
 	 *
@@ -191,21 +250,19 @@ module.exports = class NodesterRouter {
 	 * @api public
 	 */
 	addRoute(route='', handler) {
-		const parsed = new Route(route);
-		const handlerType = typeOf(handler);
+		const parsedRoute = new Route(route);
+		// Will throw exception if not valid.
+		validateParsedRouteMethood(parsedRoute);
 		
-		// ToDo: move it to separate validator:
-		if (parsed.method === undefined) {
-			const err = new TypeError(`"route" should start with one of the following methods: [GET, POST, PUT, DELETE, QUERY, HEADER, OPTIONS]`);
-			throw err;
-		}
+		const handlerType = typeOf(handler);
 
-		if (handlerType === 'Object' && !this.paths.controllers) {
-			const err = new TypeError(`Please set "controllersPath" during Router initialization.`);
+		if (handlerType === 'Object' && !this.paths.controllers && !this.paths.providers) {
+			const msg = `Please set "controllersPath" or "providersPath" during Router initialization.`;
+			const err = new TypeError(msg);
 			throw err;
 		}
 
-		const wrapped = wrapRouteHandler.call(this, parsed, handler);
+		const wrapped = wrapRouteHandler.call(this, parsedRoute, handler);
 		return this.addMiddleware(wrapped);
 	}
 
@@ -228,11 +285,18 @@ module.exports = class NodesterRouter {
 	/*
 	 * Proxy to .add.middleware()
 	 *
-	 * @param {Function} fn
+	 * @param {Function|NodesterRouter} fnOrRouter
 	 *
 	 * @api public
 	 */
-	use(fn) {
+	use(fnOrRouter) {
+		let fn = fnOrRouter;
+
+		// If Router:
+		if (fnOrRouter instanceof NodesterRouter) {
+			fn = fnOrRouter.handle.bind(fnOrRouter);
+		}
+
 		return this.add.middleware(fn);
 	}
 
@@ -249,51 +313,8 @@ module.exports = class NodesterRouter {
 		const markerFn = this._markers.get(markerName);
 
 		return {
-			route: (route, fn) => {
-				const parsed = new Route(route);
-				// ToDo: move it to separate validator:
-				if (parsed.method === undefined) {
-					const err = new TypeError(`"route" should start with one of the following methods: [GET, POST, PUT, DELETE, QUERY, HEADER, OPTIONS]`);
-					throw err;
-				}
-
-				const wrapped = async (req, res, next) => {
-					const matched = await markerFn.call(self, req, res);
-					// Skip, if marker's condition was not matched:
-					if (!matched) {
-						return next();
-					}
-
-					// Wrap and call:
-					const routeHandler = wrapRouteHandler.call(self, parsed, fn);
-					await routeHandler.call(self, req, res, next);
-
-					// If response was not sent,
-					// go to next one:
-					if (res.headersSent === false) {
-						next();
-					}
-				};
-				return self.add.route(wrapped);
-			},
-			use: (fn) => {
-				const wrapped = async (req, res, next) => {
-					const matched = await markerFn.call(self, req, res);
-					// Skip, if marker's condition was not matched:
-					if (!matched) {
-						return next();
-					}
-
-					await fn.call(self, req, res, next);
-
-					// If response was not sent,
-					// go to next one:
-					if (res.headersSent === false) {
-						next();
-					}
-				};
-				return self.use(wrapped);
-			}
+			route: (route, fn) => MarkerMethods.onlyRoute.call(self, route, fn, markerFn),
+			use: (fnOrRouter) => MarkerMethods.onlyUse.call(self, fnOrRouter, markerFn),
 		}
 	}
 

package/lib/router/markers.js

@@ -0,0 +1,78 @@
+const Route = require('./route');
+// Utils.
+const {
+	validateParsedRouteMethood,
+	wrapRouteHandler
+} = require('./routes.util');
+
+
+module.exports = {
+	onlyRoute: _onlyRoute,
+	onlyUse: _onlyUse
+}
+
+/*
+ * 
+ * @param {String} route
+ * @param {Function} fn
+ * @param {Function} markerFn
+ *
+ */
+function _onlyRoute(route, fn, markerFn) {
+	const parsedRoute = new Route(route);
+	// Will throw exception if not valid.
+	validateParsedRouteMethood(parsedRoute);
+
+	const wrapped = async (req, res, next) => {
+		const matched = await markerFn.call(this, req, res);
+		// Skip, if marker's condition was not matched:
+		if (!matched) {
+			return next();
+		}
+
+		// Wrap and call:
+		const routeHandler = wrapRouteHandler.call(this, parsedRoute, fn);
+		await routeHandler.call(this, req, res, next);
+
+		// If response was not sent,
+		// go to the next one:
+		if (res.headersSent === false) {
+			next();
+		}
+	};
+	return this.add.route(route, wrapped);
+}
+
+
+/*
+ * 
+ * @param {Function} fnOrRouter
+ * @param {Function} markerFn
+ *
+ */
+function _onlyUse(fnOrRouter, markerFn) {
+
+	const wrapped = async (req, res, next) => {
+		const matched = await markerFn.call(this, req, res);
+
+		// Skip, if marker's condition was not matched:
+		if (!matched) {
+			return next();
+		}
+
+		const isRouter = fnOrRouter.constructor.name === 'NodesterRouter';
+
+		const fn = isRouter ? fnOrRouter.handle.bind(fnOrRouter) : fnOrRouter;
+		await fn.call(this, req, res, next);
+
+		// If regular handler function:
+		if (!isRouter) {
+			// If response was not sent,
+			// go to the next one:
+			if (res.headersSent === false) {
+				next();
+			}
+		}
+	};
+	return this.use(wrapped);
+}

package/lib/router/route.js

@@ -40,17 +40,17 @@ module.exports = class NodesterRoute {
 			}
 
 			// Parse:
+			const collapsedSpaces = routeStringOrOpts.replace(/\s\s+/g, ' ');
 			const parts = routeStringOrOpts.split(' ');
-			const cleared = parts.filter(p => p.length > 0);
 
 			// Set method:
-			if (cleared[0].indexOf('/') === -1) {
-				const method = cleared.shift().toUpperCase();
+			if (parts[0].indexOf('/') === -1) {
+				const method = parts.shift().toUpperCase();
 				this.method = method;
 			}
 
 			// Build route one again and set it:
-			const clearRoute = cleared.join('');
+			const clearRoute = parts.join('');
 			this.route = clearRoute;
 
 			// Parse path parts: