nodester 0.0.1

package/lib/preprocessors/QueryPreprocessor.js

@@ -0,0 +1,64 @@
+// Constants:
+const VISITOR = 'visitor';
+const DefaultAvailableParamsForRoles = { [VISITOR]: [ 'skip', 'limit', 'order' ] };
+const DefaultStaticParamsForRoles = { [VISITOR]: { limit: 50 } };
+
+// Custom error.
+const { Err } = require('nodester/factories/errors');
+
+
+module.exports = class QueryPreprocessor {
+
+	constructor(
+		availableParamsForRoles,
+		staticParamsForRoles,
+		customProcessFunction
+	) {
+		this.availableParamsForRoles = availableParamsForRoles ?? DefaultAvailableParamsForRoles;
+		this.staticParamsForRoles = staticParamsForRoles ?? DefaultStaticParamsForRoles;
+
+		this.customProcessFunction = customProcessFunction ? customProcessFunction : ()=>{};
+	}
+
+	async extract(
+		req,
+		role
+	) {
+		try {
+			const requestQuery = req.query;
+
+			if (!requestQuery || typeof requestQuery !== 'object') {
+				const err = new Err();
+				err.name = 'ValidationError';
+				throw err;
+			}
+
+			// Get role or set "visitor"
+			const _role = typeof role === 'string' && role.length > 1 ? role : [VISITOR];
+
+			const resultQuery = {};
+
+			const params = this.availableParamsForRoles[_role] ?? [];
+			const staticValues = this.staticParamsForRoles[_role] ?? {};
+
+			params.forEach((param) => {
+				// If such param is set in query:
+				if (!!requestQuery[param]) {
+					resultQuery[param] = staticValues[param] ?? requestQuery[param];
+				}
+				// If such param is not set, but we have a "static" for it:
+				else if (!requestQuery[param] && !!staticValues[param]) {
+					resultQuery[param] = staticValues[param];
+				}
+			});
+
+			// Make further preprocessing using customly defined function.
+			await this.customProcessFunction.call(this, req, role, resultQuery);
+
+			return Promise.resolve(resultQuery);
+		}
+		catch(error) {
+			return Promise.reject(error);
+		}
+	}
+}

package/lib/routers/Default/index.js

@@ -0,0 +1,143 @@
+const Layer = require('./layer');
+
+// Utils:
+const { getType } = require('../../utils/types.util');
+
+
+module.exports = function NodesterDefaultRouter(app=null) {
+	this.markers = {};
+	this.layer = new Layer();
+
+	if (!!app) {
+		this.app = app
+	}
+
+	// Expose methods:
+	// 	Markers:
+	this.addMarker = _addMarker;
+	this.getMarker = _getMarker;
+
+	//	Routing:
+	this.handle = _handle;
+	this.only = _only;
+	this.route = _route;
+}
+
+/**
+ * Adds marker to the stack.
+ * Returns itself for chaining.
+ * @return {NodesterDefaultRouter}
+ *
+ * @alias addMarker
+ * @public
+ */
+function _addMarker(nameOrSymbol='', fn=()=>{}) {
+	if (typeof fn !== 'function') {
+		const err = new TypeError(`Router.addMarker() requires a middleware function but got a ${ getType(fn) }`);
+    throw err;
+  }
+
+  const marker = this.getMarker(nameOrSymbol);
+  if (marker.marker.index > -1) {
+  	const err = new TypeError(`Marker with key ${ nameOrSymbol } is already set.`);
+  	throw err;
+  }
+
+  this.markers[nameOrSymbol] = fn;
+
+  return this;
+}
+
+
+/**
+ * Tries to find marker's data by provided key.
+ * @return {Object}
+ *
+ * @alias getMarker
+ * @public
+ */
+function _getMarker(nameOrSymbol='') {
+	const result = {
+		marker: {
+			key: nameOrSymbol,
+			index: -1,
+		},
+		middleware: undefined		
+	}
+	try {
+		const keys = Object.keys(this.markers);
+
+		const index = keys.indexOf(nameOrSymbol);
+		if (keys.indexOf(nameOrSymbol) === -1) {
+			const err = new Error('NotFound');
+			throw err;
+		}
+
+		// Marker found:
+		result.marker.index = index;
+		result.middleware = this.markers[nameOrSymbol];
+	}
+	catch(error) {
+		result.marker.index = -1;
+	}
+
+	return result;
+}
+
+/**
+ * Start routes pipeline processing.
+ *
+ * If no callback is provided, then default error handlers will respond
+ * in the event of an error bubbling through the stack.
+ *
+ * @alias handle
+ * @public
+ */
+function _handle(req, res, callback) {
+	const method = req.method;
+	const requestPath = req.url;
+
+	console.log(method, requestPath);
+
+	let markerName = null;
+
+	// Check if this request satisfies any markers:
+	const markers = Object.entries(this.markers);
+	console.log({ markers });
+
+	for (const [marker, fn] of markers) {
+		const result = fn(req, res, callback);
+		console.log(result);
+
+		if (result === true) {
+			markerName = marker;
+			break;
+		}
+	}
+
+	console.log({ markerName });
+
+	return res.send(markerName ?? 'Hi!');
+}
+
+
+/**
+ *
+ * @alias only
+ * @public
+ */
+function _only(condition) {
+	this.layer.push('condition', condition);
+	// Return layer for chaining.
+	return this.layer;
+}
+
+
+/**
+ *
+ * @alias route
+ * @public
+ */
+function _route() {
+
+}

