nodester 0.0.1

package/lib/application/http/utils.js

@@ -0,0 +1,254 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+'use strict';
+
+const contentType = require('content-type');
+const mime = require('send').mime;
+const etag = require('etag');
+const proxyaddr = require('proxy-addr');
+const qs = require('qs');
+const querystring = require('querystring');
+
+
+exports = module.exports = {
+	acceptParams: _acceptParams,
+	normalizeType: _normalizeType,
+	normalizeTypes: _normalizeTypes,
+	compileETag: _compileETag,
+	setCharset: _setCharset
+}
+
+
+/**
+ * Parse accept params `str` returning an
+ * object with `.value`, `.quality` and `.params`.
+ * also includes `.originalIndex` for stable sorting
+ *
+ * @param {String} str
+ * @param {Number} index
+ * @return {Object}
+ *
+ * @api private
+ */
+function _acceptParams(str, index) {
+	const parts = str.split(/ *; */);
+	let result = { value: parts[0], quality: 1, params: {}, originalIndex: index };
+
+	for (let i = 1; i < parts.length; i++) {
+		const pms = parts[i].split(/ *= */);
+		if ('q' === pms[0]) {
+			result.quality = parseFloat(pms[1]);
+		} else {
+			result.params[pms[0]] = pms[1];
+		}
+	}
+
+	return result;
+}
+
+
+/**
+ * Create an ETag generator function, generating ETags with
+ * the given options.
+ *
+ * @param {object} options
+ * @return {function}
+ *
+ * @private
+ */
+function _createETagGenerator (options) {
+	return function generateETag (body, encoding) {
+		const buf = !Buffer.isBuffer(body)
+			? Buffer.from(body, encoding)
+			: body
+
+		return etag(buf, options)
+	}
+}
+
+
+/**
+ * Normalize the given `type`, for example "html" becomes "text/html".
+ *
+ * @param {String} type
+ * @return {Object}
+ *
+ * @api private
+ */
+function _normalizeType(type){
+	return ~type.indexOf('/')
+		? acceptParams(type)
+		: { value: mime.lookup(type), params: {} };
+};
+
+
+/**
+ * Normalize `types`, for example "html" becomes "text/html".
+ *
+ * @param {Array} types
+ * @return {Array}
+ *
+ * @api private
+ */
+function _normalizeTypes(types){
+	const ret = [];
+
+	for (let i = 0; i < types.length; ++i) {
+		ret.push(
+			_normalizeType(types[i])
+		);
+	}
+
+	return ret;
+};
+
+
+/**
+ * Compile "etag" value to function.
+ *
+ * @param  {Boolean|String|Function} val
+ * @return {Function}
+ *
+ * @alias compileETag
+ * @api public
+ */
+function _compileETag(val) {
+	let fn;
+
+	if (typeof val === 'function') {
+		return val;
+	}
+
+	switch (val) {
+		case true:
+		case 'weak':
+			fn = _createETagGenerator({ weak: true });
+			break;
+		case false:
+			break;
+		case 'strong':
+			fn = _createETagGenerator({ weak: false });
+			break;
+		default:
+			throw new TypeError('unknown value for etag function: ' + val);
+	}
+
+	return fn;
+}
+
+/**
+ * Compile "query parser" value to function.
+ *
+ * @param  {String|Function} val
+ * @return {Function}
+ *
+ * @api private
+ */
+
+exports.compileQueryParser = function compileQueryParser(val) {
+	let fn;
+
+	if (typeof val === 'function') {
+		return val;
+	}
+
+	switch (val) {
+		case true:
+		case 'simple':
+			fn = querystring.parse;
+			break;
+		case false:
+			fn = newObject;
+			break;
+		case 'extended':
+			fn = parseExtendedQueryString;
+			break;
+		default:
+			throw new TypeError('unknown value for query parser function: ' + val);
+	}
+
+	return fn;
+}
+
+/**
+ * Compile "proxy trust" value to function.
+ *
+ * @param  {Boolean|String|Number|Array|Function} val
+ * @return {Function}
+ *
+ * @api private
+ */
+exports.compileTrust = function(val) {
+	if (typeof val === 'function') return val;
+
+	if (val === true) {
+		// Support plain true/false
+		return function(){ return true };
+	}
+
+	if (typeof val === 'number') {
+		// Support trusting hop count
+		return function(a, i){ return i < val };
+	}
+
+	if (typeof val === 'string') {
+		// Support comma-separated values
+		val = val.split(',')
+			.map(function (v) { return v.trim() })
+	}
+
+	return proxyaddr.compile(val || []);
+}
+
+
+/**
+ * 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);
+};
+
+
+/**
+ * Parse an extended query string with qs.
+ *
+ * @return {Object}
+ * @private
+ */
+function parseExtendedQueryString(str) {
+	return qs.parse(str, {
+		allowPrototypes: true
+	});
+}
+
+
+/**
+ * Return new empty object.
+ *
+ * @return {Object}
+ *
+ * @api private
+ */
+function newObject() {
+	return {};
+}
+

