alchemymvc 1.3.20 → 1.3.22

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();
 	}

package/lib/core/client_alchemy.js

@@ -5,7 +5,7 @@
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.1.0
- * @version  1.3.0
+ * @version  1.3.21
  */
 var Alchemy = Function.inherits('Alchemy.Client.Base', function Alchemy() {
 
@@ -24,6 +24,9 @@ var Alchemy = Function.inherits('Alchemy.Client.Base', function Alchemy() {
 	this.sent_subscriptions = [];
 
 	this.distinct_problems = new Map();
+
+	// Custom handlers
+	this.custom_handlers = new Map();
 });
 
 /**
@@ -196,6 +199,79 @@ Alchemy.setMethod(function distinctProblem(id, message, options = {}) {
 	return entry;
 });
 
+/**
+ * Register a custom handler
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ *
+ * @param   {string|symbol}  type
+ * @param   {Function}       callback
+ * @param   {Number}         weight
+ */
+Alchemy.setMethod(function registerCustomHandler(type, callback, weight) {
+
+	if (typeof callback != 'function') {
+		throw new Error('Custom handler needs to be a function');
+	}
+
+	let handlers = this.custom_handlers.get(type);
+
+	if (!handlers) {
+		handlers = new Deck();
+		this.custom_handlers.set(type, handlers);
+	}
+
+	if (weight == null) {
+		weight = 10;
+	}
+
+	handlers.push(callback, weight);
+});
+
+/**
+ * Get the highest priority custom handler of the given type
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ *
+ * @param   {string|symbol}  type
+ *
+ * @return  {Function}
+ */
+Alchemy.setMethod(function getCustomHandler(type) {
+
+	let handlers = this.custom_handlers.get(type);
+
+	if (handlers) {
+		return handlers.first();
+	}
+});
+
+/**
+ * Get all the custom handlers of the given type
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ *
+ * @param   {string|symbol}  type
+ *
+ * @return  {Function[]}
+ */
+Alchemy.setMethod(function getAllCustomHandlers(type) {
+
+	let handlers = this.custom_handlers.get(type);
+
+	if (handlers) {
+		return [...handlers];
+	}
+
+	return [];
+});
+
 /**
  * Actually print a log message
  *

package/lib/core/client_base.js

@@ -294,7 +294,7 @@ ClientBase.setMethod(function getModel(name, init, options) {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.1.1
- * @version  1.3.2
+ * @version  1.3.22
  *
  * @param    {String}   name   The name of the event to emit
  * @param    {Array}    args   The parameters to pass to the event
@@ -323,7 +323,17 @@ ClientBase.setMethod(function issueEvent(name, args, next) {
 	}
 
 	if (method_name && typeof this[method_name] == 'function') {
-		promise = this[method_name].apply(this, args);
+		try {
+			promise = this[method_name].apply(this, args);
+		} catch (err) {
+			pledge.reject(err);
+
+			if (next) {
+				next(err);
+			}
+
+			return pledge;
+		}
 	}
 
 	Pledge.done(promise, function doneEventPromise(err, result) {

package/lib/core/middleware.js

@@ -426,13 +426,29 @@ Alchemy.setMethod(function minifyScript(path, options, callback) {
 
 			let minify_options = {
 				compress: {
-					keep_fargs   : true,
-					keep_fnames  : true,
+					// Keep all function arguments
+					keep_fargs      : true,
+
+					// Keep function names
+					keep_fnames     :  true,
+
+					// Keep classnames
 					keep_classnames : true,
-					hoist_funs   : false,
-					drop_console : !alchemy.settings.debug,
-					dead_code    : true,
-					global_defs  : {
+
+					// Do not hoist function declarations
+					hoist_funs      : false,
+
+					// Only drop console calls when not debugging
+					drop_console    : !alchemy.settings.debug,
+
+					// Remove dead code
+					dead_code       : true,
+
+					// Remove symbol names
+					unsafe_symbols  : true,
+
+					// Provide it some info on global definitions
+					global_defs     : {
 						'__BLAST_IS_NODE'    : false,
 						'__BLAST_IS_BROWSER' : true
 					}
@@ -440,7 +456,11 @@ Alchemy.setMethod(function minifyScript(path, options, callback) {
 				mangle: {
 					keep_fnames     : true,
 					keep_classnames : true,
-				}
+				},
+				output: {
+					// Do not wrap functions that are arguments in parenthesis
+					wrap_func_args  : false,
+				},
 			};
 
 			if (alchemy.settings.debug && alchemy.settings.source_map) {

package/lib/init/alchemy.js

@@ -19,7 +19,7 @@ var shared_objects = {},
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.0.1
- * @version  1.3.11
+ * @version  1.3.21
  */
 global.Alchemy = Function.inherits('Informer', 'Alchemy', function Alchemy() {
 
@@ -105,6 +105,9 @@ global.Alchemy = Function.inherits('Informer', 'Alchemy', function Alchemy() {
 	// Distinct problems
 	this.distinct_problems = new Map();
 
+	// Custom handlers
+	this.custom_handlers = new Map();
+
 	// Load the settings
 	this.loadSettings();
 
@@ -921,7 +924,7 @@ Alchemy.setMethod(function ready(callback) {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    1.1.2
- * @version  1.3.3
+ * @version  1.3.22
  */
 Alchemy.setMethod(async function doPreload() {
 
@@ -949,7 +952,8 @@ Alchemy.setMethod(async function doPreload() {
 		Blast.getClientPath({
 			modify_prototypes : true,
 			create_source_map : alchemy.settings.source_map,
-			enable_coverage   : !!global.__coverage__
+			enable_coverage   : !!global.__coverage__,
+			debug             : alchemy.settings.debug,
 		});
 	}
 });

package/lib/init/functions.js

@@ -441,26 +441,49 @@ Alchemy.setMethod(function createDir(target, callback) {
 /**
  * Return the key:items of the first object that are no longer in the second
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.0.1
- * @version  0.4.0
+ * @version  1.3.22
  *
- * @param    {Object}
- * @param    {Object}
+ * @param    {Object|Map}   first
+ * @param    {Object|Map}   second
  *
- * @return   {Object}   The items in the first item that are not in the second
+ * @return   {Object}       The items in the first item that are not in the second
  */
 Alchemy.setMethod(function getDifference(first, second) {
 
-	var key,
-	    result = {};
+	let first_is_map = first instanceof Map,
+	    second_is_map = second instanceof Map,
+	    first_keys,
+	    result = {},
+	    first_val,
+	    key,
+	    val;
+
+	if (first_is_map) {
+		first_keys = [...first.keys()];
+	} else {
+		first_keys = Object.keys(first);
+	}
+
+	for (key of first_keys) {
 
-	for (key in first) {
+		if (second_is_map) {
+			val = second.get(key);
+		} else {
+			val = second[key];
+		}
 
 		// If the key in the first item doesn't show up in the second item,
 		// add it to the result
-		if (typeof second[key] === 'undefined') {
-			result[key] = first[key];
+		if (typeof val === 'undefined') {
+			if (first_is_map) {
+				first_val = first.get(key);
+			} else {
+				first_val = first[key];
+			}
+
+			result[key] = first_val;
 		}
 	}
 
@@ -470,24 +493,42 @@ Alchemy.setMethod(function getDifference(first, second) {
 /**
  * Return the shared items
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.0.1
- * @version  0.4.0
+ * @version  1.3.22
  *
- * @param    {Object}
- * @param    {Object}
+ * @param    {Object|Map}   first
+ * @param    {Object|Map}   second
  *
  * @return   {Object}   The items in the second item that are also in the first
  */
 Alchemy.setMethod(function getShared(first, second) {
 
-	var key,
-	    result = {};
+	let first_is_map = first instanceof Map,
+	    second_is_map = second instanceof Map,
+	    first_keys,
+	    result = {},
+	    key,
+	    val;
+
+	if (first_is_map) {
+		first_keys = [...first.keys()];
+	} else {
+		first_keys = Object.keys(first);
+	}
 
-	for (key in first) {
+	for (key of first_keys) {
 
-		if (typeof second[key] !== 'undefined') {
-			result[key] = second[key];
+		if (second_is_map) {
+			val = second.get(key);
+		} else {
+			val = second[key];
+		}
+
+		// If the key in the first item doesn't show up in the second item,
+		// add it to the result
+		if (typeof val !== 'undefined') {
+			result[key] = val;
 		}
 	}