nodester 0.0.1 → 0.0.2

package/lib/models/mixins.js

@@ -6,35 +6,50 @@ const {
 	modelHasAssociations,
 	getModelAssociationProps,
 	compileModelAssociationData,
-} = require('nodester/utils/modelAssociations.util');
+} = require('../utils/modelAssociations.util');
+
+// Nodester query:
+const NQLexer = require('../middlewares/ql/sequelize/interpreter/QueryLexer');
+const traverseNQuery = require('../queries/traverse');
 
 
 module.exports = {
 	implementsCRUD: _implementsCRUD
 }
 
-function _implementsCRUD(modelDefinition) {
-	if (!!modelDefinition) {
 
-		// Create.
-		modelDefinition.createWithIncludes = _createWithIncludes.bind(modelDefinition);
+/**
+ * Sets all of CRUD methods to Model.
+ *
+ * @param {Object} modelDefinition
+ *
+ *
+ * @api public
+ * @alias implementsCRUD
+ */
+function _implementsCRUD(modelDefinition) {
+	if (!modelDefinition) {
+		const err = new TypeError(`"modelDefinition" argument is not provided.`);
+		throw err;
+	}
 
-		// Read:
-		modelDefinition.findById = _findById.bind(modelDefinition);
-		modelDefinition.findOneWithIncludes = _findOneWithIncludes.bind(modelDefinition);
+	// Create.
+	modelDefinition.createWithIncludes = _createWithIncludes.bind(modelDefinition);
 
-		// Update:
-		modelDefinition.updateOne = _updateOne.bind(modelDefinition);
-		modelDefinition.updateById = _updateById.bind(modelDefinition);
+	// Read:
+	modelDefinition.findById = _findById.bind(modelDefinition);
+	modelDefinition.findMany = _findMany.bind(modelDefinition);
 
-		// Delete.
-		modelDefinition.deleteById = _deleteById.bind(modelDefinition);
+	// Update:
+	modelDefinition.updateOne = _updateOne.bind(modelDefinition);
+	modelDefinition.updateById = _updateById.bind(modelDefinition);
 
-		// Associations:
-		modelDefinition.getIncludesList = _getIncludesList.bind(modelDefinition);
-	}
+	// Delete:
+	modelDefinition.deleteOne = _deleteOne.bind(modelDefinition);
+	modelDefinition.deleteById = _deleteById.bind(modelDefinition);
 }
 
+
 /* Main mixinis: */
 async function _createWithIncludes(
 	data={}
@@ -101,37 +116,76 @@ async function _createWithIncludes(
 
 function _findById(
 	id=null,
-	include=[],
-	paranoid=true
+	opts={}
 ) {
-	const query = {
-		where: { id },
-		include: include,
-		paranoid: !!paranoid
-	};
-	return this.findOne(query);
+	const { query } = opts;
+
+	let _query = {};
+
+	if (typeof query === 'string') {
+		const lexer = new NQLexer(query);
+		const nquery = lexer.query;
+		_query = traverseNQuery(nquery, null, this);
+		_query.where = {
+			..._query.where,
+			id: id
+		}
+	}
+	else {
+		const {
+			include,
+			paranoid
+		} = opts;
+
+		_query = {
+			where: { id },
+			include: include,
+			paranoid: !!paranoid
+		};
+	}
+
+	return this.findOne(_query);
 }
 
-function _findOneWithIncludes(
-	where={},
-	include=[],
-	paranoid=true
-) {
-	const query = {
-		where: where,
-		include: include,
-		paranoid: !!paranoid
-	};
-	return this.findOne(query);
+function _findMany(opts={}) {
+	const { query } = opts;
+
+	let _query = {};
+
+	if (typeof query === 'string') {
+		const lexer = new NQLexer(query);
+		const nquery = lexer.query;
+		_query = traverseNQuery(nquery, null, this);
+		_query.where = {
+			..._query.where,
+			id: id
+		}
+	}
+	else {
+		const {
+			include,
+			paranoid
+		} = opts;
+
+		_query = {
+			where: { id },
+			include: include,
+			paranoid: !!paranoid
+		};
+	}
+
+
+	return this.findAll(_query);
 }
 
+
 async function _updateOne(
 	where,
 	data,
 	include=[]
 ) {
 	try {
-		const instance = await this.findOneWithIncludes(where, include);
+		const instance = await this.findOne({ where, include });
 
 		if (!instance) {
 			const err = new Error(`Model not found`);
@@ -188,7 +242,7 @@ async function _updateOne(
 		
 		// Select this instance again, if includes was set:
 		if (include?.length > 0) {
-			const updatedInstance = await this.findOneWithIncludes(where, include);
+			const updatedInstance = await this.findOne({ where, include });
 			fullInstanceData = updatedInstance.toJSON();
 		}
 
@@ -212,6 +266,15 @@ async function _updateById(
 	);
 }
 
+
+function _deleteOne(query={}) {
+	const _query = {
+		...query,
+		limit: 1
+	}
+	return this.destroy(_query);
+}
+
 function _deleteById(
 	id=null
 ) {
@@ -222,47 +285,6 @@ function _deleteById(
 }
 /* Main mixinis\ */
 
-/* Association mixins: */
-function _getIncludesList(facadeData=null) {
-	// console.log({ facadeData, model: this });
-
-	const result = [];
-
-	const associations = this.associations;
-	const associationEntries = Object.entries(associations);
-
-	associationEntries.forEach(([
-		associationName,
-		associationDefinition
-	]) => {
-		const a = { association: associationName };
-
-		if (!!facadeData) {
-			// If facade data is set, go deeper:
-			const keys = Object.keys( facadeData );
-			if (keys.indexOf(associationName) > 0) {
-				const associationModel = associationDefinition.target;
-
-				const a = { association: associationName };
-				if (Object.entries(associationModel.associations).length > 0) {
-					const deepData = facadeData[ associationName ];
-					a.include = associationModel.getIncludesList(Array.isArray(deepData) ? deepData[0] : deepData);
-				}
-
-				result.push( a );
-			}
-		}
-		else {
-			result.push( a );
-		}
-	});
-
-	// console.log('getIncludesList', result);
-
-	return result;
-}
-/* Association mixins\ */
-
 /* Subfunctions: */
 async function _updateOrCreateOrDelete(
 	modelDefinition,

package/lib/params/Params.js

@@ -0,0 +1,37 @@
+
+module.exports = Params;
+
+/**
+ * Extracts only values in second argument
+ * from first argument.
+ * If such values is missing in first atgument,
+ * will fallback to the value in second argument.
+ *
+ * @param {Object} sourceObj
+ * @param {Object} defaultValuesList
+ *
+ * @return {Object} result
+ *
+ * @api public
+ */
+function Params(
+	sourceObj={},
+	defaultValuesList={}
+) {
+	const result = {};
+
+	const keys = Object.keys(defaultValuesList);
+	for (const key of keys) {
+
+		// If value is not set,
+		// use default one from 'defaultValuesList':
+		if (sourceObj[key] === undefined) {
+			result[key] = defaultValuesList[key];
+			continue;
+		}
+
+		result[key] = sourceObj[key];
+	}
+
+	return result;
+}

package/lib/queries/Colander.js

@@ -0,0 +1,84 @@
+const CLAUSES = ['limit', 'skip', 'order', 'order_by'];
+
+
+module.exports = class Colander {
+
+	/*
+	 *
+	 * @param {Object|Model} optsOrModelDefinition
+	 * - @param {Array} fields
+	 * - @param {Array} clauses
+	 * - @param {Object} includes
+	 * - @param {Object} statics
+	 * -- @param {Object} attributes
+	 * -- @param {Object} clauses
+	 *
+	 */
+	constructor(optsOrModelDefinition) {
+		this._fields = [];
+		this._clauses = [];
+		this._includes = {};
+		
+		this._statics = {
+			attributes: {},
+			clauses: {
+				limit: 3
+			}
+		}
+
+		// If model:
+		if (!!optsOrModelDefinition.tableName && typeof optsOrModelDefinition._schema === 'object') {
+			this._fields = Object.keys(optsOrModelDefinition.tableAttributes);
+			this._clauses = CLAUSES;
+		}
+		// If options:
+		else {
+			const {
+				fields,
+				clauses,
+				includes,
+				statics,
+			} = optsOrModelDefinition;
+
+			if (Array.isArray(fields)) {
+				this._fields = fields;
+			}
+
+			if (Array.isArray(clauses)) {
+				this._clauses = clauses;
+			}
+
+			if (typeof includes === 'object') {
+				this._includes = includes;
+			}
+
+			if (typeof statics === 'object') {
+				if (typeof statics.attributes === 'object') {
+					this._statics.attributes = statics.attributes;
+				}
+
+				if (typeof statics.clauses === 'object') {
+					this._statics.clauses = statics.clauses;
+				}
+			}
+		}
+	}
+
+	// Getters:
+	get fields() {
+		return this._fields;
+	}
+
+	get clauses() {
+		return this._clauses;
+	}
+
+	get includes() {
+		return this._includes;
+	}
+
+	get statics() {
+		return this._statics;
+	}
+	// Getters\
+}

package/lib/queries/NodesterQueryParams.js

@@ -0,0 +1,139 @@
+// Dictionary of unsafe characters:
+const NOT_ALLOWED = [
+	'{',
+	'}',
+	// `\`,
+	'^',
+	'~',
+	'[',
+	']',
+	'`'
+];
+
+const util = require('util');
+
+/*
+ * NodesterQueryParams is a ready-to-use replacement for URLSearchParams.
+ * The only difference is that NodesterQueryParams
+ * respects nested "&" during parsing.
+ */
+module.exports = class NodesterQueryParams {
+	constructor(queryString='') {
+		// Type validateion:
+		if (typeof queryString !== 'string') {
+			const err = new TypeError(`'query' must be a String.`);
+			throw err;
+		}
+
+		// You never know if it's encoded or not.
+		const decoded = decodeURI(queryString);
+
+		// Indicates, how deep the char is inside different ().
+		let deep = 0;
+
+		const paramLevels = {};
+
+		// Current query parameter.
+		let param = '';
+
+		// Current query token.
+		let token = '';
+
+		this._map = new Map();
+
+		for (let i=0; i < decoded.length; i++) {
+			const char = decoded[i];
+
+			// Validate char:
+			if (NOT_ALLOWED.indexOf(char) > -1) {
+				const err = new TypeError(`Invalid query token at ${ i }: '${ char }'`);
+				throw err;
+			}
+
+			if (char === '(') {
+				// Error If there is nothing behind:
+				if (param.length === 0) {
+					const err = new TypeError(`Invalid query token at ${ i }: '${ char }'`);
+					throw err;
+				}
+
+				// If not special token, go deeper:
+				if (['and', 'or', 'xor', 'not', '!', '|', 'like'].indexOf(token) === -1) {
+					this.append(param, token);
+					deep++;
+				}
+
+				// will set ( in token later.
+			}
+
+			if (char === ')') {
+				// If sub-level:
+				if (deep > 0) {
+					deep--
+				}
+			}
+
+			// & can mean the end of key=value pair:
+			if (char === '&') {
+				// If top-level:
+				if (deep === 0) {
+					this.append(param, token);
+					param = '';
+					token = '';
+					continue;
+				}
+
+				// If sub-level do nothing.
+			}
+			
+			// = can mean the end of param name:
+			if (char === '=') {
+				// If top-level:
+				if (deep === 0) {
+					param = token;
+					token = '';
+				}
+			}
+			
+			// Continue building token:
+			if (char !== '=' || deep > 0 ) {
+				token += char;
+			}
+
+			// If last char:
+			if (i === decoded.length-1) {
+				// Validate:
+				if (deep > 0) {
+					const err = new TypeError(`Missing ')' at ${ i }`);
+					throw err;
+				}
+
+				this.append(param, token);
+			}
+		}
+	}
+
+	append(...args) {
+		return this._map.set(...args);
+	}
+
+	get(...args) {
+		return this._map.get(...args);
+	}
+
+	delete(...args) {
+		return this._map.delete(...args);
+	}
+
+	entries(...args) {
+		return this._map.entries(...args);
+	}
+
+	toString() {
+		return this._map.toString();
+	}
+
+	[util.inspect.custom](depth, opts) {
+		return this._map;
+	}
+}