nodester 0.0.1 → 0.0.2

package/lib/factories/responses/rest.js

@@ -0,0 +1,110 @@
+/*
+ * Rest response factory.
+ */
+
+const ResponseFormats = require('../../constants/ResponseFormats');
+
+
+module.exports = {
+	createGenericResponse: _createGenericResponse,
+	createOKResponse: _createOKResponse,
+	createErrorResponse: _createErrorResponse,
+}
+
+
+/*
+ * Format for all API responses will be JSON
+ * {
+ * 	content: {...}
+ * 	error: {...}
+ * }
+ * Status code is sent in header.
+ * 	
+ * If error is not present, error should be null.
+ * If error is present, content can be null (But it's not required).
+ *
+ * @param {ServerResponse} res
+ * @param {Object} options
+ *
+ * @alias createGenericResponse
+ * @api public
+*/
+function _createGenericResponse(
+	res,
+	options = {
+		status: 200,
+		content: {},
+		error: null,
+		format: ResponseFormats.JSON
+	}
+) {
+	try {
+		const data = {
+			content: options?.content ?? null,
+			error: options?.error ?? null
+		};
+
+		switch(options?.format) {
+			case ResponseFormats.JSON:
+				return options?.res.status(options?.status).json(data);
+			case ResponseFormats.XML:
+				// TODO: format data into XML.
+				return options?.res.status(options?.status).send(data);
+				break;
+			default: {
+				const err = new TypeError("No format specified.");
+				throw err;
+			}
+		}
+	}
+	catch(error) {
+		const err = new Error(`Could not create generic response: ${error.message}`);
+		err.name = error?.name;
+		err.code = error?.code;
+		throw err;
+	}
+}
+
+
+/**
+ * Sends response with status code 200.
+ * Should be called on all successful respones.
+ *
+ * @param {ServerResponse} res
+ * @param <Object> content
+ * @param <String> format
+ *
+ * @alias createOKResponse
+ * @api public
+ */
+function _createOKResponse(res, options={}) {
+
+	return this.createGenericResponse(res, { 
+		...options,
+		status: 200,
+		format: options?.format ?? ResponseFormats.JSON
+	});
+}
+
+
+/**
+ * Sends response with provided error code.
+ * Should be called on all failed respones.
+ *
+ * @param {ServerResponse} res
+ * @param <Object> error
+ * @param <Object> content (optional)
+ * @param <Int>		 status
+ * @param <String> format
+ *
+ * @alias createErrorResponse
+ * @api public
+ */
+function _createErrorResponse(res, options) {
+
+	return this.createGenericResponse(res, {
+		...options,
+		status: options?.status ?? 500,
+		format: options?.format ?? ResponseFormats.JSON
+	});
+}

package/lib/http/codes/index.js

