alchemymvc 1.1.10 → 1.2.2

package/lib/app/datasource/mongo_datasource.js

@@ -228,7 +228,7 @@ Mongo.setMethod(function collection(name, callback) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.2.0
  */
 Mongo.setMethod(function _read(model, criteria, callback) {
 
@@ -250,22 +250,87 @@ Mongo.setMethod(function _read(model, criteria, callback) {
 
 		if (compiled.pipeline) {
 
-			collection.aggregate(compiled.pipeline, {}, function gotAggregate(err, cursor) {
+			// Sorting should happen in the pipeline
+			if (options.sort && options.sort.length) {
+				let sort_object = {};
 
-				if (err) {
-					return callback(err);
+				for (let entry of options.sort) {
+					sort_object[entry[0]] = entry[1];
 				}
 
-				cursor.toArray(function gotArray(err, items) {
+				compiled.pipeline.unshift({$sort: sort_object});
+			}
+
+			// Skipping also happens in the pipeline
+			if (options.skip) {
+				compiled.pipeline.push({$skip: options.skip});
+			}
+
+			let aggregate_options = {};
 
-					if (err) {
-						return callback(err);
+			// Limits can still be set as an option though
+			if (options.limit) {
+				aggregate_options.limit = options.limit;
+			}
+
+			Function.parallel({
+				available: function getAvailable(next) {
+
+					if (criteria.options.available === false) {
+						return next(null, null);
 					}
 
-					items = that.organizeResultItems(model, items);
+					let pipeline = JSON.clone(compiled.pipeline),
+					    cloned_options = JSON.clone(aggregate_options);
+
+					pipeline.push({$count: 'available'});
+
+					// Expensive aggregate just to get the available count...
+					collection.aggregate(pipeline, cloned_options, function gotAggregate(err, cursor) {
+
+						if (err) {
+							return next(err);
+						}
+
+						cursor.toArray(function gotAvailableArray(err, items) {
+
+							if (err) {
+								return next(err);
+							}
+
+							if (!items || !items.length) {
+								return next(null, null);
+							}
+
+							let available = items[0].available;
+
+							if (options.skip) {
+								available += options.skip;
+							}
+
+							return next(null, available);
+						});
+					});
+				},
+				items: function getItems(next) {
+					collection.aggregate(compiled.pipeline, aggregate_options, function gotAggregate(err, cursor) {
+
+						if (err) {
+							return next(err);
+						}
+
+						cursor.toArray(next);
+					});
+				}
+			}, function done(err, data) {
+
+				if (err) {
+					return callback(err);
+				}
+
+				data.items = that.organizeResultItems(model, data.items);
 
-					callback(null, items);
-				});
+				callback(err, data.items, data.available);
 			});
 
 			return;

package/lib/app/helper/backed_map.js

@@ -0,0 +1,257 @@
+const OBJECT = Symbol('Object'),
+      BACKING = Symbol('Backing'),
+	  MAP = Symbol('Map');
+
+/**
+ * The Backed map class
+ *
+ * @constructor
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.1
+ * @version  1.2.1
+ */
+const Backed = Function.inherits('Alchemy.Base', 'Alchemy.Map', function Backed(backing) {
+	this.local = new Map();
+	this.type = null;
+	this.backing = backing;
+});
+
+/**
+ * Undry the given value
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.1
+ * @version  1.2.1
+ *
+ * @param    {Object}   value
+ *
+ * @return   {EnumValues}
+ */
+Backed.setStatic(function unDry(value, custom_method, whenDone) {
+	let result = new this(value.backing);
+	return result;
+});
+
+/**
+ * Get the size
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.1
+ * @version  1.2.1
+ */
+Backed.setProperty(function size() {
+	return this.keys().length;
+});
+
+/**
+ * Set the backing value
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.1
+ * @version  1.2.1
+ */
+Backed.enforceProperty(function backing(new_value, old_value) {
+
+	this.backing = null;
+	this.type = null;
+
+	if (!new_value) {
+		return;
+	}
+
+	if (new_value instanceof Backed) {
+		this.type = BACKING;
+	} else if (new_value instanceof Map) {
+		this.type = MAP;
+	} else if (typeof new_value == 'object') {
+		this.type = OBJECT;
+	}
+
+	return new_value;
+});
+
+/**
+ * Create a (shallow) clone of this backed map.
+ * Since we don't ever touch the backing itself, we don't have to clone that.
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.1
+ * @version  1.2.1
+ *
+ * @return   {Backed}
+ */
+Backed.setMethod(function clone() {
+	let result = new Backed(this.backing);
+	result.local = new Map(this.local);
+	return result;
+});
+
+/**
+ * Create a (shallow) clone of this backed map.
+ * Since we don't ever touch the backing itself, we don't have to clone that.
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.1
+ * @version  1.2.1
+ *
+ * @return   {Backed}
+ */
+Backed.setMethod(function dryClone(wm, custom_method) {
+	return this.clone();
+});
+
+/**
+ * Simplify the object for Hawkejs
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.1
+ * @version  1.2.1
+ *
+ * @param    {WeakMap}   wm
+ *
+ * @return   {Backed}
+ */
+Backed.setMethod(function toHawkejs(wm) {
+
+	let values = new Map(),
+	    value,
+	    keys = this.keys(),
+		key;
+	
+	for (key of keys) {
+		value = this.get(key);
+		values.set(key, JSON.clone(value, 'toHawkejs', wm));
+	}
+
+	return new this.constructor(values);
+});
+
+/**
+ * Get all the keys
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.1
+ * @version  1.2.1
+ *
+ * @return   {String[]}
+ */
+Backed.setMethod(function keys() {
+
+	let result;
+
+	if (this.type == BACKING) {
+		result = this.backing.keys();
+	} else if (this.type == MAP) {
+		result = [...this.backing.keys()];
+	} else if (this.type == OBJECT) {
+		result = Object.keys(this.backing);
+	} else {
+		result = [];
+	}
+
+	if (this.local.size) {
+		for (let key of this.local.keys()) {
+			if (result.indexOf(key) == -1) {
+				result.push(key);
+			}
+		}
+	}
+
+	return result;
+});
+
+/**
+ * Get a value by it's name
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.1
+ * @version  1.2.1
+ *
+ * @param    {String}   name
+ *
+ * @return   {Mixed}
+ */
+Backed.setMethod(function get(name) {
+
+	if (this.local.has(name)) {
+		return this.local.get(name);
+	}
+
+	if (!this.type) {
+		return;
+	}
+
+	let value;
+
+	if (this.type == BACKING || this.type == MAP) {
+		value = this.backing.get(name);
+	} else if (this.type == OBJECT) {
+		value = this.backing[name];
+	}
+
+	return value;
+});
+
+/**
+ * Set a value
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.1
+ * @version  1.2.1
+ *
+ * @param    {String}   name
+ * @param    {*}        value
+ *
+ * @return   {*}
+ */
+Backed.setMethod(function set(name, value) {
+	this.local.set(name, value);
+	return value;
+});
+
+/**
+ * Dry the object
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.2.1
+ * @version  1.2.1
+ *
+ * @return   {Object}
+ */
+Backed.setMethod(function toDry() {
+	
+	let result = {
+		backing  : {}
+	};
+
+	let value,
+	    key;
+
+	for (key of this.keys()) {
+		value = this.get(key);
+		result.backing[key] = value;
+	}
+
+	return {value: result};
+});
+
+/**
+ * Iterate over the object
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.2.1
+ * @version  1.2.1
+ *
+ * @return   {Object}
+ */
+Backed.setMethod(Symbol.iterator, function* iterate() {
+
+	let value,
+	    key;
+
+	for (key of this.keys()) {
+		value = this.get(key);
+		yield value;
+	}
+});

package/lib/app/helper/enum_values.js

@@ -0,0 +1,125 @@
+/**
+ * The EnumValues class
+ *
+ * @constructor
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.1
+ * @version  1.2.1
+ */
+const EnumMap = Function.inherits('Alchemy.Map.Backed', 'Enum');
+
+/**
+ * Get a value by it's name
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.1
+ * @version  1.2.1
+ *
+ * @param    {String}   name
+ *
+ * @return   {Mixed}
+ */
+EnumMap.setMethod(function get(name) {
+
+	if (this.local.has(name)) {
+		return this.local.get(name);
+	}
+
+	let value = get.super.call(this, name);
+
+	if (value) {
+		value = this.set(name, value);
+	}
+
+	return value;
+});
+
+/**
+ * Set a value
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.1
+ * @version  1.2.1
+ *
+ * @param    {String}   name
+ * @param    {*}        value
+ *
+ * @return   {*}
+ */
+EnumMap.setMethod(function set(name, value) {
+
+	if (value == null) {
+		return;
+	}
+
+	if (value.is_enumified) {
+		this.local.set(name, value);
+		return value;
+	}
+
+	let result;
+
+	if (typeof value == 'string') {
+		result = {
+			name  : value,
+			title : value,
+		};
+	} else if (typeof value == 'function') {
+		result = {
+			name  : value.name,
+			title : value.title,
+		};
+	} else {
+		result = {
+			name  : value.name,
+			title : value.title || value.name,
+		};
+	}
+
+	result.value = value;
+	result.is_enumified = true;
+
+	this.local.set(name, result);
+
+	return result;
+});
+
+
+/**
+ * Simplify the object for Hawkejs
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.1
+ * @version  1.2.1
+ *
+ * @param    {WeakMap}   wm
+ *
+ * @return   {Enum}
+ */
+EnumMap.setMethod(function toHawkejs(wm) {
+
+	let result = toHawkejs.super.call(this, wm),
+	    original_value,
+		cloned_value,
+	    keys = this.keys(),
+		key;
+	
+	for (key of keys) {
+		original_value = this.get(key);
+		cloned_value = result.get(key);
+
+		if (original_value.value) {
+
+			if (typeof original_value.value == 'function') {
+				cloned_value.type = 'function';
+			}
+
+			if (original_value.value.schema) {
+				cloned_value.schema = JSON.clone(original_value.value.schema, 'toHawkejs', wm);
+			}
+		}
+	}
+
+	return result;
+});

package/lib/app/helper/router_helper.js

@@ -266,7 +266,7 @@ Router.setMethod(function routeConfig(name, socket_route) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.1.5
+ * @version  1.2.1
  *
  * @param    {String}   name
  * @param    {Object}   parameters
@@ -331,6 +331,12 @@ Router.setMethod(function routeUrl(name, _parameters, options) {
 		// Remove [brackets]
 		url = url.replace(/\[.*?\]/g, '');
 		url = url.assign(parameters, true, RURL.encodeUriQuery);
+
+		// Remove capturing regexes
+		if (url.indexOf('(') > -1) {
+			// @TODO: should exclude escaped colons like "\\("
+			url = url.replace(/\(.*?\)/g, '');
+		}
 	}
 
 	url = this.parseURL(url);