package/lib/routers/Default/layer.js

@@ -0,0 +1,50 @@
+
+module.exports = function NodesterDefaultRouterLayer() {
+	this.conditions = [];
+	this.routesList = {};
+
+	this.push = _push;
+	this.route = _route;
+}
+
+
+/**
+ *
+ * @alias push
+ * @public
+ */
+function _push(key='condition') {
+	let args = [...arguments].shift();
+
+	switch(key) {
+		case 'condition':
+			// this.conditions[]
+			break;
+		case 'route':
+			const route = args.shift();
+			this.routesList[route] = args;
+			break;
+		break;
+	}
+
+	return this;
+}
+
+
+/**
+ *
+ * @alias route
+ * @public
+ */
+function _route(path='/') {
+	const middlewares = [...arguments].shift();
+
+	console.log({ path });
+}
+
+
+/**
+ *
+ * @alias push
+ * @public
+ */

package/lib/routers/Main/index.js

@@ -0,0 +1,10 @@
+const express = require('express');
+
+
+class MainRouter extends express.Router {
+	constructor() {
+		super();
+	}
+}
+
+module.exports = MainRouter;

package/lib/routers/Roles/index.js

@@ -0,0 +1,81 @@
+const express = require('express');
+// Utils:
+const cwd = process.cwd();
+const Path = require('path');
+// Custom error.
+const { Err } = require('nodester/factories/errors');
+
+
+class RolesRouter extends express.Router {
+	constructor(
+		rolesToRoutesMap={},
+		pathToControllers=null
+	) {
+		super();
+
+		// rolesToRoutesMap is a map of role -> route -> controller:
+		if (!rolesToRoutesMap) {
+			const err = new Err('"rolesToRoutesMap" argument is required.');
+			throw err;
+		}
+
+		if (!pathToControllers) {
+			const err = new Err('"pathToControllers" argument is required.');
+			throw err;
+		}
+
+		// Extract all available roles.
+		const roles = Object.keys(rolesToRoutesMap);
+
+		// Flip map (Make it route -> role -> controller):
+		const routesToRolesMap = {};
+		for (const role of roles) {
+			const roleRoutes = rolesToRoutesMap[role]
+			
+			for (const route in roleRoutes) {
+				// If this route is set:
+				if (!!routesToRolesMap[route]) {
+					// Add role to set.
+					routesToRolesMap[route][role] = roleRoutes[route];
+				}
+				else {
+					// Create set for this role.
+					routesToRolesMap[route] = { [role]: roleRoutes[route] };
+				}
+			}
+		}
+
+		// At this point we have a map of route -> role -> controller.
+		// Let's now set these routes to this Router:
+		for (const route in routesToRolesMap) {
+			const rolesAndControllersMap = routesToRolesMap[route];
+
+			// Split route by space, as it has structure [<Rest method> <Route>]
+			const routeParts = route.split(/\s+/);
+			const routeMethod = routeParts[0].toLocaleLowerCase();
+			const routePath = routeParts[1].replace(/\s\s+/g, ' ');
+
+			// Set up this route:
+			this.route(routePath)[routeMethod]((req, res, next) => {
+				// Extract role:
+				const role = req?.user?.role ?? 'visitor';
+
+				// If no handler for this role-route, skip:
+				if (!rolesAndControllersMap[role]) {
+					return next();
+				}
+
+				const controllerAndMethod = rolesAndControllersMap[role].split('.');
+				const controllerName = controllerAndMethod[0];
+				const controllerMethod = controllerAndMethod[1];
+
+				// Get controller from path.
+				const controller = require(Path.join(cwd, pathToControllers, controllerName));
+
+				return controller[controllerMethod](req, res, next);
+			});
+		}
+	}
+}
+
+module.exports = RolesRouter;

