nodester 0.0.9 → 0.1.4

package/lib/facades/mixins/index.js

@@ -0,0 +1,111 @@
+const {
+	getOne,
+	getMany,
+	createOne,
+	updateOne,
+	deleteOne
+} = require('../methods');
+// Utils,
+const { lowerCaseFirstLetter } = require('nodester/utils/strings');
+
+
+module.exports = {
+	withDefaultCRUD: _withDefaultCRUD,
+}
+
+/**
+ * Sets one of or all of CRUD methods to Facade.
+ *
+ * @param {Function|Object} facade
+ * @param {Object} opts
+ * - @param {Function|Object} model
+ * - @param {String} name
+ * - @param {Array} only
+ *
+ * @return {Function|Object} facade
+ *
+ * @api public
+ * @alias withDefaultCRUD
+ */
+function _withDefaultCRUD(facade, opts={}) {
+	const {
+		model,
+
+		// Optional:
+		name,
+		only
+	} = opts;
+
+	if (!facade) {
+		const err = new TypeError(`'facade' argument is not provided.`);
+		throw err;
+	}
+	
+	// Set model info:
+	//	Set model:
+	Object.defineProperty(facade, 'model', {
+		value: model,
+		writable: false
+	});
+
+	//	Model name:
+	const modelName = model.options.name;
+	Object.defineProperty(facade, 'modelName', {
+		value: {
+			singular: lowerCaseFirstLetter(modelName.singular),
+			plural: lowerCaseFirstLetter(modelName.plural)
+		},
+		writable: false
+	});
+
+
+	// Set name of this facade:
+	Object.defineProperty(facade, 'name', {
+		value: name ?? `${ modelName.plural ?? facade.name }Facade`,
+		writable: false
+	});
+
+
+	// If only certain methods should be set:
+	if (!!only) {
+		for (const selectedMethod of only) {
+			switch(selectedMethod) {
+				case 'getOne':
+					facade.getOne    = getOne.bind(facade);
+					break;
+				case 'getMany':
+					facade.getMany   = getMany.bind(facade);
+					break;
+				case 'createOne':
+					facade.createOne = createOne.bind(facade);
+					break;
+				case 'updateOne':
+					facade.updateOne = updateOne.bind(facade);
+					break;
+				case 'deleteOne':
+					facade.deleteOne = deleteOne.bind(facade);
+					break;
+
+				default:
+					break;
+			}
+		}
+	}
+	// Or set all methods:
+	else {
+		facade.getOne    = getOne.bind(facade);
+		facade.getMany   = getMany.bind(facade);
+		facade.createOne = createOne.bind(facade);
+		facade.updateOne = updateOne.bind(facade);
+		facade.deleteOne = deleteOne.bind(facade);
+
+		// Set empty hooks:
+		facade.afterGetOne    = async () => {};
+		facade.afterGetMany   = async () => {};
+		facade.afterCreateOne = async () => {};
+		facade.afterUpdateOne = async () => {};
+		facade.afterDeleteOe  = async () => {};
+	}
+
+	return facade;
+}

package/lib/factories/errors/CustomError.js

