alchemymvc 1.2.8 → 1.3.0

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?
  *

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/model.js

@@ -643,7 +643,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 +661,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 +775,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);
 			}
 		}

package/lib/class/path_definition.js

@@ -3,12 +3,9 @@
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    1.0.0
- * @version  1.0.0
+ * @version  1.3.0
  */
-var PathDefinition = Function.inherits('Alchemy.Base', function PathDefinition(path, options) {
-
-	var tokens,
-	    i;
+const PathDefinition = Function.inherits('Alchemy.Base', function PathDefinition(path, options) {
 
 	// Store the original path
 	this.path = path;
@@ -17,22 +14,32 @@ var PathDefinition = Function.inherits('Alchemy.Base', function PathDefinition(p
 	// Store the key tokens
 	this.key_tokens = [];
 
+	// Store the param definitions
+	this.param_definitions = null;
+
 	// Store the key names
 	this.keys = [];
 
 	// Path options
 	this.options = options || {};
 
+	// The prefix of this path
+	this.prefix = this.options.prefix;
+
 	// Get the tokens
-	tokens = this.parse(path);
+	let tokens = this.parse(path);
 
 	if (!this.regex) {
+		let i;
+
 		// Compile the regex
 		this.regex = this.tokensToRegexp(tokens, this.key_tokens);
 
 		for (i = 0; i < this.key_tokens.length; i++) {
 			this.keys[i] = this.key_tokens[i].name;
 		}
+
+		this.param_definitions = Classes.Alchemy.PathParamDefinition.from(this.key_tokens);
 	}
 });
 
@@ -103,6 +110,34 @@ PathDefinition.setStatic(function escapeString(str) {
 	return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, '\\$1')
 });
 
+
+/**
+ * Does this path use any type class checks?
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ */
+PathDefinition.enforceProperty(function uses_type_class_checks(new_value) {
+
+	if (new_value == null) {
+		new_value = false;
+
+		if (this.param_definitions?.length) {
+			for (let def of this.param_definitions) {
+				def.parseTypeDefinition();
+
+				if (def.type_class_constructor) {
+					new_value = true;
+					break;
+				}
+			}
+		}
+	}
+
+	return new_value;
+});
+
 /**
  * Get the complete section identifier
  *
@@ -364,7 +399,7 @@ PathDefinition.setMethod(function getParametersObject(values, info_type) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    1.0.0
- * @version  1.1.0
+ * @version  1.3.0
  *
  * @param    {String}   path
  *
@@ -372,15 +407,7 @@ PathDefinition.setMethod(function getParametersObject(values, info_type) {
  */
 PathDefinition.setMethod(function test(path, conduit) {
 
-	var that = this,
-	    reject,
-	    values,
-	    result,
-	    pledge,
-	    tasks;
-
-	// See if it matches & get the values
-	values = this.regex.exec(path);
+	const values = this.regex.exec(path);
 
 	if (!values) {
 		return null;
@@ -389,133 +416,62 @@ PathDefinition.setMethod(function test(path, conduit) {
 	// Remove the first part of the value, it's just the match
 	values.shift();
 
-	// Create a new array
-	result = new Array(values.length);
-	tasks = [];
+	let result = new Array(values.length),
+	    do_await = false;
 
 	// Iterate over the rest of the found values
-	values.forEach(function eachValue(value, index) {
-
-		var type_check,
-		    TypeChecker,
-		    token,
-		    entry;
-
-		if (reject) {
-			return;
-		}
-
-		token = that.key_tokens[index] || {};
-
-		value = RURL.decodeUriSegment(value);
-
-		entry = {
-			name           : token.name,
-			value          : value,
-			original_value : value
-		};
+	for (let index = 0; index < values.length; index++) {
 
-		if (token.typedef) {
-			type_check = that.checkType(value, token.typedef, token, conduit);
+		let value = RURL.decodeUriSegment(values[index]);
+		let param_def = this.param_definitions?.[index];
 
-			if (typeof type_check === 'undefined') {
-				reject = true;
-				return;
-			}
+		// There will be no param definition for regex-style matching
+		if (!param_def) {
+			let token = this.key_tokens[index] || {};
 
-			entry.original_value = value;
-			entry.value = type_check;
+			result[index] = {
+				name           : token.name,
+				value          : value,
+				original_value : value
+			};
 
-			if (type_check && type_check.then) {
-				tasks.push(function waitForCheck(next) {
-					type_check.then(function gotValue(value) {
+			continue;
+		}
 
-						if (value == null) {
-							// Returning with an error still fucks shit up
-							//return next(new Error('Path definition type check returned null'));
-							reject = true;
-							return next();
-						}
+		let entry = param_def.parsePathValue(value, conduit);
 
-						entry.value = value;
-						next();
-					});
+		// Return early when one of the checks fail
+		if (!entry) {
+			return null;
+		}
 
-					type_check.catch(function onError(err) {
-						next(err);
-					});
-				});
-			}
+		if (Pledge.isThenable(entry)) {
+			do_await = true;
+		} else if (entry.rejected) {
+			return null;
 		}
 
 		result[index] = entry;
-	});
-
-	// Something made reject truthy,
-	// so return null
-	if (reject) {
-		return null;
 	}
 
-	// If there are tasks, return the pledge
-	if (tasks.length) {
-		pledge = Function.parallel(tasks, function done(err) {
+	if (do_await) {
+
+		return Function.parallel(result, (err, result) => {
 
 			if (err) {
 				return null;
 			}
 
-			if (reject) {
-				return null;
+			let i;
+
+			for (i = 0; i < result.length; i++) {
+				if (result[i]?.rejected) {
+					return null;
+				}
 			}
 
 			return result;
 		});
-
-		return pledge;
-	}
-
-	return result;
-});
-
-/**
- * Get the type checker
- *
- * @author   Jelle De Loecker   <jelle@develry.be>
- * @since    1.0.0
- * @version  1.1.0
- *
- * @param    {String|Array}   typedef
- *
- * @return   {Function}
- */
-PathDefinition.setMethod(function checkType(value, typedef, token, conduit) {
-
-	var class_name,
-	    field_name,
-	    TypeClass,
-	    is_string = typeof typedef === 'string',
-	    result,
-	    Model;
-
-	if (is_string && PathDefinition.typedefs[typedef]) {
-		result = PathDefinition.typedefs[typedef](value, token.name, conduit);
-	} else {
-
-		Model = Blast.Classes.Alchemy.Model || Blast.Classes.Alchemy.Client.Model;
-
-		if (is_string) {
-			class_name = typedef;
-		} else {
-			class_name = typedef[0];
-			field_name = typedef[1];
-		}
-
-		TypeClass = Object.path(Model, class_name) || Object.path(Blast.Classes.Alchemy, class_name) || Object.path(Blast.Classes, class_name);
-
-		if (TypeClass && TypeClass.checkPathValue) {
-			result = TypeClass.checkPathValue(value, token.name, field_name, conduit);
-		}
 	}
 
 	return result;