package/lib/services/includes.service.js

@@ -0,0 +1,79 @@
+const {
+	splitByComma,
+	splitByDot
+} = require('nodester/utils/strings.util');
+// Query util.
+const {
+	hasSubIncludesQuery,
+	cutSubIncludesQuery,
+	parseSubIncludesQuery
+} = require('nodester/utils/queries.util');
+
+
+module.exports = {
+	parseIncludesQuery: _parseIncludesQuery
+}
+
+function _parseIncludesQuery(
+	modelDefinition,
+	includesQueryString
+) {
+	const associationAndSubs = splitByComma(includesQueryString);
+	const allowedAssociations = Object.keys(modelDefinition.associations);
+
+	associationAndSubs.forEach((a) => {
+		let association = a.split('.')[0];
+
+		if (hasSubIncludesQuery(association)) {
+			const [ nestedQuery, _association ] = cutSubIncludesQuery(association);
+			association = _association;
+		}
+
+		if (allowedAssociations.indexOf(association) === -1) {
+			const err = new Error(`Association with name "${ association }" doesn't exist on this model.`);
+			err.name = 'NotFound';
+			throw err;
+		}
+	});
+
+	const result = associationAndSubs.map(associationAndSubsString => _parseSubIncludes(associationAndSubsString));
+
+	return result;
+}
+
+function _parseSubIncludes(associationAndSubsString) {
+	const associationAndSubs = splitByDot(associationAndSubsString);
+
+	// If association has SubIncludes:
+	if (associationAndSubs?.length > 0) {
+		const clearAssociation = associationAndSubs[0];
+		const subs = associationAndSubs.splice(1, associationAndSubs.length - 1);
+
+		if (subs.length > 0) {
+			const result = {
+				association: clearAssociation,
+				include: [ _parseSubIncludes(subs.join('.')) ]
+			};
+
+			_parseSubIncludesQueryIfPresent(result);
+
+			return result;
+		}
+	}
+	
+	// By default just return association.
+	const result = { association: associationAndSubsString };
+	_parseSubIncludesQueryIfPresent(result);
+	return result;
+}
+
+function _parseSubIncludesQueryIfPresent(resultQuery) {
+	if (hasSubIncludesQuery(resultQuery.association)) {
+		const [ nestedQuery, clearAssociation ] = cutSubIncludesQuery(resultQuery.association);
+
+		resultQuery.association = clearAssociation;
+		parseSubIncludesQuery(clearAssociation, nestedQuery, resultQuery);
+	}
+
+	return resultQuery;
+}

package/lib/services/jwt.service.js

