alchemymvc 1.2.8 → 1.3.1

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;

package/lib/class/path_param_definition.js

@@ -0,0 +1,202 @@
+const PathDefinition = Classes.Alchemy.PathDefinition;
+
+/**
+ * Path param definition
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ */
+const PathParamDefinition = Function.inherits('Alchemy.Base', function PathParamDefinition(config) {
+
+	// The delimiter, probably "/"
+	this.delimiter = config.delimiter;
+
+	// The name of this parameter
+	this.name = config.name;
+
+	// Is this parameter optional?
+	this.optional = config.optional || false;
+
+	this.partial = config.partial;
+	this.pattern = config.pattern;
+	this.prefix = config.prefix;
+	this.repeat = config.repeat;
+
+	// Set the raw type definition
+	this.typedef = config.typedef;
+
+	// Does this have a type definition?
+	this.has_type_definition = !!this.typedef;
+
+	// Does this use a simple typedefinition?
+	this.uses_simple_typedef = false;
+
+	// The optional type class name
+	this.type_class_name = null;
+
+	// The optional field inside the class
+	this.type_field_name = null;
+
+	// The optional type class constructor
+	this.type_class_constructor = null;
+
+	// Has all the config been parsed?
+	this.is_parsed = false;
+});
+
+/**
+ * Create path param definitions
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @param    {Array|Object}
+ */
+PathParamDefinition.setStatic(function from(input) {
+
+	if (!input) {
+		return;
+	}
+
+	if (Array.isArray(input)) {
+		let result = [],
+		    entry,
+		    temp;
+
+		for (entry of input) {
+			temp = PathParamDefinition.from(entry);
+
+			if (temp) {
+				result.push(temp);
+			}
+		}
+	
+		return result;
+	}
+
+	return new this(input);
+});
+
+/**
+ * Parse the type definition
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ */
+PathParamDefinition.setMethod(function parseTypeDefinition() {
+
+	if (this.is_parsed) {
+		return;
+	}
+
+	this.is_parsed = true;
+
+	if (!this.has_type_definition) {
+		return;
+	}
+
+	let class_name,
+	    field_name;
+
+	if (typeof this.typedef == 'string') {
+		this.uses_simple_typedef = !!PathDefinition.typedefs[this.typedef];
+
+		// If it's not a simple type, the type is a class name
+		if (!this.uses_simple_typedef) {
+			class_name = this.typedef;
+		}
+	} else {
+		class_name = this.typedef[0];
+		field_name = this.typedef[1];
+	}
+
+	if (class_name) {
+		this.type_class_name = class_name;
+		this.type_field_name = field_name;
+
+		const Model = Classes.Alchemy.Model || Classes.Alchemy.Client.Model;
+		this.type_class_constructor = Object.path(Model, class_name) || Object.path(Classes.Alchemy, class_name) || Object.path(Classes, class_name);
+	}
+});
+
+/**
+ * Check the value
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @param    {Boolean|Pledge<Boolean>}
+ */
+PathParamDefinition.setMethod(function castValueToType(value, conduit) {
+
+	if (!this.is_parsed) {
+		this.parseTypeDefinition();
+	}
+
+	let result;
+
+	if (this.uses_simple_typedef) {
+		result = PathDefinition.typedefs[this.typedef](value, this.name, conduit);
+	} else if (this.type_class_constructor?.checkPathValue) {
+		result = this.type_class_constructor.checkPathValue(value, this.name, this.type_field_name, conduit);
+	}
+
+	return result;
+});
+
+
+/**
+ * Parse an original path value
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @param    {Object|Pledge<Object>}
+ */
+PathParamDefinition.setMethod(function parsePathValue(original_value, conduit) {
+
+	let result = {
+		name     : this.name,
+		value    : original_value,
+		rejected : false,
+		original_value,
+	};
+
+	if (this.has_type_definition) {
+		let new_value = this.castValueToType(original_value, conduit);
+
+		if (typeof new_value === 'undefined') {
+			return false;
+		}
+
+		if (Pledge.isThenable(new_value)) {
+			let pledge = new Pledge();
+
+			Pledge.done(new_value, (err, new_value) => {
+
+				if (err) {
+					pledge.reject(err);
+				} else {
+					result.value = new_value;
+
+					if (new_value == null) {
+						result.rejected = true;
+					}
+
+					pledge.resolve(result);
+				}
+			});
+
+			return pledge;
+		}
+
+		result.value = new_value;
+	}
+
+	return result;
+});