alchemymvc 1.3.20 → 1.3.21

package/lib/class/conduit.js

@@ -1578,7 +1578,7 @@ Conduit.setMethod(function redirect(status, options) {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.3.16
+ * @version  1.3.21
  *
  * @param    {Nulber}  status       Response statuscode
  * @param    {Error}   message      Optional error to send
@@ -1613,7 +1613,7 @@ Conduit.setMethod(function error(status, message, print_error) {
 	if (alchemy.settings.environment == 'dev') {
 		print_dev = true;
 
-		if (is_400 && this.original_path.indexOf('.js.map') > -1) {
+		if (is_400 && this.original_path && this.original_path.indexOf('.js.map') > -1) {
 			print_dev = false;
 			print_error = false;
 		}

package/lib/class/document.js

@@ -178,6 +178,33 @@ Document.setStatic(function unDry(obj, cloned) {
 	return result;
 });
 
+/**
+ * Set the getter for this computed field
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ *
+ * @param    {String}     name     Name of the property
+ * @param    {Function}   getter   Optional getter function
+ * @param    {Function}   setter   Optional setter function
+ */
+Document.setStatic(function setComputedFieldGetter(name) {
+	this.setProperty(name, function getComputedFieldValue() {
+		this.recomputeFieldIfNecessary(name);
+		return this.$main[name];
+	}, function setComputedFieldValue(value) {
+
+		const field = this.$model.schema.getField(name);
+
+		if (field?.options?.allow_manual_set) {
+			return this.$main[name] = value;
+		}
+
+		console.error('Can not set computed field "' + name + '" to', value);
+	});
+});
+
 /**
  * Set the getter for this field
  *

package/lib/class/field.js

@@ -207,6 +207,116 @@ Field.setProperty(function is_array() {
 	return !!result;
 });
 
+/**
+ * Does this field have a computed value?
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ *
+ * @type     {Boolean}
+ */
+Field.setProperty(function is_computed() {
+	return !!this.options.is_computed;
+});
+
+/**
+ * Get the required related fields
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ *
+ * @type     {Field[]}
+ */
+Field.enforceProperty(function required_fields(new_value) {
+
+	if (!new_value) {
+		new_value = resolveFieldPaths(this, this.options.required_fields);
+	}
+
+	return new_value;
+});
+
+/**
+ * Get the optional related fields
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ *
+ * @type     {Field[]}
+ */
+Field.enforceProperty(function optional_fields(new_value) {
+
+	if (!new_value) {
+		new_value = resolveFieldPaths(this, this.options.optional_fields);
+	}
+
+	return new_value;
+});
+
+/**
+ * Get all the dependency fields
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ *
+ * @type     {Field[]}
+ */
+Field.enforceProperty(function dependency_fields(new_value) {
+
+	if (!new_value) {
+		let required_fields = this.required_fields,
+		    optional_fields = this.optional_fields;
+
+		new_value = [];
+
+		if (required_fields) {
+			new_value = new_value.concat(required_fields);
+		}
+
+		if (optional_fields) {
+			new_value = new_value.concat(optional_fields);
+		}
+	}
+
+	return new_value;
+});
+
+/**
+ * Resolve a field path to a field instance
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ */
+function resolveFieldPaths(field, field_paths) {
+	
+	let result = [],
+	    i;
+
+	if (!field_paths) {
+		return result;
+	}
+
+	for (i = 0; i < field_paths.length; i++) {
+
+		if (!field.parent_schema) {
+			continue
+		}
+
+		let other_field = field.parent_schema.getField(field_paths[i]);
+
+		if (other_field && result.indexOf(other_field) == -1) {
+			result.push(other_field);
+		}
+	}
+
+	return result;
+}
+
 /**
  * The datasource this field is used in
  *

package/lib/class/model.js

@@ -366,24 +366,49 @@ Model.setStatic(async function checkPathValue(value, name, field_name, conduit)
 	return result;
 });
 
+/**
+ * Add a computed field to this model's schema
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ *
+ * @return   {Alchemy.Field}
+ */
+Model.setStatic(function addComputedField(name, type, options) {
+	let is_new = !this.schema.has(name);
+
+	// Add it to the schema
+	let field = this.schema.addComputedField(name, type, options);
+
+	if (is_new) {
+		// Add it to the Document class
+		this.Document.setComputedFieldGetter(name);
+
+		// False means it should not be set on the server implementation
+		// (because that's where it's coming from)
+		// Yes, this also sets private fields on the server-side client document.
+		this.ClientDocument.setComputedFieldGetter(name, null, null, false);
+	}
+
+	return field;
+});
+
 /**
  * Add a field to this model's schema
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.2.4
+ * @version  1.2.21
  *
  * @return   {Alchemy.Field}
  */
 Model.setStatic(function addField(name, type, options) {
 
-	var field,
-	    is_new;
-
-	is_new = !this.schema.has(name);
+	let is_new = !this.schema.has(name);
 
 	// Add it to the schema
-	field = this.schema.addField(name, type, options);
+	let field = this.schema.addField(name, type, options);
 
 	if (is_new) {
 		// Add it to the Document class
@@ -1262,7 +1287,7 @@ Model.setMethod(async function executeMongoPipeline(pipeline) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.0.1
- * @version  1.0.7
+ * @version  1.3.21
  *
  * @param   {String}     id        The object id
  * @param   {Function}   callback
@@ -1291,14 +1316,24 @@ Model.setMethod(function remove(id, callback) {
 	let query = {};
 	query[this.primary_key] = id;
 
-	this.datasource.remove(this, query, {}, function afterRemove(err, result) {
+	Function.series(function recompute(next) {
+		that.callOrNext('beforeRemove', [id], next);
+	}, function done(err) {
 
-		if (err != null) {
-			return pledge.reject(err);
+		if (err) {
+			pledge.reject(err);
+			return;
 		}
 
-		that.emit('removed', result, {}, false, function afterRemovedEvent() {
-			pledge.resolve(result);
+		that.datasource.remove(that, query, {}, function afterRemove(err, result) {
+
+			if (err != null) {
+				return pledge.reject(err);
+			}
+	
+			that.emit('removed', result, {}, false, function afterRemovedEvent() {
+				pledge.resolve(result);
+			});
 		});
 	});
 

package/lib/class/route.js

@@ -3,7 +3,7 @@
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.3.16
+ * @version  1.3.21
  */
 const Route = Function.inherits('Alchemy.Base', function Route(router, paths, options) {
 
@@ -62,6 +62,9 @@ const Route = Function.inherits('Alchemy.Base', function Route(router, paths, op
 	// All routes can be postponed by default
 	this.can_be_postponed = true;
 
+	// Possible cache instructions
+	this.cache = null;
+
 	this.setPaths(paths);
 });
 

package/lib/class/router.js

@@ -767,7 +767,7 @@ RouterClass.setMethod(function setOption(name, value) {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.3.16
+ * @version  1.3.21
  *
  * @param    {Object}   args
  * @param    {String}   args.name            Optional route name
@@ -819,6 +819,7 @@ RouterClass.setMethod(function add(args) {
 	route.setBreadcrumb(args.breadcrumb);
 	route.sitemap = args.sitemap;
 	route.title = args.title;
+	route.cache = args.cache;
 
 	if (args.visible_location != null) {
 		route.visible_location = args.visible_location;
@@ -1167,7 +1168,7 @@ RouterClass.setMethod(function getOptions(result) {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.3.16
+ * @version  1.3.21
  *
  * @param    {Object}   result   Optional object to store sectioned results in
  *
@@ -1219,6 +1220,7 @@ RouterClass.setMethod(function getRoutes(result) {
 			is_system_route            : route.is_system_route,
 			schema                     : route.schema,
 			param_definitions          : route.param_definitions,
+			cache                      : route.cache,
 		};
 	}
 

package/lib/class/schema_client.js

@@ -183,7 +183,7 @@ Schema.addRelationCreator('HasOneChild',         {internal: false, singular: tru
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    1.3.4
- * @version  1.3.4
+ * @version  1.3.21
  *
  * @param    {String}   alias
  * @param    {String}   modelname
@@ -239,7 +239,7 @@ Schema.setMethod(function addAssociation(relation_type, relation_config, alias,
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.3.4
+ * @version  1.3.21
  *
  * @param    {Boolean}  is_internal      Is this internal (A remote record's id is stored inside this record)
  * @param    {String}   alias
@@ -295,12 +295,25 @@ Schema.setMethod(function getAssociationArguments(is_internal, alias, model_name
 	options.local_key = options.localKey = local_key;
 	options.foreign_key = options.foreignKey = foreign_key;
 
-	return {
-		alias      : alias,
+	let field_options = options.field_options;
+
+	if (!field_options) {
+		options.field_options = field_options = {};
+	}
+
+	if (options.required != null) {
+		field_options.required = options.required;
+	}
+
+	let result = {
+		alias       : alias,
 		model_name,
-		modelName  : model_name,
-		options    : options
+		modelName   : model_name,
+		options     : options,
+		constraints : options?.constraints,
 	};
+
+	return result;
 });
 
 /**
@@ -402,7 +415,7 @@ Schema.setMethod(function toDry() {
  *
  * @author   Jelle De Loecker <jelle@develry.be>
  * @since    1.1.0
- * @version  1.3.0
+ * @version  1.3.21
  */
 Schema.setMethod(function init() {
 	this.associations = {};
@@ -434,6 +447,15 @@ Schema.setMethod(function init() {
 	// Validation rules
 	this.rules = new Deck();
 
+	// Computed fields
+	this.computed_fields = {};
+
+	// How many computed fields there are
+	this.has_computed_fields = 0;
+
+	// How many computed fields require a recompute after find
+	this.has_recompute_after_find = 0;
+
 	// Behaviour count
 	this.has_behaviours = 0;
 });
@@ -456,11 +478,17 @@ Schema.setMethod(function setName(name) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  0.2.0
+ * @version  1.3.21
  *
  * @param    {Schema}   schema
  */
 Schema.setMethod(function setParent(schema) {
+
+	if (schema != this.parent) {
+		schema.has_computed_fields += this.has_computed_fields;
+		schema.has_recompute_after_find += this.has_recompute_after_find;
+	}
+	
 	this.parent = schema;
 });
 
@@ -631,18 +659,69 @@ Schema.setMethod(function getPrivateFields() {
 	return result;
 });
 
+/**
+ * Add a computed field to this schema:
+ * The value of these fields will be computed
+ * when the document is saved or loaded.
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ *
+ * @param    {String}   name
+ * @param    {String}   type
+ * @param    {Object}   options
+ *
+ * @return   {Alchemy.Field.Field}
+ */
+Schema.setMethod(function addComputedField(name, type, options) {
+
+	if (arguments.length < 3 || !type || !options) {
+		throw new Error('Schema#addComputedField expects at least 3 arguments');
+	}
+
+	if (!options.compute_method) {
+		throw new Error('Schema#addComputedField expects a compute_method option');
+	}
+
+	if (!this.name || this.model_name != this.name) {
+		throw new Error('Computed fields can only be added to the root schema');
+	}
+
+	options.is_computed = true;
+
+	let result = this.addField(name, type, options);
+
+	this.computed_fields[name] = result;
+	this.has_computed_fields++;
+
+	if (this.parent) {
+		this.parent.has_computed_fields++;
+	}
+
+	if (options.compute_after_find) {
+		this.has_recompute_after_find++;
+
+		if (this.parent) {
+			this.parent.has_recompute_after_find++;
+		}
+	}
+
+	return result;
+});
+
 /**
  * Add a field to this schema
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.3.0
+ * @version  1.3.21
  *
  * @param    {String}   name
  * @param    {String}   type
  * @param    {Object}   options
  *
- * @return   {FieldType}
+ * @return   {Alchemy.Field.Field}
  */
 Schema.setMethod(function addField(name, type, options) {
 
@@ -693,6 +772,43 @@ Schema.setMethod(function addField(name, type, options) {
 		}
 	}
 
+	if (options.constraints) {
+		let required_fields = options.required_fields,
+		    optional_fields = options.optional_fields,
+		    value,
+		    key;
+
+		if (!required_fields) {
+			required_fields = [];
+		} else {
+			required_fields = required_fields.slice(0);
+		}
+
+		if (!optional_fields) {
+			optional_fields = [];
+		} else {
+			optional_fields = optional_fields.slice(0);
+		}
+
+		for (key in options.constraints) {
+			value = options.constraints[key];
+
+			if (value && typeof value == 'object') {
+				if (value instanceof Classes.Alchemy.PathEvaluator) {
+					required_fields.push(value);
+				}
+			}
+		}
+
+		if (required_fields.length) {
+			options.required_fields = required_fields;
+		}
+
+		if (optional_fields.length) {
+			options.optional_fields = optional_fields;
+		}
+	}
+
 	field = new FieldClass(this, name, options);
 
 	if (field.requires_translating) {
@@ -723,7 +839,7 @@ Schema.setMethod(function addField(name, type, options) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.3.21
  *
  * @param    {String}   rule_name
  * @param    {Object}   options
@@ -738,10 +854,6 @@ Schema.setMethod(function addRule(rule_name, options) {
 		throw new Error('Custom function validators not yet implemented');
 	}
 
-	if (!options) {
-		throw new Error('No valid options were found for the ' + rule_name + ' validator');
-	}
-
 	let constructor = alchemy.getValidatorClass(rule_name);
 
 	if (!constructor) {
@@ -818,26 +930,57 @@ Schema.setMethod(function getField(name) {
 	return this.getFieldChain(name).last();
 });
 
+/**
+ * Get an association by name
+ *
+ * @author   Jelle De Loecker   <jelle@develry.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ *
+ * @param    {String}   name
+ *
+ * @return   {Object}
+ */
+Schema.setMethod(function getAssociation(name) {
+	return this.associations[name];
+});
+
 /**
  * Get a field
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.2.5
+ * @version  1.2.21
  *
- * @param    {String}   name
+ * @param    {String|PathEvaluator}   name
  *
  * @return   {FieldType[]}
  */
 Schema.setMethod(function getFieldChain(name) {
 
-	let result;
+	let result,
+	    pieces;
+
+	if (typeof name == 'object') {
+
+		if (name instanceof Classes.Alchemy.PathEvaluator) {
+			pieces = name.path;
+
+			if (pieces[0] == '$0') {
+				pieces = pieces.slice(1);
+				return this.root_schema.getFieldChain(pieces);
+			}
+		}
+	} else if (Array.isArray(name)) {
+		pieces = name;
+	} else if (typeof name == 'string' && name.indexOf('.') > -1) {
+		pieces = name.split('.');
+	}
 
 	// Allow getting a nested field by a path
-	if (name.indexOf('.') > -1) {
+	if (pieces) {
 
 		let current = this,
-		    pieces = name.split('.'),
 		    max = pieces.length - 1,
 		    i;
 

package/lib/class/task.js

@@ -489,7 +489,7 @@ Task.setMethod(function getParam(name) {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    1.3.17
- * @version  1.3.17
+ * @version  1.3.21
  */
 Task.setMethod(function waitUntilResumed() {
 
@@ -497,9 +497,55 @@ Task.setMethod(function waitUntilResumed() {
 		return false;
 	}
 
-	return this[PAUSE_PLEDGE];
+	let paused = this[PAUSE_PLEDGE];
+
+	if (paused) {
+		return paused;
+	}
+
+	return this.waitIfTooBusy();
+});
+
+/**
+ * Wait if the system is too busy
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ */
+Task.setMethod(function waitIfTooBusy() {
+
+	if (!alchemy.isTooBusy()) {
+		return false;
+	}
+
+	return doAsyncLoopUntilNotBusy(10);
 });
 
+/**
+ * Do a loop until the system is no longer busy
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ */
+async function doAsyncLoopUntilNotBusy(max_tries) {
+
+	let tries = 0;
+
+	if (!max_tries || max_tries < 1) {
+		max_tries = 5;
+	}
+
+	do {
+		console.log('Waiting for system to be less busy', tries)
+		await Pledge.after(500);
+		tries++;
+	} while (tries < max_tries && alchemy.isTooBusy());
+
+	return true;
+}
+
 /**
  * Report command progress
  *

package/lib/class/task_service.js

@@ -233,7 +233,7 @@ Service.setMethod(async function initSchedules() {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    1.3.17
- * @version  1.3.17
+ * @version  1.3.21
  */
 Service.setMethod(function createJanewayTaskMenu() {
 
@@ -269,6 +269,10 @@ Service.setMethod(function createJanewayTaskMenu() {
 		}
 	});
 
+	if (!running_task_menu) {
+		return;
+	}
+
 	if (!running_task_menu.addItem) {
 		return running_task_menu.remove();
 	}