@@ -0,0 +1,147 @@
+// Format of token: "Authorization: Bearer [token]".
+const ACCESS_TOKEN_NAME = 'Authorization';
+const REFRESH_TOKEN_NAME = 'x-refresh-token';
+// JWT module.
+const jwt = require('jsonwebtoken');
+// Utils.
+const { addSeconds } = require('nodester/utils/dates.util');
+
+
+module.exports = class JWTService {
+	constructor(
+		accessTokenConfigs,
+		refreshTokenConfigs
+	) {
+		if (!accessTokenConfigs || !refreshTokenConfigs){
+			throw new Error('"accessTokenConfigs" and "refreshTokenConfigs" are required arguments.');
+		}
+
+		this.accessTokenConfigs = { ...accessTokenConfigs };
+		this.refreshTokenConfigs = { ...refreshTokenConfigs };
+	}
+
+	extractTokenFromRequest(request) {
+		let token;
+
+		if (request.header(ACCESS_TOKEN_NAME)) {
+			token = this._parseAccessToken(
+								request.header(ACCESS_TOKEN_NAME)
+							);
+		}
+		else if (request.cookies[ACCESS_TOKEN_NAME]) {
+			token = this._parseAccessToken(
+								request.cookies[ACCESS_TOKEN_NAME]
+							);
+		}
+		// Check token in query:
+		else if (!!request.query.token) {
+			token = request.query.token;
+			delete request.body.token;
+		}
+		// Check token in body:
+		else if (!!request.body.token) {
+			token = request.body.token;
+			delete request.query.token;
+		} 
+		else {
+			const err = new Error(`No ${ACCESS_TOKEN_NAME} was found`);
+			err.name = 'NoToken';
+			err.details = { message:err.message };
+			throw err;
+		}
+
+		return token;
+	}
+
+	extractRefreshTokenFromRequest(request) {
+		let token;
+
+		if (request.header(REFRESH_TOKEN_NAME)) {
+			token = request.header(REFRESH_TOKEN_NAME);
+		}
+		else if (request.cookies[REFRESH_TOKEN_NAME]) {
+			token = request.cookies[REFRESH_TOKEN_NAME];
+		}
+		// Check token in query:
+		else if (!!request.query.token) {
+			token = request.query.token;
+			delete request.body.token;
+		}
+		// Check token in body:
+		else if (!!request.body.token) {
+			token = request.body.token;
+			delete request.query.token;
+		} 
+		else {
+			const err = new Error(`No ${REFRESH_TOKEN_NAME} was found`);
+			err.name = 'NoToken';
+			err.details = { message:err.message };
+			throw err;
+		}
+
+		return token;
+	}
+
+	issueAccessToken(payload) {
+		const { secret, expiresIn } = this.accessTokenConfigs;
+		return this._issueToken({ payload, secret, expiresIn });
+	}
+
+	issueRefreshToken(payload) {
+		const { secret, expiresIn } = this.refreshTokenConfigs;
+		return this._issueToken({ payload, secret, expiresIn });
+	}
+
+	verifyAccessToken(token) {
+		const { secret } = this.accessTokenConfigs;
+		return this._verifyToken({ token, secret });
+	}
+
+	verifyRefreshToken(token) {
+		const { secret } = this.refreshTokenConfigs;
+		return this._verifyToken({ token, secret });
+	}
+
+	async _issueToken({ payload, secret, expiresIn }) {
+		try {
+			const token = jwt.sign(payload, secret, { expiresIn });
+			const expirationDateValue = (addSeconds(new Date(), expiresIn/1000)).valueOf();
+
+			const fullToken = { token, expiresIn, expirationDateValue };
+			return Promise.resolve(fullToken);
+		}
+		catch(error) {
+			return Promise.reject(error);
+		}
+	}
+
+	async _verifyToken({ token, secret }) {
+		try {
+			const parsedToken = await jwt.verify(token, secret, {});
+			return Promise.resolve(parsedToken);
+		}
+		catch(error) {
+			const err = new Error('Invalid signature.');
+			err.name = 'ValidationError';
+			return Promise.reject(err);
+		}
+	}
+
+	_parseAccessToken(token) {
+		let parsed = '';
+
+		const parts = token.split(' ');
+
+		if (parts.length === 2 && /^Bearer$/.test(parts[0])) {
+			parsed = parts[1];
+		} 
+		else {
+			const err = new Error(`Format for ${ACCESS_TOKEN_NAME}: Bearer [token]`);
+			err.name = 'InvalidFormat';
+			err.details = { message: err.message };
+			throw err;
+		}
+
+		return parsed;
+	}
+}

