nodester 0.0.1

package/lib/utils/json.util.js

@@ -0,0 +1,49 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+'use strict';
+
+
+exports = module.exports = {
+  stringify: _stringify
+}
+
+/**
+ * Stringify JSON, like JSON.stringify, but v8 optimized, with the
+ * ability to escape characters that can trigger HTML sniffing.
+ *
+ * @param {*} value
+ * @param {function} replacer
+ * @param {number} spaces
+ * @param {boolean} escape
+ * @returns {string}
+ *
+ * @alias stringify
+ * @private
+ */
+function _stringify (value, replacer, spaces, escape) {
+  // v8 checks arguments.length for optimizing simple call
+  // https://bugs.chromium.org/p/v8/issues/detail?id=4730
+  var json = replacer || spaces
+    ? JSON.stringify(value, replacer, spaces)
+    : JSON.stringify(value);
+
+  if (escape && typeof json === 'string') {
+    json = json.replace(/[<>&]/g, function (c) {
+      switch (c.charCodeAt(0)) {
+        case 0x3c:
+          return '\\u003c'
+        case 0x3e:
+          return '\\u003e'
+        case 0x26:
+          return '\\u0026'
+        /* istanbul ignore next: unreachable default */
+        default:
+          return c
+      }
+    })
+  }
+
+  return json
+}

package/lib/utils/mappers/Routes/index.js

@@ -0,0 +1,100 @@
+const express = require('express');
+const path = require('path');
+
+const cwd = process.cwd();
+
+// Utils:
+const { isString } = require('util');
+const {
+	isConstructor,
+	splitByLastDot
+} = require('./utils');
+
+
+module.exports = function RoutesMapper(
+	routes,
+	pathToController,
+	middlewareGenerals = []
+) {
+	const router = express.Router();
+
+	let requestMethodPath;
+	let requestMethod;
+	
+	let controllerMethod;
+	let controller;
+	let contr;
+
+	let handler;
+
+	let myPath;
+	const myPathToController = path.join(cwd, pathToController);
+
+	Object.entries(routes).forEach((value) => {
+		let middlewares;
+		// To let use an array or only one function as general middlewares:
+		if (Array.isArray(middlewareGenerals)) {
+			middlewares = [ ...middlewareGenerals ];
+		}
+		else if (typeof middlewareGenerals === 'function') {
+			middlewares = [ middlewareGenerals ];
+		}
+		else {
+			middlewares = [];
+		}
+		requestMethodPath = value[0].replace(/\s\s+/g, ' ');
+		requestMethod = requestMethodPath.split(' ')[0].toLocaleLowerCase();
+		myPath = requestMethodPath.split(' ')[1];
+
+		if (isString(value[1])) {
+			controller = splitByLastDot(value[1])[0];
+			controllerMethod = splitByLastDot(value[1])[1];
+		}
+		else {
+			// Contains middlewares and other configuration.
+			const props = value[1];
+
+			// Extract controller paths:
+			if (props.path !== undefined) {
+				controller = splitByLastDot(props.path)[0];
+				controllerMethod = splitByLastDot(props.path)[1];
+			}
+
+			// Extract middlewares:
+			if (
+				props.middlewares !== undefined &&
+				Array.isArray(props.middlewares)
+			) {
+				middlewares.push(...props.middlewares);
+			}
+		}
+		middlewares = middlewares.filter(el => el != null);
+
+		try {
+			handler = require(`${ myPathToController }${ controller }`);
+			const isConstructable = isConstructor(handler);
+			const type = typeof handler;
+
+			if (isConstructable) {
+				contr = new handler();
+			}
+			else if (type === 'function') {
+				contr = handler();
+			}
+			else if (type === 'object') {
+				contr = handler;
+			}
+		}
+		catch (err) {
+			console.error('Routes mapper error:', err);
+			
+			require('@babel/register');
+			handler = require(`${ myPathToController }${ controller }`).default;
+			contr = new handler();
+		}
+
+		router.route(myPath)[requestMethod](middlewares, contr[controllerMethod].bind(contr));
+	});
+
+	return router;
+};

package/lib/utils/mappers/Routes/utils.js

@@ -0,0 +1,20 @@
+
+module.exports = {
+	isConstructor: _isConstructor,
+	splitByLastDot: _splitByLastDot,
+}
+
+function _isConstructor(functionOrClass) {
+	try {
+		new functionOrClass();
+	} catch (err) {
+		return false;
+	}
+
+	return true;
+};
+
+function _splitByLastDot(str) {
+	const index = str.lastIndexOf('.');
+	return [str.slice(0, index), str.slice(index + 1)];
+};

package/lib/utils/modelAssociations.util.js

