nodester 0.1.4 → 0.2.0

package/lib/http/response/headers.js

@@ -0,0 +1,138 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+
+'use strict';
+
+// Constants.
+const CHARSET_REGEX = /;\s*charset\s*=/;
+
+// Utils:
+const mime = require('mime');
+
+
+module.exports = {
+	setHeader: _setHeader,
+	appendHeader: _appendHeader,
+	getHeader: _getHeader,
+	removeHeader: _removeHeader,
+}
+
+/**
+ * Set header `field` to `value`, or pass
+ * an object of header fields.
+ *
+ * Examples:
+ *
+ *    res.set('Foo', ['bar', 'baz']);
+ *    res.set('Accept', 'application/json');
+ *    res.set({ Accept: 'text/plain', 'X-API-Key': 'tobi' });
+ *
+ * Aliased as `res.header()`.
+ *
+ * @param {String|Object} keyOrObject
+ * @param {String|Array} value
+ *
+ * @return {ServerResponse} for chaining
+ *
+ * @alias setHeader
+ * @api public
+ */
+function _setHeader(keyOrObject, value) {
+	// As a pair:
+	if (arguments.length === 2) {
+		let _value = Array.isArray(value) ? value.map(String) : String(value);
+
+		// Add charset to content-type:
+		if (keyOrObject.toLowerCase() === 'content-type') {
+			
+			if (Array.isArray(_value)) {
+				throw new TypeError('Content-Type cannot be set to an Array');
+			}
+
+			if (!CHARSET_REGEX.test(_value)) {
+				const charset = mime.charsets.getType(_value.split(';')[0]);
+				
+				if (charset) {
+					_value += '; charset=' + charset.toLowerCase();
+				}
+			}
+		}
+
+		this.setHeader(keyOrObject, _value);
+	}
+	// As an object
+	else if (typeof keyOrObject === 'object') {
+		for (let key in keyOrObject) {
+			this.setHeader(key, keyOrObject[key]);
+		}
+	}
+	else {
+		const err = new TypeError(`'keyOrObject' must be of type String|Object.`);
+		Error.captureStackTrace(err, _setHeader);
+		throw err;
+	}
+
+	return this;
+};
+
+
+/**
+ * Append additional header `field` with value `val`.
+ *
+ * Example:
+ *
+ *    res.append.header('Link', ['<http://localhost/>', '<http://localhost:3000/>']);
+ *    res.append.header('Set-Cookie', 'foo=bar; Path=/; HttpOnly');
+ *    res.append.header('Warning', '199 Miscellaneous warning');
+ *
+ * @param {String} field
+ * @param {String|Array} value
+ * @return {ServerResponse} for chaining
+ *
+ * @alias appendHeader
+ * @api public
+ */
+function _appendHeader(field, value) {
+	const prev = this.get(field);
+	let _value = value;
+
+	if (prev) {
+		// concat the new and prev values:
+		_value = Array.isArray(prev) ? prev.concat(value)
+			: Array.isArray(value) ? [prev].concat(value)
+				: [prev, value]
+	}
+
+	return this.setHeader(field, _value);
+};
+
+
+/**
+ * Get value for header `key`.
+ *
+ * @param {String} key
+ *
+ * @return {String}
+ *
+ * @alias getHeader
+ * @api public
+ */
+function _getHeader(key) {
+	return this.getHeader(key);
+};
+
+/**
+ * Remove value for header `key`.
+ *
+ * @param {String} key
+ *
+ * @return {String}
+ *
+ * @alias removeHeader
+ * @api public
+ */
+function _removeHeader(key) {
+	return this.removeHeader(key);
+};

package/lib/http/response/index.js