@@ -0,0 +1,157 @@
+const symbolsByTag = {
+	// Informational:
+	CONTINUE: Symbol('100: Continue'),
+	SWITCHING_PROTOCOLS: Symbol('101: Switching Protocols'),
+	PROCESSING: Symbol('102: Processing'),
+	EARLY_HINTS: Symbol('103: Early Hints'),
+
+	// Success:
+	OK: Symbol('200: OK'),
+	CREATED: Symbol('201: Created'),
+	ACCEPTED: Symbol('202: Accepted'),
+	NON_AUTHORITATIVE_INFORMATION: Symbol('203: Non-Authoritative Information'),
+	NO_CONTENT: Symbol('204: No Content'),
+	RESET_CONTENT: Symbol('205: Reset Content'),
+	PARTIAL_CONTENT: Symbol('206: Partial Content'),
+	MULTI_STATUS: Symbol('207: Multi-Status'),
+	ALREADY_REPORTED: Symbol('208: Already Reported'),
+	IM_USED: Symbol('226: IM Used'),
+
+	// Redirections:
+	MULTIPLE_CHOICES: Symbol('300: Multiple Choices'),
+	MOVED_PERMANENTLY: Symbol('301: Moved Permanently'),
+	FOUND: Symbol('302: Found'),
+	SEE_OTHER: Symbol('303: See Other'),
+	NOT_MODIFIED: Symbol('304: Not Modified'),
+	USE_PROXY: Symbol('305: Use Proxy'),
+	TEMPORARY_REDIRECT: Symbol('307: Temporary Redirect'),
+	PERMANENT_REDIRECT: Symbol('308: Permanent Redirect'),
+
+	// Client Errors:
+	BAD_REQUEST: Symbol('400: Bad Request'),
+	UNAUTHORIZED: Symbol('401: Unauthorized'),
+	PAYMENT_REQUIRED: Symbol('402: Payment Required'),
+	FORBIDDEN: Symbol('403: Forbidden'),
+	NOT_FOUND: Symbol('404: Not Found'),
+	METHOD_NOT_ALLOWED: Symbol('405: Method Not Allowed'),
+	NOT_ACCEPTABLE: Symbol('406: Not Acceptable'),
+	PROXY_AUTHENTICATION_REQUIRED: Symbol('407: Proxy Authentication Required'),
+	REQUEST_TIMEOUT: Symbol('408: Request Timeout'),
+	CONFLICT: Symbol('409: Conflict'),
+	GONE: Symbol('410: Gone'),
+	LENGTH_REQUIRED: Symbol('411: Length Required'),
+	PRECONDITION_FAILED: Symbol('412: Precondition Failed'),
+	PAYLOAD_TOO_LARGE: Symbol('413: Payload Too Large'),
+	URI_TOO_LONG: Symbol('414: URI Too Long'),
+	UNSUPPORTED_MEDIA_TYPE: Symbol('415: Unsupported Media Type'),
+	RANGE_NOT_SATISFIABLE: Symbol('416: Range Not Satisfiable'),
+	EXPECTATION_FAILED: Symbol('417: Expectation Failed'),
+	IM_A_TEAPOT: Symbol("418: I'm a teapot"),
+	MISDIRECTED_REQUEST: Symbol('421: Misdirected Request'),
+	UNPROCESSABLE_ENTITY: Symbol('422: Unprocessable Entity'),
+	LOCKED: Symbol('423: Locked'),
+	FAILED_DEPENDENCY: Symbol('424: Failed Dependency'),
+	TOO_EARLY: Symbol('425: Too Early'),
+	UPGRADE_REQUIRED: Symbol('426: Upgrade Required'),
+	PRECONDITION_REQUIRED: Symbol('428: Precondition Required'),
+	TOO_MANY_REQUESTS: Symbol('429: Too Many Requests'),
+	REQUEST_HEADER_FIELDS_TOO_LARGE: Symbol('431: Request Header Fields Too Large'),
+	UNAVAILABLE_FOR_LEGAL_REASONS: Symbol('451: Unavailable For Legal Reasons'),
+
+	// Server Errors:
+	INTERNAL_SERVER_ERROR: Symbol('500: Internal Server Error'),
+	NOT_IMPLEMENTED: Symbol('501: Not Implemented'),
+	BAD_GATEWAY: Symbol('502: Bad Gateway'),
+	SERVICE_UNAVAILABLE: Symbol('503: Service Unavailable'),
+	GATEWAY_TIMEOUT: Symbol('504: Gateway Timeout'),
+	HTTP_VERSION_NOT_SUPPORTED: Symbol('505: HTTP Version Not Supported'),
+	VARIANT_ALSO_NEGOTIATES: Symbol('506: Variant Also Negotiates'),
+	INSUFFICIENT_STORAGE: Symbol('507: Insufficient Storage'),
+	LOOP_DETECTED: Symbol('508: Loop Detected'),
+	NOT_EXTENDED: Symbol('510: Not Extended'),
+	NETWORK_AUTHENTICATION_REQUIRED: Symbol('511: Network Authentication Required')
+}
+
+const descriptionsByCode = {
+	// Informational:
+	100: 'Continue',
+	101: 'Switching Protocols',
+	102: 'Processing',
+	103: 'Early Hints',
+
+	// Success:
+	200: 'OK',
+	201: 'Created',
+	202: 'Accepted',
+	203: 'Non-Authoritative Information',
+	204: 'No Content',
+	205: 'Reset Content',
+	206: 'Partial Content',
+	207: 'Multi-Status',
+	208: 'Already Reported',
+	226: 'IM Used',
+
+	// Redirections:
+	300: 'Multiple Choices',
+	301: 'Moved Permanently',
+	302: 'Found',
+	303: 'See Other',
+	304: 'Not Modified',
+	305: 'Use Proxy',
+	307: 'Temporary Redirect',
+	308: 'Permanent Redirect',
+
+	// Client Errors:
+	400: 'Bad Request',
+	401: 'Unauthorized',
+	402: 'Payment Required',
+	403: 'Forbidden',
+	404: 'Not Found',
+	405: 'Method Not Allowed',
+	406: 'Not Acceptable',
+	407: 'Proxy Authentication Required',
+	408: 'Request Timeout',
+	409: 'Conflict',
+	410: 'Gone',
+	411: 'Length Required',
+	412: 'Precondition Failed',
+	413: 'Payload Too Large',
+	414: 'URI Too Long',
+	415: 'Unsupported Media Type',
+	416: 'Range Not Satisfiable',
+	417: 'Expectation Failed',
+	418: 'I\'m a teapot',
+	421: 'Misdirected Request',
+	422: 'Unprocessable Entity',
+	423: 'Locked',
+	424: 'Failed Dependency',
+	425: 'Too Early',
+	426: 'Upgrade Required',
+	428: 'Precondition Required',
+	429: 'Too Many Requests',
+	431: 'Request Header Fields Too Large',
+	451: 'Unavailable For Legal Reasons',
+
+	// Server Errors:
+	500: 'Internal Server Error',
+	501: 'Not Implemented',
+	502: 'Bad Gateway',
+	503: 'Service Unavailable',
+	504: 'Gateway Timeout',
+	505: 'HTTP Version Not Supported',
+	506: 'Variant Also Negotiates',
+	507: 'Insufficient Storage',
+	508: 'Loop Detected',
+	510: 'Not Extended',
+	511: 'Network Authentication Required'
+};
+
+module.exports = {
+	descriptions: {
+		byCode: descriptionsByCode
+	},
+
+	symbols: {
+		byTag: symbolsByTag
+	}
+}

