alchemymvc 1.3.0 → 1.3.2

package/lib/app/helper_validator/00_validator.js

@@ -60,13 +60,13 @@ Validator.setMethod(function toDry() {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    1.1.0
- * @version  1.1.0
+ * @version  1.3.1
  *
  * @param    {FieldValue}   fv   The FieldValue instance
  *
  * @return   {String}
  */
-Validator.setMethod(function getInvalidFieldMessage(fv) {
+Validator.setTypedMethod([Types.Alchemy.FieldValue], function getInvalidFieldMessage(fv) {
 
 	let field = fv.field,
 	    value = fv.value;
@@ -105,20 +105,52 @@ Validator.setMethod(function createFieldViolation(fv) {
 	return result;
 });
 
+/**
+ * Validate a value
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.1
+ * @version  1.3.1
+ *
+ * @param    {Field}   field
+ * @param    {*}       value
+ *
+ * @return   {Promise<Violation|undefined>}
+ */
+Validator.setTypedMethod([Types.Alchemy.Field, Types.Any], function validateFieldValue(field, value) {
+	return this.validateFieldValue(field, field.path, value);
+});
+
+/**
+ * Validate a value
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.1
+ * @version  1.3.1
+ *
+ * @param    {Field}   field
+ * @param    {String}  path
+ * @param    {*}       value
+ *
+ * @return   {Promise<Violation|undefined>}
+ */
+Validator.setTypedMethod([Types.Alchemy.Field, Types.String, Types.Any], function validateFieldValue(field, path, value) {
+	let fv = new Classes.Alchemy.FieldValue(field, path, value);
+	return this.validateFieldValue(fv);
+});
+
 /**
  * Validate a value
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    1.1.0
- * @version  1.1.4
+ * @version  1.3.1
  *
  * @param    {FieldValue[]}   field_values   The FieldValue instance(s)
  *
  * @return   {Promise<Violation|undefined>}
  */
-Validator.setMethod(async function validateFieldValue(field_values) {
-
-	field_values = Array.cast(field_values);
+Validator.setTypedMethod([Types.Alchemy.FieldValue.array()], async function validateFieldValue(field_values) {
 
 	let violation,
 	    passes,

package/lib/app/helper_validator/not_empty_validator.js

@@ -10,9 +10,7 @@
  *
  * @param    {Object}   options
  */
-var NotEmpty = Function.inherits('Alchemy.Validator', function NotEmpty(options) {
-	NotEmpty.super.call(this, options);
-});
+const NotEmpty = Function.inherits('Alchemy.Validator', 'NotEmpty');
 
 /**
  * The message to use inside errors

package/lib/app/routes.js

@@ -1,3 +1,9 @@
 Router.add(['get', 'post'], 'APIResource', '/api/{action}', 'Api#{action}');
 Router.get('AlchemyInfo', '/alchemy-info', 'AlchemyInfo#info');
-Router.get('Postponed', '/alchemy/postponed/{id}', 'AlchemyInfo#postponed');
+
+Router.POSTPONED_ROUTE = Router.add({
+	name             : 'AlchemyInfo#postponed',
+	paths            : '/alchemy/postponed/{id}',
+	methods          : ['get'],
+	can_be_postponed : false,
+});

package/lib/class/conduit.js

@@ -1231,19 +1231,67 @@ Conduit.setMethod(function callHandler() {
 	this.route.callHandler(this);
 });
 
+/**
+ * Put this request in a queue
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.1
+ * @version  1.3.1
+ *
+ * @param    {Object}   options   Options or url
+ */
+Conduit.setMethod(function postponeAndQueue(options) {
+
+	if (!options) {
+		options = {};
+	}
+
+	const postponement = this.postponeRequest({
+		put_in_queue : true,
+	});
+
+	return postponement;
+});
+
+/**
+ * Postpone the response and the request
+ *
+ * This does not stop the current request from processing.
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.1
+ * @version  1.3.1
+ *
+ * @param    {Number|Object}   options   Options or time to wait
+ *
+ * @return   {Alchemy.Conduit.Postponement}
+ */
+Conduit.setMethod(function postponeRequest(options) {
+
+	let postponement = this.postponeResponse(options);
+
+	this.afterOnce('get-postponed-response', () => {
+		this.callMiddleware();
+	});
+
+	return postponement;
+});
+
 /**
  * End the current request with a 202 status
- * and tell the client to look at another url later
+ * and tell the client to look at another url later.
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * This does not stop the current request from processing.
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    1.1.0
- * @version  1.2.5
+ * @version  1.3.1
  *
- * @param    {String|Object}   options   Options or url
+ * @param    {Number|Object}   options   Options or time to wait
+ *
+ * @return   {Alchemy.Conduit.Postponement}
  */
-Conduit.setMethod(function postpone(options) {
-
-	let session = this.getSession();
+Conduit.setMethod(function postponeResponse(options) {
 
 	if (typeof options == 'number') {
 		options = {
@@ -1253,36 +1301,55 @@ Conduit.setMethod(function postpone(options) {
 		options = {};
 	}
 
-	// Make sure the scene id exists
-	this.createScene();
+	return this._postpone(options);
+});
 
-	// Already set the cookies
-	if (this.new_cookie_header.length) {
-		this.response.setHeader('set-cookie', this.new_cookie_header);
-	}
+/**
+ * Handle the postponement
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.1
+ * @version  1.3.1
+ *
+ * @param    {Object}   options
+ *
+ * @return   {Alchemy.Conduit.Postponement}
+ */
+Conduit.setMethod(function _postpone(options) {
 
-	let postponed_id = session.postpone(this),
-	    url = '/alchemy/postponed/' + postponed_id;
+	let session = this.getSession();
 
-	// Set the location header where the client should look at later
-	this.response.setHeader('Location', url);
-	this.response.setHeader('Content-Type', 'text/html');
+	let postponement = session.getExistingPostponement(this);
 
-	if (options.expected_duration) {
-		this.response.setHeader('Expected-Duration', Number(options.expected_duration / 1000).toFixed(2));
+	if (postponement) {
+		return postponement.showPostponementMessage(this);
 	}
 
-	// Write the headers & 202 status
-	this.response.writeHead(202);
+	let response = this.response;
 
-	// End the response
-	this.response.end('The response has been postponed, you can find it at <a href="' + url + '">' + url + '</a>');
+	this.postponed_response = response;
+
+	// Make sure the scene id exists
+	this.createScene();
+
+	postponement = session.postpone(this, options);
+
+	if (options.put_in_queue) {
+		postponement.putInQueue();
+	}
+
+	if (options.show_postponement_message !== false) {
+		postponement.showPostponementMessage();
+	}
 
 	// Nullify the response
 	this.response = null;
 
 	// Set the original url
-	this.overrideResponseUrl(this.url)
+	this.overrideResponseUrl(this.url);
+
+	// Return the postponement
+	return postponement;
 });
 
 /**
@@ -1436,15 +1503,17 @@ Conduit.setMethod(function redirect(status, options) {
 /**
  * Respond with an error
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.3.1
  *
  * @param    {Nulber}  status       Response statuscode
  * @param    {Error}   message      Optional error to send
- * @param    {Boolean} printError   Print the error, defaults to true
+ * @param    {Boolean} print_error  Print the error, defaults to true
  */
-Conduit.setMethod(function error(status, message, printError) {
+Conduit.setMethod(function error(status, message, print_error) {
+
+	let print_dev = false;
 
 	if (status instanceof Classes.Alchemy.Error.HTTP) {
 		message = status;
@@ -1466,14 +1535,33 @@ Conduit.setMethod(function error(status, message, printError) {
 		message = error;
 	}
 
-	let subject = 'Error found on ' + this.original_path + '';
+	let is_400 = (status >= 400 && status <= 500);
 
-	if (printError === false) {
-		log.error(subject + ':\n' + message);
-	} else if (message instanceof Error) {
-		alchemy.printLog('error', [subject, String(message), message], {err: message, level: -2});
-	} else {
-		log.error(subject + ':\n' + message);
+	if (alchemy.settings.environment == 'dev') {
+		print_dev = true;
+	}
+
+	if (print_error == null) {
+		if (is_400) {
+			print_error = false;
+		} else {
+			print_error = true;
+		}
+	}
+
+	if (print_dev) {
+		let subject = 'Error found on ' + this.original_path + '';
+		log.error(subject + ':\n' + message, this);
+	} else if (print_error) {
+		let subject = 'Error found on ' + this.original_path + '';
+
+		if (is_400) {
+			log.error(subject + ':\n' + message);
+		} else if (message instanceof Error) {
+			alchemy.printLog('error', [subject, String(message), message], {err: message, level: -2});
+		} else {
+			log.error(subject + ':\n' + message);
+		}
 	}
 
 	// Make sure the client doesn't expect compression
@@ -1497,7 +1585,12 @@ Conduit.setMethod(function error(status, message, printError) {
 		} else {
 			this.set('status', status);
 			this.set('message', message);
-			this.render(['error/' + status, 'error/unknown']);
+
+			if (alchemy.isTooBusyForRequests()) {
+				this._end(`Error ${status}:\n${message}`);
+			} else {
+				this.render(['error/' + status, 'error/unknown']);
+			}
 		}
 	} else {
 		// Requests for images or scripts just get a non-expensive string response
@@ -1710,9 +1803,9 @@ Conduit.setMethod(function end(message) {
 /**
  * Call the actual end method
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.3.1
  */
 Conduit.setMethod(function _end(message, encoding = 'utf-8') {
 
@@ -1728,6 +1821,8 @@ Conduit.setMethod(function _end(message, encoding = 'utf-8') {
 
 		this._end_arguments = args;
 
+		this.emit('after-postponed-end', args);
+
 		return;
 	}
 
@@ -2120,9 +2215,9 @@ Conduit.setMethod(function _sendStream(stream, options) {
 /**
  * Create a session
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.3.1
  *
  * @param    {Boolean}   create   Create a session if none exist
  *
@@ -2130,16 +2225,16 @@ Conduit.setMethod(function _sendStream(stream, options) {
  */
 Conduit.setMethod(function getSession(allow_create = true) {
 
-	var cookie_name,
-	    fingerprint,
-	    session_id,
-	    session;
-
 	// Only do this once per request
 	if (this.sessionData != null) {
 		return this.sessionData;
 	}
 
+	let cookie_name,
+	    fingerprint,
+	    session_id,
+	    session;
+
 	// Set the name of the cookie (could change in the future)
 	cookie_name = alchemy.settings.session_key || 'alchemy_sid';
 
@@ -2498,6 +2593,72 @@ Conduit.setMethod(function supports(feature) {
 	return null;
 });
 
+/**
+ * Should this request be delayed because the server is too busy?
+ * This performs an early check, the controller might also check this later.
+ * This is mainly so we can prevent Server-Side-Renders from happening
+ * when the system is already overloaded.
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.1
+ * @version  1.3.1
+ *
+ * @return   {Boolean}
+ */
+Conduit.setMethod(function shouldBePostponed() {
+
+	if (!alchemy.settings.postpone_requests_on_overload) {
+		return false;
+	}
+
+	const route = this.route;
+
+	// If no route is found, it can be allowed.
+	// Most of the time this means it's a middleware-request
+	// (like stylesheets, images, scripts, ...)
+	// But also 404s (This can be delayed later by the controller)
+	if (route == null) {
+		return false;
+	}
+
+	// Some routes can't even be postponed
+	if (!route.can_be_postponed) {
+		return false;
+	}
+
+	// If alchemy isn't even too busy, it's obviously allowed
+	if (!alchemy.isTooBusyForRequests()) {
+		return false;
+	}
+
+	// Some users have the permission to skip postponements
+	if (this.hasPermission('alchemy.queue.skip')) {
+		return false;
+	}
+
+	let session = this.getSession(false);
+
+	if (session) {
+
+		// Do not postpone clients that have already been in the queue
+		if (session.hasAlreadyQueued()) {
+			return false;
+		}
+
+		// Do not postpone clients that have already rendered something
+		if (session.render_counter > 0 && session.is_active) {
+			return false;
+		}
+	}
+
+	// AJAX requests are allowed a bit more
+	if (this.ajax) {
+		return alchemy.isTooBusyForAjax();
+	}
+
+	return true;
+});
+
 /**
  * Broadcast data to every connected user
  *

package/lib/class/controller.js

@@ -225,9 +225,9 @@ Controller.setMethod(function renderDialogIn(config, template) {
 /**
  * Render the given template and send it to the client
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.3.1
  *
  * @param   {Number}   status
  * @param   {Array}    template
@@ -236,17 +236,24 @@ Controller.setMethod(function renderDialogIn(config, template) {
  */
 Controller.setMethod(function render(status, template) {
 
-	var that = this,
-	    pledge = new Classes.Pledge();
+	const conduit = this.conduit;
 
-	this.renderHTML(status, template).done(function gotHtml(err, output) {
+	const session = conduit.getSession(false);
+
+	if (session) {
+		session.incrementRenderCount();
+	}
+
+	let pledge = new Classes.Pledge();
+
+	this.renderHTML(status, template).done(async (err, output) => {
 
 		if (err) {
-			that.conduit.error(err);
+			conduit.error(err);
 			return pledge.resolve(false);
 		}
 
-		that.conduit.end(output);
+		conduit.end(output);
 		pledge.resolve(true);
 	});
 
@@ -466,7 +473,7 @@ Controller.setAction(async function readDatasource(conduit) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    1.0.4
- * @version  1.0.6
+ * @version  1.3.1
  */
 Controller.setAction(async function saveRecord(conduit) {
 
@@ -488,14 +495,10 @@ Controller.setAction(async function saveRecord(conduit) {
 		return;
 	}
 
-	let that = this,
-	    data = conduit.param('data'),
-	    options = conduit.param('options');
+	let body = JSON.undry(conduit.body);
 
-	// @TODO: Add some checks here?
-	if (data) {
-		data = JSON.undry({data: data}).data;
-	}
+	let options = body.options,
+	    data = body.data;
 
 	if (Object.isPlainObject(data)) {
 		data = model.createDocument(data);

package/lib/class/datasource.js

@@ -189,7 +189,7 @@ Datasource.setMethod(function toDatasource(schema, data, callback) {
 	if (!schema) {
 
 		if (alchemy.settings.debug) {
-			log.todo('Schema not found: not normalizing data', data);
+			alchemy.distinctProblem('schema-not-found', 'Schema not found: not normalizing data');
 		}
 
 		pledge = Pledge.resolve(data);
@@ -256,7 +256,7 @@ Datasource.setMethod(function toDatasource(schema, data, callback) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.3.1
  *
  * @param    {Schema|Model}   schema
  * @param    {Object}         query
@@ -281,7 +281,7 @@ Datasource.setMethod(function toApp(schema, query, options, data, callback) {
 	schema = this.getSchema(schema);
 
 	if (schema == null) {
-		log.todo('Schema not found: not unnormalizing data');
+		alchemy.distinctProblem('schema-not-found-unnormalize', 'Schema not found: not un-normalizing data');
 
 		let pledge = Pledge.resolve(data);
 		pledge.done(callback);
@@ -519,13 +519,22 @@ Datasource.setMethod(function read(model, criteria, callback) {
 			return pledge.reject(err);
 		}
 
+		if (criteria.options.return_raw_data) {
+			criteria.setOption('document', false);
+			return handleResults(null, results);
+		}
+
 		tasks = results.map(function eachEntry(entry) {
 			return function entryToApp(next) {
 				that.toApp(model, criteria, {}, entry, next);
 			};
 		});
 
-		sub_pledge = Function.parallel(tasks, function done(err, app_results) {
+		sub_pledge = Function.parallel(tasks, handleResults);
+
+		pledge._addProgressPledge(sub_pledge);
+
+		function handleResults(err, app_results) {
 
 			if (err) {
 				return pledge.reject(err);
@@ -549,9 +558,7 @@ Datasource.setMethod(function read(model, criteria, callback) {
 			}
 
 			pledge.resolve(result);
-		});
-
-		pledge._addProgressPledge(sub_pledge);
+		}
 	});
 
 	if (this.queryCache && model.cache && cache_pledge) {

package/lib/class/field.js

@@ -301,16 +301,17 @@ Field.setStatic(function unDry(value) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.3.1
  *
  * @return   {Object}
  */
 Field.setMethod(function toDry() {
 	return {
 		value: {
+			bla: 1,
 			schema  : this.schema,
 			name    : this.name,
-			options : this.options
+			options : this.getOptionsForDrying(),
 		}
 	};
 });
@@ -684,7 +685,7 @@ Field.setMethod(function _toDatasource(value, data, datasource, callback) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.1.5
+ * @version  1.3.1
  *
  * @param    {Object}   values
  */
@@ -698,6 +699,10 @@ Field.setMethod(function regularToDatasource(value, data, datasource, callback)
 		return this._toDatasource(value, data, datasource, callback);
 	}
 
+	if (!value) {
+		return callback();
+	}
+
 	// Arrayable fields need to process every value inside the array
 	tasks = value.map(function eachValue(entry) {
 		return function eachValueToDs(next) {
@@ -1033,6 +1038,19 @@ Field.setMethod(function getClientConfigOptions(wm) {
 	return JSON.clone(this.options, 'toHawkejs', wm);
 });
 
+/**
+ * Get the options that can be used for drying
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.1
+ * @version  1.3.1
+ *
+ * @return   {Object}
+ */
+Field.setMethod(function getOptionsForDrying() {
+	return this.options;
+});
+
 /**
  * Get all the rules for this field
  *

package/lib/class/migration.js

@@ -118,7 +118,7 @@ Migration.setStatic(async function start() {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    1.2.0
- * @version  1.2.0
+ * @version  1.3.1
  */
 Migration.setMethod(function processRecords(model_name, fnc) {
 
@@ -127,6 +127,7 @@ Migration.setMethod(function processRecords(model_name, fnc) {
 	let options = {
 		document       : false,
 		parallel_limit : 1,
+		return_raw_data: true,
 	};
 
 	return model.eachRecord(options, async (record, index, next) => {

package/lib/class/model.js

@@ -509,7 +509,7 @@ Model.setStatic(function getField(name) {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    1.0.0
- * @version  1.2.7
+ * @version  1.3.1
  */
 Model.setStatic(function getClientConfig() {
 
@@ -518,10 +518,21 @@ Model.setStatic(function getClientConfig() {
 		schema        : this.schema,
 		primary_key   : this.prototype.primary_key,
 		display_field : this.prototype.display_field,
+		ancestors     : 0,
 	};
 
 	if (this.super.name != 'Model') {
 		result.parent = this.super.name;
+
+		let ancestors = 0,
+		    ancestor = this.super;
+		
+		while (ancestor && ancestor.name != 'Model') {
+			ancestors++;
+			ancestor = ancestor.super;
+		}
+
+		result.ancestors = ancestors;
 	}
 
 	return result;