@@ -0,0 +1,44 @@
+
+module.exports = {
+	modelHasAssociations: _modelHasAssociations,
+	getModelAssociationProps: _getModelAssociationProps,
+	compileModelAssociationData: _compileModelAssociationData,
+};
+
+function _modelHasAssociations(modelDifinition) {
+	return Object.keys(modelDifinition.associations)?.length > 0;
+}
+
+function _getModelAssociationProps(
+	associationDefinition,
+	requestData
+) {
+	// Extract neccessary variables and functions:
+	const associatedModel = associationDefinition.target;
+	const { foreignKey } = associationDefinition.options;
+	const {
+		associationType,
+		accessors,
+	} = associationDefinition;
+
+	return {
+		associatedModel,
+		foreignKey,
+		associationType,
+		accessors,
+	};
+}
+
+function _compileModelAssociationData({
+	dataOfAssociation,
+	parentForeignKey,
+	parentModelId,
+}) {
+	const result = {
+		...dataOfAssociation,
+		[parentForeignKey]: parentModelId,
+		deletedAt: null
+	};
+
+	return result;
+}

package/lib/utils/objects.util.js

@@ -0,0 +1,69 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+'use strict';
+
+
+module.exports = {
+	copyWithCertainAttributes: _copyWithCertainAttributes,
+	merge: _merge
+}
+
+/**
+ * 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
+ *
+ * @alias copyWithCertainAttributes
+ * @public
+ */
+function _copyWithCertainAttributes(targetObj={}, attributes=[]) {
+	const result = {};
+
+	attributes.forEach(a => result[a] = targetObj[a]);
+
+	return result;
+}
+
+/**
+ * Merge the property descriptors of `src` into `dest`
+ *
+ * @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
+ *
+ * @alias merge
+ * @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')
+	}
+
+	if (redefine === true) {
+		dest = Object.assign(dest, src);
+	}
+	else {
+		Object.getOwnPropertyNames(src)
+				.forEach(function forEachOwnPropertyName(name) {
+			if (!redefine && hasOwnProperty.call(dest, name)) {
+				// Skip descriptor.
+				return;
+			}
+
+			// Copy descriptor:
+			const descriptor = Object.getOwnPropertyDescriptor(src, name)
+			Object.defineProperty(dest, name, descriptor)
+		});
+	}
+
+	return dest;
+}

package/lib/utils/params.util.js

@@ -0,0 +1,19 @@
+
+module.exports = Params;
+
+function Params(
+	sourceObject={},
+	defaultValuesList={}
+) {
+	const result = {};
+
+	const keys = Object.keys(defaultValuesList);
+	for (const key of keys) {
+		result[key] = typeof sourceObject[key] !== 'boolean' && !sourceObject[key] ?
+										defaultValuesList[key]
+										:
+										sourceObject[key];
+	}
+
+	return result;
+}

package/lib/utils/path.util.js

@@ -0,0 +1,26 @@
+
+exports = module.exports = {
+	isAbsolute: _isAbsolute
+}
+
+/**
+ * Check if `path` looks absolute.
+ *
+ * @param {String} path
+ * @return {Boolean}
+ * @api private
+ * @alias isAbsolute
+ */
+function _isAbsolute(path) {
+	// Unix:
+	if ('/' === path[0])
+		return true;
+
+	// Windows:
+	if (':' === path[1] && ('\\' === path[2] || '/' === path[2]))
+		return true;
+
+	// Microsoft Azure:
+	if ('\\\\' === path.substring(0, 2))
+		return true;
+};

package/lib/utils/queries.util.js

