nodester 0.0.9 → 0.1.0

package/Readme.md

@@ -28,9 +28,22 @@ app.listen(8080, function() {
 
 ## Documentation
 
+
 ### Core concepts
 [Go to core concepts documentaion](docs/CoreConcepts.md)
 
+### Queries & Querying - Nodester Query Language (NQR)
+One of the main power points of nodester is it's query language. It's an extension of a REST API syntaxis for a broader integration with a database SQL. Read more about it in the documentation:
+
+[Go to NQR documentaion](docs/Queries.md)
+
+
+### Database
+Nodester is built upon a powerful [Sequelize](https://sequelize.org/).
+Supported drivers:
+- MySQL
+- PostgreSQL
+
 
 ### Extending Application functionality
 
@@ -95,7 +108,7 @@ The Philosophy of `nodester` is to provide a developer with a tool that can buil
 
 ### Goal
 
-The goal of `nodester` is to be a robust and flexible framework that makes iterative development easy.
+The goal of `nodester` is to be a robust and flexible framework that makes development in iteratations easy, and further scale possible.
 
 
 ## LICENSE

package/lib/application/index.js

@@ -7,17 +7,25 @@
 
 const Emitter = require('events');
 const DefaultRouter = require('../router');
+
 // Server:
 const http = require('http');
 const request = require('../http/request');
 const response = require('../http/response');
+
 // Middlewares:
 const nodesterQL = require('../middlewares/ql/sequelize');
+const bodyParser = require('body-parser');
+
 // Utils:
 const {
 	typeOf,
 	isConstructor
 } = require('../utils/types.util');
+const {
+	associateModels
+} = require('../database/utils');
+
 const { merge } = require('../utils/objects.util');
 const consl = require('../logger/console');
 const debug = require('debug')('nodester:application');
@@ -52,6 +60,13 @@ module.exports = class Application extends Emitter {
 			beforeStart: ()=>{}
 		};
 
+		// Default middlewares:
+		const _withoutMiddlewares = opts?.middlewares?.without ?? [];
+
+		if (_withoutMiddlewares.indexOf('body-parser') === -1) {
+			this.use(bodyParser.json());
+		}
+
 		// Indicatorors.
 		this.isListening = false;
 	}
@@ -104,7 +119,7 @@ module.exports = class Application extends Emitter {
 	 *
 	 * @public
 	 */
-	setDatabase(sequilizeConnection, crashOnError=true) {
+	async setDatabase(sequilizeConnection, crashOnError=true) {
 		try {
 			if (!sequilizeConnection) {
 				const err = new TypeError('Connection to database (Sequilize) can not be null or undefined.');
@@ -116,10 +131,14 @@ module.exports = class Application extends Emitter {
 				throw err;
 			}
 
-			const result = sequilizeConnection.authenticate();
+			// Test connection.
+			const result = await sequilizeConnection.authenticate();
+			// Associate models.
+			await associateModels(sequilizeConnection.models);
+			// Set database.
 			this._database = sequilizeConnection;
 
-			return result;
+			return Promise.resolve(result);
 		}
 		catch(error) {
 			if (crashOnError === true) {
@@ -128,6 +147,8 @@ module.exports = class Application extends Emitter {
 			else {
 				consl.error(error);
 			}
+
+			return Promise.reject(error);
 		}
 	}
 
@@ -188,14 +209,14 @@ module.exports = class Application extends Emitter {
 
 
 	/*
-	 * Proxy to .add.middleware()
+	 * Proxy to router.use()
 	 *
-	 * @param {Function} fn
+	 * @param {Function|NodesterRouter} fnOrRouter
 	 *
 	 * @api public
 	 */
-	use(fn) {
-		return this._router.add.middleware(fn);
+	use(fnOrRouter) {
+		return this._router.use(fnOrRouter);
 	}
 
 

package/lib/controllers/methods/index.js

@@ -14,8 +14,13 @@ module.exports = {
  */
 async function _getOne(req, res) {
 	try {
-
-		const result = await this.facade.getOne();
+		const params = {
+			query: {
+				...req.query,
+				where: req.params
+			}
+		}
+		const result = await this.facade.getOne(params);
 
 		if (this.afterGetOne) {
 			await this.afterGetOne(req, res, result);
@@ -26,7 +31,6 @@ async function _getOne(req, res) {
 		});
 	}
 	catch(error) {
-		console.error('getOne', error);
 		if (this.processError) {
 			return this.processError(error, req, res);
 		}
@@ -47,7 +51,10 @@ async function _getOne(req, res) {
  */
 async function _getMany(req, res) {
 	try {
-		const result = await this.facade.getMany();
+		const params = {
+			query: req.query
+		}
+		const result = await this.facade.getMany(params);
 
 		if (this.afterGetMany) {
 			await this.afterGetMany(req, res, result);
@@ -78,8 +85,14 @@ async function _getMany(req, res) {
  */
 async function _createOne(req, res) {
 	try {
-
-		const result = await this.facade.createOne();
+		const params = {
+			query: {
+				...req.query,
+				where: req.params
+			},
+			data: req.body,
+		}
+		const result = await this.facade.createOne(params);
 
 		if (this.afterCreateOne) {
 			await this.afterCreateOne(req, res, result);
@@ -110,8 +123,14 @@ async function _createOne(req, res) {
  */
 async function _updateOne(req, res) {
 	try {
-
-		const result = await this.facade.updateOne();
+		const params = {
+			query: {
+				...req.query,
+				where: req.params
+			},
+			data: req.body,
+		}
+		const result = await this.facade.updateOne(params);
 
 		if (this.afterUpdateOne) {
 			await this.afterUpdateOne(req, res, result);
@@ -142,8 +161,13 @@ async function _updateOne(req, res) {
  */
 async function _deleteOne(req, res) {
 	try {
-
-		const result = await this.facade.deleteOne();
+		const params = {
+			query: {
+				...req.query,
+				where: req.params
+			}
+		}
+		const result = await this.facade.deleteOne(params);
 
 		if (this.afterDeleteOn) {
 			await this.afterDeleteOne(req, res, result);

package/lib/controllers/mixins/index.js

@@ -134,6 +134,7 @@ function _withDefaultErrorProcessing(controller, opts={}) {
 
 	// Set processError:
 	controller.processError = function (error, req, res) {
+		
 		// Default error message.
 		let errorMessage = error?.message ?? 'Internal server error';
 		// Default HTTP status code.
@@ -169,23 +170,31 @@ function _withDefaultErrorProcessing(controller, opts={}) {
 			}
 			case('InternalValidationError'): {
 				statusCode = 500;
-				errorResponse.details = { message:'Error' };
+				errorResponse.details = { message: 'Error' };
 				break;
 			}
 			default: {
-				errorResponse.details = { message:errorMessage };
+				errorResponse.details = { message: errorMessage };
 				break;
 			}
 		}
 
-		// Send error response with provided status code.
-		return this.respondNotOk(res, {
+		// Send error response with provided status code:
+		const data = {
 			error: {
 				...errorResponse,
 				code: statusCode
 			},
 			status: statusCode
-		});
+		}
+
+		if (!!this.respondNotOk) {
+			return this.respondNotOk(res, data);
+		}
+
+		// Barebones response:
+		res.status(statusCode);
+		res.json(data);
 	}
 
 	return controller;

package/lib/database/connection.js

@@ -0,0 +1,34 @@
+// ORM.
+const Sequelize = require('sequelize');
+
+
+module.exports = {
+	buildConnection: _buildConnection
+};
+
+function _buildConnection(opts={}) {
+	
+
+	const dbName = opts.name;
+	const username = opts.username;
+	const password = opts.password;
+
+
+	const connection = new Sequelize(
+		dbName,
+		username,
+		password,
+		{
+			host: opts.host,
+			port: opts.port,
+			dialect: opts.dialect,
+			pool: opts.pool,
+			charset: opts.charset,
+			collate: opts.collate, 
+			timestamps: opts.timestamps,
+			logging: opts.logging
+		}
+	);
+
+	return connection;
+}

package/lib/database/migration.js

@@ -0,0 +1,42 @@
+const { associateModels } = require('./utils');
+
+
+module.exports = {
+	migrate: _migrate
+}
+
+async function _migrate(databaseConnection, force=false) {
+	try {
+		// Validation of 'force' parameter.
+		if (typeof force !== 'boolean') {
+			const err = new Error('Wrong "force" parameter; must be boolean.');
+			throw err;
+		}
+
+		// Test connection.
+		await databaseConnection.authenticate();
+
+
+		const models = databaseConnection.models;
+		const modelNames = Object.keys(models);
+		console.info('Models to sync:', modelNames);
+		console.info('Forcefully?', force);
+		console.info('Syncing...\n');
+		await associateModels(models);
+		await databaseConnection.sync({ force });
+		console.info('Successful migration!');
+
+		const output = {
+			synced: true,
+			modelNames: modelNames,
+			models: models
+		}
+		return Promise.resolve(output);
+	}
+	catch(error) {
+		console.error('Migration failed!');
+		console.error(error);
+		return Promise.reject(error);
+	}
+}
+

package/lib/database/utils.js

@@ -0,0 +1,19 @@
+
+module.exports = {
+	associateModels: _associateModels
+}
+
+async function _associateModels(models) {
+	return new Promise((resolve, reject) => {
+		try {
+			Object.keys(models).map(modelName => (
+				models[modelName].associate(models)
+			));
+
+			return resolve(models);
+		}
+		catch(error) {
+			reject(error);
+		}
+	});
+}

package/lib/facades/methods/index.js

@@ -0,0 +1,173 @@
+const Params = require('nodester/params');
+
+
+module.exports = {
+	getOne: _getOne,
+	getMany: _getMany,
+	createOne: _createOne,
+	updateOne: _updateOne,
+	deleteOne: _deleteOne
+}
+
+
+/*
+ *
+ * @param {Object} params
+ *
+ * @alias getOne
+ * @api public
+ */
+async function _getOne(params) {
+	try {
+		const {
+			query
+		} = Params(params, {
+			query: {}
+		});
+
+		const instance = await this.model.findOne(query);
+
+		const result = {
+			[this.modelName.singular]: instance,
+			count: 0 + instance !== null
+		}
+		return Promise.resolve(result);
+	}
+	catch(error) {
+		return Promise.reject(error);
+	}
+}
+
+
+/*
+ *
+ * @param {Object} params
+ *
+ * @alias getMany
+ * @api public
+ */
+async function _getMany(params) {
+	try {
+		const {
+			query
+		} = Params(params, {
+			query: {}
+		});
+
+		const instances = await this.model.findAll(query);
+
+		const result = {
+			[this.modelName.plural]: instances,
+			count: instances.length
+		}
+		return Promise.resolve(result);
+	}
+	catch(error) {
+		return Promise.reject(error);
+	}
+}
+
+
+/*
+ *
+ * @param {Object} params
+ *
+ * @alias createOne
+ * @api public
+ */
+async function _createOne(params) {
+	try {
+		const {
+			data,
+			includes,
+		} = Params(params, {
+			data: null,
+			includes: null,
+		});
+
+		const instance = await this.model.create({ ...data }, {
+			include: this.model.getIncludesList(data)
+		});
+
+		// If includes are set, "find" this record with includes:
+		if (!!includes && includes?.length > 0) {
+			await instance.reload({ include: includes });
+		}
+
+		const result = {
+			[this.modelName.singular]: instance,
+			count: instance === null ? 0 : 1
+		}
+
+		// Call after create.
+		await this.afterCreateOne(instance, params, result);
+
+		return Promise.resolve(result);
+	}
+	catch(error) {
+		return Promise.reject(error);
+	}
+}
+
+
+/*
+ *
+ * @param {Object} params
+ *
+ * @alias updateOne
+ * @api public
+ */
+async function _updateOne(params) {
+	try {
+		const {
+			query,
+			data
+		} = Params(params, {
+			query: {},
+			data: null
+		});
+
+		const updateResult = await this.model.updateOne(query.where, data);;
+
+		const [ isNewRecord, instance ] = updateResult;
+
+		const result = {
+			success: isNewRecord === false,
+			[this.modelName.singular]: instance,
+			count: !!instance ? 1 : 0
+		}
+		return Promise.resolve(result);
+	}
+	catch(error) {
+		return Promise.reject(error);
+	}
+}
+
+
+/*
+ *
+ * @param {Object} params
+ *
+ * @alias deleteOne
+ * @api public
+ */
+async function _deleteOne(params) {
+	try {
+		const {
+			query
+		} = Params(params, {
+			query: null
+		});
+
+		const count = await this.model.deleteOne(query);
+
+		const result = {
+			success: count > 0,
+			count: count
+		};
+		return Promise.resolve(result);
+	}
+	catch(error) {
+		return Promise.reject(error);
+	}
+}

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/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

@@ -16,7 +16,7 @@ class ModelsTreeNode {
 
 		this.includes = opts.includes ?? [];
 		this.order = opts.order ?? 'asc';
-		this.orderBy = opts.orderBy ?? 'id';
+		this.order_by = opts.order_by ?? 'id';
 	}
 
 	get hasParent() {
@@ -64,7 +64,7 @@ class ModelsTreeNode {
 			skip: this.skip,
 			limit: this.limit,
 			order: this.order,
-			orderBy: this.orderBy,
+			order_by: this.order_by,
 			
 			fields: this.fields,
 

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

@@ -378,7 +378,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 +406,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)