nodester 0.1.5 → 0.2.1

package/lib/http/response/utils.js

@@ -0,0 +1,38 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+
+'use strict';
+
+// Utils:
+const contentType = require('content-type');
+
+module.exports = {
+	setCharset: _setCharset
+}
+
+/**
+ * Set the charset in a given Content-Type string.
+ *
+ * @param {String} type
+ * @param {String} charset
+ *
+ * @return {String}
+ *
+ * @api private
+ */
+function _setCharset(type, charset) {
+	if (!type || !charset) {
+		return type;
+	}
+
+	// parse type
+	const parsed = contentType.parse(type);
+
+	// set charset
+	parsed.parameters.charset = charset;
+
+	// format type
+	return contentType.format(parsed);
+}

package/lib/middlewares/SearchParams/index.js

@@ -0,0 +1,25 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+ 
+'use strict';
+
+
+module.exports = function initSearchParamsMiddleware() {
+	return handle;
+}
+
+function handle(req, res, next) {
+	// If no query, skip:
+	if (req.url.indexOf('?') === -1) {
+		return next();
+	}
+
+	const querystring = req.url.split('?')[1];
+	const params = new URLSearchParams(querystring);
+
+	req.searchParams = params;
+
+	next();
+}

package/lib/middlewares/cookies/index.js

@@ -0,0 +1,44 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+ 
+'use strict';
+
+const cookie = require('cookie');
+const cookieSignature = require('cookie-signature');
+
+
+module.exports = function initCookiesMiddleware(options={}) {
+	const context = {
+		options
+	}
+	return cookiesHandle.bind(context);
+};
+
+function cookiesHandle(req, res, next) {
+	try {
+		if (req.headers.cookie === undefined) {
+			req.cookies = {};
+			return next();
+		}
+
+		const cookies = cookie.parse(req.headers.cookie);
+		req.cookies = cookies;
+
+		next();
+	}
+	catch(error) {
+		console.error(error);
+
+		const statusCode = error.status || 406;
+		res.status(statusCode);
+		res.json({
+			error: {
+				message: error.message,
+				code: statusCode
+			},
+			status: statusCode
+		});
+	}
+}

package/lib/middlewares/etag/index.js

@@ -1,38 +1,54 @@
-'use strict'
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+
+'use strict';
 
 const calculate = require('etag');
 const Stream = require('stream');
+
+// Utils:
 const promisify = require('util').promisify;
 const fs = require('fs');
-
 const getFileStats = promisify(fs.stat);
 
+
 /**
- * Expose `etag` middleware.
+ * Initialize `etag` middleware.
+ *
+ * @param {Object}  options
+ * @param {Boolean} options.weak
  *
- * Add ETag header field.
- * @param {object} [options] see https://github.com/jshttp/etag#options
- * @param {boolean} [options.weak]
  * @return {Function}
+ *
  * @api public
  */