@@ -0,0 +1,248 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+
+'use strict';
+
+const { ServerResponse } = require('http');
+
+const {
+	setHeader,
+	appendHeader,
+	getHeader,
+	removeHeader,
+} = require('./headers');
+
+const calculateEtag = require('etag');
+
+// Utils:
+const statuses = require('statuses');
+const mime = require('mime');
+const {
+	setCharset
+} = require('./utils');
+
+
+const response = ServerResponse.prototype;
+
+// Mixin custom methods:
+response.status = _status;
+response.sendStatus = _sendStatus;
+
+response.send = _send;
+response.json = _json;
+
+//	Headers:
+response.set    = setHeader;
+response.append = appendHeader;
+response.get    = getHeader;
+response.remove = removeHeader;
+
+//	ContentType:
+response.setContentType = _setContentType;
+response.getContentType = _getContentType;
+// Mixins\
+
+module.exports = response;
+
+/**
+ * Set status `code`.
+ *
+ * @param {Number} code
+ *
+ * @return {ServerResponse}
+ *
+ * @alias status
+ * @api public
+ */
+function _status(code) {
+	this.statusCode = code;
+	return this;
+};
+
+
+/**
+ * Send given HTTP status code.
+ *
+ * Sets the response status to `statusCode` and the body of the
+ * response to the standard description from node's http.STATUS_CODES
+ * or the statusCode number if no description.
+ *
+ * Examples:
+ *
+ *     res.sendStatus(200);
+ *
+ * @param {number} statusCode
+ *
+ * @alias _sendStatus
+ * @api public
+ */
+function _sendStatus(statusCode) {
+	const body = statuses.message[statusCode] || String(statusCode);
+
+	this.statusCode = statusCode;
+	this.setContentType('txt');
+
+	return this.send(body);
+};
+
+/**
+ * Sends a response.
+ *
+ * Examples:
+ *
+ *     res.send(Buffer.from('wahoo'));
+ *     res.send({ some: 'json' });
+ *     res.send('<p>some html</p>');
+ *
+ * @param {string|number|boolean|object|Buffer} body
+ *
+ * @alias send
+ * @api public
+ */
+function _send(body) {
+	const req = this.req;
+	const app = this.app;
+
+	let chunk = body;
+	let encoding;
+	let type;
+
+	switch (typeof chunk) {
+		// strings defaulting to html:
+		case 'string':
+			if (!this.getContentType()) {
+				this.setContentType('html');
+			}
+			break;
+		case 'boolean':
+		case 'number':
+		case 'object':
+			if (chunk === null) {
+				chunk = '';
+			}
+			else if (Buffer.isBuffer(chunk)) {
+				if (!this.getContentType()) {
+					this.setContentType('bin');
+				}
+			}
+			else {
+				return this.json(chunk);
+			}
+			break;
+	}
+
+	// Write strings in utf-8:
+	if (typeof chunk === 'string') {
+		encoding = 'utf8';
+		type = this.getContentType();
+
+		// reflect this in content-type
+		if (typeof type === 'string') {
+			this.setContentType( setCharset(type, 'utf-8') );
+		}
+	}
+
+	// Freshness of the REQUEST:
+	if (req.fresh) {
+		this.statusCode = 304;
+	}
+
+	// Strip irrelevant headers for:
+	// - 204 (No Content)
+	// - 303 (Not Modified)
+	if (
+		this.statusCode === 204
+		||
+		this.statusCode === 304
+	) {
+		this.remove('Content-Type');
+		this.remove('Content-Length');
+		this.remove('Transfer-Encoding');
+		chunk = '';
+	}
+
+	// Alter headers for 205 (Reset Content):
+	if (this.statusCode === 205) {
+		this.set('Content-Length', '0');
+		this.remove('Transfer-Encoding');
+		chunk = ''
+	}
+
+	if (req.method === 'HEAD') {
+		// skip body for HEAD.
+		this.end();
+	}
+	else {
+		// Calculate etag:
+		const etag = calculateEtag(chunk);
+		this.set('etag', etag);
+
+		// Respond.
+		this.end(chunk, encoding);
+	}
+
+	return this;
+};
+
+
+/**
+ * Send JSON response.
+ *
+ * @param {string|number|boolean|object} obj
+ *
+ * @alias json
+ * @api public
+ */
+function _json(obj) {
+
+	// Ensure content-type:
+	if (!this.getContentType()) {
+		this.setContentType('application/json');
+	}
+
+	const body = JSON.stringify(obj);
+	return this.send(body);
+};
+
+/**
+ * Set _Content-Type_ response header with `type` through `mime.getType()`
+ * when it does not contain "/", or set the Content-Type to `type` otherwise.
+ *
+ * Examples:
+ *
+ *     res.type('.html');
+ *     res.type('html');
+ *     res.type('json');
+ *     res.type('application/json');
+ *     res.type('png');
+ *
+ * @param {String} type
+ *
+ * @return {ServerResponse} for chaining
+ *
+ * @alias setContentType
+ * @api public
+ */
+function _setContentType(type) {
+	const contentType = type.indexOf('/') === -1 ?
+												mime.getType(type)
+												:
+												type;
+
+	this.setHeader('Content-Type', contentType);
+	return this;
+};
+
+/**
+ * Returns _Content-Type_ header.
+ *
+ * @return {String} type
+ *
+ * @alias getContentType
+ * @api public
+ */
+function _getContentType() {
+	return this.getHeader('Content-Type');
+};

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,9 +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 = {};
 
@@ -18,7 +28,6 @@ async function NodesterQL(req, res, next) {
 	}
 
 	try {
-		// Convert to URLSearchParams.
 		const queryString = req.url.split('?')[1];
 
 		const lexer = new QueryLexer(queryString);
@@ -28,7 +37,7 @@ async function NodesterQL(req, res, next) {
 		next();
 	}
 	catch(error) {
-		res.status(422);
+		res.status(error.status ?? httpCodes.UNPROCESSABLE_ENTITY);
 		res.json({ error: error.toString() });
 	}
 }

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

@@ -2,10 +2,11 @@
  * /nodester
  * MIT Licensed
  */
+
 'use strict';
 
+const Enum = require('nodester/enum');
 
-const Enum = require('../../../../enums/Enum');
 const { ModelsTree, ModelsTreeNode } = require('./ModelsTree');
 const util = require('util');
 const debug = require('debug')('nodester:interpreter:QueryLexer');
@@ -60,7 +61,7 @@ module.exports = class QueryLexer {
 		const isSubQuery = tree.node.model !== 'root';
 		debug({ isSubQuery, startAt });
 
-		// Token is accumulated char-by-char.
+		// Token is String, accumulated char-by-char.
 		let token = '';
 		// Value of param ('id=10' OR 'fields=id,text').
 		let value = [];
@@ -375,7 +376,7 @@ module.exports = class QueryLexer {
 				const param = this.parseParamFromToken(token);
 
 				if (isSubQuery === true && param === 'includes') {
-					const err = new TypeError(`'include' is forbidden inside subquery (position ${ i }). Use: 'model.model' or 'model.model+model'.`);
+					const err = new TypeError(`'include' is forbidden inside subquery (position ${ i }). Use: 'model.model1' or 'model.model1+model2'.`);
 					throw err;
 				}