nodester 0.0.1 → 0.0.6

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.orderBy = opts.orderBy ?? '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,
+			orderBy: this.orderBy,
+			
+			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;