alchemymvc 1.4.1 → 1.4.3

package/lib/app/helper_component/paginate_component.js

@@ -107,12 +107,7 @@ Paginate.setMethod(function find(model, criteria) {
 			return;
 		}
 
-		let PageInfo = conduit.internal('PageInfo');
-
-		if (PageInfo == null) {
-			PageInfo = {};
-			conduit.internal('PageInfo', PageInfo);
-		}
+		let PageInfo = conduit.internal('PageInfo') || {};
 
 		let entry = {
 			page     : page,
@@ -127,6 +122,11 @@ Paginate.setMethod(function find(model, criteria) {
 		}
 
 		PageInfo[name] = entry;
+
+		// Store the populated object, not an empty one we mutate afterwards: the
+		// renderer's internal store snapshots/transforms the value on set, so a
+		// later mutation of a previously-stored object no longer propagates.
+		conduit.internal('PageInfo', PageInfo);
 	});
 
 	return pledge;

package/lib/app/helper_datasource/05-fallback_datasource.js

@@ -130,6 +130,13 @@ Fallback.setMethod(function storeInUpperDatasource(model, data, options) {
 		// Allow extraneous values (the ones we just added in this function)
 		options.extraneous = true;
 
+		// Store the *converted* data (with the temp values added above), not the
+		// original app-side record. Without this the upper datasource caches the
+		// raw working values: e.g. a class-typed field is structured-cloned by
+		// IndexedDB into a plain, prototype-less object that can't be revived on
+		// read. The normal create()/update() flow does this same setConvertedData.
+		context.setConvertedData(data);
+
 		let promise;
 
 		if (options.create === false) {
@@ -158,7 +165,7 @@ Fallback.setMethod(function storeInUpperDatasource(model, data, options) {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.1.0
- * @version  1.4.0
+ * @version  1.4.2
  *
  * @param    {Alchemy.OperationalContext.ReadDocumentFromDatasource}   context
  *
@@ -176,7 +183,7 @@ Fallback.setMethod(function read(context) {
 		let lower_context = context.createChild();
 		lower_context.setCriteria(lower_criteria);
 
-		tasks.push(() => this.lower.read(context));
+		tasks.push(() => this.lower.read(lower_context));
 	}
 
 	let upper_criteria = criteria.clone();
@@ -195,7 +202,7 @@ Fallback.setMethod(function read(context) {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.1.0
- * @version  1.1.0
+ * @version  1.4.2
  *
  * @param    {Model}   model
  *
@@ -204,21 +211,16 @@ Fallback.setMethod(function read(context) {
 Fallback.setMethod(function getRecordsToSync(model) {
 
 	var that = this,
-	    pledge = new Pledge,
 	    criteria = model.find();
 
 	criteria.where('_$needs_remote_save').equals(1);
 
-	this.upper.read(model, criteria, function gotRecords(err, records) {
-
-		if (err) {
-			return pledge.reject(err);
-		}
+	let context = new Classes.Alchemy.OperationalContext.ReadDocumentFromDatasource();
+	context.setDatasource(this.upper);
+	context.setModel(model);
+	context.setCriteria(criteria);
 
-		pledge.resolve(records);
-	});
-
-	return pledge;
+	return this.upper.read(context);
 });
 
 /**

package/lib/app/helper_field/time_field.js

@@ -8,7 +8,7 @@
  * @version  1.1.0
  */
 var Time = Function.inherits('Alchemy.Field', function Time(schema, name, options) {
-	Time.call(this, schema, name, options);
+	Time.super.call(this, schema, name, options);
 });
 
 /**

package/lib/app/model/system_task_history_model.js

@@ -116,4 +116,138 @@ SystemTaskHistory.constitute(function chimeraConfig() {
 		route        : 'Chimera.Editor#taskMonitor',
 		route_params : {task_history_id: '$pk'},
 	});
+});
+
+/**
+ * Derive a single-word status from the recorded fields.
+ *
+ *   - 'running': is_running is still true
+ *   - 'failed':  had_error is true
+ *   - 'done':    started AND ended cleanly
+ *   - 'aborted': started but never ended (pre-1.4.2 zombies, or a process
+ *                that died mid-task without unwinding the try/finally)
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.2
+ *
+ * @return   {string}
+ */
+SystemTaskHistory.setDocumentMethod(function getStatus() {
+
+	if (this.had_error) {
+		return 'failed';
+	}
+
+	if (this.is_running) {
+		return 'running';
+	}
+
+	if (this.ended_at) {
+		return 'done';
+	}
+
+	if (this.started_at) {
+		return 'aborted';
+	}
+
+	return 'scheduled';
+});
+
+/**
+ * Return how long this run took (or has been running so far), in
+ * milliseconds. Null when nothing has started yet.
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.2
+ *
+ * @return   {number|null}
+ */
+SystemTaskHistory.setDocumentMethod(function getDuration() {
+
+	if (!this.started_at) {
+		return null;
+	}
+
+	let end = this.ended_at || (this.is_running ? new Date() : null);
+
+	if (!end) {
+		return null;
+	}
+
+	return end.getTime() - this.started_at.getTime();
+});
+
+/**
+ * Query the most recent task runs with optional filters. Centralized
+ * here so that both Chimera-side dashboards and MCP / API consumers can
+ * use the same paginated query - avoids forking the criteria.
+ *
+ * Options:
+ *   type    {string}  Filter by task type_path (e.g. 'arcana.task.sync_harvest_clients')
+ *   status  {string}  'running' | 'done' | 'failed' | 'aborted'
+ *   since   {Date}    Earliest started_at to include
+ *   limit   {number}  Page size (1-100, default 25)
+ *   offset  {number}  Skip count
+ *
+ * Returns `{rows, total}` where `total` is the unpaginated count.
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.2
+ *
+ * @param    {Object}   [options]
+ *
+ * @return   {Promise<{rows: DocumentList, total: number}>}
+ */
+SystemTaskHistory.setMethod(async function findRecent(options) {
+
+	options = options || {};
+
+	let crit = this.find();
+
+	if (options.type) {
+		crit.where('type').equals(options.type);
+	}
+
+	if (options.status) {
+		switch (options.status) {
+			case 'running':
+				crit.where('is_running').equals(true);
+				break;
+
+			case 'failed':
+				crit.where('had_error').equals(true);
+				break;
+
+			case 'done':
+				crit.where('is_running').equals(false);
+				crit.where('had_error').not().equals(true);
+				crit.where('ended_at').exists(true);
+				break;
+
+			case 'aborted':
+				crit.where('is_running').equals(false);
+				crit.where('had_error').not().equals(true);
+				crit.where('ended_at').isEmpty();
+				crit.where('started_at').exists(true);
+				break;
+
+			default:
+				throw new Error('Unknown task-run status filter: ' + options.status);
+		}
+	}
+
+	if (options.since) {
+		crit.where('started_at').gte(options.since);
+	}
+
+	let limit = Math.min(Math.max(options.limit || 25, 1), 100);
+	let offset = Math.max(options.offset || 0, 0);
+
+	crit.sort({started_at: -1});
+	crit.setOption('available', true);
+	crit.limit(limit);
+	if (offset > 0) crit.skip(offset);
+
+	let rows = await this.find('all', crit);
+	return {rows, total: rows.available || 0};
 });

package/lib/class/datasource.js

@@ -508,7 +508,7 @@ Datasource.setMethod(function read(context) {
 
 	model.emit('reading_datasource', criteria);
 
-	return Pledge.Swift.waterfall(
+	let read_pledge = Pledge.Swift.waterfall(
 		that._read(context),
 		_result => {
 
@@ -548,6 +548,18 @@ Datasource.setMethod(function read(context) {
 			}
 		);
 	});
+
+	// If a cache_pledge was created, make sure it gets rejected on error
+	// so that subsequent queries with the same hash don't hang forever
+	if (cache_pledge) {
+		Pledge.Swift.done(read_pledge, (err) => {
+			if (err) {
+				cache_pledge.reject(err);
+			}
+		});
+	}
+
+	return read_pledge;
 });
 
 /**
@@ -603,7 +615,7 @@ Datasource.setMethod(function update(context) {
 
 	let result = Swift.waterfall(
 		// Convert the data into something the datasource will understand
-		this.toDatasource(context),
+		() => this.toDatasource(context),
 
 		// Actually create the data
 		converted_data => this._update(context.setConvertedData(converted_data)),

package/lib/class/document.js

@@ -427,7 +427,7 @@ Document.setMethod(function toHawkejs(wm) {
 
 		result.setDataRecord(record, options);
 	} else {
-		record.$record = record;
+		result.$record = record;
 	}
 
 	// Clone $hold values if they are available

package/lib/class/inode_file.js

@@ -74,6 +74,8 @@ File.setStatic(function getMimetype(path) {
 
 			pledge.resolve(result);
 		});
+	} else {
+		pledge.resolve(File.guessMimetypeFromPath(path));
 	}
 
 	return pledge;

package/lib/class/model.js

@@ -390,7 +390,7 @@ Model.setStatic(async function checkPathValue(value, name, field_name, conduit)
 	if (result) {
 		let found_value = result[field_name];
 
-		if (found_value != value && !Object.alike(value, found_value)) {
+		if (conduit && found_value != value && !Object.alike(value, found_value)) {
 			conduit.rewriteRequestRouteParam(name, found_value);
 		}
 	}
@@ -534,7 +534,7 @@ Model.setStatic(function getField(name) {
 	if (name.indexOf('.') > -1) {
 		split = name.split('.');
 
-		alias = name[0];
+		alias = split[0];
 
 		if (this.schema.associations[alias] == null) {
 			model = this;

package/lib/class/plugin.js

@@ -116,7 +116,7 @@ Plugin.setMethod(async function startPlugin() {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.4.0
- * @version  1.4.0
+ * @version  1.4.3
  *
  * @return   {boolean}
  */
@@ -138,31 +138,16 @@ Plugin.setMethod(function loadSettingDefinitions() {
 	// Get/create this plugin's group definition
 	let group = this.getSettingsGroup();
 
-	// Get any already-existing settings
-	let parent = alchemy.system_settings.get('plugins');
-	let existing = parent.get(this.name);
-
-	if (existing) {
-		// Remove the existing settings.
-		// They are not linked properly anyway.
-		parent.remove(this.name);
-	}
-
-	// Require the settings.js file now
+	// Register the plugin's setting definitions
 	this.useFile(settings_path, {client: false});
 
-	// Create the new group settings with default values
-	let default_group = group.generateValue();
-
-	if (this.default_settings) {
-		default_group.setDefaultValue(this.default_settings);
-	}
-
-	if (existing) {
-		default_group.setValueSilently(existing);
-	}
-
-	parent.injectSubGroupValue(this.name, default_group);
+	// Rebuild this plugin's sub-group from its real definitions, preserving any
+	// values already applied to it (config overrides / an orphan created before
+	// the plugin loaded) plus the plugin's hard-coded default_settings. This is
+	// the same orphan-fix the general reconciler uses
+	// (Setting.GroupValue#rebuildSubGroup) - a single source of truth.
+	let parent = alchemy.system_settings.get('plugins');
+	parent.rebuildSubGroup(this.name, group, this.default_settings);
 
 	return true;
 });

package/lib/class/postponement.js

@@ -466,7 +466,7 @@ Postponement.setMethod(function putInQueue() {
 		return;
 	}
 
-	let new_length = QUEUE.push(this) - 1;
+	let new_length = QUEUE.push(this);
 
 	this.last_queue_position = new_length - 1;
 

package/lib/class/router.js

@@ -233,7 +233,8 @@ RouterClass.setMethod(function getFullMount() {
 RouterClass.setMethod(function getPrefix(path) {
 
 	var prefix,
-	    begin;
+	    begin,
+	    key;
 
 	// See if the path starts with any set prefix
 	for (key in prefixes) {

package/lib/class/schema_client.js

@@ -1184,7 +1184,7 @@ Schema.setMethod(function addIndex(_field_or_name, _options) {
 		}
 	};
 
-	if (typeof options.order == 'number') {
+	if (typeof options.order == 'string') {
 		if (options.order == 'asc') {
 			options.order = 1;
 		} else {

package/lib/class/task.js

@@ -371,33 +371,51 @@ Task.setMethod(async function start(payload) {
 	let result;
 
 	try {
-		result = await this.executor();
-	} catch (err) {
-		if (err == 'stopped') {
-			this.report('stopped', 'Stopped');
-			return;
+		try {
+			result = await this.executor();
+		} catch (err) {
+			if (err == 'stopped') {
+				this.report('stopped', 'Stopped');
+				return;
+			}
+
+			// Set the error
+			this.error = err;
+
+			// Report failed
+			let report = this.report('failed');
+			report.error = err;
+
+			// Surface the failure on the history document - without
+			// this, the row is left with `is_running: true` and no
+			// error info, looking identical to a still-running task.
+			document.had_error = true;
+			document.error_message = String(err && err.message || err);
+			document.error_stack = err && err.stack || null;
+
+			throw err;
 		}
 
-		// Set the error
-		this.error = err;
-
-		// Report failed
-		let report = this.report('failed');
-		report.error = err;
-
-		throw err;
-	}
-
-	// If the command hasn't been manually stopped,
-	// report it as done
-	if (!this.manual_stop_end) {
-		this.report('done');
+		// If the command hasn't been manually stopped,
+		// report it as done
+		if (!this.manual_stop_end) {
+			this.report('done');
+		}
+	} finally {
+		// Always close out the history document so it doesn't get
+		// stuck as a zombie "running forever" row.
+		document.ended_at = new Date();
+		document.is_running = false;
+
+		try {
+			await document.save();
+		} catch (save_err) {
+			// Don't let a history-save failure swallow the original
+			// executor error on its way out of the catch above.
+			alchemy.registerError(save_err);
+		}
 	}
 
-	document.ended_at = new Date();
-	document.is_running = false;
-	await document.save();
-
 	this[RUNNING_PLEDGE].resolve(result);
 
 	return result;
@@ -567,7 +585,7 @@ async function doAsyncLoopUntilNotBusy(max_tries) {
 	}
 
 	do {
-		console.log('Waiting for system to be less busy', tries)
+		log.info('Waiting for system to be less busy, try', tries);
 		await Pledge.after(500);
 		tries++;
 	} while (tries < max_tries && alchemy.isTooBusy());

package/lib/core/prefix.js

@@ -242,7 +242,7 @@ Connection.url = function url(connectionName, options) {
 Connection.fill = function fill(url, params) {
 
 	if (params) {
-		for (paramName in params) {
+		for (let paramName in params) {
 			url = url.replace(':'+paramName, params[paramName]);
 		}
 	}

package/lib/core/setting.js

@@ -1255,6 +1255,118 @@ GroupValue.setMethod(function injectSubGroupValue(name, value) {
 	this[VALUE][name] = value;
 });
 
+/**
+ * Rebuild a single sub-group value from its real definition, preserving any
+ * values that were already applied to the current (possibly orphaned) node.
+ *
+ * A config-file override that lands before a group's definition is registered
+ * leaves an "orphan" value backed by an ad-hoc, action-less definition (see
+ * `Group#assign`). This rebuilds the node from the real definition so it
+ * regains its full sub-structure and its leaves' actions, then silently
+ * replays the captured values. It fires NO actions - those run once, later,
+ * in the `settings.perform_actions` stage.
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.3
+ * @version  1.4.3
+ *
+ * @param    {string}                  name                 Child to rebuild
+ * @param    {Alchemy.Setting.Group}   group_definition     The real definition
+ * @param    {Object}                  [hardcoded_defaults] Defaults to re-apply
+ *
+ * @return   {Alchemy.Setting.GroupValue}
+ */
+GroupValue.setMethod(function rebuildSubGroup(name, group_definition, hardcoded_defaults) {
+
+	// Capture whatever value currently sits under `name` (orphan or not).
+	let existing = this.get(name);
+
+	if (existing) {
+		// Detach it so the slot is rebuilt cleanly.
+		this.remove(name);
+	}
+
+	// Materialise a fresh value tree from the REAL definition: recursively
+	// creates every real child with its default and the real `.definition`
+	// (which carries the action / global_variable an orphan stub lacks).
+	let fresh = group_definition.generateValue();
+
+	// Re-apply any hard-coded defaults (e.g. a plugin's `default_settings`).
+	if (hardcoded_defaults) {
+		fresh.setDefaultValue(hardcoded_defaults);
+	}
+
+	// Replay the previously-applied values WITHOUT firing actions. Only a
+	// group value can be replayed onto a group; a scalar sitting where a group
+	// belongs is a malformed override - drop it (and warn) rather than crash.
+	if (existing) {
+		if (existing.is_group) {
+			fresh.setValueSilently(existing);
+		} else {
+			alchemy.distinctProblem(
+				'setting-scalar-over-group-' + group_definition.setting_id,
+				'Setting "' + group_definition.setting_id + '" is a group but received a non-group override value; ignoring it'
+			);
+		}
+	}
+
+	// Slot the rebuilt node back into the live tree, in place.
+	this.injectSubGroupValue(name, fresh);
+
+	return fresh;
+});
+
+/**
+ * Walk this group's REAL definition tree and rebuild any sub-group whose live
+ * value was fabricated ad-hoc (by a config-file override that arrived before
+ * the definition was registered). Healthy nodes - identified by definition
+ * identity - are left untouched (recursed only, to catch nested orphans), so
+ * this is a strict no-op when there are no orphans. Fires NO actions.
+ *
+ * Intended to run after all setting definitions are registered and before the
+ * database values are applied / actions are fired (the `settings.reconcile`
+ * stage).
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.3
+ * @version  1.4.3
+ */
+GroupValue.setMethod(function reconcileOrphanGroups() {
+
+	let definition = this.definition;
+
+	if (!definition || !definition.children) {
+		return;
+	}
+
+	for (let [child_name, child_definition] of definition.children) {
+
+		// Only sub-groups can be orphaned. A leaf either already carries the
+		// real definition, or is an unknown key with nothing to rebuild.
+		if (!child_definition.is_group) {
+			continue;
+		}
+
+		let live = this.get(child_name);
+
+		// Nothing applied here yet: nothing to preserve, nothing orphaned.
+		if (!live) {
+			continue;
+		}
+
+		// Healthy node: its value is backed by the canonical definition.
+		// Leave it byte-for-byte, but recurse to catch nested orphans.
+		if (live.is_group && live.definition === child_definition) {
+			live.reconcileOrphanGroups();
+			continue;
+		}
+
+		// Orphan: the live value carries an ad-hoc definition. Rebuild it from
+		// the real definition, replaying the captured values silently.
+		this.rebuildSubGroup(child_name, child_definition);
+	}
+});
+
 /**
  * Get all the setting values with executable actions in order.
  *
@@ -1429,7 +1541,7 @@ GroupValue.setMethod(function _setPath(silent, path, raw_value) {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.4.0
- * @version  1.4.0
+ * @version  1.4.3
  *
  * @param    {string|Array}   path
  * @param    {Value}
@@ -1450,7 +1562,31 @@ GroupValue.setMethod(function forceValueInstanceAtPath(path, value) {
 
 	while (path.length && current) {
 		let next = path.shift();
-		current = current.get(next);
+
+		let child = current.get(next);
+
+		// Create missing intermediate group values instead of crashing.
+		// (A partial config-file override of a group can drop sibling
+		// sub-group value instances; recreate them on demand here.)
+		if (!child) {
+
+			// Can only create a child under a group value; a leaf has no
+			// child definitions to generate from.
+			if (!current.is_group) {
+				return;
+			}
+
+			let child_definition = current.definition.get(next);
+
+			if (!child_definition) {
+				return;
+			}
+
+			child = child_definition.generateValue();
+			current.injectSubGroupValue(next, child);
+		}
+
+		current = child;
 	}
 
 	current[VALUE][last] = value;

package/lib/stages/20-settings.js

@@ -15,13 +15,32 @@ const settings = STAGES.createStage('settings');
 // Do not start this stage before the datasources are connected
 settings.dependsOn('datasource.connect');
 
+/**
+ * "settings.reconcile"
+ * Rebuild any setting groups that were orphaned by a config-file override
+ * landing before the group's definition was registered (app definitions load
+ * in `app_bootstrap`, plugins in `load_app.plugins` - both after the config
+ * merge in the Alchemy constructor). Runs before `load` so the database values
+ * land on the real-definition value nodes, and before `perform_actions` so
+ * actions fire exactly once over the reconciled tree. Silent: fires no actions.
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.3
+ * @version  1.4.3
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const reconcile = settings.createStage('reconcile', () => {
+	alchemy.system_settings.reconcileOrphanGroups();
+});
+
 /**
  * "settings.load"
  * Load the settings from the database
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.4.0
- * @version  1.4.0
+ * @version  1.4.3
  *
  * @type     {Alchemy.Stages.Stage}
  */
@@ -38,6 +57,11 @@ const load = settings.createStage('load', async () => {
 	}
 });
 
+// Orphan reconciliation must finish before DB values are applied, so the
+// values land on the real-definition nodes. Creation order already runs
+// `reconcile` first; this makes the contract explicit and reorder-proof.
+load.dependsOn('settings.reconcile');
+
 /**
  * "settings.perform_actions"
  * Do all the setting-associated actions.

package/lib/stages/50-routes.js

@@ -204,7 +204,7 @@ const middleware = routes.createStage('middleware', () => {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.4.0
- * @version  1.4.0
+ * @version  1.4.3
  *
  * @type     {Alchemy.Stages.Stage}
  */
@@ -212,6 +212,16 @@ const app_routes = routes.createStage('app_routes', () => {
 	try {
 		alchemy.useOnce(libpath.resolve(PATH_APP, 'config', 'routes.js'));
 	} catch (err) {
+
+		// A missing routes.js is fine (the file is optional). Any other error
+		// is a real problem inside the file and must NOT be swallowed - that
+		// would leave the app running with no routes and only a warning.
+		let is_not_found = err.code === 'ENOENT' || err.message.indexOf('Cannot find') > -1;
+
+		if (!is_not_found) {
+			throw err;
+		}
+
 		// Only output warning when not in client mode
 		if (!alchemy.getSetting('client_mode')) {
 			log.warn('No app routes were found:', err);

package/lib/testing/harness.js

@@ -55,6 +55,12 @@ const TestHarness = Function.inherits('Informer', 'Alchemy.Testing', function Te
 		// Use mongo-unit for in-memory MongoDB (default: true)
 		use_mongo_unit: true,
 
+		// Extra options forwarded to mongo-unit's start() (e.g. `version`
+		// to pin the mongod binary, or `dbpath` to point at a tmpfs dir).
+		// `storageEngine` defaults to 'wiredTiger' in startMongo - see why
+		// there.
+		mongo_unit_options: {},
+
 		// Server port (default: random between 3470-3570)
 		port: 3470 + Math.floor(Math.random() * 100),
 
@@ -243,10 +249,21 @@ TestHarness.setMethod(async function startMongo() {
 	}
 
 	let MongoUnit = this.getMongoUnit();
-	this._mongo_uri = await MongoUnit.start({ verbose: false });
+
+	// mongo-unit defaults its standalone storage engine to
+	// `ephemeralForTest`, which was removed in MongoDB 6.0 (and
+	// `inMemory` is Enterprise-only). Force `wiredTiger` so a modern
+	// mongod binary actually boots. Callers can still override it (or
+	// pin `version` / set `dbpath`) via `mongo_unit_options`.
+	let mongo_opts = Object.assign({
+		verbose       : false,
+		storageEngine : 'wiredTiger',
+	}, this.options.mongo_unit_options);
+
+	this._mongo_uri = await MongoUnit.start(mongo_opts);
 
 	if (!this._mongo_uri) {
-		throw new Error('Failed to start mongo-unit');
+		throw new Error('Failed to start mongo-unit (no URI returned)');
 	}
 
 	return this._mongo_uri;
@@ -278,6 +295,15 @@ TestHarness.setMethod(function startServer() {
 			STAGES.getStage('datasource').addPostTask(() => {
 				Datasource.create('mongo', 'default', { uri: this._mongo_uri });
 			});
+		} else if (this.options.use_mongo_unit) {
+			// mongo-unit was requested but never produced a URI (startMongo
+			// failed or wasn't called). Refuse to start - otherwise the app
+			// silently falls back to whatever default datasource is
+			// configured, which can be a REAL database. That fallback is how
+			// a broken in-memory mongo ends up polluting (and reading stale
+			// data from) a live dev DB. Fail loud instead.
+			return reject(new Error('TestHarness: use_mongo_unit is enabled but no mongo URI is available '
+				+ '(did startMongo() fail?). Refusing to start the server to avoid connecting to a non-test database.'));
 		}
 
 		// Register additional module search paths
@@ -392,7 +418,15 @@ TestHarness.setMethod(async function stop() {
 
 	// Stop mongo-unit
 	if (this._mongo_unit && this._mongo_uri) {
-		this._mongo_unit.stop();
+
+		// mongodb-memory-server kills a standalone mongod with SIGINT (then
+		// SIGKILL) rather than a clean admin shutdown. Under some mongod
+		// builds that triggers a coredump on the way down. Ask mongod to
+		// shut down cleanly first, so the subsequent signal hits an already
+		// gone process and short-circuits.
+		await this._gracefullyShutdownMongo(this._mongo_uri);
+
+		await this._mongo_unit.stop();
 		this._mongo_uri = null;
 	}
 
@@ -403,6 +437,54 @@ TestHarness.setMethod(async function stop() {
 	}
 });
 
+/**
+ * Ask a mongod to shut down cleanly via the admin command, so the
+ * subsequent signal-based kill from mongodb-memory-server hits an
+ * already-gone process. Best-effort: any failure is swallowed and we
+ * fall through to the normal stop path.
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.2
+ *
+ * @param    {string}   uri
+ *
+ * @return   {Promise}
+ */
+TestHarness.setMethod(async function _gracefullyShutdownMongo(uri) {
+
+	if (!uri) {
+		return;
+	}
+
+	let MongoClient;
+
+	try {
+		MongoClient = require('mongodb').MongoClient;
+	} catch (err) {
+		// No mongodb driver available - nothing we can do, let the
+		// normal stop path handle it.
+		return;
+	}
+
+	let client;
+
+	try {
+		client = await MongoClient.connect(uri, { directConnection: true });
+		try {
+			await client.db('admin').command({ shutdown: 1, force: true, timeoutSecs: 1 });
+		} catch (err) {
+			// mongod closes the connection mid-command while shutting down,
+			// surfacing as a network error. That means it worked - swallow.
+		}
+	} catch (err) {
+		// Couldn't reach mongod - fall through to the signal-based stop.
+	} finally {
+		if (client) {
+			try { await client.close(true); } catch (_) {}
+		}
+	}
+});
+
 /**
  * Get a full URL for a path
  *

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "alchemymvc",
 	"description": "MVC framework for Node.js",
-	"version": "1.4.1",
+	"version": "1.4.3",
 	"author": "Jelle De Loecker <jelle@elevenways.be>",
 	"keywords": [
 		"alchemy",
@@ -63,8 +63,8 @@
 	"devDependencies": {
 		"codecov"                 : "~3.8.1",
 		"istanbul-lib-instrument" : "~6.0.1",
-		"mocha"                   : "~10.2.0",
-		"mongo-unit"              : "~3.3.0",
+		"mocha"                   : "^11.7.5",
+		"mongo-unit"              : "^3.4.0",
 		"nyc"                     : "^15.1.0",
 		"puppeteer"               : "~21.3.6",
 		"source-map"              : "~0.7.3"
@@ -79,4 +79,4 @@
 	"engines": {
 		"node" : ">=16.20.1"
 	}
-}
+}