nodester 0.6.4 → 0.6.6

package/lib/constants/Operators.js

@@ -0,0 +1,23 @@
+const Enum = require('nodester/enum');
+
+
+module.exports = new Enum({
+	and: Symbol.for('and'),
+	between: Symbol.for('between'),
+	contains: Symbol.for('contains'),
+	eq: Symbol.for('eq'),
+	ne: Symbol.for('ne'),
+	gte: Symbol.for('gte'),
+	gt: Symbol.for('gt'),
+	lte: Symbol.for('lte'),
+	lt: Symbol.for('lt'),
+	not: Symbol.for('not'),
+	is: Symbol.for('is'),
+	in: Symbol.for('in'),
+	notIn: Symbol.for('notIn'),
+	like: Symbol.for('like'),
+	notLike: Symbol.for('notLike'),
+	notBetween: Symbol.for('notBetween'),
+	or: Symbol.for('or'),
+	xor: Symbol.for('xor'),
+});

package/lib/middlewares/404/index.js

@@ -0,0 +1,38 @@
+/**
+ * nodester
+ * MIT Licensed
+ */
+ 
+'use strict';
+
+const {
+	HTTP_CODE_NOT_FOUND
+} = require('nodester/http/codes');
+
+const { createErrorResponse } = require('nodester/factories/responses/rest');
+
+
+/**
+ * Initialize `404` middleware.
+ *
+ * @param {Object}  [options]
+ *
+ * @return {Function}
+ *
+ * @access public
+ */
+module.exports = function init404Middleware(options={}) {
+	const context = {
+		options
+	}
+	return handle.bind(context);
+}
+
+function handle(req, res, next) {
+	const err = new Error('Route not found');
+	
+	return createErrorResponse(res, {
+		error: err,
+		status: HTTP_CODE_NOT_FOUND
+	});
+}

package/lib/middlewares/etag/index.js

@@ -0,0 +1,81 @@
+/**
+ * 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);
+
+
+module.exports = initETagMiddleware;
+
+/**
+ * Initialize `etag` middleware.
+ *
+ * @param {Object}  [options]
+ * @param {boolean} options.weak
+ *
+ * @return {Function}
+ *
+ * @access public
+ */
+function initETagMiddleware(options) {
+	const context = {
+		options
+	}
+	return handle.bind(context);
+}
+
+/**
+ * Add ETag header field.
+ */
+function handle(req, res, next) {
+	// console.log('e', req.headers);
+	return next();
+}
+
+async function _getResponseEntity(res) {
+	// If body is not defined:
+	const { body } = res;
+	if (!body || res.get('etag'))
+		return;
+
+	// Status code.
+	const status = res.statusCode / 100 | 0;
+
+	console.log('getResponseEntity', status, { tag: res.get('etag') });
+
+	// 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) {
+	console.log('setEtag', typeof res, entity);
+
+	if (!entity)
+		return;
+
+	res.etag = calculate(entity, options);
+}

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
+ * @access 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/mixins.js

@@ -212,10 +212,8 @@ async function _updateOne(
 
 		// Will contain data from parent instance and associations.
 		const fullInstanceData = instance.toJSON();
+		const parentData = { ...data };
 
-		const parentData = {
-			...data
-		}
 		for (let includeConfig of include) {
 			const { association } = includeConfig;
 
@@ -223,6 +221,7 @@ async function _updateOne(
 				continue;
 			}
 
+			// Remove association from parentData (handled separately)
 			delete parentData[association];
 
 			const associationDefinition = this.associations[association];
@@ -246,6 +245,15 @@ async function _updateOne(
 			// If association type is HasMany or HasOne (We don't work with any other):
 			switch(associationType) {
 				case 'HasMany': {
+					// Handle empty array (remove all old associations):
+					if (Array.isArray(includeData) && includeData.length === 0) {
+						const where = {
+							[foreignKey]: instance.id 
+						}
+						await associatedModel.destroy({ where });
+						fullInstanceData[association] = [];
+					}
+
 					const promises = includeData.map(singleData => {
 						// Note: for now we are only able to work with a model with single PrimaryKey:
 						const where = {
@@ -263,16 +271,25 @@ async function _updateOne(
 				}
 
 				case 'HasOne': {
-					// Note: for now we are only able to work with a model with single PrimaryKey:
-					const where = {
-						[pkField]: includeData[pkField]
+					// Handle null case (remove old association)
+					if (includeData === null) {
+						const where = {
+							[foreignKey]: instance.id
+						}
+						await associatedModel.destroy({ where });
+						fullInstanceData[association] = null;
+					}
+					else {
+						// Note: for now we are only able to work with a model with single PrimaryKey:
+						const where = {
+							[pkField]: includeData[pkField]
+						}
+						fullInstanceData[association] = await associatedModel.updateOne(
+																							where,
+																							includeData,
+																							associationUpdateOpts
+																						);
 					}
-					fullInstanceData[association] = await associatedModel.updateOne(
-																						where,
-																						includeData,
-																						associationUpdateOpts
-																					);
-
 					continue;
 				}
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodester",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "description": "A versatile REST framework for Node.js",
   "directories": {
     "docs": "docs",
@@ -89,8 +89,8 @@
     "http-errors": "^2.0.0",
     "inflection": "^2.0.1",
     "mime": "^3.0.0",
-    "mysql2": "^3.6.0",
-    "pg": "^8.11.3",
+    "mysql2": "^3.14.4",
+    "pg": "^8.16.3",
     "pg-hstore": "^2.3.4",
     "qs": "^6.11.0",
     "sequelize": "^6.6.5"

package/tests/ast.js

@@ -0,0 +1,18 @@
+const { ModelsTree } = require('../lib/middlewares/ql/sequelize/interpreter/ModelsTree');
+const { AST_ModelsTree } = require('../lib/tools/nql.tool');
+
+const tree = new ModelsTree();
+tree.node.addWhere({ id: ['1000'] });
+tree.include('comments').use('comments');
+tree.node.order = 'desc';
+tree.up();
+tree.include('users');
+tree.include('likes') && tree.use('likes');
+tree.node.order = 'rand';
+tree.up();
+tree.include('reposts');
+
+console.debug(
+	AST_ModelsTree(tree)
+);
+