alchemymvc 1.4.0-alpha.9 → 1.4.0

package/lib/app/helper/router_helper.js

@@ -29,14 +29,26 @@ var Route = Function.inherits('Alchemy.Helper.Router', function Route(renderer)
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.1.0
- * @version  1.2.5
+ * @version  1.4.0
  *
  * @type     {RURL}
  */
 Router.setProperty(function current_url() {
-	if (this.view_render?.variables?.__url) {
-		return this.view_render.variables.__url.clone();
-	} else if (Blast.isBrowser) {
+
+	let renderer = this.view_render;
+
+	if (renderer?.variables) {
+		try {
+			let url = renderer.variables.get('__url');
+			if (url) {
+				return url.clone();
+			}
+		} catch (err) {
+			// Ignore
+		}
+	}
+	
+	if (Blast.isBrowser) {
 
 		if (hawkejs?.scene?.opening_url?.url) {
 			return Blast.Classes.RURL.parse(hawkejs.scene.opening_url.url);
@@ -270,7 +282,27 @@ Router.setMethod(function applyDirective(element, name, options) {
 	}
 
 	if (method_attribute && config.methods?.[0]) {
-		element.setAttribute(method_attribute, config.methods[0]);
+		let existing_method = element.getAttribute(method_attribute);
+
+		// Assume the user knows what they're doing when there is an existing method
+		if (!existing_method) {
+			let found_method = false;
+
+			// There is no method, look for the best one (we prefer a post)
+			for (let method of config.methods) {
+				method = method.toLowerCase();
+
+				if (method == 'post' || method == 'put') {
+					element.setAttribute(method_attribute, method);
+					found_method = true;
+					break;
+				}
+			}
+
+			if (!found_method) {
+				element.setAttribute(method_attribute, config.methods[0]);
+			}
+		}
 	}
 
 	if (disable_ajax) {

package/lib/app/helper/socket_helper.js

@@ -16,7 +16,7 @@ function isStream(obj) {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.3.10
+ * @version  1.4.0
  *
  * @param    {string}   type
  */
@@ -43,12 +43,21 @@ var Linkup = Blast.Collection.Function.inherits('Informer', function ClientLinku
 	// The initial submitted data
 	this.initialData = data;
 
+	// Has this linkup been destroyed?
+	this.destroyed = false;
+
 	// Make the linkup store itself
 	client.linkups[this.id] = this;
 
 	// The parent server
 	this.client = client;
 
+	// Listen for socket disconnection
+	this._onClientClose = () => {
+		this._markDisconnected();
+	};
+	client.on('close', this._onClientClose);
+
 	if (server_object) {
 		this.submit('ready');
 	} else {
@@ -146,23 +155,51 @@ Linkup.setMethod(function createStream() {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.3.10
+ * @version  1.4.0
  */
 Linkup.setMethod(function destroy() {
+	if (this.destroyed) {
+		return;
+	}
+
 	this.submit('__destroy__');
 	this._destroy();
 	this.removeAllListeners();
 });
 
+/**
+ * Mark the linkup as disconnected due to socket close
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ */
+Linkup.setMethod(function _markDisconnected() {
+	if (this.destroyed) {
+		return;
+	}
+
+	// Emit the close event so listeners can handle disconnect
+	this.emit('close');
+});
+
 /**
  * Make sure the linkup is removed
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.3.10
- * @version  1.3.10
+ * @version  1.4.0
  */
 Linkup.setMethod(function _destroy() {
+	this.destroyed = true;
 	delete this.client.linkups[this.id];
+
+	// Remove the close listener from the client
+	if (this._onClientClose) {
+		this.client.removeListener('close', this._onClientClose);
+		this._onClientClose = null;
+	}
+
 	this.emit('destroyed');
 });
 
@@ -352,7 +389,7 @@ Client.setMethod(function createStream() {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.3.12
+ * @version  1.4.0
  *
  * @param    {Function} callback
  */
@@ -487,7 +524,8 @@ Client.setMethod(function connect(address, data, callback) {
 	});
 
 	server.on('error', function(err) {
-		console.log('Socket error:', err);
+		log.error('Socket error:', err);
+		that.emit('error', err);
 	});
 
 	// Listen for cookies
@@ -547,16 +585,22 @@ Client.setMethod(function connect(address, data, callback) {
 				}
 			}
 
-			try {
-				if (packet.data && typeof packet.data == 'object') {
-					packet.data = JSON.undry(packet.data);
-				}
-			} catch (err) {
-				console.log('ERROR UNDRYING PACKET:', err, packet);
-				return;
+		try {
+			if (packet.data && typeof packet.data == 'object') {
+				packet.data = JSON.undry(packet.data);
 			}
+		} catch (err) {
+			log.error('Error undrying response data:', err);
 
-			if (packet.noData) {
+			// Still call the callback with an error instead of silently dropping
+			let undry_error = new Error('Failed to deserialize response data: ' + err.message);
+			undry_error.cause = err;
+			that.callbacks[packet.respond_to](undry_error, null);
+			delete that.callbacks[packet.respond_to];
+			return;
+		}
+
+		if (packet.noData) {
 				that.callbacks[packet.respond_to](packet.err, packet.stream);
 			} else if (packet.stream) {
 				that.callbacks[packet.respond_to](packet.err, packet.data, packet.stream);
@@ -578,7 +622,20 @@ Client.setMethod(function connect(address, data, callback) {
 				packet.data = JSON.undry(packet.data);
 			}
 		} catch (err) {
-			console.log('ERROR UNDRYING PACKET:', err, packet);
+			log.error('Error undrying packet data:', err);
+
+			// If the sender expects a response, send back an error
+			if (packet.respond) {
+				let response_packet = {
+					err: new Error('Failed to deserialize packet data: ' + err.message),
+					respond_to: packet.id,
+					data: null
+				};
+				server.emit('response', response_packet);
+			}
+
+			// Emit error event so callers can be aware
+			that.emit('packet_error', err, packet);
 			return;
 		}
 

package/lib/app/helper/syncable.js

@@ -15,7 +15,7 @@ const SESSION_KEY = 'Syncables',
  *
  * @param    {string}   type
  */
-const Syncable = Function.inherits('Alchemy.Base', function Syncable(type) {
+const Syncable = Function.inherits('Alchemy.Base', 'Alchemy.Syncable', function Syncable(type) {
 
 	if (!type) {
 		throw new Error('Each Syncable must have a type');
@@ -44,39 +44,35 @@ if (Blast.isNode) {
 	 *
 	 * @author   Jelle De Loecker <jelle@elevenways.be>
 	 * @since    1.3.10
-	 * @version  1.3.10
+	 * @version  1.4.0
 	 *
 	 * @param    {Conduit}
 	 * @param    {Linkup}
 	 * @param    {Object}
 	 */
-	Syncable.setStatic(function handleLink(conduit, linkup, config) {
+	Syncable.setStatic(async function handleLink(conduit, linkup, config) {
 
 		let syncables = conduit.session(SESSION_KEY),
-		    syncable,
-		    error_msg;
-
-		if (!syncables) {
-			error_msg = 'No syncables found';
-		} else {
+		    syncable;
 
+		if (syncables) {
 			let type_map = syncables.get(config.type);
 
-			if (!type_map) {
-				error_msg = 'No syncables found for type: ' + config.type;
-			} else {
+			if (type_map) {
 				syncable = type_map.get(config.id);
-
-				if (!syncable) {
-					error_msg = 'No syncable found for id: ' + config.id;
-				}
 			}
 		}
 
-		if (error_msg) {
-			let err = new Error(error_msg);
-			console.log('ERROR:', err);
-			linkup.emit('error', err);
+		// If syncable not found, try to recreate it
+		if (!syncable) {
+			syncable = await this.tryRecreate(conduit, config);
+		}
+
+		if (!syncable) {
+			linkup.submit('error', {
+				code: 'SYNCABLE_NOT_FOUND',
+				message: 'No syncable found for type: ' + config.type + ', id: ' + config.id,
+			});
 			linkup.destroy();
 			return;
 		}
@@ -84,6 +80,65 @@ if (Blast.isNode) {
 		syncable.attachClient(conduit, linkup, config);
 	}, false);
 
+	/**
+	 * Try to recreate a syncable that wasn't found in the session.
+	 * This is called when a client reconnects after a server restart.
+	 *
+	 * @author   Jelle De Loecker <jelle@elevenways.be>
+	 * @since    1.4.0
+	 * @version  1.4.0
+	 *
+	 * @param    {Conduit}   conduit
+	 * @param    {Object}    config    Contains type, id, and version from the client
+	 *
+	 * @return   {Syncable}  The recreated syncable, or null if recreation failed
+	 */
+	Syncable.setStatic(async function tryRecreate(conduit, config) {
+
+		// Find the Syncable class for this type.
+		// For Specialized syncables, config.type is the class's type_path (includes namespace prefix).
+		// For ad-hoc syncables, config.type is a custom string and won't match any class.
+		let SyncableClass = this.getDescendant(config.type);
+
+		if (!SyncableClass) {
+			return null;
+		}
+
+		// Check if this class supports recreation
+		if (typeof SyncableClass.recreate !== 'function') {
+			return null;
+		}
+
+		try {
+			let syncable = await SyncableClass.recreate(conduit, config);
+
+			if (syncable) {
+				// Make sure it's registered
+				syncable.registerClient(conduit);
+			}
+
+			return syncable;
+		} catch (err) {
+			log.error('Failed to recreate syncable:', err);
+			return null;
+		}
+	}, false);
+
+	/**
+	 * Recreate a syncable instance after server restart.
+	 * Override this in subclasses to enable automatic recreation.
+	 *
+	 * @author   Jelle De Loecker <jelle@elevenways.be>
+	 * @since    1.4.0
+	 * @version  1.4.0
+	 *
+	 * @param    {Conduit}   conduit
+	 * @param    {Object}    config    Contains type, id, and version from the client
+	 *
+	 * @return   {Syncable}  The recreated syncable, or null if recreation not possible
+	 */
+	// Base class does not implement recreate - subclasses must opt-in
+
 	/**
 	 * Attach a client
 	 *
@@ -205,7 +260,7 @@ if (Blast.isBrowser) {
 	 *
 	 * @author   Jelle De Loecker <jelle@elevenways.be>
 	 * @since    1.3.10
-	 * @version  1.3.10
+	 * @version  1.4.0
 	 */
 	Syncable.setMethod(function startSyncLink() {
 
@@ -214,6 +269,27 @@ if (Blast.isBrowser) {
 			return;
 		}
 
+		// Prevent concurrent connection attempts
+		if (this._connecting) {
+			return;
+		}
+
+		this._connecting = true;
+
+		// Clean up existing broken link if any
+		if (this.c2s_link) {
+			if (!this.c2s_link.destroyed) {
+				this.c2s_link.destroy();
+			}
+			this.c2s_link = null;
+		}
+
+		// Clear any pending reconnect
+		if (this._reconnect_timeout) {
+			clearTimeout(this._reconnect_timeout);
+			this._reconnect_timeout = null;
+		}
+
 		alchemy.enableWebsockets();
 
 		let data = {
@@ -223,6 +299,8 @@ if (Blast.isBrowser) {
 		};
 
 		let link = this.c2s_link = alchemy.linkup('syncablelink', data, () => {
+			this._connecting = false;
+			this._reconnect_attempts = 0; // Reset on successful connection
 			this.emit('ready');
 		});
 
@@ -234,6 +312,74 @@ if (Blast.isBrowser) {
 
 			this.version = data.version;
 		});
+
+		// Handle socket disconnection
+		link.on('close', () => {
+			this._connecting = false;
+			this.emit('disconnected');
+			this._scheduleReconnect();
+		});
+
+		// Handle server errors
+		link.on('error', (err) => {
+			this._connecting = false;
+
+			// Use error codes when available, fall back to string matching for backwards compatibility
+			let code = err?.code;
+			let message = err?.message || '';
+
+			if (code === 'SYNCABLE_NOT_FOUND' || message.includes('No syncable found')) {
+				// Server doesn't recognize us - stop trying to reconnect
+				// This happens after server restart. The only recovery is a page reload
+				// to get fresh syncables from the server.
+				this._released = true;
+				CLIENT_MAP.delete(this.id);
+				this.emit('needs_resync');
+			} else if (code === 'PERMISSION_DENIED' || message === 'Permission denied') {
+				// User doesn't have permission - stop trying to reconnect
+				this._released = true;
+				this.emit('permission_denied', err?.required_permission);
+			} else {
+				// Unknown error - log it and emit for consumers
+				console.warn('[Syncable] Link error:', err);
+				this.emit('error', err);
+			}
+		});
+	});
+
+	/**
+	 * Schedule a reconnection attempt with exponential backoff and jitter
+	 *
+	 * @author   Jelle De Loecker <jelle@elevenways.be>
+	 * @since    1.4.0
+	 * @version  1.4.0
+	 */
+	Syncable.setMethod(function _scheduleReconnect() {
+
+		// Don't schedule if already pending
+		if (this._reconnect_timeout) {
+			return;
+		}
+
+		// Don't reconnect if explicitly released
+		if (this._released) {
+			return;
+		}
+
+		// Increment attempt counter
+		this._reconnect_attempts = (this._reconnect_attempts || 0) + 1;
+
+		// Calculate delay with exponential backoff: 5s, 7.5s, 11.25s, ... max 60s
+		let base_delay = 5000;
+		let delay = Math.min(base_delay * Math.pow(1.5, this._reconnect_attempts - 1), 60000);
+
+		// Add jitter (0-1000ms) to prevent thundering herd
+		delay += Math.random() * 1000;
+
+		this._reconnect_timeout = setTimeout(() => {
+			this._reconnect_timeout = null;
+			this.startSyncLink();
+		}, delay);
 	});
 }
 
@@ -449,7 +595,7 @@ Syncable.setStatic(function setStateProperty(name, options) {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.3.10
- * @version  1.3.10
+ * @version  1.4.0
  *
  * @param    {Object}   data
  *
@@ -457,14 +603,34 @@ Syncable.setStatic(function setStateProperty(name, options) {
  */
 Syncable.setStatic(function unDry(data) {
 
-	let result;
+	let result,
+	    old_instance;
 
 	// Try to reuse the same instance on the client side
 	if (Blast.isBrowser) {
 		result = CLIENT_MAP.get(data.id);
 
 		if (result) {
-			return result;
+			if (result.c2s_link && !result.c2s_link.destroyed) {
+				// Server version is older - client has newer data, keep client instance
+				if (data.version < result.version) {
+					return result;
+				}
+				
+				// Server version is same or newer - update client state from server
+				// We update the state even if versions match because nested Syncables
+				// may have changed (their unDry already ran and updated them)
+				if (data.state) {
+					result.state = data.state;
+				}
+				result.version = data.version;
+				
+				return result;
+			}
+
+			// Link is broken - need to replace the instance
+			old_instance = result;
+			CLIENT_MAP.delete(data.id);
 		}
 	}
 
@@ -478,7 +644,20 @@ Syncable.setStatic(function unDry(data) {
 	result.queues = clone.queues;
 
 	if (Blast.isBrowser) {
+		CLIENT_MAP.set(result.id, result);
 		result.startSyncLink();
+
+		// Now that the new instance is ready, clean up the old one
+		if (old_instance) {
+			// Mark the old instance as replaced
+			old_instance._replaced = true;
+			
+			// Emit 'replaced' event with the new instance so listeners can switch
+			old_instance.emit('replaced', result);
+			
+			// Release the old instance (cancels pending reconnects)
+			old_instance.release();
+		}
 	}
 
 	return result;
@@ -692,12 +871,13 @@ Syncable.setMethod(function sendUpdates() {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.3.10
- * @version  1.3.10
+ * @version  1.4.0
  *
  * @param    {string}   property
  */
 Syncable.setMethod(function emitPropertyChange(property) {
-	let value = this[property];
+	// Use state directly to support properties without explicit getters
+	let value = this.state[property];
 	this.emit('property_change_' + property, value, null);
 });
 
@@ -706,14 +886,15 @@ Syncable.setMethod(function emitPropertyChange(property) {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.3.10
- * @version  1.3.10
+ * @version  1.4.0
  *
  * @param    {string}   property
  * @param    {Function} callback
  */
 Syncable.setMethod(function watchProperty(property, callback) {
 	this.on('property_change_' + property, callback);
-	let value = this[property];
+	// Use state directly to support properties without explicit getters
+	let value = this.state[property];
 	callback(value);
 });
 
@@ -975,10 +1156,25 @@ Syncable.setMethod(function setProperty(key, value) {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.3.10
- * @version  1.3.10
+ * @version  1.4.0
  */
 Syncable.setMethod(function release() {
 
+	// Mark as released to prevent auto-reconnection
+	this._released = true;
+
+	// Cancel any pending reconnection
+	if (this._reconnect_timeout) {
+		clearTimeout(this._reconnect_timeout);
+		this._reconnect_timeout = null;
+	}
+
+	// Cancel any pending update
+	if (this[UPDATE_ID]) {
+		clearTimeout(this[UPDATE_ID]);
+		this[UPDATE_ID] = null;
+	}
+
 	if (this.c2s_link) {
 		this.c2s_link.destroy();
 		this.c2s_link = null;
@@ -987,4 +1183,31 @@ Syncable.setMethod(function release() {
 	if (Blast.isBrowser) {
 		CLIENT_MAP.delete(this.id);
 	}
-});
+
+	this.emit('released');
+});
+
+/**
+ * The Specialized Syncable class:
+ * A syncable subclass that automatically derives its type from the class's type_path or type_name.
+ * Use this as the base class for syncables that need to support recreation after server restart.
+ *
+ * @constructor
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ */
+const Specialized = Function.inherits('Alchemy.Syncable', function Specialized() {
+	
+	let type = this.constructor.type_path || this.constructor.type_name;
+
+	if (!type) {
+		throw new Error('Specialized Syncable subclasses must have a type_path or type_name (set automatically by Alchemy.Base)');
+	}
+
+	Specialized.super.call(this, type);
+});
+
+// Make it abstract - it should not be instantiated directly
+Specialized.makeAbstractClass();