alchemymvc 1.3.19 → 1.3.21

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
  *
@@ -414,6 +489,17 @@ SchemaField.setMethod(function _toAppFromValue(query, options, value, callback)
 		record = {
 			[this.schema.name] : options.parent_value
 		};
+	} else if (options._root_data) {
+
+		let root_data = options._root_data;
+
+		if (root_data[this.schema.name]) {
+			root_data = root_data[this.schema.name];
+		}
+
+		record = {
+			[this.schema.name] : root_data
+		};
 	} else {
 		record = {
 			[this.schema.name] : {

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;
@@ -1626,7 +1647,7 @@ Hawkejs.Model = Model;
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.0.1
- * @version  1.1.1
+ * @version  1.3.20
  *
  * @param    {Document}   document
  * @param    {Object}     options
@@ -1675,9 +1696,9 @@ Model.setMethod(function saveRecord(document, options, callback) {
 			creating = options.create || doc.$pk == null;
 			next();
 		});
-	}, function doBeforeSave(next) {
+	}, function doBeforeNormalize(next) {
 		// @TODO: make "beforeSave" only use promises
-		that.callOrNext('beforeSave', [document, options], next);
+		that.callOrNext('beforeNormalize', [document, options], next);
 	}, function emitSavingEvent(next) {
 		// @TODO: Should this be able to stop the saving without throwing an error?
 		that.issueEvent('saving', [document, options, creating], next);
@@ -1771,28 +1792,42 @@ Model.setMethod(function compose(data, options) {
 /**
  * Create a record in the database
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.3.1
+ * @version  1.3.21
  *
- * @param    {Object}     data       The record data to check
+ * @param    {Document}   document
  * @param    {Object}     options
  * @param    {Function}   callback
  */
-Model.setMethod(function createRecord(data, options, callback) {
+Model.setMethod(function createRecord(document, options, callback) {
 
 	const that = this;
 
 	// Normalize & clone the data, set default values, ...
-	data = this.compose(data, options);
+	let data = this.compose(document, options);
+
+	document = createDocumentForSaving(this, document, data);
 
-	Function.series(function validate(next) {
+	Function.series(function recompute(next) {
+		let result = document.recomputeValues();
+
+		if (result) {
+			result.done(next);
+		} else {
+			next();
+		}
+	}, function doBeforeValidate(next) {
+		that.callOrNext('beforeValidate', [document, options], next);
+	}, function validate(next) {
 
 		if (options.validate === false || !that.schema) {
 			return next();
 		}
 
-		Pledge.done(that.schema.validate(that.createDocument(data)), next);
+		Pledge.done(that.schema.validate(document), next);
+	}, function doBeforeSave(next) {
+		that.callOrNext('beforeSave', [document, options], next);
 	}, function done(err) {
 
 		if (err) {
@@ -1816,32 +1851,70 @@ Model.setMethod(function createRecord(data, 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@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.3.1
+ * @version  1.3.21
  *
- * @param    {Object}     data       The record data to check
+ * @param    {Document}   document
  * @param    {Object}     options
  * @param    {Function}   callback
  */
-Model.setMethod(function updateRecord(data, options, callback) {
+Model.setMethod(function updateRecord(document, options, callback) {
 
 	const that = this;
 
 	// Normalize the data, but no default values should be set (skip non present items)
-	data = this.compose(data, Object.assign({update: true}, options));
+	let data = this.compose(document, Object.assign({update: true}, options));
+
+	// Turn it into a new document
+	document = createDocumentForSaving(this, document, data);
+
+	Function.series(function recompute(next) {
+		let result = document.recomputeValues();
 
-	Function.series(function validate(next) {
+		if (result) {
+			result.done(next);
+		} else {
+			next();
+		}
+	}, function doBeforeValidate(next) {
+		that.callOrNext('beforeValidate', [document, options], next);
+	}, function validate(next) {
 
 		if (options.validate === false || !that.schema) {
 			return next();
 		}
 
-		Pledge.done(that.schema.validate(that.createDocument(data)), next);
+		Pledge.done(that.schema.validate(document), next);
 
+	}, function doBeforeSave(next) {
+		that.callOrNext('beforeSave', [document, options], next);
 	}, function done(err) {
 
 		if (err) {

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