alchemymvc 1.4.0 → 1.4.1

package/lib/class/import_stream_parser.js

@@ -0,0 +1,299 @@
+const libstream = require('stream');
+
+/**
+ * The ImportStreamParser class:
+ * Handles parsing of Alchemy's binary import stream format.
+ * 
+ * Stream format:
+ * - 0x01 [1-byte size] [model name]: Model header
+ * - 0x02 [4-byte size BE] [document data]: Document data
+ * - 0xFF [4-byte size BE] [extra data]: Extra import data for current document
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.1
+ * @version  1.4.1
+ */
+const ImportStreamParser = Function.inherits('Alchemy.Base', function ImportStreamParser(input, options) {
+
+	// The input stream to parse
+	this.input = input;
+
+	// Options
+	this.options = options || {};
+
+	// The model resolver function - receives model name, returns Model instance
+	// Can throw an error to abort parsing
+	this.model_resolver = null;
+
+	// State machine variables
+	this.current_type = null;
+	this.extra_stream = null;
+	this.stopped = false;
+	this.paused = false;
+	this.buffer = null;
+	this.model = null;
+	this.value = null;
+	this.seen = 0;
+	this.left = 0;
+	this.size = 0;
+	this.doc = null;
+
+	// Track stream end and pending imports
+	this.stream_ended = false;
+	this.pending_import = false;
+
+	// The pledge that resolves when parsing is complete
+	this.pledge = new Pledge();
+});
+
+/**
+ * Set the model resolver function.
+ * Called when a 0x01 model header is encountered.
+ * 
+ * The resolver receives (model_name, current_model) and should:
+ * - Return a Model instance to use for subsequent documents
+ * - Throw an error to abort parsing
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.1
+ * @version  1.4.1
+ *
+ * @param    {Function}   resolver   (model_name, current_model) => Model
+ */
+ImportStreamParser.setMethod(function setModelResolver(resolver) {
+	this.model_resolver = resolver;
+});
+
+/**
+ * Start parsing the input stream.
+ * Returns a Pledge that resolves when parsing is complete.
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.1
+ * @version  1.4.1
+ *
+ * @return   {Pledge}
+ */
+ImportStreamParser.setMethod(function parse() {
+
+	let that = this;
+
+	if (!this.model_resolver) {
+		return Pledge.reject(new Error('No model resolver has been set'));
+	}
+
+	this.input.on('data', function onData(data) {
+
+		if (that.stopped) {
+			return;
+		}
+
+		if (that.buffer) {
+			that.buffer = Buffer.concat([that.buffer, data]);
+		} else {
+			that.buffer = data;
+		}
+
+		that.handleBuffer();
+	});
+
+	this.input.on('end', function onEnd() {
+		that.stream_ended = true;
+
+		// Only resolve if we're not in the middle of importing a document
+		if (!that.stopped && !that.pending_import) {
+			that.pledge.resolve();
+		}
+	});
+
+	this.input.on('error', function onError(err) {
+		that.stopped = true;
+		that.pledge.reject(err);
+	});
+
+	return this.pledge;
+});
+
+/**
+ * Handle the current buffer data.
+ * Implements the state machine for parsing packet headers.
+ *
+ * State machine:
+ * - current_type = null: waiting for a new packet header
+ * - current_type = 0x01/0x02/0xFF: header parsed, processing payload
+ *
+ * We must NOT set current_type until we have the FULL header,
+ * otherwise a TCP chunk boundary could leave us in an invalid state.
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.1
+ * @version  1.4.1
+ */
+ImportStreamParser.setMethod(function handleBuffer() {
+
+	if (this.paused) {
+		return;
+	}
+
+	if (!this.current_type) {
+		// Need at least 1 byte to peek at the marker type
+		if (this.buffer.length < 1) {
+			return;
+		}
+
+		let marker = this.buffer.readUInt8(0);
+
+		if (marker == 0x01) {
+			// Type 0x01: 1-byte marker + 1-byte size = 2 bytes header
+			if (this.buffer.length < 2) {
+				return; // Wait for more data (don't consume the marker yet)
+			}
+			this.current_type = marker;
+			this.size = this.buffer.readUInt8(1);
+			this.buffer = this.buffer.slice(2);
+		} else if (marker == 0x02) {
+			// Type 0x02: 1-byte marker + 4-byte size = 5 bytes header
+			if (this.buffer.length < 5) {
+				return; // Wait for more data (don't consume the marker yet)
+			}
+			this.current_type = marker;
+			this.size = this.buffer.readUInt32BE(1);
+			this.buffer = this.buffer.slice(5);
+		} else if (marker == 0xFF) {
+			// Type 0xFF: 1-byte marker + 4-byte size = 5 bytes header
+			if (this.buffer.length < 5) {
+				return; // Wait for more data (don't consume the marker yet)
+			}
+			this.current_type = marker;
+			this.size = this.buffer.readUInt32BE(1);
+			this.buffer = this.buffer.slice(5);
+			this.seen = 0;
+
+			if (!this.doc) {
+				this.stopped = true;
+				this.pledge.reject(new Error('Found extra import data, but no active document'));
+			} else {
+				this.extra_stream = new libstream.PassThrough();
+				this.doc.extraImportFromStream(this.extra_stream);
+			}
+		} else {
+			// Unknown marker - this shouldn't happen in valid data
+			this.stopped = true;
+			this.pledge.reject(new Error('Unknown marker byte: 0x' + marker.toString(16)));
+			return;
+		}
+	}
+
+	this.handlePayload();
+});
+
+/**
+ * Handle the payload data after a header has been parsed.
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.1
+ * @version  1.4.1
+ */
+ImportStreamParser.setMethod(function handlePayload() {
+
+	let that = this;
+
+	// Handle extra data streaming (0xFF)
+	if (this.current_type == 0xFF) {
+		this.left = this.size - this.seen;
+		this.value = this.buffer.slice(0, this.left);
+
+		this.seen += this.value.length;
+
+		if (this.value.length == this.buffer.length) {
+			this.buffer = null;
+		} else if (this.value.length < this.buffer.length) {
+			this.buffer = this.buffer.slice(this.left);
+		}
+
+		this.extra_stream.write(this.value);
+
+		if (this.value.length == this.left) {
+			this.extra_stream.end();
+			this.current_type = null;
+
+			if (this.buffer) {
+				this.handleBuffer();
+			}
+		}
+
+		return;
+	}
+
+	// Wait for full payload
+	if (this.buffer.length >= this.size) {
+		this.value = this.buffer.slice(0, this.size);
+		this.buffer = this.buffer.slice(this.size);
+	} else {
+		// Wait for next call
+		return;
+	}
+
+	// Handle model header (0x01)
+	if (this.current_type == 0x01) {
+		let model_name = this.value.toString();
+
+		try {
+			this.model = this.model_resolver(model_name, this.model);
+			this.doc = null;
+		} catch (err) {
+			this.stopped = true;
+			return this.pledge.reject(err);
+		}
+
+		if (!this.model) {
+			this.stopped = true;
+			return this.pledge.reject(new Error('Model resolver returned no model for "' + model_name + '"'));
+		}
+
+		this.current_type = null;
+		this.size = 0;
+	}
+	// Handle document data (0x02)
+	else if (this.current_type == 0x02) {
+		this.doc = this.model.createDocument();
+		this.input.pause();
+		this.paused = true;
+		this.pending_import = true;
+
+		this.doc.importFromBuffer(this.value, this.options).done(function done(err, result) {
+
+			that.pending_import = false;
+
+			if (err) {
+				that.stopped = true;
+				return that.pledge.reject(err);
+			}
+
+			that.current_type = null;
+			that.paused = false;
+
+			// Check if there's more data to process
+			if (that.buffer && that.buffer.length > 0) {
+				that.input.resume();
+				that.handleBuffer();
+				return;
+			}
+
+			// No more data in buffer
+			that.input.resume();
+
+			// If the stream has ended and there's no more data, resolve
+			if (that.stream_ended && !that.stopped) {
+				that.pledge.resolve();
+			}
+		});
+
+		return;
+	}
+
+	// Continue processing remaining buffer
+	if (this.buffer && this.buffer.length) {
+		this.handleBuffer();
+	}
+});