package/lib/application/index.js

@@ -0,0 +1,292 @@
+/*!
+ * /nodester
+ * MIT Licensed
+ */
+
+'use strict';
+
+const Emitter = require('events');
+const MiddlewareStack = require('./MiddlewareStack');
+// Server:
+const http = require('http');
+const request = require('./http/request');
+const response = require('./http/response');
+// Utils:
+const { typeOf } = require('../utils/types.util');
+const { merge } = require('../utils/objects.util');
+const consl = require('../logger/console');
+const debug = require('debug')('nodester:application');
+
+
+module.exports = class Application extends Emitter {
+	
+	/**
+	 * Initialize a new `Application`.
+	 *
+	 * @api public
+	 */
+	constructor(opts={}) {
+		super();
+
+		// Fallback port.
+		this.port = opts?.port ?? 8080;
+
+		// Reference to middlewares stack.
+		this._middlewares = new MiddlewareStack();
+
+		// Reference to the database connection.
+		this.database = null;
+
+		// Reference to the http(s) server,
+		this.server = null;
+
+		this._hooks = {
+			beforeStart: ()=>{}
+		};
+
+		// Indicatorors.
+		this.isListening = false;
+	}
+
+	/*
+	 * Expose the prototype that will get set on requests.
+	 *
+	 * @api public
+	 */
+	get request() {
+		return Object.create(request, {
+			app: { configurable: true, enumerable: true, writable: true, value: app }
+		})
+	}
+
+
+	/*
+	 * Expose the prototype that will get set on responses.
+	 *
+	 * @api public
+	 */
+	get response() {
+		return Object.create(response, {
+			app: { configurable: true, enumerable: true, writable: true, value: app }
+		})
+	}
+
+
+	/*
+	 * Sets (or overrides):
+	 * - (database) main database of the application and tries to make connection
+	 * - (router) default Router
+	 *
+	 * @api public
+	 */
+	get set() {
+		return {
+			database: this.setDatabase.bind(this),
+			router: this.setRouter.bind(this)
+		}
+	}
+
+
+	/**
+	 * Sets (or overrides) main database of the application and tries to make connection.
+	 * @param {Sequilize} sequilizeConnection
+	 * @param {Boolean} crashOnError
+	 * @return {sequilizeConnection.authenticate}
+	 *
+	 * @public
+	 */
+	setDatabase(sequilizeConnection, crashOnError=true) {
+		try {
+			if (!sequilizeConnection) {
+				const err = new Error('Connection to database (Sequilize) can not be null or undefined.');
+				throw err;
+			}
+
+			const result = sequilizeConnection.authenticate();
+			this.database = sequilizeConnection;
+
+			return result;
+		}
+		catch(error) {
+			if (crashOnError === true) {
+				throw error;
+			}
+			else {
+				consl.error(error);
+			}
+		}
+	}
+
+
+	/**
+	 * Overrides default Router.
+	 *
+	 * @public
+	 */
+	setRouter(newRouter) {
+		this.router = newRouter.init(this);
+	}
+
+
+	/*
+	 * Adds:
+	 * - (middleware) new middleware to the stack;
+	 *
+	 * @api public
+	 */
+	get add() {
+		return {
+			middleware: this.addMiddleware.bind(this)
+		}
+	}
+
+
+	/*
+	 * Adds new middleware to the stack.
+	 *
+	 * @api public
+	 */
+	addMiddleware(fn) {
+		if (this._middlewares.isLocked === true) {
+			const err = new Error(`Can't add more middlewares after application has been started.`);
+			throw err;
+		}
+
+		this._middlewares.add(fn);
+	}
+
+
+	/*
+	 * Proxy to .add().
+	 *
+	 * @param {Function} fn
+	 *
+	 * @api public
+	 */
+	use(fn) {
+		return this.add(fn);
+	}
+
+
+	/**
+	 * Adds to hooks stack (beforeStart).
+	 *
+	 * @api public
+	 */
+	beforeStart(fn) {
+		if (typeOf(fn) !== 'function') {
+			const err = new TypeError('"fn" argument must be a function');
+			throw err;
+		}
+		this._hooks.beforeStart = fn;
+
+		return this._hooks.beforeStart;
+	}
+
+
+	/**
+	 * Return a request handler callback
+	 * for node's native http server.
+	 *
+	 * @return {Function}
+	 *
+	 * @api public
+	 */
+	start() {
+		try {
+			this._hooks.beforeStart.call(this);
+		}
+		catch(error) {
+			console.error('Application did not start due to error.');
+			consl.error(error);
+			return;
+		}
+
+		// Lock middlewares stack.
+		this._middlewares.lock();
+
+		return this.handle.bind(this);
+	}
+
+
+	/**
+	 * Shorthand for:
+	 *
+	 *    http.createServer(app.start()).listen(...)
+	 *
+	 * @param {Int} port
+	 * @param {Mixed} ...
+	 * @return {import('http').Server}
+	 *
+	 * @api public
+	 */
+	listen(port, ...args) {
+		// Remember port:
+		const _port = port ?? this.port;
+		this.port = _port;
+
+		debug(`listen on port ${ this.port }`);
+
+		if (!this.server) {
+			this.server = http.createServer(this.start());
+		}
+
+		this.isListening = true;
+		return this.server.listen(_port, ...args);
+	}
+
+
+	/**
+	 * Handles server request.
+	 *
+	 * @api public
+	 */
+	handle(req, res) {
+		// Req & res with mixins:
+		merge(req, this.request);
+		merge(res, this.response);
+
+		// Exchange references:
+		req.res = res;
+		res.req = req;
+
+		return this._middlewares.process(req, res)
+	}
+
+
+	/**
+	 * Extends Application & makes sure, that "key" param is not present already.
+	 * @param {String} key
+	 * @param {Any} fnOrProperty
+	 * @return {Any} fnOrProperty in Application
+	 *
+	 * @api public
+	 */
+	extend(key='', fnOrProperty) {
+		const keys = Object.keys(this);
+		if (keys.indexOf(key) > -1) {
+			const err = new TypeError(`Key ${ key } is already present in Application instance`);
+			throw err;
+		}
+
+		this[key] = fnOrProperty;
+
+		return this[key];
+	}
+
+
+	/**
+	 * Stops server
+	 *
+	 * @api public
+	 */
+	stop() {
+		if (this.isListening !== true) {
+			console.warn('Nothing to stop. Server is not listening.');
+			return;
+		}
+
+		this.server.close();
+		this.isListening = false;
+	}
+}

package/lib/constants/ConstantsEnum.js

@@ -0,0 +1,13 @@
+
+module.exports = function ConstantsEnum(constantsList = {}) {
+	// Set list.
+	this.list = constantsList;
+
+	// Set getters.
+	Object.keys(constantsList).forEach(key => {
+		this[key] = constantsList[key];
+	});
+
+	// Set constants in static array.
+	this.asArray = Object.values(constantsList);
+}

package/lib/constants/ResponseFormats.js

@@ -0,0 +1,7 @@
+const ConstantsEnum = require('nodester/constants/ConstantsEnum');
+
+
+module.exports = new ConstantsEnum({
+	JSON: 'JSON',
+	XML: 'XML',
+});