package/lib/{application/http → http}/request.js

@@ -7,14 +7,14 @@
 const accepts = require('accepts');
 const isIP = require('net').isIP;
 const typeis = require('type-is');
-const http = require('http');
+const { IncomingMessage } = require('http');
 const fresh = require('fresh');
 const parseRange = require('range-parser');
 const parse = require('parseurl');
 const proxyaddr = require('proxy-addr');
 
 
-const req = http.IncomingMessage.prototype;
+const req = IncomingMessage.prototype;
 
 module.exports = req;
 
@@ -355,39 +355,15 @@ defineGetter(req, 'path', function path() {
 
 /**
  * Parse the "Host" header field to a hostname.
- *
- * When the "trust proxy" setting trusts the socket
- * address, the "X-Forwarded-Host" header field will
- * be trusted.
+ * Will return  "X-Forwarded-Host" if set,
+ * or "Host" as a fallback.
  *
  * @return {String}
  * @public
  */
 defineGetter(req, 'hostname', function hostname() {
-	const trust = this.app.get('trust proxy fn');
-	let host = this.get('X-Forwarded-Host');
-
-	if (!host || !trust(this.connection.remoteAddress, 0)) {
-		host = this.get('Host');
-	}
-	else if (host.indexOf(',') !== -1) {
-		// Note: X-Forwarded-Host is normally only ever a
-		//       single value, but this is to be safe.
-		host = host.substring(0, host.indexOf(',')).trimRight()
-	}
-
-	if (!host)
-		return;
-
-	// IPv6 literal support
-	const offset = host[0] === '['
-		? host.indexOf(']') + 1
-		: 0;
-	const index = host.indexOf(':', offset);
-
-	return index !== -1
-		? host.substring(0, index)
-		: host;
+	const host = this.get('X-Forwarded-Host') ?? this.get('Host');
+	return host;
 });
 
 

package/lib/{application/http → http}/response.js

@@ -12,7 +12,7 @@ const contentDisposition = require('content-disposition');
 const createError = require('http-errors')
 const encodeUrl = require('encodeurl');
 const escapeHtml = require('escape-html');
-const http = require('http');
+const { ServerResponse } = require('http');
 const onFinished = require('on-finished');
 const statuses = require('statuses')
 const sign = require('cookie-signature').sign;
@@ -28,10 +28,10 @@ const {
 const path = require('path');
 const extname = path.extname;
 const resolve = path.resolve;
-const { isAbsolute } = require('../../utils/path.util');
+const { isAbsolute } = require('../utils/path.util');
 
 
-const res = http.ServerResponse.prototype;
+const res = ServerResponse.prototype;
 module.exports = res;
 
 /**
@@ -135,53 +135,26 @@ res.send = function send(body) {
 		}
 	}
 
-	// determine if ETag should be generated
-	const etagFn = app.get('etag fn')
-	const generateETag = !this.get('ETag') && typeof etagFn === 'function'
-
-	// populate Content-Length
-	let bufferLength = undefined;
-	if (chunk !== undefined) {
-		if (Buffer.isBuffer(chunk)) {
-			// Get length of the Buffer.
-			bufferLength = chunk.length
-		}
-		else if (!generateETag && chunk.length < 1000) {
-			// Just calculate length when no ETag + small chunk.
-			bufferLength = Buffer.byteLength(chunk, encoding)
-		}
-		else {
-			// Convert chunk to Buffer and calculate:
-			chunk = Buffer.from(chunk, encoding)
-			encoding = undefined;
-			bufferLength = chunk.length
-		}
-
-		this.set('Content-Length', bufferLength);
-	}
-
-	// Populate ETag
-	let etag = undefined;
-	if (generateETag && bufferLength !== undefined) {
-		if ((etag = etagFn(chunk, encoding))) {
-			this.set('ETag', etag);
-		}
-	}
-
 	// freshness:
-	if (req.fresh) {
-		this.statusCode = 304;
-	}
-
-	// strip irrelevant headers
-	if (204 === this.statusCode || 304 === this.statusCode) {
+	// if (req.fresh) {
+	// 	this.statusCode = 304;
+	// }
+
+	// Strip irrelevant headers for:
+	// - 204 (No Content)
+	// - 303 (Not Modified)
+	if (
+		this.statusCode === 204
+		||
+		this.statusCode === 304
+	) {
 		this.removeHeader('Content-Type');
 		this.removeHeader('Content-Length');
 		this.removeHeader('Transfer-Encoding');
 		chunk = '';
 	}
 
-	// alter headers for 205
+	// Alter headers for 205 (Reset Content):
 	if (this.statusCode === 205) {
 		this.set('Content-Length', '0')
 		this.removeHeader('Transfer-Encoding')
@@ -189,11 +162,11 @@ res.send = function send(body) {
 	}
 
 	if (req.method === 'HEAD') {
-		// skip body for HEAD
+		// skip body for HEAD.
 		this.end();
 	}
 	else {
-		// respond
+		// Respond.
 		this.end(chunk, encoding);
 	}
 
@@ -214,19 +187,13 @@ res.send = function send(body) {
  * @public
  */
 res.json = function json(obj) {
-	const app = this.app;
-
-	// Settings:
-	const escape = app.get('json escape')
-	const replacer = app.get('json replacer');
-	const spaces = app.get('json spaces');
-	const body = stringify(obj, replacer, spaces, escape)
 
-	// content-type
+	// If content-type not set:
 	if (!this.get('Content-Type')) {
 		this.set('Content-Type', 'application/json');
 	}
 
+	const body = JSON.stringify(obj);
 	return this.send(body);
 };
 

package/lib/middlewares/etag/index.js

@@ -0,0 +1,62 @@
+'use strict'
+
+const calculate = require('etag');
+const Stream = require('stream');
+const promisify = require('util').promisify;
+const fs = require('fs');
+
+const getFileStats = promisify(fs.stat);
+
+/**
+ * Expose `etag` middleware.
+ *
+ * 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);
+	}
+}
+
+
+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;
+
+	// 2xx
+	if (status !== 2)
+		return;
+
+	if (body instanceof Stream) {
+		if (!body.path)
+			return;
+
+		const stats = await getFileStats(body.path);
+		return stats;
+	}
+	else if ((typeof body === 'string') || Buffer.isBuffer(body)) {
+		return body;
+	}
+	else {
+		return JSON.stringify(body);
+	}
+}
+
+
+function setEtag (res, entity, options) {
+	if (!entity)
+		return;
+
+	res.etag = calculate(entity, options);
+}

package/lib/middlewares/ql/sequelize/index.js

@@ -0,0 +1,34 @@
+const QueryLexer = require('./interpreter/QueryLexer');
+
+
+module.exports = NodesterQL;
+
+async function NodesterQL(req, res, next) {
+	// Object, which will be populated with parsed query.
+	req.nquery = {};
+
+	// Unwrap neccessary params.
+	const {
+		url
+	} = req;
+
+	// If no query, skip:
+	if (url.indexOf('?') === -1) {
+		return next();
+	}
+
+	try {
+		// Convert to URLSearchParams.
+		const queryString = req.url.split('?')[1];
+
+		const lexer = new QueryLexer(queryString);
+
+		// Go on!
+		req.nquery = lexer.query;
+		next();
+	}
+	catch(error) {
+		res.status(422);
+		res.json({ error: error.toString() });
+	}
+}

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

@@ -0,0 +1,121 @@
+const debug = require('debug')('nodester:interpreter:ModelsTree');
+
+
+class ModelsTreeNode {
+	constructor(model, parent=null, opts={}) {
+		this.model = model;
+		this.parent = parent;
+		this.activeParam = null;
+		this.op = null;
+
+		// for override:
+		this.fields = [];
+		this._where = {};
+		this.skip = 0;
+		this.limit = -1; // No limit
+
+		this.includes = opts.includes ?? [];
+		this.order = opts.order ?? 'asc';
+		this.order_by = opts.order_by ?? 'id';
+	}
+
+	get hasParent() {
+		return this.parent !== null;
+	}
+
+	get includesCount() {
+		return Object.values(this.includes).length;
+	}
+
+	get hasIncludes() {
+		return this.includesCount > 0;
+	}
+
+	get where() {
+		return this._where;
+	}
+
+	resetActiveParam() {
+		this.activeParam = null;
+	}
+
+	resetOP() {
+		this.op = null;
+	}
+
+	addWhere(condition={}) {
+		this._where = {
+			...this.where,
+			...condition
+		}
+	}
+
+	include(modelTreeNode) {
+		modelTreeNode.parent = this;
+		this.includes.push(modelTreeNode);
+		return modelTreeNode;
+	}
+
+	toObject() {
+		return {
+			model: this.model,
+
+			where: this.where,
+			skip: this.skip,
+			limit: this.limit,
+			order: this.order,
+			order_by: this.order_by,
+			
+			fields: this.fields,
+
+			includes: this.includes.map(i => i.toObject())
+		}
+	}
+}
+
+class ModelsTree {
+	constructor() {
+		this.root = new ModelsTreeNode('root', null);
+		this.node = this.root;
+	}
+
+	include(model, opts={}) {
+		debug('include', model);
+
+		const node = new ModelsTreeNode(model, this.node, opts);
+		this.node.include(node);
+		return this;
+	}
+
+	use(model) {
+		let foundOne = null;
+		// Dirty search:
+		for (const include of this.node.includes) {
+			if (include.model === model) {
+				foundOne = this.node = include;
+				break;
+			}
+		}
+
+		debug('use', model, !!foundOne ? '' : '-> failed.');
+		
+		return foundOne;
+	}
+
+	up() {
+		if (this.node.hasParent) {
+			this.node = this.node.parent;
+		}
+
+		debug('go up to', this.node.model);
+	}
+
+	upToRoot() {
+		this.node = this.root;
+
+		debug('go up to root');
+	}
+}
+
+exports.ModelsTreeNode = ModelsTreeNode;
+exports.ModelsTree = ModelsTree;