alchemymvc 1.4.0-alpha.9 → 1.4.0

package/lib/app/behaviour/sluggable_behaviour.js

@@ -282,15 +282,86 @@ Sluggable.setMethod(function createSlug(record, new_value, callback) {
 
 		return Function.parallel(tasks, callback);
 	} else {
+		let existing_slug = record[that.target_field.name];
+
 		// Only generate a new slug if it doesn't exist yet
-		if (!record[that.target_field.name]) {
+		if (!existing_slug) {
 			return that.generateSlug(record[that.source_field.name], false, record, callback);
 		}
+
+		// Check if the existing slug is a duplicate (belongs to another record)
+		return that.checkSlugIsDuplicate(existing_slug, false, record, function checked(err, is_duplicate) {
+			if (err) {
+				return callback(err);
+			}
+
+			// If the slug is a duplicate, regenerate from the source field
+			if (is_duplicate) {
+				return that.generateSlug(record[that.source_field.name], false, record, callback);
+			}
+
+			// Slug is not a duplicate, keep it
+			callback(null, existing_slug);
+		});
 	}
 
 	callback();
 });
 
+/**
+ * Check if a slug already exists (belongs to another record)
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @param    {string}   slug
+ * @param    {string}   key        The translation key (or false)
+ * @param    {Document} record
+ * @param    {Function} callback
+ */
+Sluggable.setMethod(function checkSlugIsDuplicate(slug, key, record, callback) {
+
+	let that = this,
+	    for_record_id = record?._id,
+	    model = Model.get(this.model.name),
+	    path = this.target_field.name;
+
+	if (key) {
+		path += '.' + key;
+	}
+
+	let conditions = {};
+	conditions[path] = slug;
+
+	// Also include unique_modifier_fields in the check
+	if (this.unique_modifier_fields.length && record) {
+		for (let i = 0; i < this.unique_modifier_fields.length; i++) {
+			let field = this.unique_modifier_fields[i];
+			conditions[field] = record[field];
+		}
+	}
+
+	model.find('first', {conditions: conditions}, function gotFirst(err, found_item) {
+		if (err) {
+			return callback(err);
+		}
+
+		// If no item found, it's not a duplicate
+		if (!found_item) {
+			return callback(null, false);
+		}
+
+		// If the found item is the same as the current record, it's not a duplicate
+		if (for_record_id && String(for_record_id) == String(found_item._id)) {
+			return callback(null, false);
+		}
+
+		// It's a duplicate
+		callback(null, true);
+	});
+});
+
 /**
  * Actually generate the slug from the given string,
  * and look for existing slugs in the path

package/lib/app/conduit/electron_conduit.js

@@ -80,7 +80,7 @@ ElectronConduit.setMethod(function prepareViewRender() {
 });
 
 ElectronConduit.setMethod(function setHeader(name, val) {
-	console.log('Setting header', name, val);
+	// Headers are not used in Electron conduit
 });
 
 /**

package/lib/app/conduit/socket_conduit.js

@@ -6,7 +6,7 @@ var iostream = alchemy.use('socket.io-stream'),
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.3.10
+ * @version  1.4.0
  *
  * @param    {Socker}   socket
  * @param    {Object}   announcement
@@ -25,6 +25,10 @@ var SocketConduit = Function.inherits('Alchemy.Conduit', function Socket(socket,
 	// Store the announcement data
 	this.announcement = announcement;
 
+	if (!this.canCreateSocketConnection()) {
+		return;
+	}
+
 	// Detect node clients
 	if (this.headers['user-agent'] == 'node-XMLHttpRequest') {
 		this.isNodeClient = true;
@@ -84,8 +88,8 @@ var SocketConduit = Function.inherits('Alchemy.Conduit', function Socket(socket,
 
 	// Listen for responses on the stream socket
 	this.stream.on('response', function onStreamResponse(stream, data) {
-		packet.stream = stream;
-		that.onPayload(packet);
+		data.stream = stream;
+		that.onPayload(data);
 	});
 
 	// Listen to data subscriptions
@@ -145,6 +149,22 @@ SocketConduit.setProperty(function is_connected() {
 	return this.socket?.connected || false;
 });
 
+/**
+ * Is this client allowed to create a socket connection?
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ */
+SocketConduit.setMethod(function canCreateSocketConnection() {
+
+	if (this.isCrawler()) {
+		return false;
+	}
+
+	return true;
+});
+
 /**
  * Parse the request, get information from the url
  *
@@ -166,7 +186,7 @@ SocketConduit.setMethod(function parseRequest() {
  *
  * @param    {Object}   data
  */
