alchemymvc 1.2.8 → 1.3.0

package/lib/class/schema_client.js

@@ -79,6 +79,12 @@ Schema.setStatic(function unDry(value, custom_method, whenDone) {
 Schema.setDeprecatedProperty('modelName',     'model_name');
 Schema.setDeprecatedProperty('modelClass',    'model_class');
 Schema.setDeprecatedProperty('modelInstance', 'model_instance');
+Schema.setDeprecatedProperty('hasTranslations', 'has_translations');
+Schema.setDeprecatedProperty('hasAlternates', 'has_alternates');
+Schema.setDeprecatedProperty('translatableFields', 'translatable_fields');
+Schema.setDeprecatedProperty('indexFields', 'index_fields');
+Schema.setDeprecatedProperty('enumValues', 'enum_values');
+Schema.setDeprecatedProperty('hasBehaviours', 'has_behaviours');
 
 /**
  * Set a reference to itself
@@ -128,6 +134,19 @@ Schema.setProperty(function field_count() {
 	return result;
 });
 
+/**
+ * Does this schema have translatable fields?
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @type     {Boolean}
+ */
+Schema.setProperty(function has_translatable_fields() {
+	return this.has_translations;
+});
+
 /**
  * Clone for JSON-Dry (JSON.clone())
  *
@@ -164,19 +183,33 @@ Schema.setMethod(function clone() {
  *
  * @author   Jelle De Loecker <jelle@develry.be>
  * @since    1.1.0
- * @version  1.1.0
+ * @version  1.3.0
  *
  * @return   {Object}
  */
 Schema.setMethod(function toDry() {
 
-	var value = {
+	const value = {
 		name         : this.name,
 		associations : this.associations,
 		fields       : [],
-		rules        : this.rules,
+		rules        : new Deck(),
 	};
 
+	let rule_dict = this.rules.getDict();
+
+	// Only add rules that are manually added to the schema,
+	// not ones defined by the field (else we would revive the rules double)
+	for (let key in rule_dict) {
+		let entry = rule_dict[key];
+
+		if (entry.options?.from_field) {
+			continue;
+		}
+
+		value.rules.set(key, entry);
+	}
+
 	if (this.parent) {
 		value.parent = this.parent;
 	}
@@ -216,7 +249,7 @@ Schema.setMethod(function toDry() {
  *
  * @author   Jelle De Loecker <jelle@develry.be>
  * @since    1.1.0
- * @version  1.1.0
+ * @version  1.3.0
  */
 Schema.setMethod(function init() {
 	this.associations = {};
@@ -225,19 +258,19 @@ Schema.setMethod(function init() {
 	this.indexes = {};
 
 	// All fields belonging to an index group
-	this.indexFields = {};
+	this.index_fields = {};
 
 	// All translatable fields
-	this.translatableFields = {};
+	this.translatable_fields = {};
 
 	// Amount of translatable fields
-	this.hasTranslations = 0;
+	this.has_translations = 0;
 
 	// Amount of alternate indexes
-	this.hasAlternates = 0;
+	this.has_alternates = 0;
 
 	// Enum values
-	this.enumValues = {};
+	this.enum_values = {};
 
 	// Attached behaviours
 	this.behaviours = {};
@@ -249,7 +282,7 @@ Schema.setMethod(function init() {
 	this.rules = new Deck();
 
 	// Behaviour count
-	this.hasBehaviours = 0;
+	this.has_behaviours = 0;
 });
 
 /**
@@ -448,9 +481,9 @@ Schema.setMethod(function getPrivateFields() {
 /**
  * Add a field to this schema
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.1.7
+ * @version  1.3.0
  *
  * @param    {String}   name
  * @param    {String}   type
@@ -510,8 +543,8 @@ Schema.setMethod(function addField(name, type, options) {
 	field = new FieldClass(this, name, options);
 
 	if (field.requires_translating) {
-		this.hasTranslations++;
-		this.translatableFields[name] = field;
+		this.has_translations++;
+		this.translatable_fields[name] = field;
 	}
 
 	this.set(name, field);
@@ -521,12 +554,12 @@ Schema.setMethod(function addField(name, type, options) {
 		    i;
 
 		for (i = 0; i < rules.length; i++) {
-			this.addRule(rules[i], [name]);
+			this.addRule(rules[i], {from_field: true, fields: [name]});
 		}
 	}
 
 	if (options.required) {
-		this.addRule('not_empty', [name]);
+		this.addRule('not_empty', {from_field: true, fields: [name]});
 	}
 
 	return field;
@@ -706,7 +739,7 @@ Schema.setMethod(function getFieldNames() {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.3.0
  *
  * @param    {String|FieldType}   _field
  * @param    {Object}             options
@@ -772,7 +805,7 @@ Schema.setMethod(function addIndex(_field, _options) {
 	// it needs the 'alternate' property in order to be used
 	// as an alternate method of updating without _id
 	if (options.alternate) {
-		this.hasAlternates++;
+		this.has_alternates++;
 	}
 
 	that.getDatasource().done(function gotDs(err, datasource) {
@@ -799,7 +832,7 @@ Schema.setMethod(function addIndex(_field, _options) {
 
 		// Store the field order in the index groups
 		that.indexes[options.name].fields[path] = options.order;
-		that.indexFields[path] = options;
+		that.index_fields[path] = options;
 
 		datasource.ensureIndex(that.model_class, that.indexes[options.name], function ensuredIndex(err, result) {
 

package/lib/class/sitemap.js

@@ -0,0 +1,341 @@
+let cached_sitemap;
+
+/**
+ * Sitemap class
+ *
+ * @constructor
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ */
+const Sitemap = Function.inherits('Alchemy.Base', function Sitemap() {
+	this.categories = {};
+});
+
+/**
+ * Get the sitemap
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @return   {Pledge}
+ */
+Sitemap.setStatic(function get() {
+
+	if (cached_sitemap) {
+		return cached_sitemap;
+	}
+
+	let pledge = new Pledge();
+	let sitemap = new Sitemap();
+	cached_sitemap = pledge;
+
+	let loading = sitemap.load();
+
+	Pledge.done(loading, err => {
+
+		if (err) {
+			pledge.reject(err);
+		} else {
+			pledge.resolve(sitemap);
+		}
+	});
+
+	return cached_sitemap;
+});
+
+/**
+ * Get all the categories
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @return   {Object}
+ */
+Sitemap.setMethod(function getCategories(prefix) {
+
+	let result = [],
+	    category,
+	    new_category,
+	    entry,
+	    name;
+
+	for (name in this.categories) {
+		category = this.categories[name];
+		new_category = [];
+
+		for (entry of category) {
+
+			if (entry.prefix && prefix && entry.prefix != prefix) {
+				continue;
+			}
+
+			new_category.push(entry);
+		}
+
+		if (new_category.length) {
+			result.push({
+				name  : name,
+				pages : new_category,
+			});
+		}
+	}
+
+	return result;
+});
+
+/**
+ * Start loading the contents
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @return   {Pledge}
+ */
+Sitemap.setMethod(function load() {
+
+	let sections = Router.getFullRoutes(),
+	    promises = [],
+	    key;
+	
+	for (key in sections) {
+		let promise = this.processSection(sections[key]);
+		promises.push(promise);
+	}
+
+	return Function.parallel(promises);
+});
+
+/**
+ * Add a URL to the sitemap
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ */
+Sitemap.setMethod(function addUrl(category, url, config = {}, prefix = '') {
+
+	if (!this.categories[category]) {
+		this.categories[category] = [];
+	}
+
+	this.categories[category].push({
+		url          : url,
+		title        : config.title,
+		changefreq   : config.changefreq,
+		priority     : config.priority,
+		lastmod      : config.lastmod,
+		prefix       : prefix,
+	});
+});
+
+/**
+ * Process a route section
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @return   {Promise}
+ */
+Sitemap.setMethod(function processSection(section) {
+
+	let promise,
+	    tasks = [],
+	    route,
+	    key;
+
+	for (key in section) {
+		route = section[key];
+
+		if (!route.sitemap) {
+			continue;
+		}
+
+		promise = this.processRoute(route, route.sitemap);
+
+		if (promise) {
+			tasks.push(promise);
+		}
+	}
+
+	return Function.parallel(tasks);
+});
+
+/**
+ * Process a route & its sitemap config
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @return   {Promise}
+ */
+Sitemap.setTypedMethod([Types.Alchemy.Route], function processRoute(route) {
+
+	if (!route.sitemap) {
+		return;
+	}
+
+	return this.processRoute(route, route.sitemap);
+});
+
+/**
+ * Process a route & its sitemap config
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @return   {Promise}
+ */
+Sitemap.setTypedMethod([Types.Alchemy.Route, Types.Boolean], function processRoute(route, value) {
+
+	if (!value) {
+		return;
+	}
+
+	return this.processRoute(route, {category: 'general'});
+});
+
+/**
+ * Process a route & its sitemap config
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @return   {Promise}
+ */
+Sitemap.setTypedMethod([Types.Alchemy.Route, Types.Object], function processRoute(route, config) {
+
+	const category = config.category;
+
+	if (!category) {
+		return;
+	}
+
+	let criteria = config.criteria;
+
+	if (criteria) {
+
+		if (typeof criteria == 'function') {
+
+			let prefixes = [];
+
+			for (let prefix in route.paths) {
+				if (prefix) {
+					prefixes.push(prefix);
+				}
+			}
+
+			if (prefixes.length) {
+				let tasks = [];
+
+				for (let prefix of prefixes) {
+					let prefixed_criteria = criteria(prefix);
+					let task = this.processRouteCriteria(route, config, prefixed_criteria);
+
+					if (task) {
+						tasks.push(task);
+					}
+				}
+
+				return Function.parallel(tasks);
+			}
+
+			criteria = criteria();
+		}
+
+		return this.processRouteCriteria(route, config, criteria);
+	}
+
+	return this.addRouteWithParameters(route, config);
+});
+
+/**
+ * Process a route & its sitemap config
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @return   {Promise}
+ */
+Sitemap.setTypedMethod([Types.Alchemy.Route, Types.Object, Types.Alchemy.Criteria], async function processRouteCriteria(route, config, criteria) {
+
+	let prefix = criteria.options.locale;
+
+	for await (const record of criteria) {
+		this.addRouteWithParameters(route, config, record, prefix);
+	}
+});
+
+/**
+ * Add a route with the given parameters
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @return   {Promise}
+ */
+Sitemap.setMethod(function addRouteWithParameters(route, config, parameters, forced_prefix) {
+
+	if (!parameters) {
+		parameters = {};
+	} else {
+		parameters = Object.create(parameters);
+	}
+
+	let route_parameters = Object.assign(parameters, config.parameters),
+	    prefixes = [];
+	
+	if (forced_prefix) {
+		prefixes.push(forced_prefix);
+	} else {
+		for (let prefix in route.paths) {
+			prefixes.push(prefix);
+		}
+	}
+
+	for (let prefix of prefixes) {
+
+		if (!route.paths[prefix]) {
+			continue;
+		}
+
+		let url = Router.getUrl(route.name, route_parameters, {
+			absolute             : true,
+			locale               : prefix,
+			extra_get_parameters : false,
+		});
+
+		let route_config = Object.assign({}, config);
+
+		if (parameters && parameters.getDisplayFieldValue) {
+			route_config.title = parameters.getDisplayFieldValue({prefix});
+		}
+
+		if (!route_config.title) {
+			if (route.title) {
+				if (typeof route.title == 'object' && !(route.title instanceof Classes.Alchemy.Microcopy)) {
+					route_config.title = route.title[prefix] || route.title[''];
+				} else {
+					route_config.title = route.title;
+				}
+			}
+		}
+
+		if (!route_config.title) {
+			route_config.title = route.name;
+		}
+
+		this.addUrl(config.category, url, route_config, prefix);
+	}
+});

package/lib/core/base.js

@@ -233,9 +233,9 @@ Base.setStatic(function getAllChildren() {
 /**
  * Find a member of this group
  *
- * @author   Jelle De Loecker <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.3.0
- * @version  1.1.4
+ * @version  1.3.0
  */
 Base.setStatic(function getMember(name) {
 
@@ -243,6 +243,10 @@ Base.setStatic(function getMember(name) {
 		throw new Error('Unable to get class member of ' + this.name + ', given name is empty');
 	}
 
+	if (name.includes('.')) {
+		return this.getDescendant(name);
+	}
+
 	if (this.group == null) {
 		return null;
 	}

package/lib/core/client_alchemy.js

@@ -5,7 +5,7 @@
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.1.0
- * @version  1.0.5
+ * @version  1.3.0
  */
 var Alchemy = Function.inherits('Alchemy.Client.Base', function Alchemy() {
 
@@ -22,6 +22,8 @@ var Alchemy = Function.inherits('Alchemy.Client.Base', function Alchemy() {
 
 	// Sent subscriptions
 	this.sent_subscriptions = [];
+
+	this.distinct_problems = new Map();
 });
 
 /**
@@ -125,6 +127,73 @@ Alchemy.setMethod(function initScene(scene, options) {
 	});
 });
 
+
+/**
+ * Log a distinct warning
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @param    {String}   id
+ * @param    {String}   message
+ * @param    {Object}   options
+ *
+ * @return   {Object}
+ */
+Alchemy.setMethod(function distinctProblem(id, message, options = {}) {
+
+	if (!id) {
+		return;
+	}
+
+	let do_log = true,
+	    entry = this.distinct_problems.get(id),
+	    now = Date.now();
+
+	if (!entry) {
+		entry = {
+			id,
+			last_seen    : 0,
+			last_logged  : 0,
+			counter      : 0,
+			repeat_after : options.repeat_after || 0,
+		};
+
+		this.distinct_problems.set(id, entry);
+	} else {
+		if (entry.repeat_after) {
+			let wait_until = entry.last_logged + entry.repeat_after;
+
+			if (now >= wait_until) {
+				do_log = true;
+			}
+		} else {
+			do_log = false;
+		}
+	}
+
+	if (do_log) {
+		let args = ['[Distinct]', id];
+
+		if (message) {
+			args.push(message);
+		}
+
+		if (options.error) {
+			args.push(options.error);
+		}
+
+		this.printLog(options.level || 'error', args, options);
+		entry.last_logged = now;
+	}
+
+	entry.counter++;
+	entry.last_seen = now;
+
+	return entry;
+});
+
 /**
  * Actually print a log message
  *
@@ -511,7 +580,7 @@ Alchemy.setMethod(function linkup(type, data, cb) {
  *
  * @author    Jelle De Loecker   <jelle@develry.be>
  * @since     0.3.0
- * @version   1.2.5
+ * @version   1.3.0
  *
  * @param     {Object}   variables
  * @param     {Object}   render_data
@@ -542,7 +611,7 @@ Alchemy.setMethod(function markLinks(variables, render_data) {
 	elements = document.querySelectorAll('[data-alchemy-language-switch]');
 
 	for (i = 0; i < elements.length; i++) {
-		hawkejs.scene.general_renderer.helpers.Router.updateLanguageSwitcher(elements[i]);
+		hawkejs.scene.general_renderer.helpers.Router.updateLanguageSwitcher(elements[i], variables);
 	}
 
 	// Get all the elements with a breadcrumb set
@@ -835,17 +904,17 @@ Alchemy.decorateMethod(Blast.Decorators.memoize({max_age: 500, ignore_callbacks:
 /**
  * Get a route
  *
- * @author    Jelle De Loecker   <jelle@develry.be>
+ * @author    Jelle De Loecker   <jelle@elevenways.be>
  * @since     1.1.0
- * @version   1.1.0
+ * @version   1.3.0
  *
  * @param     {String}   href         The href or route name
  * @param     {Object}   parameters   Route parameters
  *
  * @return    {String}
  */
-Alchemy.setMethod(function routeUrl(href, parameters) {
-	let temp = hawkejs.scene.helpers.Router.routeUrl(href, parameters);
+Alchemy.setMethod(function routeUrl(href, parameters, options) {
+	let temp = hawkejs.scene.helpers.Router.routeUrl(href, parameters, options);
 
 	if (temp) {
 		temp = String(temp);

package/lib/core/client_base.js

@@ -294,19 +294,22 @@ ClientBase.setMethod(function getModel(name, init, options) {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.1.1
- * @version  1.1.1
+ * @version  1.3.0
  *
  * @param    {String}   name   The name of the event to emit
  * @param    {Array}    args   The parameters to pass to the event
  * @param    {Function} next   The optional callback
+ *
+ * @return   {Pledge}
  */
 ClientBase.setMethod(function issueEvent(name, args, next) {
 
 	let that = this,
 	    method_name,
-	    promise;
+	    promise,
+	    pledge = new Pledge();
 
-	if (typeof args == 'function') {
+	if (typeof args == 'function' || !Array.isArray(args)) {
 		next = args;
 		args = [];
 	}
@@ -326,20 +329,23 @@ ClientBase.setMethod(function issueEvent(name, args, next) {
 	Pledge.done(promise, function doneEventPromise(err, result) {
 
 		if (err) {
+			pledge.reject(err);
 			return next(err);
 		}
 
-		if (result === false) {
-			return;
-		}
+		if (result !== false) {
+			let event_args = args.slice(0);
 
-		let event_args = args.slice(0);
+			event_args.unshift(name);
+			event_args.push(next);
 
-		event_args.unshift(name);
-		event_args.push(next);
+			that.emit.apply(that, event_args);
+		}
 
-		that.emit.apply(that, event_args);
+		pledge.resolve(result);
 	});
+
+	return pledge;
 });
 
 if (!Blast.isBrowser) {