package/lib/class/migration.js

@@ -20,7 +20,7 @@ const Migration = Function.inherits('Alchemy.Base', function Migration(document)
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.2.0
- * @version  1.2.0
+ * @version  1.4.1
  */
 Migration.setStatic(async function start() {
 
@@ -32,7 +32,10 @@ Migration.setStatic(async function start() {
 
 	await dir.loadContents();
 
-	for (let entry of dir) {
+	// Sort entries alphabetically so numbered prefixes (001_, 002_) run in order
+	let entries = [...dir].sort((a, b) => a.name.localeCompare(b.name));
+
+	for (let entry of entries) {
 
 		let name = entry.name.beforeLast('.js');
 

package/lib/class/model.js

@@ -1590,7 +1590,7 @@ Model.setMethod(function exportToStream(output, options) {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.5
- * @version  1.0.5
+ * @version  1.4.1
  *
  * @param    {Stream}   input
  * @param    {Object}   options
@@ -1612,150 +1612,20 @@ Model.setMethod(function importFromStream(input, options) {
 		return Pledge.reject(new Error('No source input stream has been given'));
 	}
 
-	let that = this,
-	    current_type = null,
-	    extra_stream,
-	    pledge = new Pledge(),
-	    stopped,
-	    paused,
-	    buffer,
-	    value,
-	    seen = 0,
-	    left,
-	    size,
-	    doc;
-
-	input.on('data', function onData(data) {
-
-		if (stopped) {
-			return;
-		}
+	let that = this;
+	let parser = new Classes.Alchemy.ImportStreamParser(input, options);
 
-		if (buffer) {
-			buffer = Buffer.concat([buffer, data]);
-		} else {
-			buffer = data;
+	// Model resolver for single-model import:
+	// Validates that the model name matches, returns this model instance
+	parser.setModelResolver(function resolveModel(model_name, current_model) {
+		if (model_name == that.model_name) {
+			return that;
 		}
 
-		handleBuffer();
+		throw new Error('Model names do not match: expected "' + that.model_name + '", got "' + model_name + '"');
 	});
 
-	function handleBuffer() {
-
-		if (paused) {
-			return;
-		}
-
-		if (!current_type && buffer.length < 2) {
-			return;
-		}
-
-		if (!current_type) {
-			current_type = buffer.readUInt8(0);
-
-			if (current_type == 0x01) {
-				size = buffer.readUInt8(1);
-				buffer = buffer.slice(2);
-			} else if (current_type == 0x02 && buffer.length >= 5) {
-				size = buffer.readUInt32BE(1);
-				buffer = buffer.slice(5);
-			} else if (current_type == 0xFF) {
-				size = buffer.readUInt32BE(1);
-				buffer = buffer.slice(5);
-				seen = 0;
-
-				if (!doc) {
-					stopped = true;
-					pledge.reject(new Error('Found extra import data, but no active document'));
-				} else {
-					extra_stream = new require('stream').PassThrough();
-					doc.extraImportFromStream(extra_stream);
-				}
-			} else {
-				// Not enough data? Wait
-				current_type = null;
-				return;
-			}
-		}
-
-		handleRest();
-	}
-
-	function handleRest() {
-
-		if (current_type == 0xFF) {
-			left = size - seen;
-			value = buffer.slice(0, left);
-
-			seen += value.length;
-
-			if (value.length == buffer.length) {
-				buffer = null;
-			} else if (value.length < buffer.length) {
-				buffer = buffer.slice(left);
-			}
-
-			extra_stream.write(value);
-
-			if (value.length == left) {
-				extra_stream.end();
-				current_type = null;
-
-				if (buffer) {
-					handleBuffer();
-				}
-			}
-
-			return;
-		}
-
-		if (buffer.length >= size) {
-			value = buffer.slice(0, size);
-			buffer = buffer.slice(size);
-		} else {
-			// Wait for next call
-			return;
-		}
-
-		if (current_type == 0x01) {
-			value = value.toString();
-
-			if (value == that.model_name) {
-				// Found name!
-				current_type = null;
-				size = 0;
-			} else {
-				stopped = true;
-				return pledge.reject(new Error('Model names do not match'));
-			}
-		} else if (current_type == 0x02) {
-			doc = that.createDocument();
-			input.pause();
-			paused = true;
-
-			doc.importFromBuffer(value).done(function done(err, result) {
-
-				if (err) {
-					stopped = true;
-					return pledge.reject(err);
-				}
-
-				current_type = null;
-				paused = false;
-				input.resume();
-
-				handleBuffer();
-			});
-
-			return;
-		}
-
-		if (buffer && buffer.length) {
-			handleBuffer();
-		}
-	}
-
-	return pledge;
+	return parser.parse();
 });
 
 /**

package/lib/class/plugin.js

@@ -41,7 +41,7 @@ const Plugin = Function.inherits('Alchemy.Base', function Plugin(name, path, def
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.4.0
- * @version  1.4.0
+ * @version  1.4.1
  *
  * @return   {boolean}
  */
@@ -52,16 +52,45 @@ Plugin.setMethod(function doPreload() {
 	}
 
 	// Create settings from the `config/settings.js` file
-	this.loadSettingDefinitions();
+	// This can fail if the config is invalid
+	try {
+		this.loadSettingDefinitions();
+	} catch (err) {
+		this._handleLoadError('settings', err);
+		return false;
+	}
 
 	// Load the bootstrap file
-	this.loadBootstrap();
+	// This can fail due to syntax errors or runtime errors
+	try {
+		this.loadBootstrap();
+	} catch (err) {
+		this._handleLoadError('bootstrap', err);
+		return false;
+	}
+
+	this[FLAGS].preloaded = true;
 
 	PLUGINS_STAGE.addPostTask(() => {
 		return this.startPlugin();
 	});
 });
 
+/**
+ * Handle a plugin loading error
+ * Plugin errors are fatal - the server cannot start with a broken plugin
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.1
+ * @version  1.4.1
+ *
+ * @param    {string}   phase   Which phase failed (settings, bootstrap, start)
+ * @param    {Error}    err     The error that occurred
+ */
+Plugin.setMethod(function _handleLoadError(phase, err) {
+	alchemy.handlePluginError(this.name, phase, err);
+});
+
 /**
  * Do the rest of the plugin loading
  *

package/lib/class/router.js

@@ -200,7 +200,7 @@ RouterClass.setMethod(function headerBypass(prefix) {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    0.3.0
- * @version  0.3.0
+ * @version  1.4.1
  */
 RouterClass.setMethod(function getFullMount() {
 
@@ -215,6 +215,11 @@ RouterClass.setMethod(function getFullMount() {
 		}
 	}
 
+	// Remove trailing slash (but keep single "/" for root)
+	if (result.length > 1 && result[result.length - 1] == '/') {
+		result = result.slice(0, -1);
+	}
+
 	return result;
 });
 
@@ -1053,34 +1058,12 @@ RouterClass.setMethod('delete', function _delete(name, paths, fnc, options) {
 	return this.add(['delete'], name, paths, fnc, options);
 });
 
-/**
- * Get an object of all the routes in this router and its children
- *
- * @author   Jelle De Loecker <jelle@elevenways.be>
- * @since    0.2.0
- * @version  0.2.0
- */
-RouterClass.setMethod(function getFullMount() {
-
-	var result = this.mount;
-
-	if (this.parent != null && this.parent.mount != '/') {
-		result = this.parent.mount + result;
-	}
-
-	if (result[result.length-1] == '/') {
-		result = result.slice(0, -1);
-	}
-
-	return result;
-});
-
 /**
  * Get the full route object, for internal use
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    0.5.0
- * @version  0.5.0
+ * @version  1.4.1
  *
  * @param    {Object}   result   Optional object to store sectioned results in
  *
@@ -1111,7 +1094,14 @@ RouterClass.setMethod(function getFullRoutes(result) {
 		temp = {};
 
 		for (prefix in route.paths) {
-			temp[prefix] = mount + route.paths[prefix].source;
+			let source = route.paths[prefix].source;
+
+			// Avoid double slashes when mount is '/' and path starts with '/'
+			if (mount == '/' && source[0] == '/') {
+				temp[prefix] = source;
+			} else {
+				temp[prefix] = mount + source;
+			}
 		}
 
 		section[route.name] = route;
@@ -1175,7 +1165,7 @@ RouterClass.setMethod(function getOptions(result) {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.3.21
+ * @version  1.4.1
  *
  * @param    {Object}   result   Optional object to store sectioned results in
  *
@@ -1206,7 +1196,14 @@ RouterClass.setMethod(function getRoutes(result) {
 		temp = {};
 
 		for (prefix in route.paths) {
-			temp[prefix] = mount + route.paths[prefix].source;
+			let source = route.paths[prefix].source;
+
+			// Avoid double slashes when mount is '/' and path starts with '/'
+			if (mount == '/' && source[0] == '/') {
+				temp[prefix] = source;
+			} else {
+				temp[prefix] = mount + source;
+			}
 		}
 
 		section[route.name] = {

package/lib/class/schema_client.js

@@ -1079,7 +1079,7 @@ Schema.setMethod(function getFieldNames() {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.4.0
+ * @version  1.4.1
  *
  * @param    {string|FieldType}   _field_or_name   Field name, or index name when using `fields` option
  * @param    {Object}             options
@@ -1111,15 +1111,46 @@ Schema.setMethod(function addIndex(_field_or_name, _options) {
 		// When `fields` is provided, the first argument is the index name
 		options.name = _field_or_name;
 
+		// Create the index entry
+		if (this.indexes[options.name] == null) {
+			this.indexes[options.name] = {
+				fields: {},
+				options: options
+			};
+		}
+
+		// Add all fields to the index
 		for (let field_name of options.fields) {
-			this.addIndex(field_name, {
-				name: options.name,
-				unique: options.unique,
-				sparse: options.sparse,
-				order: options.order,
-			});
+			let field = this.getField(field_name);
+
+			if (!field) {
+				throw new Error('Could not find field "' + field_name + '" for compound index "' + options.name + '"');
+			}
+
+			let path = field.path;
+			this.indexes[options.name].fields[path] = options.order || 1;
+			this.index_fields[path] = options;
 		}
 
+		// Now call ensureIndex once with the complete compound index
+		const that = this;
+
+		that.getDatasource().done(function gotDs(err, datasource) {
+			if (err) {
+				throw err;
+			}
+
+			if (datasource.supports('ensure_index') === false) {
+				return;
+			}
+
+			datasource.ensureIndex(that.model_class, that.indexes[options.name], function ensuredIndex(err, result) {
+				if (err) {
+					alchemy.printLog('error', ['Error ensuring compound index', options.name, 'in model', that.model_name], {err: err});
+				}
+			});
+		});
+
 		return;
 	}