alchemymvc 1.2.8 → 1.3.0

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

package/lib/class/route.js

@@ -3,9 +3,9 @@
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.2.5
+ * @version  1.3.0
  */
-var Route = Function.inherits('Alchemy.Base', function Route(router, paths, options) {
+const Route = Function.inherits('Alchemy.Base', function Route(router, paths, options) {
 
 	// Store the parent router
 	this.router = router;
@@ -45,6 +45,12 @@ var Route = Function.inherits('Alchemy.Base', function Route(router, paths, opti
 	this.permission = null;
 	this.has_permission_assignments = false;
 
+	// The sitemap configuration
+	this.sitemap = null;
+
+	// Can this route's path be used in the browser's address location?
+	this.visible_location = true;
+
 	// If no fnc is given, these will be called
 	this.controller = null;
 	this.action = null;
@@ -61,6 +67,65 @@ var Route = Function.inherits('Alchemy.Base', function Route(router, paths, opti
  */
 Route.setDeprecatedProperty('isMiddleware', 'is_middleware');
 
+/**
+ * Does this route require extra data for translating to another language?
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @return   {Boolean}
+ */
+Route.setProperty(function requires_data_for_translation() {
+
+	if (!this.is_prefix_aware || !this.has_path_assignments) {
+		return false;
+	}
+
+	return true;
+});
+
+/**
+ * Does this route have any path assignments?
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @return   {Boolean}
+ */
+Route.setProperty(function has_path_assignments() {
+	return !!this.keys?.length;
+});
+
+/**
+ * Does this route use any type class checks?
+ * (Type CLASS checks use the type checker of a specific class)
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @return   {Boolean}
+ */
+Route.setProperty(function has_type_class_checks() {
+
+	let result = false,
+	    path,
+	    key;
+
+	for (key in this.paths) {
+		path = this.paths[key];
+
+		if (path.uses_type_class_checks) {
+			result = true;
+			break;
+		}
+	}
+
+	return result;
+});
+
 /**
  * Set the breadcrumb for this route
  *
@@ -122,7 +187,7 @@ Route.setMethod(function setPermission(permission) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.3.0
  *
  * @param    {String|Object}   paths
  */
@@ -150,7 +215,10 @@ Route.setMethod(function setPaths(paths) {
 
 	for (prefix in paths) {
 		path = paths[prefix];
-		definition = new Classes.Alchemy.PathDefinition(path, {end: !this.is_middleware});
+		definition = new Classes.Alchemy.PathDefinition(path, {
+			prefix,
+			end: !this.is_middleware,
+		});
 		this.paths[prefix] = definition;
 
 		if (definition.keys.length) {
@@ -513,29 +581,21 @@ Route.setMethod(function generateUrl(parameters, conduit) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.0.5
+ * @version  1.3.0
  *
  * @param    {Conduit}   conduit
  */
-Route.setMethod(function callController(conduit) {
+Route.setMethod(function callController(...args) {
 
-	var instance,
-	    args,
-	    i;
+	const conduit = args[0];
 
 	if (this.controller) {
-		instance = Controller.get(this.controller, conduit);
+		let instance = Controller.get(this.controller, conduit);
 
 		if (!instance) {
 			return conduit.error(new Error('Could not find controller "' + this.controller + '"'));
 		}
 
-		args = new Array(arguments.length);
-
-		for (i = 0; i < args.length; i++) {
-			args[i] = arguments[i];
-		}
-
 		return instance.doAction(this.action, args);
 	}
 
@@ -546,41 +606,125 @@ Route.setMethod(function callController(conduit) {
  * Call a controller action as handler, but get info from the url first.
  * This gets called by `callHandler`.
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  0.2.0
+ * @version  1.3.0
  *
  * @param    {Conduit}   conduit
  */
-Route.setMethod(function callControllerAssignments(conduit) {
+Route.setMethod(function callControllerAssignments(...args) {
 
-	var controller,
-	    instance,
-	    action,
-	    args,
-	    i;
+	const conduit = args[0];
 
 	if (this.controller) {
 
 		// Get the controller name from the route parameters
-		controller = this.controller.assign(conduit.params);
+		let controller = this.controller.assign(conduit.params);
 
 		// Try getting a controller instance
-		instance = Controller.get(controller, conduit);
+		let instance = Controller.get(controller, conduit);
 
 		if (!instance) {
 			throw new Error('Could not find controller "' + controller + '"');
 		}
 
-		args = new Array(arguments.length);
+		let action = this.action.assign(conduit.params);
+		return instance.doAction(action, args);
+	}
+
+	throw new Error('No valid controller was set');
+});
+
+/**
+ * Set the values needed for translating this route
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @param    {Controller}   controller
+ * @param    {Conduit}      conduit
+ */
+Route.setMethod(function getRouteTranslations(controller, conduit) {
+
+	if (!this.has_type_class_checks) {
+		return;
+	}
+
+	const current_prefix = conduit.prefix,
+	      paths = [];
+
+	let path;
+
+	for (let key in this.paths) {
+
+		if (!key || key == current_prefix) {
+			continue;
+		}
+
+		path = this.paths[key];
 
-		for (i = 0; i < args.length; i++) {
-			args[i] = arguments[i];
+		if (!path?.param_definitions?.length) {
+			continue;
 		}
 
-		action = this.action.assign(conduit.params);
-		return instance.doAction(action, args);
+		paths.push(path);
 	}
 
-	throw new Error('No valid controller was set');
+	if (!paths.length) {
+		return;
+	}
+
+	return this._getRouteTranslations(controller, conduit, paths);
+});
+
+/**
+ * Do the actual path value translations
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @param    {Controller}   controller
+ * @param    {Conduit}      conduit
+ */
+Route.setMethod(async function _getRouteTranslations(controller, conduit, paths) {
+
+	let param_def,
+	    result = {},
+	    path;
+
+	// Also add the current prefix
+	result[conduit.prefix] = alchemy.routeUrl(this.name, conduit.route_string_parameters, {prefix: conduit.prefix});
+
+	for (path of paths) {
+		
+		// Create a shallow clone of the original string parameters
+		let params = Object.assign({}, conduit.route_string_parameters);
+
+		for (param_def of path.param_definitions) {
+			let current_value = conduit.param(param_def.name),
+			    new_value;
+
+			if (current_value && current_value.getTranslatedValueOfField) {
+				new_value = await current_value.getTranslatedValueOfField(param_def.name, path.prefix);
+			}
+
+			if (!new_value) {
+				params = false;
+				break;
+			}
+
+			params[param_def.name] = new_value;
+		}
+
+		if (!params) {
+			result[path.prefix] = false;
+			continue;
+		}
+
+		result[path.prefix] = alchemy.routeUrl(this.name, params, {prefix: path.prefix});
+	}
+
+	return result;
 });

package/lib/class/router.js

@@ -701,7 +701,7 @@ RouterClass.setMethod(function use(_paths, _fnc, _options) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    1.1.0
- * @version  1.1.0
+ * @version  1.3.0
  *
  * @param    {String}   module_name   The name of the dependency
  * @param    {Object}   options       The options or single string
@@ -740,6 +740,10 @@ RouterClass.setMethod(function serveDependencyFile(module_name, options) {
 	}
 
 	this.use(options.alias, function serveFile(req, res) {
+
+		// Cache this file so earlier middleware can handle this from now on
+		alchemy.getCache('files.assets').set(req.url, {path: options.path});
+
 		req.conduit.serveFile(options.path);
 	});
 });
@@ -763,7 +767,7 @@ RouterClass.setMethod(function setOption(name, value) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.2.5
+ * @version  1.3.0
  *
  * @param    {Object}   args
  * @param    {String}   args.name            Optional route name
@@ -813,6 +817,12 @@ RouterClass.setMethod(function add(args) {
 	route.name = args.name;
 	route.methods = args.methods;
 	route.setBreadcrumb(args.breadcrumb);
+	route.sitemap = args.sitemap;
+	route.title = args.title;
+
+	if (args.visible_location != null) {
+		route.visible_location = args.visible_location;
+	}
 
 	if (args.permission) {
 		route.setPermission(args.permission);
@@ -846,6 +856,8 @@ RouterClass.setMethod(function add(args) {
 		allroutes[this.name + '::' + args.name] = '' + this.name + ' - ' + args.name;
 	}
 
+	alchemy.checkExposedRouteData();
+
 	return route;
 });
 
@@ -1147,7 +1159,7 @@ RouterClass.setMethod(function getOptions(result) {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.2.7
+ * @version  1.3.0
  *
  * @param    {Object}   result   Optional object to store sectioned results in
  *
@@ -1194,6 +1206,8 @@ RouterClass.setMethod(function getRoutes(result) {
 			methods                    : route.methods,
 			permission                 : route.permission || undefined,
 			has_permission_assignments : route.has_permission_assignments || undefined,
+			title                      : route.title,
+			visible_location           : route.visible_location,
 		};
 	}
 

package/lib/class/schema.js

@@ -74,7 +74,7 @@ Schema.setStatic(function unDry(value) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  0.2.3
+ * @version  1.3.0
  *
  * @param    {String}   behaviour_name
  * @param    {Object}   options
@@ -88,7 +88,7 @@ Schema.setMethod(function addBehaviour(behaviour_name, options) {
 		throw new Error('Could not find Behaviour "' + behaviour_name + '"');
 	}
 
-	this.hasBehaviours++;
+	this.has_behaviours++;
 
 	if (!options) {
 		options = {};
@@ -122,7 +122,7 @@ Schema.setMethod(function addBehaviour(behaviour_name, options) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  0.3.0
+ * @version  1.3.0
  *
  * @param    {Object}   data
  * @param    {String}   hasType   Get indexes with this type only
@@ -138,8 +138,8 @@ Schema.setMethod(function getRecordIndexes(data, hasType) {
 	result = {};
 
 	for (fieldName in data) {
-		if (this.indexFields[fieldName] != null) {
-			indexName = this.indexFields[fieldName].name;
+		if (this.index_fields[fieldName] != null) {
+			indexName = this.index_fields[fieldName].name;
 
 			// Skip non alternates
 			if (hasType && !this.indexes[indexName].options[hasType]) {
@@ -412,18 +412,18 @@ Schema.setMethod(function addAssociation(type, alias, modelName, options) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  0.2.0
+ * @version  1.3.0
  *
  * @param    {String}   name
  * @param    {Object}   values
  */
 Schema.setMethod(function addEnumValues(name, values) {
 
-	if (this.enumValues[name] == null) {
-		this.enumValues[name] = {};
+	if (this.enum_values[name] == null) {
+		this.enum_values[name] = {};
 	}
 
-	Object.assign(this.enumValues[name], values);
+	Object.assign(this.enum_values[name], values);
 });
 
 /**
@@ -432,13 +432,13 @@ Schema.setMethod(function addEnumValues(name, values) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  0.2.0
+ * @version  1.3.0
  *
  * @param    {String}   name
  * @param    {Object}   values
  */
 Schema.setMethod(function setEnumValues(name, values) {
-	this.enumValues[name] = values;
+	this.enum_values[name] = values;
 });
 
 /**