@@ -0,0 +1,240 @@
+// Constants.
+const SubIncludesQueryRegex = /\([^)]*\)/g;
+
+// Sequelize.
+const Op = require('sequelize').Op;
+
+// Utils.
+const {
+	splitByDot,
+	splitByAmpersand
+} = require('nodester/utils/strings.util');
+
+
+module.exports = {
+	parseQueryParams: _parseQueryParams,
+	deleteQuerySortParams: _deleteQuerySortParams,
+
+	// SubIncludes Query:
+	hasSubIncludesQuery: _hasSubIncludesQuery,
+	cutSubIncludesQuery: _cutSubIncludesQuery,
+	parseSubIncludesQuery: _parseSubIncludesQuery
+}
+
+function _parseQueryParams(
+	requestQueryObject={},
+	sequilizeQuery=null
+) {
+	const skip = parseInt(requestQueryObject?.skip ?? 0);
+	const limit = parseInt(requestQueryObject?.limit ?? 50);
+
+	sequilizeQuery.offset = skip;
+	sequilizeQuery.limit = limit;
+
+	const order = requestQueryObject?.order;
+
+	// If order is set:
+	if (!!order) {
+		const orderBy = requestQueryObject?.order_by ?? 'id';
+
+		sequilizeQuery.order = [
+			[ orderBy, order ]
+		];
+	}
+
+	// Clear sort params.
+	_deleteQuerySortParams(requestQueryObject);
+
+	// Get include names.
+	const _includes = sequilizeQuery?.include?.map( include => include.association ) ?? [];
+
+	// Count query keys.
+	const keysCount = Object.keys(requestQueryObject).length;
+
+	// If query has no keys,
+	// stop further execution:
+	if (keysCount === 0) {
+		return;
+	}
+
+	// This container is a reference to current "where".
+	let container = null;
+	let isContainerArray = false;
+
+	// If query has only 1 key:
+	if (keysCount === 1) {
+		// Define empty query's where.
+		sequilizeQuery.where = {};
+		container = sequilizeQuery.where;
+	}
+	else {
+		// Define conjuction of params in query's where.
+		sequilizeQuery.where = {
+			[Op.and]: []
+		};
+		container = sequilizeQuery.where[Op.and];
+		isContainerArray = true;
+	}
+
+	// Go through query's keys:
+	Object.keys(requestQueryObject)
+				.forEach((queryKey) => {
+
+		// Parse value of this key:
+		const value = requestQueryObject[queryKey];
+		// If value is not a number, parse it further.
+		const parsedValue = isNaN( value ) ? _parseHTTPQueryValue( `${ requestQueryObject[queryKey] }` ) : value;
+		
+		// If we got nested key:
+		if (queryKey.indexOf('.') !== -1) {
+
+			// If this key is included as association:
+			const associationIndex = _includes.indexOf(queryKey.split('.')[0]);
+			if (associationIndex > -1) {
+				sequilizeQuery.include[associationIndex].where = { [`$${queryKey}$`]: parsedValue };
+			}
+			// Use special sequelize syntax for nested SELECT:
+			else if (isContainerArray) {
+				const selectObject = { [`$${queryKey}$`]: parsedValue };
+				container.push(selectObject);
+			}
+			else {
+				container[`$${queryKey}$`] = parsedValue;
+			}
+		}
+		// On regular key, set regular key-value pair:
+		else {
+			if (isContainerArray) {
+				const selectObject = { [queryKey]: parsedValue };
+				container.push(selectObject);
+			}
+			else {
+				container[queryKey] = parsedValue;
+			}
+		}
+	});
+}
+
+function _parseHTTPQueryValue(
+	value='',
+	isNumber=false
+) {
+	// If value matches "and()":
+	if (value.slice(0, 4) === 'and(') {
+		// Remove "and()".
+		const clearValuesString = value.substr(4, value.length - 'and()'.length);
+
+		const clearValues = clearValuesString.split(',');
+
+		return {
+			[Op.and]: clearValues.map(cv => _parseHTTPQueryValue(cv))
+		}
+	}
+	// If value matches "like(value)":
+	else if (value.slice(0, 5) === 'like(') {
+		// Remove "like()".
+		const clearValue = value.substr(5, value.length - 'like()'.length);
+
+		return {
+			[Op.like]: `%${ _parseHTTPQueryValue(clearValue) }%`
+		}
+	}
+	// If value matches "notLike(value)":
+	else if (value.slice(0, 8) === 'notLike(') {
+		// Remove "notLike()".
+		const clearValue = value.substr(8, value.length - 'notLike()'.length);
+
+		return {
+			[Op.notLike]: `%${ _parseHTTPQueryValue(clearValue) }%`
+		}
+	}
+	// If value matches "not(value)":
+	else if (value.slice(0, 4) === 'not(') {
+		// Remove "not()".
+		const clearValue = value.substr(4, value.length - 'not()'.length);
+
+		return {
+			[Op.not]: _parseHTTPQueryValue(clearValue)
+		};
+	}
+	// If value matches "or()":
+	else if (value.slice(0, 3) === 'or(') {
+		// Remove "or()".
+		const clearValuesString = value.substr(3, value.length - 'or()'.length);
+
+		const clearValues = clearValuesString.split(',');
+
+		return {
+			[Op.or]: clearValues.map(cv => _parseHTTPQueryValue(cv))
+		}
+	}
+	// If value is a number:
+	// else if (!isNaN(value)) {
+	// 	const number = parseFloat(value);
+	// 	return number;
+	// }
+	// For default, just set this value in "where"
+	return value;
+}
+
+function _deleteQuerySortParams(requestQueryObject={}) {
+	delete requestQueryObject.skip;
+	delete requestQueryObject.limit;
+	delete requestQueryObject.order;
+	delete requestQueryObject.order_by;
+}
+
+// If string has nested query "()":
+function _hasSubIncludesQuery(string='') {
+	return SubIncludesQueryRegex.test(string);
+}
+
+function _cutSubIncludesQuery(string='') {
+	const query = string.match(SubIncludesQueryRegex)[0];
+	const newString = string.replace(SubIncludesQueryRegex, '');
+
+	return [ query, newString ];
+}
+
+function _parseSubIncludesQuery(
+	associationName,
+	subIncludesQuery='',
+	sequilizeQuery=null
+) {
+	const query = {};
+
+	// Magic trick to make everything work (DO NOT REMOVE).
+	sequilizeQuery.separate = true;
+
+	// If first "("" & ")" are set, cut them:
+	const subIncludesQueryRegex = /\([^)]*\)/g;
+	const clearQuery = subIncludesQueryRegex.test(subIncludesQuery) ?
+												subIncludesQuery.substr(1, subIncludesQuery.length - 2)
+												:
+												subIncludesQuery;
+
+	const keyValues = splitByAmpersand(clearQuery).map(kv => {
+											const keyValue = kv.split('=');
+											query[keyValue[0]] = keyValue[1];
+										});
+
+
+	if (!!query.skip) {
+		const skip = parseInt(query.skip ?? 0);
+		sequilizeQuery[`$${ associationName }.offset$`] = skip;
+	}
+
+	if (!!query.limit) {
+		const limit = parseInt(query.limit ?? 50);
+		sequilizeQuery[`$${ associationName }.limit$`] = limit;
+	}
+
+	// If order is set:
+	if (!!query.order) {
+		const orderBy = query?.order_by ?? 'id';
+
+		sequilizeQuery.order = [
+			[ orderBy, query.order ]
+		];
+	}
+}

