alchemymvc 1.3.20 → 1.3.21

package/lib/app/helper/alchemy_helper.js

@@ -30,7 +30,7 @@ Alchemy.setStatic(function onScene(scene, options) {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.0.1
- * @version  1.2.7
+ * @version  1.3.21
  *
  * @param    {String|Object}   options
  * @param    {Object}          data
@@ -122,10 +122,14 @@ Alchemy.setMethod(function getResource(options, data, callback) {
 
 		config = this.view.helpers.Router.routeConfig(options.name);
 
-		if (config && config.methods) {
-			if (config.methods.indexOf('get') == -1) {
+		if (config) {
+			if (config.methods && config.methods.indexOf('get') == -1) {
 				method = config.methods[0];
 			}
+
+			if (config.cache != null && options.cache == null) {
+				options.cache = config.cache;
+			}
 		}
 
 		// Get the url to the resource
@@ -150,7 +154,7 @@ Alchemy.setMethod(function getResource(options, data, callback) {
 		options[method] = true;
 	}
 
-	pledge = hawkejs.scene.fetch(options);
+	pledge = this.view.fetch(options);
 	pledge.done(callback);
 
 	return pledge;

package/lib/app/helper_controller/controller.js

@@ -359,6 +359,7 @@ Controller.setMethod(async function doAction(name, args) {
 	if (route) {
 
 		if (route.options?.title) {
+			// @TODO: Add support for objects with language keys
 			let title = route.options.title;
 
 			if (alchemy.settings && alchemy.settings.title_suffix) {

package/lib/app/helper_field/big_int_field.js

@@ -50,7 +50,7 @@ BigIntField.setMethod(function cast(value) {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    1.3.6
- * @version  1.3.20
+ * @version  1.3.21
  *
  * @param    {Mixed}   value
  * @param    {Array}   field_paths   The path to the field
@@ -60,7 +60,7 @@ BigIntField.setMethod(function cast(value) {
 BigIntField.setMethod(function _castCondition(value, field_paths) {
 
 	value = this.cast(value);
-	value = this.convertBigIntForDatasource(value);
+	value = this.datasource.convertBigIntForDatasource(value);
 
 	return value;
 });

package/lib/app/helper_field/mixed_field.js

@@ -0,0 +1,73 @@
+/**
+ * The Mixed Field class
+ *
+ * @constructor
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ */
+const MixedField = Function.inherits('Alchemy.Field', 'Mixed');
+
+/**
+ * Set the datatype name
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ */
+MixedField.setDatatype('object');
+
+/**
+ * This field value is self-contained
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ */
+MixedField.setSelfContained(true);
+
+/**
+ * Store objects as strings, if wanted
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ *
+ * @param    {Mixed}        value       The field's own value
+ * @param    {Object}       data        The main record
+ * @param    {Datasource}   datasource  The datasource instance
+ *
+ * @return   {Mixed}
+ */
+MixedField.setMethod(function _toDatasource(value, data, datasource, callback) {
+
+	if (value && typeof value == 'object' && !Object.isPlainObject(value)) {
+		if (!(value instanceof Date)) {
+			value = JSON.toDryObject(value);
+		}
+	}
+
+	Blast.nextTick(callback, null, null, value);
+});
+
+/**
+ * Convert from database to app
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ *
+ * @param    {Object}   query     The original query
+ * @param    {Object}   options   The original query options
+ * @param    {Mixed}    value     The field value, as stored in the DB
+ * @param    {Function} callback
+ */
+MixedField.setMethod(function _toApp(query, options, value, callback) {
+
+	if (value && typeof value == 'object' && typeof value.dry == 'string') {
+		value = JSON.unDry(value);
+	}
+
+	callback(null, value);
+});

package/lib/app/helper_field/schema_field.js

@@ -110,7 +110,7 @@ SchemaField.setProperty(function requires_translating() {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.3.7
+ * @version  1.3.21
  *
  * @param    {Object}   record      This *should* be the schema context (might not be the root)
  * @param    {String}   some_path   Some path to a field in the wanted schema
@@ -124,56 +124,131 @@ SchemaField.setMethod(function getSubschema(record, some_path) {
 	// If schema is a string,
 	// it needs to be extracted from another field's value
 	if (typeof schema == 'string') {
+		schema = this.resolveSchemaPath(this.schema, record, some_path, schema);
+	}
 
-		// When there are 2 pieces, the second piece is the property name
-		let pieces = schema.split('.');
+	return schema;
+});
 
-		// The first piece is the external field name
-		let external_field_name = pieces[0];
+/**
+ * Get the subschema of a given schema
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ *
+ * @param    {Schema}   context_schema   The schema context (probably the schema this field is in)
+ * @param    {Object}   record           This *should* be the schema context (might not be the root)
+ * @param    {String}   some_path        Some path to a field in the wanted schema
+ * @param    {String}   schema           The schema path to resolve
+ *
+ * @return   {Schema}
+ */
+SchemaField.setMethod(function resolveSchemaPath(context_schema, record, field_path, schema_path) {
 
-		// The second piece is the property name
-		let property_name = pieces[1] || 'schema';
+	if (typeof schema_path != 'string') {
+		return schema_path;
+	}
 
-		// Get that other field by its name
-		let field = this.schema.getField(external_field_name);
+	let schema;
 
-		if (!field) {
-			console.error('Failed to get subschema', external_field_name, 'of', this.schema, some_path);
-			return null;
-		}
+	// When there are 2 pieces, the second piece is the property name
+	let pieces = schema_path.split('.');
 
-		// Get the values that field can have (probably an enum)
-		let values = field.getValues();
+	// The first piece is the external field name
+	let external_field_name = pieces.shift();
 
-		if (values == null) {
-			return null;
-		}
+	// The rest of the pieces is the property path
+	let property_name = pieces.join('.') || 'schema';
 
-		// Now get the actual external value from the record
-		let record_value = field.getRecordValue(record);
+	// Get that other field by its name
+	let field = context_schema.getField(external_field_name);
 
-		// I'm not sure if this will help
-		if (record_value == null) {
-			record_value = field.getRecordValue(record, some_path);
-		}
+	if (!field) {
+		let association = context_schema.getAssociation(external_field_name);
+		return this.getSubschemaFromAssociation(record, property_name, association);
+	}
 
-		// Get the correct field value
-		let enum_value = values.get(record_value);
+	if (!field) {
+		console.error('Failed to get subschema', external_field_name, 'of', context_schema, field_path);
+		return null;
+	}
 
-		if (!enum_value) {
-			schema = null;
-		} else if (enum_value.schema) {
-			schema = enum_value.schema;
-		} else if (enum_value.value) {
-			schema = enum_value.value[property_name] || enum_value.value.schema;
-		} else {
-			console.log('Could not find', schema, 'in', record, 'enum values:', enum_value, 'of field', field)
-		}
+	// Get the values that field can have (probably an enum)
+	let values = field.getValues();
+
+	if (values == null) {
+		return null;
+	}
+
+	// Now get the actual external value from the record
+	let record_value = field.getRecordValue(record);
+
+	// I'm not sure if this will help
+	if (record_value == null) {
+		record_value = field.getRecordValue(record, field_path);
+	}
+
+	// Get the correct field value
+	let enum_value = values.get(record_value);
+
+	if (!enum_value) {
+		schema = null;
+	} else if (enum_value.schema) {
+		schema = enum_value.schema;
+	} else if (enum_value.value) {
+		schema = enum_value.value[property_name] || enum_value.value.schema;
+	} else {
+		console.log('Could not find', schema_path, 'in', record, 'enum values:', enum_value, 'of field', field)
 	}
 
 	return schema;
 });
 
+/**
+ * Get the subschema via an association
+ * @TODO: Work in progress!
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    0.2.0
+ * @version  1.3.21
+ *
+ * @param    {Object}   record       This *should* be the schema context (might not be the root)
+ * @param    {String}   path         The path inside the associated schema
+ * @param    {Object}   association  The association object
+ *
+ * @return   {Schema}   Response might be a promise
+ */
+SchemaField.setMethod(function getSubschemaFromAssociation(record, path, association) {
+
+	let local_value = record[association.options.local_key];
+
+	if (!local_value) {
+		return false;
+	}
+
+	const associated_model = alchemy.getModel(association.model_name);
+
+	if (!associated_model) {
+		return false;
+	}
+
+	return Pledge.Swift.execute(async () => {
+
+		let result = await associated_model.findByValues({
+			[association.options.foreign_key]: local_value,
+		});
+
+		if (!result) {
+			return null;
+		}
+
+		let found_schema = this.resolveSchemaPath(associated_model.schema, result, path, path);
+
+		return found_schema;
+	});
+});
+
 /**
  * Cast all the subschema values using their _toDatasource method
  *

package/lib/app/helper_model/criteria.js

@@ -1116,6 +1116,19 @@ Criteria.setMethod(function and(value) {
 	return this._applyGroup('and');
 });
 
+/**
+ * Alias for `ne`: Not equals check
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.2
+ *
+ * @param    {*}   value
+ */
+Criteria.setMethod(function notEquals(value) {
+	return this.ne(value);
+});
+
 Criteria.addValueExpression('equals');
 Criteria.addValueExpression('gte');
 Criteria.addValueExpression('gt');

package/lib/app/helper_model/document.js

@@ -131,6 +131,32 @@ Document.setStatic(function setMethod(key, method, on_server) {
 	return Blast.Collection.Function.setMethod(this, key, method);
 });
 
+/**
+ * Set a 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    {Boolean}    on_server  Also set on the server implementation
+ */
+Document.setStatic(function setComputedFieldGetter(name, on_server) {
+	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);
+	}, on_server);
+});
+
 /**
  * Set a getter for this field
  *
@@ -858,6 +884,209 @@ Document.setMethod(function setValues(values) {
 
 });
 
+/**
+ * Recompute the given field if required
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ *
+ * @param    {string|Alchemy.Field}   name
+ * @param    {boolean}                force
+ *
+ * @return   {Pledge|undefined}
+ */
+Document.setMethod(function recomputeFieldIfNecessary(name, force = false) {
+
+	const field = this.$model.schema.getField(name),
+	      original = this.$main[name];
+
+	if (!field) {
+		return original;
+	}
+
+	let options = field.options;
+
+	if (!options.compute_method) {
+		return original;
+	}
+
+	let required_field_count = options.required_fields?.length || 0,
+	    optional_field_count = options.optional_fields?.length || 0;
+
+	if (!force && original == null) {
+		// If the value is null, it hasn't been computed yet
+		// and we need to compute it
+		force = true;
+	}
+
+	if (!force) {
+		let has_changed = false;
+
+		if (required_field_count) {
+			for (let required_field of options.required_fields) {
+				if (this.hasChanged(required_field)) {
+					has_changed = true;
+					break;
+				}
+			}
+		}
+
+		if (!has_changed && optional_field_count) {
+			for (let optional_field of options.optional_fields) {
+				if (this.hasChanged(optional_field)) {
+					has_changed = true;
+					break;
+				}
+			}
+		}
+
+		if (!has_changed) {
+			return original;
+		}
+	}
+
+	// Make sure the required fields are set
+	if (required_field_count) {
+		let has_value = true;
+
+		for (let required_field of options.required_fields) {
+			if (this[required_field] == null) {
+				has_value = false;
+				break;
+			}
+		}
+
+		if (!has_value) {
+			// If not all required field values are set,
+			// the result will also be undefined
+			return this._setComputedFieldValue(name, undefined);
+		}
+	}
+
+	let compute_method = options.compute_method;
+
+	if (typeof compute_method == 'string') {
+		let fnc = this[compute_method];
+
+		if (typeof fnc == 'function') {
+			compute_method = fnc;
+		} else {
+			// Handle special cases in the browser
+			compute_method = alchemy.getCustomHandler('recompute_field');
+		}
+	}
+
+	if (!compute_method) {
+		return original;
+	}
+
+	let result = compute_method.call(this, this, field);
+
+	return this._setComputedFieldValue(name, result);
+});
+
+/**
+ * Set a computed field to a specific value
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ *
+ * @param    {string|Alchemy.Field}   name
+ * @param    {*}                      value
+ *
+ * @return   {Pledge|undefined}
+ */
+Document.setMethod(function _setComputedFieldValue(name, value) {
+
+	const field = this.$model.schema.getField(name);
+
+	if (value == null && field?.options?.allow_manual_set) {
+		return this.$main[name];
+	}
+
+	if (Pledge.isThenable(value)) {
+		value.then(value => {
+			this.$main[name] = value;
+		});
+	} else {
+		this.$main[name] = value;
+	}
+
+	return value;
+});
+
+/**
+ * Recompute values of computed fields.
+ * This might be async. If it is, a pledge will be returned.
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ *
+ * @return   {Pledge|undefined}
+ */
+Document.setMethod(function recomputeValues() {
+
+	const schema = this.$model.schema;
+
+	if (!schema.has_computed_fields) {
+		return;
+	}
+
+	let promises = [];
+
+	for (let key in schema.computed_fields) {
+		let field = schema.computed_fields[key];
+		let options = field.options;
+
+		// Make sure the required fields are set
+		if (options.required_fields?.length) {
+			let has_value = true;
+
+			for (let required_field of options.required_fields) {
+				if (this[required_field] == null) {
+					has_value = false;
+					break;
+				}
+			}
+
+			if (!has_value) {
+				// If not all required field values are set,
+				// the result will also be undefined
+				this._setComputedFieldValue(key, undefined);
+				continue;
+			}
+		}
+
+		let compute_method = options.compute_method;
+
+		if (typeof compute_method == 'string') {
+			let fnc = this[compute_method];
+	
+			if (typeof fnc == 'function') {
+				compute_method = fnc;
+			} else {
+				// Handle special cases in the browser
+				compute_method = alchemy.getCustomHandler('recompute_field');
+			}
+		}
+	
+		if (!compute_method) {
+			continue;
+		}
+
+		let result = compute_method.call(this, this, field);
+
+		this._setComputedFieldValue(key, result);
+	}
+
+	if (promises.length) {
+		return Pledge.all(promises);
+	}
+});
+
 /**
  * Get the clean options
  *

package/lib/app/helper_model/model.js

@@ -629,7 +629,7 @@ Model.setMethod(function getAliasModel(alias) {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.0.1
- * @version  1.3.8
+ * @version  1.3.21
  *
  * @param    {String}     type       The type of find (first, all)
  * @param    {Criteria}   criteria   The criteria object
@@ -797,6 +797,27 @@ Model.setMethod(function find(type, criteria, callback) {
 				next();
 			}
 		});
+	}, function recomputeAfterFind(next) {
+
+		if (!that.schema.has_recompute_after_find || criteria.options.document === false) {
+			return next();
+		}
+
+		let tasks = [];
+
+		for (let document of records) {
+			tasks.push((next) => {
+				let promise = document.recomputeValues();
+
+				if (!promise) {
+					return next();
+				}
+
+				Pledge.done(promise, next);
+			});
+		}
+
+		Function.parallel(8, tasks, next);
 	}, function done(err) {
 
 		var i;
@@ -1773,7 +1794,7 @@ Model.setMethod(function compose(data, options) {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.3.20
+ * @version  1.3.21
  *
  * @param    {Document}   document
  * @param    {Object}     options
@@ -1786,10 +1807,17 @@ Model.setMethod(function createRecord(document, options, callback) {
 	// Normalize & clone the data, set default values, ...
 	let data = this.compose(document, options);
 
-	// Turn it into a new document
-	document = this.createDocument(data);
+	document = createDocumentForSaving(this, document, data);
+
+	Function.series(function recompute(next) {
+		let result = document.recomputeValues();
 
-	Function.series(function doBeforeValidate(next) {
+		if (result) {
+			result.done(next);
+		} else {
+			next();
+		}
+	}, function doBeforeValidate(next) {
 		that.callOrNext('beforeValidate', [document, options], next);
 	}, function validate(next) {
 
@@ -1823,12 +1851,35 @@ Model.setMethod(function createRecord(document, options, callback) {
 	})
 });
 
+/**
+ * Create a document used for saving
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.21
+ * @version  1.3.21
+ *
+ * @param    {Model}             model
+ * @param    {Document|Object}   original_input
+ * @param    {Object}            data
+ */
+function createDocumentForSaving(model, original_input, data) {
+
+	// Turn it into a new document
+	let document = model.createDocument(data);
+
+	if (original_input?.$attributes.original_record) {
+		document.$attributes.original_record = original_input.$attributes.original_record;
+	}
+
+	return document;
+}
+
 /**
  * Update a record in the database
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.3.20
+ * @version  1.3.21
  *
  * @param    {Document}   document
  * @param    {Object}     options
@@ -1842,9 +1893,17 @@ Model.setMethod(function updateRecord(document, options, callback) {
 	let data = this.compose(document, Object.assign({update: true}, options));
 
 	// Turn it into a new document
-	document = this.createDocument(data);
+	document = createDocumentForSaving(this, document, data);
+
+	Function.series(function recompute(next) {
+		let result = document.recomputeValues();
 
-	Function.series(function doBeforeValidate(next) {
+		if (result) {
+			result.done(next);
+		} else {
+			next();
+		}
+	}, function doBeforeValidate(next) {
 		that.callOrNext('beforeValidate', [document, options], next);
 	}, function validate(next) {