-module.exports = function etag (options) {
-	return async function(req, res, next) {
-		await next()
-		const entity = await getResponseEntity(req, res)
-		setEtag(res, entity, options);
+module.exports = function initETagMiddleware(options) {
+	const context = {
+		options
 	}
+	return handle.bind(context);
 }
 
+/*
+ * Add ETag header field.
+ */
+function handle(req, res, next) {
+	// console.log('e', req.headers);
+	next();
+}
 
-async function getResponseEntity (res) {
+async function _getResponseEntity(res) {
 	// If body is not defined:
 	const { body } = res;
 	if (!body || res.get('etag'))
 		return;
 
 	// Status code.
-	const status = res.status / 100 | 0;
+	const status = res.statusCode / 100 | 0;
+
+	console.log('getResponseEntity', status, { tag: res.get('etag') });
 
 	// 2xx
 	if (status !== 2)
@@ -45,7 +61,7 @@ async function getResponseEntity (res) {
 		const stats = await getFileStats(body.path);
 		return stats;
 	}
-	else if ((typeof body === 'string') || Buffer.isBuffer(body)) {
+	else if (typeof body === 'string' || Buffer.isBuffer(body)) {
 		return body;
 	}
 	else {
@@ -53,8 +69,9 @@ async function getResponseEntity (res) {
 	}
 }
 
+function _setEtag(res, entity, options) {
+	console.log('setEtag', typeof res, entity);
 
-function setEtag (res, entity, options) {
 	if (!entity)
 		return;
 

package/lib/middlewares/formidable/index.js

@@ -2,36 +2,41 @@
  * /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
-			});
-		}
+module.exports = function initFormidableMiddleware(formidableOptions={}) {
+	const context = {
+		formidableOptions
 	}
+	return formidableHandle.bind(context);
 };
 
+async function formidableHandle(req, res, next) {
+	try {
+		const form = formidable(this.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/index.js

@@ -1,10 +1,19 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+ 
+'use strict';
+
 const QueryLexer = require('./interpreter/QueryLexer');
 const httpCodes = require('nodester/http/codes');
 
 
-module.exports = NodesterQL;
+module.exports = function initNodesterQL() {
+	return nqlHandle;
+};
 
-async function NodesterQL(req, res, next) {
+async function nqlHandle(req, res, next) {
 	// Object, which will be populated with parsed query.
 	req.nquery = {};
 

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

@@ -2,10 +2,11 @@
  * /nodester
  * MIT Licensed
  */
-'use strict';
 
+'use strict';
 
 const Enum = require('nodester/enum');
+
 const { ModelsTree, ModelsTreeNode } = require('./ModelsTree');
 const util = require('util');
 const debug = require('debug')('nodester:interpreter:QueryLexer');
@@ -221,6 +222,13 @@ module.exports = class QueryLexer {
 					const model = token;
 					tree.use(model) ?? tree.include(model);
 
+					// Last token (model) was included,
+					// now jump to root and proceed to collect next token (model).
+					tree.node.resetActiveParam();
+					tree.upToRoot();
+
+					tree.node.activeParam = 'includes';
+
 					token = '';
 					continue;
 				}
@@ -402,7 +410,7 @@ module.exports = class QueryLexer {
 					const err = MissingCharError(i+1, ')');
 					throw err;
 				}
-
+				
 				this.setNodeParam(tree.node, token, value);
 
 				// If end of subquery:

package/lib/middlewares/render/index.js

@@ -0,0 +1,62 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+ 
+'use strict';
+
+
+module.exports = function initRenderMiddleware() {
+	return handle;
+}
+
+
+function handle(req, res, next) {
+	const context = { req, res, next };
+	res.render = _render.bind(context);
+	next();
+}
+
+
+/**
+ * Render `view` with the given `options` and optional callback `fn`.
+ * When a callback function is given a response will _not_ be made
+ * automatically, otherwise a response of _200_ and _text/html_ is given.
+ *
+ * Options:
+ *
+ *  - `cache`     boolean hinting to the engine it should cache
+ *  - `filename`  filename of the view being rendered
+ *
+ * @alias render
+ * @api public
+ */
+function _render(view, options, callback) {
+	const app = this.req.app;
+	let done = callback;
+	let opts = options || {};
+	
+	const req = this.req;
+	const res = this.res;
+	const next = this.next;
+
+	// support callback function as second arg
+	if (typeof options === 'function') {
+		done = options;
+		opts = {};
+	}
+
+	// merge res.locals
+	opts._locals = res.locals;
+
+	// default callback to respond
+	done = done || function (err, str) {
+		if (err)
+			return next(err);
+		
+		res.send(str);
+	};
+
+	// render
+	app.render(view, opts, done);
+};

package/lib/models/associate.js

@@ -1,5 +1,17 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+ 
+'use strict';
 
-module.exports = async function associateModels(databaseConnection) {
+
+module.exports = {
+	associateModels: _associateModels,
+	associateModelsSync: _associateModelsSync
+}
+
+async function _associateModels(databaseConnection) {
 	try {
 		const models = databaseConnection.models;
 
@@ -15,3 +27,15 @@ module.exports = async function associateModels(databaseConnection) {
 		return Promise.reject(error);
 	}
 }
+
+function _associateModelsSync(databaseConnection) {
+	const models = databaseConnection.models;
+
+	const modelNames = Object.keys(models);
+
+	for (let modelName of modelNames) {
+		models[modelName].associate(models);
+	}
+
+	return models;
+}

package/lib/models/define.js

@@ -2,6 +2,7 @@
  * /nodester
  * MIT Licensed
  */
+ 
 'use strict';
 
 // CRUD mixins.
@@ -18,7 +19,7 @@ module.exports = defineModel;
  * @param {Function} definition
  * @param {Object} options
  *   - ... Sequilize model options
- *   - noCRUD (Bool)
+ *   - @param {Boolean} noCRUD
  */
 function defineModel(
 	databaseConnection,
@@ -30,16 +31,24 @@ function defineModel(
 	const _options = {
 		// Set snake-cased table name.
 		// tableName: underscore( pluralize(modelName) ),
+		
 		// Set snake-case.
 		underscored: true,
+		
 		// Enable automatic 'created_at' and 'updated_at' fields.
 		timestamps: true,
 
-		// The only way to get snake-cased timestamps (issue: https://github.com/sequelize/sequelize/issues/10857)
+		// The only way to get snake-cased timestamps:
+		// (issue: https://github.com/sequelize/sequelize/issues/10857)
 		createdAt: 'created_at',
 		updatedAt: 'updated_at',
 		deletedAt: 'deleted_at',
 
+		// Configs related to nodester:
+		nodester: {
+			output: 'underscored'
+		},
+
 		// Add user-defined options (they can override upper ones).
 		...options
 	};
@@ -76,11 +85,8 @@ function _getIncludesList(facadeData=null) {
 	const associations = this.associations;
 	const associationEntries = Object.entries(associations);
 
-	associationEntries.forEach(([
-		associationName,
-		associationDefinition
-	]) => {
-		const a = { association: associationName };
+	for (const [ associationName, associationDefinition ] of associationEntries) {
+		const formatted = { association: associationName };
 
 		if (!!facadeData) {
 			// If facade data is set, go deeper:
@@ -88,19 +94,17 @@ function _getIncludesList(facadeData=null) {
 			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);
+					formatted.include = associationModel.getIncludesList(
+												Array.isArray(deepData) ? deepData[0] : deepData
+											);
 				}
-
-				result.push( a );
 			}
 		}
-		else {
-			result.push( a );
-		}
-	});
+
+		result.push( formatted );
+	}
 
 	return result;
 }

package/lib/models/mixins.js

@@ -1,3 +1,10 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+ 
+'use strict';
+
 /*
  *	CRUD mixins for any model:
  */