package/lib/utils/sanitizations.util.js

@@ -0,0 +1,111 @@
+
+module.exports = {
+	NUMBER: _NUMBER,
+	INT: _INT,
+	BOOLEAN: _BOOLEAN,
+	STRING: _STRING,
+
+	DATE: _DATE,
+
+	JSON: _JSON
+}
+
+function _isNumber(value) {
+	return !isNaN(`${value}`);
+}
+
+function _NUMBER(value=undefined, options={ fallback:undefined, min:undefined, max:undefined }) {
+	try {
+		if (!_isNumber(value))
+			throw new Error(`Not a number`);
+
+		if (_isNumber(options?.min) && value < options?.min)
+			return options?.min;
+
+		if (_isNumber(options?.max) && value > options?.max)
+			return options?.max;
+
+		return value;
+	}
+	catch(ex) {
+		return options?.fallback;
+	}
+}
+
+function _INT(value=undefined, options={ fallback:undefined, min:undefined, max:undefined }) {
+	const num = _NUMBER(value, { fallback:undefined, min:options?.min, max:options?.max });
+	return num === undefined ? options?.fallback : parseInt(num);
+}
+
+function _BOOLEAN(value=undefined, options={ fallback:undefined }) {
+	try {
+		// If clear boolean.
+		if (value === true || value === false || toString.call(value) === '[object Boolean]')
+			return value;
+
+		// If string-boolean.
+		if (typeof value === "string")
+			return value === "true";
+
+		throw new Error(`Not a Boolean`);
+	}
+	catch(ex) {
+		return options?.fallback;
+	}
+}
+
+function _STRING(value=undefined, options={ fallback:undefined }) {
+	try {
+		if (typeof value !== "string")
+			throw new Error(`Not a String`);
+			
+		return value;
+	}
+	catch(ex) {
+		return options?.fallback;
+	}
+}
+
+function _DATE(value=undefined, options={ fallback:undefined }) {
+	try {
+		const type = Object.prototype.toString.call(value);
+
+		switch(type) {
+			case('[object Date]'): {
+				if (isNaN(value.valueOf())){
+					throw new Error('Not a date');				
+				}
+				return value;
+			}
+			case('[object String]'): {
+				const check = new Date(value);
+				if (check instanceof Date)
+					return value;
+
+				break;
+			}
+			default:
+				break;
+		}
+
+		throw new Error('Not a date');
+	}
+	catch(ex) {
+		return options?.fallback;
+	}
+}
+
+function _JSON(value=undefined, options={ fallback:undefined }) {
+	try {
+		if (typeof value === "string")
+			return JSON.parse(value);
+
+		if (typeof value !== 'object')
+			throw new Error(`Not an object`);
+		
+		return value;
+	}
+	catch(ex) {
+		return options?.fallback;
+	}
+}