package/lib/tools/sql.tool.js

@@ -0,0 +1,82 @@
+const { QueryTypes } = require('sequelize');
+// Utils:
+const fs = require('fs');
+const { promisify } = require('util');
+const readFile = promisify(fs.readFile);
+
+
+module.exports = {
+	parseSQLFileContents: _parseSQLFileContents,
+
+	rawSelect: _rawSelect,
+	rawUpdate: _rawUpdate,
+	rawInsert: _rawInsert
+}
+
+async function _parseSQLFileContents(filePath) {
+	try {
+		const fileContent = await readFile(filePath, 'utf8');
+		const sqlCommands = fileContent.toString()
+																	 .split('\n')
+																	 .filter(command => command !== '');
+
+		const output = { commands: sqlCommands };
+		return Promise.resolve(output);
+	}
+	catch(error) {
+		return Promise.reject(error);
+	}
+}
+
+function _rawSelect(db, tableName) {
+	const query = `select * from ${ tableName }`;
+	return db.query(query, { type: QueryTypes.SELECT });
+}
+
+function _rawUpdate(db, tableName, where, data) {
+	const dataKeys = Object.keys(data);
+
+	let sqlAttributes = '';
+
+	for (let i=0; i < dataKeys.length; i++) {
+		const key = dataKeys[i];
+		const val = data[key];
+
+		sqlAttributes += `${ key }='${ val }'`;
+
+		if (i < dataKeys.length-1) {
+			sqlAttributes += ', ';
+		}
+	}
+
+	const sql = `UPDATE \`${ tableName }\` SET ${ sqlAttributes } where ${ where };`;
+
+	return db.query(sql, {
+		type: QueryTypes.INSERT
+	});
+}
+
+function _rawInsert(db, tableName, data) {
+	const dataKeys = Object.keys(data);
+	const dataValues = Object.values(data);
+	
+	let values = '';
+	for (let i=0; i < dataValues.length-1; i++) {
+		const val = dataValues[i];
+
+		if (val === undefined || val === null)
+			values += 'null, ';
+		else if (typeof val === 'object')
+			values += `'${ JSON.stringify(val) }', `;
+			// values += `'{}', `;
+		else
+			values += `'${val}', `;
+	}
+	values += `'${ dataValues[dataValues.length-1] }'`;
+
+	const sql = `INSERT INTO \`${ tableName }\` (${ dataKeys.join(', ') }) VALUES (${ values });`;
+
+	return db.query(sql, {
+		type: QueryTypes.INSERT
+	});
+}

package/lib/utils/dates.util.js

@@ -0,0 +1,23 @@
+
+module.exports = {
+	addSeconds: _addSeconds,
+	addDays: _addDays
+}
+
+function _addSeconds(
+	date=null,
+	seconds=0
+) {
+	const newDate = new Date(date.valueOf());
+	newDate.setSeconds(newDate.getSeconds() + seconds);
+	return newDate;
+}
+
+function _addDays(
+	date=null,
+	days=0
+) {
+	const newDate = new Date(date.valueOf());
+	newDate.setDate(newDate.getDate() + days);
+	return newDate;
+}

package/lib/utils/forms.util.js

@@ -0,0 +1,22 @@
+// Utils.
+const formidable = require('formidable');
+
+
+module.exports = {
+	parseRequestForm: _parseRequestForm,
+}
+
+function _parseRequestForm(req) {
+	return new Promise(function (resolve, reject) {
+		const form = new formidable.IncomingForm();
+
+		form.parse(req, function (err, fields, files) {
+			if (err) {
+					return reject(err);
+			}
+
+			const result = { fields, files };
+			return resolve(result);
+		});
+	});
+}