alchemymvc 1.3.19 → 1.3.21

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

@@ -105,7 +105,7 @@ Service.setMethod(function checksumSystemSchedule(type_path, cron, settings) {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    1.3.17
- * @version  1.3.17
+ * @version  1.3.20
  */
 Service.setMethod(async function initSchedules() {
 
@@ -179,6 +179,7 @@ Service.setMethod(async function initSchedules() {
 			// If this checksum has already been seen, also remove it
 			if (existing_system_records.has(checksum)) {
 				await record.remove();
+				continue;
 			}
 
 			// Update the record
@@ -188,6 +189,8 @@ Service.setMethod(async function initSchedules() {
 
 			await record.save();
 
+			existing_system_records.set(checksum, record);
+
 		} catch (err) {
 			alchemy.registerError(err);
 		}
@@ -230,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() {
 
@@ -266,6 +269,10 @@ Service.setMethod(function createJanewayTaskMenu() {
 		}
 	});
 
+	if (!running_task_menu) {
+		return;
+	}
+
 	if (!running_task_menu.addItem) {
 		return running_task_menu.remove();
 	}
@@ -526,12 +533,15 @@ class TaskSchedules {
 	 *
 	 * @author   Jelle De Loecker   <jelle@elevenways.be>
 	 * @since    1.3.17
-	 * @version  1.3.17
+	 * @version  1.3.20
 	 */
-	#startFromMenu(task_record) {
+	async #startFromMenu(task_record) {
 		console.log('Manually starting', task_record.type, 'task:', task_record);
 		let schedule = new TaskSchedule(this, null, task_record.settings, task_record);
-		schedule.startManually();
+		let task_instance = await schedule.startManually();
+		console.log(' -- Started:', task_instance);
+
+		return task_instance;
 	}
 
 	/**
@@ -579,6 +589,7 @@ class TaskSchedule {
 	janeway_menu_item = null;
 
 	#change_counter = 0;
+	#instance_pledge = null;
 
 	/**
 	 * Initialize the instance
@@ -845,10 +856,22 @@ class TaskSchedule {
 	 *
 	 * @author   Jelle De Loecker   <jelle@elevenways.be>
 	 * @since    1.3.17
-	 * @version  1.3.17
+	 * @version  1.3.20
+	 *
+	 * @return   {Task}
 	 */
 	async startManually() {
-		return this.#run(true);
+
+		if (this.is_running) {
+			return false;
+		}
+
+		let pledge = new Pledge();
+		this.#instance_pledge = pledge;
+
+		this.#run(true);
+
+		return pledge;
 	}
 
 	/**
@@ -856,7 +879,7 @@ class TaskSchedule {
 	 *
 	 * @author   Jelle De Loecker   <jelle@elevenways.be>
 	 * @since    1.3.17
-	 * @version  1.3.17
+	 * @version  1.3.20
 	 */
 	async #run(started_manually = false) {
 
@@ -889,6 +912,12 @@ class TaskSchedule {
 			if (started_manually || await this.ownsScheduledTask()) {
 				let instance = this.createInstance();
 				this.task_instance = instance;
+
+				if (this.#instance_pledge) {
+					this.#instance_pledge.resolve(instance);
+					this.#instance_pledge = null;
+				}
+
 				await instance.start();
 			}
 		} catch (err) {

package/lib/core/base.js

@@ -471,7 +471,11 @@ Base.setMethod(function getClassPathAfter(after) {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
- * @version  1.2.2
+ * @version  1.3.20
+ *
+ * @param    {String}   name   The name of the method to call
+ * @param    {Array}    args   The arguments to pass
+ * @param    {Function} next   The callback to call afterwards
  */
 Base.setMethod(function callOrNext(name, args, next) {
 
@@ -480,14 +484,25 @@ Base.setMethod(function callOrNext(name, args, next) {
 		args = [];
 	}
 
-	if (typeof this[name] == 'function') {
+	const fnc = this[name];
+
+	if (typeof fnc == 'function') {
+
+		let has_callback = false,
+		    promise;
 
-		if (next) {
+		if (next && fnc.length > args.length) {
+			has_callback = true;
 			args.push(next);
 		}
 
 		try {
-			this[name].apply(this, args);
+			promise = this[name].apply(this, args);
+
+			if (!has_callback) {
+				Pledge.done(promise, next);
+			}
+
 		} catch (err) {
 			next(err);
 		}

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
  *
@@ -635,6 +711,13 @@ function getRoutesDict() {
 
 // From here on, only client-side code is added
 if (Blast.isBrowser) {
+	window.LocalDateTime = Blast.Classes.Develry.LocalDateTime;
+	window.LocalDate = Blast.Classes.Develry.LocalDate;
+	window.LocalTime = Blast.Classes.Develry.LocalTime;
+	window.Decimal = Blast.Classes.Develry.Decimal;
+	window.MutableDecimal = Blast.Classes.Develry.MutableDecimal;
+	window.FixedDecimal = Blast.Classes.Develry.FixedDecimal;
+	window.MutableFixedDecimal = Blast.Classes.Develry.MutableFixedDecimal;
 	window.alchemy = new Alchemy();
 } else {
 	return;

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