alchemymvc 1.2.8 → 1.3.1

package/lib/class/controller.js

@@ -225,9 +225,9 @@ Controller.setMethod(function renderDialogIn(config, template) {
 /**
  * Render the given template and send it to the client
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.3.1
  *
  * @param   {Number}   status
  * @param   {Array}    template
@@ -236,17 +236,24 @@ Controller.setMethod(function renderDialogIn(config, template) {
  */
 Controller.setMethod(function render(status, template) {
 
-	var that = this,
-	    pledge = new Classes.Pledge();
+	const conduit = this.conduit;
 
-	this.renderHTML(status, template).done(function gotHtml(err, output) {
+	const session = conduit.getSession(false);
+
+	if (session) {
+		session.incrementRenderCount();
+	}
+
+	let pledge = new Classes.Pledge();
+
+	this.renderHTML(status, template).done(async (err, output) => {
 
 		if (err) {
-			that.conduit.error(err);
+			conduit.error(err);
 			return pledge.resolve(false);
 		}
 
-		that.conduit.end(output);
+		conduit.end(output);
 		pledge.resolve(true);
 	});
 
@@ -466,7 +473,7 @@ Controller.setAction(async function readDatasource(conduit) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    1.0.4
- * @version  1.0.6
+ * @version  1.3.1
  */
 Controller.setAction(async function saveRecord(conduit) {
 
@@ -488,14 +495,10 @@ Controller.setAction(async function saveRecord(conduit) {
 		return;
 	}
 
-	let that = this,
-	    data = conduit.param('data'),
-	    options = conduit.param('options');
+	let body = JSON.undry(conduit.body);
 
-	// @TODO: Add some checks here?
-	if (data) {
-		data = JSON.undry({data: data}).data;
-	}
+	let options = body.options,
+	    data = body.data;
 
 	if (Object.isPlainObject(data)) {
 		data = model.createDocument(data);

package/lib/class/datasource.js

@@ -165,7 +165,7 @@ Datasource.setMethod(function getSchema(schema) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.2.0
+ * @version  1.3.0
  *
  * @param    {Schema|Model}   schema
  * @param    {Object}         data
@@ -187,7 +187,11 @@ Datasource.setMethod(function toDatasource(schema, data, callback) {
 	}
 
 	if (!schema) {
-		log.todo('Schema not found: not normalizing data', data);
+
+		if (alchemy.settings.debug) {
+			alchemy.distinctProblem('schema-not-found', 'Schema not found: not normalizing data');
+		}
+
 		pledge = Pledge.resolve(data);
 		pledge.done(callback);
 		return pledge;
@@ -252,7 +256,7 @@ Datasource.setMethod(function toDatasource(schema, data, callback) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.3.1
  *
  * @param    {Schema|Model}   schema
  * @param    {Object}         query
@@ -277,7 +281,7 @@ Datasource.setMethod(function toApp(schema, query, options, data, callback) {
 	schema = this.getSchema(schema);
 
 	if (schema == null) {
-		log.todo('Schema not found: not unnormalizing data');
+		alchemy.distinctProblem('schema-not-found-unnormalize', 'Schema not found: not un-normalizing data');
 
 		let pledge = Pledge.resolve(data);
 		pledge.done(callback);
@@ -515,13 +519,22 @@ Datasource.setMethod(function read(model, criteria, callback) {
 			return pledge.reject(err);
 		}
 
+		if (criteria.options.return_raw_data) {
+			criteria.setOption('document', false);
+			return handleResults(null, results);
+		}
+
 		tasks = results.map(function eachEntry(entry) {
 			return function entryToApp(next) {
 				that.toApp(model, criteria, {}, entry, next);
 			};
 		});
 
-		sub_pledge = Function.parallel(tasks, function done(err, app_results) {
+		sub_pledge = Function.parallel(tasks, handleResults);
+
+		pledge._addProgressPledge(sub_pledge);
+
+		function handleResults(err, app_results) {
 
 			if (err) {
 				return pledge.reject(err);
@@ -545,9 +558,7 @@ Datasource.setMethod(function read(model, criteria, callback) {
 			}
 
 			pledge.resolve(result);
-		});
-
-		pledge._addProgressPledge(sub_pledge);
+		}
 	});
 
 	if (this.queryCache && model.cache && cache_pledge) {

package/lib/class/document.js

@@ -647,7 +647,7 @@ Document.setMethod(['populate', 'addAssociatedData'], function addAssociatedData
  *
  * @author   Jelle De Loecker <jelle@develry.be>
  * @since    0.3.0
- * @version  0.3.0
+ * @version  1.3.0
  *
  * @param    {Object}   options
  *
@@ -663,7 +663,7 @@ Document.setMethod(function getDisplayFieldValue(options) {
 		options = {};
 	}
 
-	display_field = Array.cast(this.$model.displayField);
+	display_field = Array.cast(this.$model.display_field);
 
 	// If there are fields we prefer, check those first
 	if (options.prefer) {
@@ -674,7 +674,7 @@ Document.setMethod(function getDisplayFieldValue(options) {
 		result = this[display_field[i]];
 
 		if (result) {
-			result = alchemy.pickTranslation(undefined, result).result;
+			result = alchemy.pickTranslation(options.prefix, result).result;
 
 			if (result) {
 				return result;

package/lib/class/field.js

@@ -100,6 +100,19 @@ Field.setStatic(function createPathEvaluator(path) {
 	return new Classes.Alchemy.PathEvaluator(path);
 });
 
+/**
+ * Get the description of the field
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @type     {String}
+ */
+Field.setProperty(function description() {
+	return this.options?.description || this.options?.options?.description || null;
+});
+
 /**
  * Is this a private field?
  *
@@ -288,16 +301,17 @@ Field.setStatic(function unDry(value) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.3.1
  *
  * @return   {Object}
  */
 Field.setMethod(function toDry() {
 	return {
 		value: {
+			bla: 1,
 			schema  : this.schema,
 			name    : this.name,
-			options : this.options
+			options : this.getOptionsForDrying(),
 		}
 	};
 });
@@ -671,7 +685,7 @@ Field.setMethod(function _toDatasource(value, data, datasource, callback) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.1.5
+ * @version  1.3.1
  *
  * @param    {Object}   values
  */
@@ -685,6 +699,10 @@ Field.setMethod(function regularToDatasource(value, data, datasource, callback)
 		return this._toDatasource(value, data, datasource, callback);
 	}
 
+	if (!value) {
+		return callback();
+	}
+
 	// Arrayable fields need to process every value inside the array
 	tasks = value.map(function eachValue(entry) {
 		return function eachValueToDs(next) {
@@ -1020,6 +1038,19 @@ Field.setMethod(function getClientConfigOptions(wm) {
 	return JSON.clone(this.options, 'toHawkejs', wm);
 });
 
+/**
+ * Get the options that can be used for drying
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.1
+ * @version  1.3.1
+ *
+ * @return   {Object}
+ */
+Field.setMethod(function getOptionsForDrying() {
+	return this.options;
+});
+
 /**
  * Get all the rules for this field
  *

package/lib/class/inode.js

@@ -26,6 +26,33 @@ var Inode = Function.inherits('Alchemy.Base', 'Alchemy.Inode', function Inode(pa
 	this.stat = null;
 });
 
+/**
+ * Get the correct Inode instance for the given path
+ *
+ * @author   Jelle De Loecker   <jelle@develry.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ * 
+ * @param    {String}   path
+ *
+ * @return   {Pledge<Inode>}
+ */
+Inode.setStatic(function from(path) {
+
+	const pledge = new Pledge();
+
+	Inode.process(path, null, (err, inode) => {
+
+		if (err) {
+			return pledge.reject(err);
+		}
+
+		pledge.resolve(inode);
+	});
+
+	return pledge;
+});
+
 /**
  * Process given path
  *

package/lib/class/inode_file.js

@@ -1,4 +1,10 @@
-const fs = alchemy.use('fs');
+const HASH = Symbol('hash'),
+      ALGORITHM = Symbol('algorithm'),
+      LIBMAGIC = alchemy.use('mmmagic'),
+      LIBMIME = alchemy.use('mime'),
+      fs = alchemy.use('fs');
+
+let Magic;
 
 /**
  * The File class
@@ -17,8 +23,8 @@ var File = Function.inherits('Alchemy.Inode', function File(path) {
 		return File.from(path);
 	}
 
+	this.possible_type = null;
 	this.type = null;
-	this.hash = null;
 
 	File.super.call(this, path);
 });
@@ -34,12 +40,130 @@ var File = Function.inherits('Alchemy.Inode', function File(path) {
  */
 File.setProperty('is_file', true);
 
+/**
+ * Detect the filetype of the given path
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @param    {String}   path
+ *
+ * @return   {Pledge<String>}
+ */
+File.setStatic(function getMimetype(path) {
+
+	let pledge = new Pledge();
+
+	if (!Magic && LIBMAGIC) {
+		Magic = new LIBMAGIC.Magic(LIBMAGIC.MAGIC_MIME_TYPE);
+	}
+
+	if (Magic) {
+		Magic.detectFile(path, (err, result) => {
+
+			if (err || result == 'application/octet-stream' || result == 'text/plain') {
+				result = File.guessMimetypeFromPath(path, result);
+			}
+
+			if (result == 'application/javascript') {
+				result = 'text/javascript';
+			} else if (result == 'image/svg') {
+				result = 'image/svg+xml';
+			}
+
+			pledge.resolve(result);
+		});
+	}
+
+	return pledge;
+});
+
+/**
+ * Guess the mimetype from the path
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @param    {String}   path
+ * @param    {String}   fallback
+ *
+ * @return   {String}
+ */
+File.setStatic(function guessMimetypeFromPath(path, fallback) {
+
+	let result = fallback;
+
+	if (LIBMIME) {
+		result = LIBMIME.getType(path);
+
+		if (fallback && result != fallback) {
+			if (result == 'application/octet-stream' || result == 'text/plain') {
+				result = fallback;
+			}
+		}
+	}
+
+	return result;
+});
+
+/**
+ * Create a File instance from the given variable
+ * (From an untrusted source)
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ */
+File.setStatic(function fromUntrusted(obj) {
+
+	if (!obj) {
+		return;
+	}
+
+	if (typeof obj == 'string') {
+		return File.from(obj);
+	}
+
+	let path,
+	    name,
+	    type,
+	    hash,
+	    size;
+
+	if (obj.originalFilename) {
+		// Formidable 2.0
+		path = obj.filepath;
+		name = obj.originalFilename;
+		type = obj.mimetype;
+		hash = obj.hash;
+		size = obj.size;
+	} else {
+		path = obj.path;
+		name = obj.name;
+		type = obj.type;
+		hash = obj.hash;
+		size = obj.size;
+	}
+
+	obj = {
+		path,
+		name,
+		hash,
+		size,
+		possible_type : type,
+	};
+
+	return File.from(obj);
+});
+
 /**
  * Create a File instance from the given variable
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    1.1.0
- * @version  1.2.7
+ * @version  1.3.0
  */
 File.setStatic(function from(obj) {
 
@@ -47,7 +171,8 @@ File.setStatic(function from(obj) {
 		return;
 	}
 
-	let path,
+	let possible_type,
+	    path,
 	    name,
 	    type,
 	    hash,
@@ -68,6 +193,7 @@ File.setStatic(function from(obj) {
 		type = obj.type;
 		hash = obj.hash;
 		size = obj.size;
+		possible_type = obj.possible_type;
 	}
 
 	let file = new File(path);
@@ -88,9 +214,83 @@ File.setStatic(function from(obj) {
 		file.hash = hash;
 	}
 
+	if (possible_type) {
+		file.possible_type = possible_type;
+	}
+
 	return file;
 });
 
+/**
+ * Get the mimetype of the file
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @return   {String|Pledge<String>}
+ */
+File.setMethod(function getMimetype() {
+
+	if (!this.type) {
+		const pledge = new Pledge();
+		this.type = pledge;
+
+		File.getMimetype(this.path).done((err, result) => {
+
+			if (err || !result) {
+				result = this.possible_type;
+			}
+
+			this.type = result;
+			pledge.resolve(result);
+		});
+	}
+
+	return this.type;
+});
+
+/**
+ * Get the SHA1 hash of the file
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @param    {String}   algorithm
+ *
+ * @return   {String|Pledge<String>}
+ */
+File.setMethod(function getHash(algorithm) {
+
+	algorithm = algorithm || alchemy.settings.file_hash_algorithm;
+
+	if (!this[HASH] || this[ALGORITHM] != algorithm) {
+		const options = {algorithm};
+		this[HASH] = alchemy.hashFile(this.path, options);
+		this[ALGORITHM] = algorithm;
+
+		this[HASH].done((err, result) => {
+			this[HASH] = result;
+		});
+	}
+
+	return this[HASH];
+});
+
+/**
+ * Create a read stream
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @param    {Object}   options   Options passed to the `fs.createReadStream` method
+ */
+File.setMethod(function createReadStream(options) {
+	return fs.createReadStream(this.path, options);
+});
+
 /**
  * Read and return the contents
  *

package/lib/class/migration.js

@@ -118,7 +118,7 @@ Migration.setStatic(async function start() {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    1.2.0
- * @version  1.2.0
+ * @version  1.3.1
  */
 Migration.setMethod(function processRecords(model_name, fnc) {
 
@@ -127,6 +127,7 @@ Migration.setMethod(function processRecords(model_name, fnc) {
 	let options = {
 		document       : false,
 		parallel_limit : 1,
+		return_raw_data: true,
 	};
 
 	return model.eachRecord(options, async (record, index, next) => {

package/lib/class/model.js

@@ -509,7 +509,7 @@ Model.setStatic(function getField(name) {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    1.0.0
- * @version  1.2.7
+ * @version  1.3.1
  */
 Model.setStatic(function getClientConfig() {
 
@@ -518,10 +518,21 @@ Model.setStatic(function getClientConfig() {
 		schema        : this.schema,
 		primary_key   : this.prototype.primary_key,
 		display_field : this.prototype.display_field,
+		ancestors     : 0,
 	};
 
 	if (this.super.name != 'Model') {
 		result.parent = this.super.name;
+
+		let ancestors = 0,
+		    ancestor = this.super;
+		
+		while (ancestor && ancestor.name != 'Model') {
+			ancestors++;
+			ancestor = ancestor.super;
+		}
+
+		result.ancestors = ancestors;
 	}
 
 	return result;
@@ -643,7 +654,7 @@ Model.setMethod(function aggregate(pipeline, callback) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.2.7
+ * @version  1.3.0
  *
  * @param    {Array}    items
  * @param    {Object}   options   Optional options object
@@ -661,7 +672,7 @@ Model.setMethod(function translateItems(items, options, callback) {
 	}
 
 	// No fields in this schema are translatable
-	if (!this.schema.hasTranslations) {
+	if (!this.schema.has_translations) {
 		return callback();
 	}
 
@@ -775,8 +786,8 @@ Model.setMethod(function translateItems(items, options, callback) {
 		for (j = 0; j < collection.length; j++) {
 			record = collection[j];
 
-			for (fieldName in this.schema.translatableFields) {
-				field = this.schema.translatableFields[fieldName];
+			for (fieldName in this.schema.translatable_fields) {
+				field = this.schema.translatable_fields[fieldName];
 				field.translateRecord(prefixes, record, options.allow_empty);
 			}
 		}