@@ -1,3 +1,10 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+
+'use strict';
+
 
 module.exports = class CustomError extends Error {
 	constructor(message) {

package/lib/factories/errors/NodesterQueryError.js

@@ -0,0 +1,23 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+
+'use strict';
+
+const {
+	NODESTER_QUERY_ERROR,
+} = require('nodester/constants/ErrorCodes');
+
+
+module.exports = class NodesterQueryError extends Error {
+	constructor(message) {
+		super(message);
+
+		this.name = NODESTER_QUERY_ERROR;
+		this.status = 422;
+
+		// Remove constructor info from stack.
+		Error.captureStackTrace(this, this.constructor);
+	}
+}

package/lib/factories/errors/index.js

@@ -1,9 +1,16 @@
-/*
- * Add all your custom errors in this file.
+/*!
+ * /nodester
+ * MIT Licensed
  */
+
+'use strict';
+
+
 const Err = require('./CustomError');
+const NodesterQueryError = require('./NodesterQueryError');
 
 
 module.exports = {
-	Err
+	Err,
+	NodesterQueryError
 }

package/lib/loggers/dev.js

@@ -0,0 +1,28 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+
+'use strict';
+
+
+exports = module.exports = {
+	error: _error
+}
+
+/**
+ * Log error using console.error.
+ *
+ * @param {Array} args
+ *
+ * @alias error
+ * @public
+ */
+
+function _error(...args) {
+	const activeEnv = process.env.NODE_ENV
+
+	if (activeEnv === 'development' || activeEnv === 'testing') {
+  	console.error(...args);
+	}
+}

package/lib/middlewares/formidable/index.js

@@ -0,0 +1,37 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+'use strict';
+
+const { formidable } = require('formidable');
+
+
+module.exports = function FormidableMiddleware(formidableOptions={}) {
+	return async function(req, res, next) {
+		try {
+			const form = formidable(formidableOptions);
+			const [fields, files] = await form.parse(req);
+
+			// Add to request:
+			req.form = {
+				fields,
+				files
+			};
+
+			next();
+		}
+		catch(error) {
+			const statusCode = error.status || 406;
+			res.status(statusCode);
+			res.json({
+				error: {
+					message: error.message,
+					code: statusCode
+				},
+				status: statusCode
+			});
+		}
+	}
+};
+

package/lib/middlewares/ql/sequelize/interpreter/ModelsTree.js

@@ -1,3 +1,9 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+'use strict';
+
 const debug = require('debug')('nodester:interpreter:ModelsTree');
 
 
@@ -7,16 +13,18 @@ class ModelsTreeNode {
 		this.parent = parent;
 		this.activeParam = null;
 		this.op = null;
+		this.fn = null;
 
 		// for override:
 		this.fields = [];
 		this._where = {};
+		this._functions = [];
 		this.skip = 0;
 		this.limit = -1; // No limit
 
 		this.includes = opts.includes ?? [];
 		this.order = opts.order ?? 'asc';
-		this.orderBy = opts.orderBy ?? 'id';
+		this.order_by = opts.order_by ?? 'id';
 	}
 
 	get hasParent() {
@@ -35,6 +43,10 @@ class ModelsTreeNode {
 		return this._where;
 	}
 
+	get functions() {
+		return this._functions;
+	}
+
 	resetActiveParam() {
 		this.activeParam = null;
 	}
@@ -43,6 +55,10 @@ class ModelsTreeNode {
 		this.op = null;
 	}
 
+	resetFN() {
+		this.fn = null;
+	}
+
 	addWhere(condition={}) {
 		this._where = {
 			...this.where,
@@ -50,6 +66,10 @@ class ModelsTreeNode {
 		}
 	}
 
+	addFunction(fnParams={}) {
+		this._functions.push(fnParams);
+	}
+
 	include(modelTreeNode) {
 		modelTreeNode.parent = this;
 		this.includes.push(modelTreeNode);
@@ -60,13 +80,16 @@ class ModelsTreeNode {
 		return {
 			model: this.model,
 
+			fields: this.fields,
+			functions: this.functions,
+
 			where: this.where,
+
 			skip: this.skip,
 			limit: this.limit,
 			order: this.order,
-			orderBy: this.orderBy,
+			order_by: this.order_by,
 			
-			fields: this.fields,
 
 			includes: this.includes.map(i => i.toObject())
 		}

package/lib/middlewares/ql/sequelize/interpreter/QueryLexer.js

@@ -1,3 +1,10 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+'use strict';
+
+
 const Enum = require('../../../../enums/Enum');
 const { ModelsTree, ModelsTreeNode } = require('./ModelsTree');
 const util = require('util');
@@ -21,6 +28,10 @@ const OP_TOKENS = new Enum({
 	LOWER_OR_EQUAL: 'lte'
 });
 
+const FN_TOKENS = new Enum({
+	COUNT: 'count',
+});
+
 
 module.exports = class QueryLexer {
 	constructor(queryString='') {
@@ -71,22 +82,29 @@ module.exports = class QueryLexer {
 					token = '';
 					continue;
 				}
-				// If model subquery:
-				else {
-					const model = token;
-					tree.use(model) ?? tree.include(model).use(model);
+				
+				// If FN token:
+				if (FN_TOKENS.asArray.indexOf(token) > -1) {
+					// Set function token.
+					tree.node.fn = token;
 					token = '';
+					continue;
+				}
 
-					// Process subquery:
-					i++;
-					const [ charsCount ] = this.parseIsolatedQuery(queryString, i, tree);
-					i += charsCount;
+				// If model subquery:
+				const model = token;
+				tree.use(model) ?? tree.include(model).use(model);
+				token = '';
 
-					previousActive = model;
-					tree.up();
+				// Process subquery:
+				i++;
+				const [ charsCount ] = this.parseIsolatedQuery(queryString, i, tree);
+				i += charsCount;
 
-					continue;
-				}
+				previousActive = model;
+				tree.up();
+
+				continue;
 			}
 
 			// ) can mean end of OP token params,
@@ -126,6 +144,40 @@ module.exports = class QueryLexer {
 					continue;
 				}
 
+				// If end of FN token:
+				if (!!tree.node.fn) {
+					// If token is empty, error:
+					if (token === '') {
+						const err = UnexpectedCharError(i, char);
+						throw err;
+					}
+
+					let fnParams = {};
+					switch (tree.node.fn) {
+						case 'count':
+							fnParams = {
+								fn: 'count',
+								args: [token]
+							};
+							break;
+						default:
+							fnParams = {
+								fn: [tree.node.fn],
+								args: [token]
+							};
+							break;
+					}
+
+					tree.node.addFunction(fnParams);
+
+					// Reset:
+					tree.node.resetFN();
+					tree.node.activeParam = 'includes';
+					token = '';
+					value = [];
+					continue;
+				}
+
 				// If end of subquery:
 				if (!!tree.node.activeParam && tree.node.activeParam !== 'includes') {
 					// Set value.
@@ -378,7 +430,7 @@ module.exports = class QueryLexer {
 				return 'order';
 			case 'order_by':
 			case 'o_by':
-				return 'orderBy';
+				return 'order_by';
 			case 'fields':
 			case 'f':
 				return 'fields';
@@ -406,8 +458,8 @@ module.exports = class QueryLexer {
 			case 'order':
 				treeNode.order = token;
 				break;
-			case 'orderBy':
-				treeNode.orderBy = token;
+			case 'order_by':
+				treeNode.order_by = token;
 				break;
 			case 'fields':
 				if (token)

package/lib/models/define.js

@@ -2,6 +2,8 @@
 const { implementsCRUD } = require('./mixins');
 // ORM.
 const { DataTypes } = require('sequelize');
+// NQL.
+const Colander = require('../queries/Colander');
 
 
 module.exports = defineModel;
@@ -41,10 +43,19 @@ function defineModel(
 	const model = databaseConnection.define(modelName, definitionObject, _options);
 
 	if (options.noCRUD !== true) {
-		// Add createWithIncludes, findById, updateById, deleteById, etc.
+		// Add:
+		// - createWithIncludes;
+		// - findById;
+		// - updateById;
+		// - deleteById;
+		// - etc.
 		implementsCRUD(model);
 	}
 
+	// Association helpers:
+	model.associate = (models) => {};
+	model.getIncludesList = _getIncludesList.bind(model);
+
 	// Instance methods:
 	model.prototype.toJSON = function() {
 		const values = { ...this.get() };
@@ -54,3 +65,40 @@ function defineModel(
 
 	return model;
 }
+
+/* Association mixins: */
+function _getIncludesList(facadeData=null) {
+	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 );
+		}
+	});
+
+	return result;
+}
+/* Association mixins\ */

package/lib/models/mixins.js

@@ -8,6 +8,10 @@ const {
 	compileModelAssociationData,
 } = require('../utils/modelAssociations.util');
 
+// Nodester query:
+const NQLexer = require('../middlewares/ql/sequelize/interpreter/QueryLexer');
+const traverseNQuery = require('../queries/traverse');
+
 
 module.exports = {
 	implementsCRUD: _implementsCRUD
@@ -34,17 +38,15 @@ function _implementsCRUD(modelDefinition) {
 
 	// Read:
 	modelDefinition.findById = _findById.bind(modelDefinition);
-	modelDefinition.findOneWithIncludes = _findOneWithIncludes.bind(modelDefinition);
+	modelDefinition.findMany = _findMany.bind(modelDefinition);
 
 	// Update:
 	modelDefinition.updateOne = _updateOne.bind(modelDefinition);
 	modelDefinition.updateById = _updateById.bind(modelDefinition);
 
-	// Delete.
+	// Delete:
+	modelDefinition.deleteOne = _deleteOne.bind(modelDefinition);
 	modelDefinition.deleteById = _deleteById.bind(modelDefinition);
-
-	// Associations:
-	modelDefinition.getIncludesList = _getIncludesList.bind(modelDefinition);
 }
 
 
@@ -114,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`);
@@ -201,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();
 		}
 
@@ -225,6 +266,15 @@ async function _updateById(
 	);
 }
 
+
+function _deleteOne(query={}) {
+	const _query = {
+		...query,
+		limit: 1
+	}
+	return this.destroy(_query);
+}
+
 function _deleteById(
 	id=null
 ) {
@@ -235,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,