-SocketConduit.setMethod(function parseAnnouncement() {
+SocketConduit.setMethod(async function parseAnnouncement() {
 
 	var connections,
 	    data = this.announcement;
@@ -179,6 +199,10 @@ SocketConduit.setMethod(function parseAnnouncement() {
 	// Register the connection in the user's session
 	this.getSession().registerConnection(this);
 
+	// Allow plugins to restore session state (e.g., persistent login cookies)
+	// This is critical after server restarts when the session exists but has no user data
+	await alchemy.emit('restoring_websocket_session', this);
+
 	// Tell the client we're ready
 	this.websocket.emit('ready');
 
@@ -192,7 +216,7 @@ SocketConduit.setMethod(function parseAnnouncement() {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    0.2.0
- * @version  0.4.0
+ * @version  1.4.0
  *
  * @param    {Object}   packet
  */
@@ -237,9 +261,39 @@ SocketConduit.setMethod(function onLinkup(packet) {
 		router = Router;
 	}
 
+	// Helper to send permission denied error and clean up
+	const send_permission_denied = (required_permission) => {
+		let error_linkup = new Linkup(this, type, id, packet.data);
+		error_linkup.submit('error', {
+			code: 'PERMISSION_DENIED',
+			message: 'Permission denied',
+			required_permission: required_permission
+		});
+		error_linkup.destroy();
+	};
+
 	// See if any socket routes have been set
 	if (router.linkupRoutes[type]) {
-		fnc = router.linkupRoutes[type];
+		let route_config = router.linkupRoutes[type];
+
+		// Support both old format (just fnc) and new format ({fnc, permission})
+		if (typeof route_config === 'function' || typeof route_config === 'string') {
+			fnc = route_config;
+		} else {
+			fnc = route_config.fnc;
+
+			// Check the linkup route's permission
+			if (route_config.permission && !this.hasPermission(route_config.permission)) {
+				send_permission_denied(route_config.permission);
+				return;
+			}
+		}
+
+		// Check the router section's permissions
+		if (!router.checkPermission(this)) {
+			send_permission_denied(router.permissions);
+			return;
+		}
 
 		// Create the new linkup instance
 		linkup = new Linkup(this, type, id, packet.data);
@@ -335,7 +389,7 @@ SocketConduit.setMethod(function onPayload(packet) {
 			let test = linkup.simpleListeners.get(packet.type);
 
 			if (!test) {
-				console.error('Linkup', linkup, 'has no listener for', packet.type);
+				log.warn('Linkup has no listener for', packet.type);
 			}
 
 			if (packet.stream) {
@@ -679,6 +733,6 @@ Linkup.setMethod(function createStream() {
  * @param    {Function}   callback
  */
 Linkup.setMethod(function error(err, callback) {
-	console.log('Error:', err);
+	log.error('Linkup error:', err);
 	this.submit('error', {stack: err.stack, message: err.message}, callback);
 });

package/lib/app/controller/alchemy_info_controller.js

@@ -149,8 +149,8 @@ Info.setAction(function postponed(conduit, id) {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.3.10
- * @version  1.3.10
+ * @version  1.4.0
  */
 Info.setAction(function syncable(conduit, linkup, config) {
-	Classes.Alchemy.Syncable.handleLink(conduit, linkup, config);
+	Classes.Alchemy.Syncable.Syncable.handleLink(conduit, linkup, config);
 });

package/lib/app/datasource/mongo_datasource.js

@@ -84,7 +84,7 @@ Mongo.setSupport('querying_associations', true);
  *
  * @return   {Object}
  */
-Mongo.setProperty('allowed_find_options', [
+Mongo.setProperty('allowed_find_options', new Set([
 	'limit',
 	'sort',
 	'projection',
@@ -111,7 +111,7 @@ Mongo.setProperty('allowed_find_options', [
 	'maxTimeMS',
 	'collation',
 	'session'
-]);
+]));
 
 /**
  * Convert the given value to a BigInt
@@ -230,7 +230,7 @@ Mongo.setMethod(function normalizeFindOptions(options) {
 	}
 
 	for (key in options) {
-		if (this.allowed_find_options.indexOf(key) == -1) {
+		if (!this.allowed_find_options.has(key)) {
 			continue;
 		}
 
@@ -354,90 +354,69 @@ Mongo.setMethod(function _read(context) {
 				// Sorting should happen in the pipeline
 				if (options.sort && options.sort.length) {
 					let sort_object = {};
-	
+
 					for (let entry of options.sort) {
-						sort_object[entry[0]] = entry[1];
+						let field_name = entry[0];
+						let assoc_name = entry[2];
+
+						// If there's an association, prefix the field with the association alias
+						if (assoc_name) {
+							field_name = assoc_name + '.' + field_name;
+						}
+
+						sort_object[field_name] = entry[1];
 					}
-	
-					compiled.pipeline.unshift({$sort: sort_object});
+
+					// Add $sort at the END of the pipeline (after $lookup stages)
+					// so that we can sort by fields from associated models
+					compiled.pipeline.push({$sort: sort_object});
 				}
-	
-				// Skipping also happens in the pipeline
+
+				// Use $facet to combine count and data retrieval in a single query
+				// This avoids running the expensive $lookup stages twice
+				// Note: $skip and $limit go INSIDE the data facet so count reflects total matches
+				let data_pipeline = [];
+
 				if (options.skip) {
-					compiled.pipeline.push({$skip: options.skip});
+					data_pipeline.push({$skip: options.skip});
 				}
-	
-				let aggregate_options = {};
-	
-				Function.parallel({
-					available: function getAvailable(next) {
-	
-						if (criteria.options.available === false) {
-							return next(null, null);
-						}
-	
-						let pipeline = JSON.clone(compiled.pipeline),
-							cloned_options = JSON.clone(aggregate_options);
-	
-						pipeline.push({$count: 'available'});
-	
-						// Expensive aggregate just to get the available count...
-						Pledge.done(collection.aggregate(pipeline, cloned_options), function gotAggregate(err, cursor) {
-	
-							if (err) {
-								return next(err);
-							}
-	
-							Pledge.done(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);
-							});
-						});
-					},
-					rows: function getRows(next) {
-	
-						let pipeline = JSON.clone(compiled.pipeline);
-	
-						// Limits also have to be set in the pipeline now
-						// (We have to do it here, so the `available` count is correct)
-						if (options.limit) {
-							pipeline.push({$limit: options.limit});
-						}
-	
-						Pledge.done(collection.aggregate(pipeline, aggregate_options), function gotAggregate(err, cursor) {
-	
-							if (err) {
-								return next(err);
-							}
-	
-							Pledge.done(cursor.toArray(), next);
-						});
+
+				if (options.limit) {
+					data_pipeline.push({$limit: options.limit});
+				}
+
+				let facet_stage = {
+					$facet: {
+						data: data_pipeline,
 					}
-				}, function done(err, data) {
-	
-					if (err) {
-						return pledge.reject(err);
+				};
+
+				// Only include count facet if available is requested
+				if (criteria.options.available !== false) {
+					facet_stage.$facet.count = [{$count: 'total'}];
+				}
+
+				compiled.pipeline.push(facet_stage);
+
+				try {
+					let cursor = await collection.aggregate(compiled.pipeline, {});
+					let results = await cursor.toArray();
+
+					let facet_result = results[0] || {};
+					let rows = facet_result.data || [];
+					let available = null;
+
+					if (criteria.options.available !== false) {
+						available = facet_result.count?.[0]?.total || 0;
 					}
-	
-					data.rows = that.organizeResultItems(model, data.rows);
-	
-					pledge.resolve(data);
-				});
-	
+
+					rows = that.organizeResultItems(model, rows);
+
+					pledge.resolve({rows, available});
+				} catch (err) {
+					pledge.reject(err);
+				}
+
 				return pledge;
 			}
 	
@@ -457,13 +436,13 @@ Mongo.setMethod(function _read(context) {
 					Pledge.done(cursor.toArray(), next);
 				}
 			}, function done(err, data) {
-	
+
 				if (err) {
-					return callback(err);
+					return pledge.reject(err);
 				}
-	
+
 				data.rows = that.organizeResultItems(model, data.rows);
-	
+
 				pledge.resolve(data);
 			});
 
@@ -506,38 +485,39 @@ Mongo.setMethod(function _create(context) {
 				data[key] = val;
 			}
 
-			Pledge.done(collection.insertOne(data, {w: 1, fullResult: true}), function afterInsert(err, result) {
-
-				// Clear the cache
-				model.nukeCache();
-
-				if (err != null) {
-					return pledge.reject(err);
-				}
+		Pledge.done(collection.insertOne(data, {w: 1}), function afterInsert(err, result) {
 
-				// @TODO: fix because of mongodb 6
-				let write_errors = result.message?.documents?.[0]?.writeErrors;
+			// Clear the cache
+			model.nukeCache();
 
-				if (write_errors) {
+			if (err != null) {
+				// In MongoDB driver 6.x, write errors are thrown as MongoServerError
+				// Check if this is a write error that should be converted to validation violations
+				if (err.code || err.writeErrors) {
 					let violations = new Classes.Alchemy.Error.Validation.Violations();
 
-					if (write_errors.length) {
-						let entry;
-
-						for (entry of write_errors) {
+					// Handle bulk write errors (array of errors)
+					if (err.writeErrors && err.writeErrors.length) {
+						for (let entry of err.writeErrors) {
 							let violation = new Classes.Alchemy.Error.Validation.Violation();
-							violation.message = entry.errmsg || entry.message || entry.code;
+							violation.message = entry.errmsg || entry.message || String(entry.code);
 							violations.add(violation);
 						}
 					} else {
-						violations.add(new Error('Unknown database error'));
+						// Single error (e.g., duplicate key)
+						let violation = new Classes.Alchemy.Error.Validation.Violation();
+						violation.message = err.errmsg || err.message || String(err.code);
+						violations.add(violation);
 					}
 
 					return pledge.reject(violations);
 				}
 
-				pledge.resolve(Object.assign({}, data));
-			});
+				return pledge.reject(err);
+			}
+
+			pledge.resolve(Object.assign({}, data));
+		});
 
 			return pledge;
 		}
@@ -645,7 +625,7 @@ const performUpdate = (collection, model, context) => {
 	}
 
 	if (options.debug) {
-		console.log('Updating with obj', id, update_object);
+		log.debug('Updating with obj', id, update_object);
 	}
 
 	let promise;

package/lib/app/element/al_time.js

@@ -0,0 +1,126 @@
+const DATETIME = Symbol('datetime');
+
+/**
+ * The custom al-time element
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ */
+const AlTime = Function.inherits('Alchemy.Element', 'AlTime');
+
+/**
+ * The preferred format
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    0.3.0
+ * @version  0.3.0
+ */
+AlTime.setAttribute('format', null, function setFormat(format) {
+	this._populate({value: this.datetime, format: format});
+	return format;
+});
+
+/**
+ * Get/set the datetime value
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    0.3.0
+ * @version  0.3.0
+ */
+AlTime.setAttribute('datetime', null, function setDatetime(value) {
+	this._populate({value: value});
+	return this[DATETIME];
+});
+
+/**
+ * Set the value with a function call
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    0.3.0
+ * @version  0.3.0
+ */
+AlTime.setMethod(function setDatetime(value) {
+	this.datetime = value;
+});
+
+/**
+ * Populate the element
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    0.3.0
+ * @version  0.3.0
+ *
+ * @return   {Object[]}
+ */
+AlTime.setMethod(function populate() {
+	let iso_string = this._populate({value: this.value, format: this.format});
+	this[DATETIME] = iso_string;
+	return iso_string;
+});
+
+/**
+ * Populate the element
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    0.3.0
+ * @version  0.3.0
+ */
+AlTime.setMethod(function _populate(input) {
+
+	if (!input) {
+		input = {};
+	}
+
+	let {value, format} = input;
+
+	if (value == null) {
+		value = this[DATETIME];
+	}
+
+	if (format == null) {
+		format = this.format;
+	}
+
+	let iso_date,
+	    date;
+
+	if (value) {
+		date = Date.create(value);
+		iso_date = date.toISOString();
+	} else {
+		iso_date = '';
+	}
+
+	value = iso_date;
+
+	if (Blast.isServer) {
+		return value;
+	}
+
+	let target_element = this.children?.[0];
+
+	if (!target_element) {
+		target_element = this.createElement('time');
+		this.append(target_element);
+	}
+
+	let tag_name = target_element.tagName;
+	let formatted;
+
+	if (format) {
+		formatted = date.format(format);
+	} else {
+		formatted = date + '';
+	}
+
+	if (tag_name == 'INPUT') {
+		target_element.value = formatted;
+	} else {
+		if (tag_name == 'TIME') {
+			target_element.setAttribute('datetime', iso_date);
+		}
+
+		target_element.textContent = formatted;
+	}
+});

package/lib/app/helper/enum_values.js

@@ -70,17 +70,23 @@ EnumMap.setMethod(function set(name, value) {
 			result = {
 				name  : value.name,
 				title : value.title,
+				short_title : value.short_title,
 			};
 		} else {
 			result = {
 				name  : value.name,
 				title : value.title || value.name,
+				short_title : value.short_title,
 			};
 
 			if (value.icon) {
 				result.icon = value.icon;
 			}
 
+			if (value.icon_style) {
+				result.icon_style = value.icon_style;
+			}
+
 			if (value.color) {
 				result.color = value.color;
 			}
@@ -96,6 +102,9 @@ EnumMap.setMethod(function set(name, value) {
 	}
 
 	result.number = this.local.size + 1;
+	
+	// "value" does not mean the value that is stored in the database
+	// it can be the function that houses info
 	result.value = value;
 	result.is_enumified = true;