meadow 2.0.36 → 2.0.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meadow",
-  "version": "2.0.36",
+  "version": "2.0.38",
   "description": "A data access library.",
   "main": "source/Meadow.js",
   "scripts": {
@@ -83,22 +83,22 @@
     "alasql": "^4.17.0",
     "better-sqlite3": "^12.6.2",
     "dgraph-js-http": "^21.3.0",
-    "fable": "^3.1.70",
+    "fable": "^3.1.71",
     "gulp-util": "^3.0.8",
-    "meadow-connection-dgraph": "^1.0.2",
-    "meadow-connection-mongodb": "^1.0.2",
-    "meadow-connection-mssql": "^1.0.21",
-    "meadow-connection-mysql": "^1.0.17",
-    "meadow-connection-postgresql": "^1.0.3",
-    "meadow-connection-rocksdb": "^0.0.2",
-    "meadow-connection-solr": "^1.0.2",
-    "meadow-connection-sqlite": "^1.0.18",
+    "meadow-connection-dgraph": "^1.0.3",
+    "meadow-connection-mongodb": "^1.0.3",
+    "meadow-connection-mssql": "^1.0.23",
+    "meadow-connection-mysql": "^1.0.19",
+    "meadow-connection-postgresql": "^1.0.5",
+    "meadow-connection-rocksdb": "^1.0.0",
+    "meadow-connection-solr": "^1.0.3",
+    "meadow-connection-sqlite": "^1.0.19",
     "meadow-connection-sqlite-browser": "^1.0.2",
     "mongodb": "^6.12.0",
     "mysql2": "^3.18.2",
     "pict-docuserve": "^0.1.5",
     "puppeteer": "^24.38.0",
-    "quackage": "^1.1.2",
+    "quackage": "^1.2.3",
     "solr-client": "^0.9.0"
   },
   "dependencies": {

package/scripts/dgraph-test-db.sh

@@ -39,12 +39,18 @@ start_dgraph() {
 		exit 1
 	fi
 
-	echo "Waiting for DGraph to be ready..."
+	# Two-stage readiness probe. /health turns 200 as soon as Zero is up, but
+	# Alpha (the write/schema endpoint) can take many seconds longer to start
+	# accepting /alter — under Colima/QEMU this gap is wide enough that the
+	# downstream test's drop_all + applyDGraphSchema hangs and burns the
+	# 30s mocha hook budget. Probe /alter with a no-op so we don't return
+	# until the full write path is alive.
+	echo "Waiting for DGraph /health..."
 	RETRIES=30
-	until curl -sf "http://localhost:${DGRAPH_HTTP_PORT}/health" > /dev/null 2>&1; do
+	until curl -sf --max-time 2 "http://localhost:${DGRAPH_HTTP_PORT}/health" > /dev/null 2>&1; do
 		RETRIES=$((RETRIES - 1))
 		if [ $RETRIES -le 0 ]; then
-			echo "ERROR: DGraph failed to become ready in time."
+			echo "ERROR: DGraph /health failed to become ready in time."
 			docker logs "${CONTAINER_NAME}" 2>&1 | tail -20
 			exit 1
 		fi
@@ -52,6 +58,20 @@ start_dgraph() {
 		sleep 2
 	done
 
+	echo "Waiting for DGraph /alter (Alpha write path)..."
+	RETRIES=30
+	# Empty schema is a valid alter — round-trips through Alpha without changing state.
+	until curl -sf --max-time 5 -X POST -H "Content-Type: application/json" -d '{"schema":""}' "http://localhost:${DGRAPH_HTTP_PORT}/alter" > /dev/null 2>&1; do
+		RETRIES=$((RETRIES - 1))
+		if [ $RETRIES -le 0 ]; then
+			echo "ERROR: DGraph /alter never accepted writes in time."
+			docker logs "${CONTAINER_NAME}" 2>&1 | tail -30
+			exit 1
+		fi
+		echo "  ...waiting on alter (${RETRIES} retries left)"
+		sleep 2
+	done
+
 	# Apply schema predicates for the FableTest type and MeadowCounter type
 	# Note: FableTest fields use unscoped predicate names to match FoxHound DGraph dialect output
 	echo "Applying DGraph schema..."

package/scripts/mssql-runner.js

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+// mssql-runner.js — sqlcmd-equivalent for the test-database scripts.
+//
+// Replaces `docker exec <container> /opt/mssql-tools.../sqlcmd ...` with a
+// host-side connection over the mapped port. Avoids depending on tooling
+// the SQL Server image happens to bundle (which varies — Azure SQL Edge's
+// :latest, for example, has dropped the in-container sqlcmd binary).
+//
+// Modes:
+//   --readiness                  Probe-and-retry until the engine accepts a
+//                                login + SELECT 1. Exit 0 when ready.
+//   --query "<SQL>"              Run a single statement and exit.
+//   (stdin, no mode flag)        Read SQL from stdin, split on `^GO$` lines,
+//                                execute each batch in order.
+//
+// Connection parameters via env (with defaults that match mssql-test-db.sh):
+//   MSSQL_HOST     127.0.0.1
+//   MSSQL_PORT     31433
+//   MSSQL_USER     sa
+//   MSSQL_PASSWORD 1234567890abc.
+//   MSSQL_DATABASE master   (override with --db <name>)
+
+const libTedious = require('tedious');
+
+const tmpArgs = process.argv.slice(2);
+const tmpMode = (() =>
+{
+	if (tmpArgs.includes('--readiness')) return 'readiness';
+	const tmpQueryIdx = tmpArgs.indexOf('--query');
+	if (tmpQueryIdx >= 0) return 'query';
+	return 'stdin';
+})();
+
+const tmpDBIdx = tmpArgs.indexOf('--db');
+const tmpDatabase = (tmpDBIdx >= 0 && tmpArgs[tmpDBIdx + 1]) ? tmpArgs[tmpDBIdx + 1] : (process.env.MSSQL_DATABASE || 'master');
+
+const tmpQueryIdx = tmpArgs.indexOf('--query');
+const tmpInlineQuery = (tmpQueryIdx >= 0 && tmpArgs[tmpQueryIdx + 1]) ? tmpArgs[tmpQueryIdx + 1] : null;
+
+const tmpConfig =
+{
+	server: process.env.MSSQL_HOST || '127.0.0.1',
+	authentication:
+	{
+		type: 'default',
+		options:
+		{
+			userName: process.env.MSSQL_USER || 'sa',
+			password: process.env.MSSQL_PASSWORD || '1234567890abc.'
+		}
+	},
+	options:
+	{
+		port: parseInt(process.env.MSSQL_PORT || '31433', 10),
+		database: tmpDatabase,
+		// TLS with cert trust — matches sqlcmd -C and what newer SQL Server
+		// / Azure SQL Edge images expect by default. trustServerCertificate
+		// is required for the self-signed cert the container generates.
+		encrypt: true,
+		trustServerCertificate: true,
+		// Default 15s timeout cuts off readiness probing on slow startups.
+		// Bump it so the probe loop owns the retry cadence, not tedious.
+		connectTimeout: 60000,
+		requestTimeout: 60000,
+		rowCollectionOnRequestCompletion: false
+	}
+};
+
+function connect()
+{
+	return new Promise((fResolve, fReject) =>
+	{
+		const tmpConnection = new libTedious.Connection(tmpConfig);
+		tmpConnection.on('connect', (pError) =>
+		{
+			if (pError) return fReject(pError);
+			return fResolve(tmpConnection);
+		});
+		tmpConnection.connect();
+	});
+}
+
+function execSql(pConnection, pSQL)
+{
+	return new Promise((fResolve, fReject) =>
+	{
+		const tmpRequest = new libTedious.Request(pSQL, (pError) =>
+		{
+			if (pError) return fReject(pError);
+			return fResolve();
+		});
+		pConnection.execSql(tmpRequest);
+	});
+}
+
+function close(pConnection)
+{
+	return new Promise((fResolve) =>
+	{
+		pConnection.on('end', fResolve);
+		pConnection.close();
+	});
+}
+
+// Split a multi-batch script on `^GO$` lines (case-insensitive, trimmed).
+// sqlcmd's GO separator is a batch delimiter, not a SQL keyword — it must
+// appear alone on its own line.
+function splitBatches(pScript)
+{
+	const tmpLines = pScript.split(/\r?\n/);
+	const tmpBatches = [];
+	let tmpCurrent = [];
+	for (const tmpLine of tmpLines)
+	{
+		if (/^\s*GO\s*$/i.test(tmpLine))
+		{
+			const tmpJoined = tmpCurrent.join('\n').trim();
+			if (tmpJoined.length > 0) tmpBatches.push(tmpJoined);
+			tmpCurrent = [];
+		}
+		else
+		{
+			tmpCurrent.push(tmpLine);
+		}
+	}
+	const tmpTail = tmpCurrent.join('\n').trim();
+	if (tmpTail.length > 0) tmpBatches.push(tmpTail);
+	return tmpBatches;
+}
+
+async function runReadiness()
+{
+	const tmpMaxRetries = parseInt(process.env.MSSQL_RUNNER_RETRIES || '60', 10);
+	const tmpSleepMs = parseInt(process.env.MSSQL_RUNNER_SLEEP_MS || '2000', 10);
+	for (let i = 0; i < tmpMaxRetries; i++)
+	{
+		try
+		{
+			const tmpConn = await connect();
+			await execSql(tmpConn, 'SELECT 1');
+			await close(tmpConn);
+			return;
+		}
+		catch (pError)
+		{
+			const tmpRemaining = tmpMaxRetries - 1 - i;
+			if (tmpRemaining <= 0)
+			{
+				console.error(`ERROR: MSSQL not ready after ${tmpMaxRetries} attempts: ${pError.message}`);
+				process.exit(1);
+			}
+			console.log(`  ...waiting (${tmpRemaining} retries left)`);
+			await new Promise((fResolve) => setTimeout(fResolve, tmpSleepMs));
+		}
+	}
+}
+
+async function runQuery(pSQL)
+{
+	const tmpConn = await connect();
+	try
+	{
+		await execSql(tmpConn, pSQL);
+	}
+	finally
+	{
+		await close(tmpConn);
+	}
+}
+
+async function runStdin()
+{
+	const tmpChunks = [];
+	for await (const tmpChunk of process.stdin) tmpChunks.push(tmpChunk);
+	const tmpScript = Buffer.concat(tmpChunks).toString('utf8');
+	const tmpBatches = splitBatches(tmpScript);
+	if (tmpBatches.length < 1) return;
+
+	const tmpConn = await connect();
+	try
+	{
+		for (const tmpBatch of tmpBatches)
+		{
+			await execSql(tmpConn, tmpBatch);
+		}
+	}
+	finally
+	{
+		await close(tmpConn);
+	}
+}
+
+(async () =>
+{
+	try
+	{
+		if (tmpMode === 'readiness') await runReadiness();
+		else if (tmpMode === 'query') await runQuery(tmpInlineQuery);
+		else await runStdin();
+		process.exit(0);
+	}
+	catch (pError)
+	{
+		console.error(`mssql-runner: ${pError.message}`);
+		process.exit(1);
+	}
+})();

package/scripts/mssql-test-db.sh

@@ -15,10 +15,27 @@ CONTAINER_NAME="meadow-mssql-test"
 SA_PASSWORD="1234567890abc."
 MSSQL_DATABASE="bookstore"
 MSSQL_PORT="31433"
-MSSQL_IMAGE="mcr.microsoft.com/mssql/server:2022-latest"
+# Azure SQL Edge — multi-arch (amd64 + arm64). The full SQL Server image
+# (mcr.microsoft.com/mssql/server) ships amd64 only, which crashes on
+# Apple Silicon under Colima/QEMU because of address-layout assumptions
+# the SQL Server binary makes. Azure SQL Edge speaks the same wire
+# protocol and T-SQL surface the meadow tests need.
+MSSQL_IMAGE="mcr.microsoft.com/azure-sql-edge:latest"
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 SEED_GENERATOR="${SCRIPT_DIR}/bookstore-seed.js"
+# Host-side TDS runner — replaces `docker exec <ctn> sqlcmd ...`. Recent
+# Azure SQL Edge images strip the in-container sqlcmd binary, and the
+# stand-alone `mcr.microsoft.com/mssql-tools` image is amd64-only (crashes
+# under Colima/QEMU on Apple Silicon). Going host-side via tedious sidesteps
+# both — connection works against the mapped port regardless of image arch.
+MSSQL_RUNNER="${SCRIPT_DIR}/mssql-runner.js"
+
+# Connection params for the runner (and matched by the test config).
+export MSSQL_HOST="127.0.0.1"
+export MSSQL_PORT
+export MSSQL_USER="sa"
+export MSSQL_PASSWORD="${SA_PASSWORD}"
 
 start_mssql() {
 	# Check if container already exists
@@ -46,30 +63,22 @@ start_mssql() {
 	fi
 
 	echo "Waiting for MSSQL to be ready..."
-	RETRIES=30
-	until docker exec "${CONTAINER_NAME}" /opt/mssql-tools18/bin/sqlcmd -S localhost -U sa -P "${SA_PASSWORD}" -C -Q "SELECT 1" > /dev/null 2>&1; do
-		RETRIES=$((RETRIES - 1))
-		if [ $RETRIES -le 0 ]; then
-			echo "ERROR: MSSQL failed to become ready in time."
-			docker logs "${CONTAINER_NAME}" 2>&1 | tail -20
-			exit 1
-		fi
-		echo "  ...waiting (${RETRIES} retries left)"
-		sleep 2
-	done
+	if ! node "${MSSQL_RUNNER}" --readiness; then
+		echo "ERROR: MSSQL failed to become ready in time."
+		docker logs "${CONTAINER_NAME}" 2>&1 | tail -20
+		exit 1
+	fi
 
 	# Create the bookstore database
 	echo "Creating database '${MSSQL_DATABASE}'..."
-	docker exec "${CONTAINER_NAME}" /opt/mssql-tools18/bin/sqlcmd \
-		-S localhost -U sa -P "${SA_PASSWORD}" -C \
-		-Q "IF NOT EXISTS(SELECT * FROM sys.databases WHERE name = '${MSSQL_DATABASE}') BEGIN CREATE DATABASE [${MSSQL_DATABASE}] END"
+	node "${MSSQL_RUNNER}" --db master --query \
+		"IF NOT EXISTS(SELECT * FROM sys.databases WHERE name = '${MSSQL_DATABASE}') BEGIN CREATE DATABASE [${MSSQL_DATABASE}] END"
 
 	# Load bookstore schema and seed data (GUIDs minted at generation time via fable-uuid)
 	if [ -f "${SEED_GENERATOR}" ]; then
 		echo "Loading bookstore schema and seed data..."
 		node "${SEED_GENERATOR}" --dialect mssql | \
-			docker exec -i "${CONTAINER_NAME}" /opt/mssql-tools18/bin/sqlcmd \
-				-S localhost -U sa -P "${SA_PASSWORD}" -C -d "${MSSQL_DATABASE}"
+			node "${MSSQL_RUNNER}" --db "${MSSQL_DATABASE}"
 		if [ $? -ne 0 ]; then
 			echo "WARNING: Failed to load seed data. Tests requiring pre-populated data may fail."
 		else

package/source/behaviors/Meadow-CollisionRename.js

@@ -0,0 +1,281 @@
+// ##### Part of the **[retold](https://stevenvelozo.github.io/retold/)** system
+/**
+* @license MIT
+* @author <steven@velozo.com>
+*/
+var libCrypto = require('crypto');
+
+/**
+* Meadow Behavior - Soft-Deleted Collision Rename
+*
+* When an INSERT (or upsert-create branch) would collide on a UNIQUE
+* constraint AND the conflicting existing row is soft-deleted (Deleted=1),
+* rename the soft-deleted row's conflicting column(s) so the new row can
+* take that slot. Frees downstream schemas from needing dialect-specific
+* `WHERE Deleted=0` partial-index syntax to keep soft-deleted rows out of
+* the unique-index domain.
+*
+* Renamed-value format: `__mdsd_{16hex}` where the hex is the first 16
+* characters of sha1("{IDRecord}:{Column}:{OriginalValue}"). Deterministic,
+* bounded length (~22 chars), and forensics-traceable: given a soft-deleted
+* row's pk + original value, recompute the hash to verify the renamed slot.
+*
+* The schema opts in via per-column `Unique: true` (single-column constraint)
+* or `UniqueGroup: "<name>"` (composite index — all columns sharing a group
+* name). Columns of `Type: AutoGUID` are treated as implicitly unique. If a
+* schema declares no unique columns, this is a no-op.
+*/
+
+var COLLISION_RENAME_PREFIX = '__mdsd_';
+var COLLISION_RENAME_HASH_LENGTH = 16;
+
+var buildRenamedValue = function (pIDRecord, pColumn, pOriginalValue)
+{
+	var tmpInput = String(pIDRecord) + ':' + String(pColumn) + ':' + String(pOriginalValue);
+	var tmpHash = libCrypto.createHash('sha1').update(tmpInput).digest('hex').slice(0, COLLISION_RENAME_HASH_LENGTH);
+	return COLLISION_RENAME_PREFIX + tmpHash;
+};
+
+/**
+* Walk a meadow schema and collect unique-constraint groupings.
+*
+* Returns an array of { Columns, GroupName }, where Columns is the list of
+* columns participating in the constraint and GroupName is null for single
+* columns or the user's UniqueGroup name for composite constraints.
+*/
+var collectUniqueConstraints = function (pSchema)
+{
+	var tmpConstraints = [];
+	if (!Array.isArray(pSchema))
+	{
+		return tmpConstraints;
+	}
+
+	var tmpGroups = {};
+
+	for (var i = 0; i < pSchema.length; i++)
+	{
+		var tmpEntry = pSchema[i];
+
+		// AutoGUID columns are implicitly unique. The pre-flight handles
+		// BOTH soft-deleted-rename AND live-conflict error here, replacing
+		// the old standalone GUID-conflict check in Meadow-Create — one
+		// Read covers both behaviors instead of two.
+		if (tmpEntry.Type === 'AutoGUID')
+		{
+			tmpConstraints.push({ Columns: [tmpEntry.Column], GroupName: '__autoguid_' + tmpEntry.Column, AutoGUID: true });
+		}
+
+		if (tmpEntry.Unique === true)
+		{
+			tmpConstraints.push({ Columns: [tmpEntry.Column], GroupName: null, AutoGUID: false });
+		}
+
+		if (typeof (tmpEntry.UniqueGroup) === 'string' && tmpEntry.UniqueGroup.length > 0)
+		{
+			if (!tmpGroups[tmpEntry.UniqueGroup])
+			{
+				tmpGroups[tmpEntry.UniqueGroup] = { Columns: [], GroupName: tmpEntry.UniqueGroup, AutoGUID: false };
+			}
+			tmpGroups[tmpEntry.UniqueGroup].Columns.push(tmpEntry.Column);
+		}
+	}
+
+	var tmpGroupNames = Object.keys(tmpGroups);
+	for (var g = 0; g < tmpGroupNames.length; g++)
+	{
+		tmpConstraints.push(tmpGroups[tmpGroupNames[g]]);
+	}
+
+	return tmpConstraints;
+};
+
+/**
+* Find the schema entry for the soft-delete flag column, if any.
+* Returns the column name (e.g. "Deleted") or null when no soft-delete
+* tracking is configured.
+*/
+var findDeletedColumn = function (pSchema)
+{
+	if (!Array.isArray(pSchema))
+	{
+		return null;
+	}
+	for (var i = 0; i < pSchema.length; i++)
+	{
+		if (pSchema[i].Type === 'Deleted')
+		{
+			return pSchema[i].Column;
+		}
+	}
+	return null;
+};
+
+/**
+* For one constraint: scan for matching rows (with delete tracking
+* disabled), and rename any that are soft-deleted on the constraint
+* columns. Live conflicts pass through untouched so the regular DB
+* unique-index error fires.
+*/
+var processConstraint = function (pMeadow, pNewRecord, pConstraint, pDeletedColumn, fCallback)
+{
+	for (var i = 0; i < pConstraint.Columns.length; i++)
+	{
+		var tmpColumn = pConstraint.Columns[i];
+		// If the new record doesn't supply a value for every column in the
+		// constraint, no meaningful conflict query can be formed — skip.
+		if (!Object.prototype.hasOwnProperty.call(pNewRecord, tmpColumn))
+		{
+			return fCallback();
+		}
+		var tmpValue = pNewRecord[tmpColumn];
+		if (tmpValue === '' || tmpValue === null || typeof (tmpValue) === 'undefined')
+		{
+			return fCallback();
+		}
+		// AutoGUID gating mirrors the old Meadow-Create Step 0 check: only
+		// scan when the value is at least 5 chars (FoxHound's GUID min) and
+		// not the schema's '0x0000000000000000' placeholder. Without these,
+		// schemas with placeholder defaults would trigger spurious renames.
+		if (pConstraint.AutoGUID && (typeof (tmpValue) !== 'string' || tmpValue.length < 5 || tmpValue === '0x0000000000000000'))
+		{
+			return fCallback();
+		}
+	}
+
+	var tmpReadQuery = pMeadow.query.clone().setDisableDeleteTracking(true);
+	for (var c = 0; c < pConstraint.Columns.length; c++)
+	{
+		tmpReadQuery.addFilter(pConstraint.Columns[c], pNewRecord[pConstraint.Columns[c]]);
+	}
+
+	pMeadow.provider.Read(tmpReadQuery, function ()
+	{
+		if (tmpReadQuery.error)
+		{
+			return fCallback(tmpReadQuery.error);
+		}
+
+		var tmpRows = tmpReadQuery.result.value;
+		if (!Array.isArray(tmpRows) || tmpRows.length < 1)
+		{
+			return fCallback();
+		}
+
+		var tmpSoftDeletedRows = [];
+		for (var r = 0; r < tmpRows.length; r++)
+		{
+			var tmpFlag = pDeletedColumn ? tmpRows[r][pDeletedColumn] : 0;
+			// Backends are inconsistent: SQLite returns the integer 1, MySQL
+			// can return a Buffer or boolean, MongoDB a boolean, etc. Treat
+			// any truthy value as soft-deleted.
+			if (tmpFlag == 1 || tmpFlag === true)
+			{
+				tmpSoftDeletedRows.push(tmpRows[r]);
+			}
+		}
+
+		if (tmpSoftDeletedRows.length < 1)
+		{
+			// AutoGUID columns get an explicit pre-flight error to preserve
+			// the legacy Meadow-Create Step 0 contract: callers expect the
+			// "Record with GUID X already exists!" string before the INSERT
+			// fires, not a downstream DB unique-index error. User-defined
+			// Unique columns keep deferring to the DB so the error surface
+			// for those isn't expanded by this refactor.
+			if (pConstraint.AutoGUID)
+			{
+				var tmpGUIDValue = pNewRecord[pConstraint.Columns[0]];
+				return fCallback('Record with GUID ' + tmpGUIDValue + ' already exists!');
+			}
+			return fCallback();
+		}
+
+		var tmpRenameNext = function (pIndex)
+		{
+			if (pIndex >= tmpSoftDeletedRows.length)
+			{
+				return fCallback();
+			}
+
+			var tmpRow = tmpSoftDeletedRows[pIndex];
+			var tmpRowID = tmpRow[pMeadow.defaultIdentifier];
+			var tmpRenameRecord = {};
+			tmpRenameRecord[pMeadow.defaultIdentifier] = tmpRowID;
+			for (var k = 0; k < pConstraint.Columns.length; k++)
+			{
+				var tmpCol = pConstraint.Columns[k];
+				tmpRenameRecord[tmpCol] = buildRenamedValue(tmpRowID, tmpCol, tmpRow[tmpCol]);
+			}
+
+			var tmpUpdateQuery = pMeadow.query.clone()
+				.setDisableDeleteTracking(true)
+				.addRecord(tmpRenameRecord)
+				.addFilter(pMeadow.defaultIdentifier, tmpRowID);
+
+			// Use the meadow's IDUser so audit columns get a sensible value
+			// — the rename is a side effect of the new record's create, so
+			// the same user identity drives both.
+			tmpUpdateQuery.query.IDUser = pMeadow.userIdentifier;
+
+			pMeadow.provider.Update(tmpUpdateQuery, function ()
+			{
+				if (tmpUpdateQuery.error)
+				{
+					return fCallback(tmpUpdateQuery.error);
+				}
+				return tmpRenameNext(pIndex + 1);
+			});
+		};
+
+		tmpRenameNext(0);
+	});
+};
+
+/**
+* Top-level: walk all unique constraints in the schema and rename any
+* soft-deleted conflicts so the imminent INSERT can take the slot.
+*/
+var renameSoftDeletedConflicts = function (pMeadow, pNewRecord, fCallback)
+{
+	var tmpConstraints = collectUniqueConstraints(pMeadow.schema);
+	if (tmpConstraints.length < 1)
+	{
+		return fCallback();
+	}
+
+	var tmpDeletedColumn = findDeletedColumn(pMeadow.schema);
+	// If there's no Deleted column in the schema, soft-delete tracking
+	// isn't a concept here — nothing can be soft-deleted, so nothing to
+	// rename. Bail out early.
+	if (!tmpDeletedColumn)
+	{
+		return fCallback();
+	}
+
+	var tmpProcessNext = function (pIndex)
+	{
+		if (pIndex >= tmpConstraints.length)
+		{
+			return fCallback();
+		}
+
+		processConstraint(pMeadow, pNewRecord, tmpConstraints[pIndex], tmpDeletedColumn, function (pError)
+		{
+			if (pError)
+			{
+				return fCallback(pError);
+			}
+			return tmpProcessNext(pIndex + 1);
+		});
+	};
+
+	tmpProcessNext(0);
+};
+
+module.exports = renameSoftDeletedConflicts;
+module.exports.buildRenamedValue = buildRenamedValue;
+module.exports.collectUniqueConstraints = collectUniqueConstraints;
+module.exports.findDeletedColumn = findDeletedColumn;
+module.exports.COLLISION_RENAME_PREFIX = COLLISION_RENAME_PREFIX;
+module.exports.COLLISION_RENAME_HASH_LENGTH = COLLISION_RENAME_HASH_LENGTH;

package/source/behaviors/Meadow-Create.js

@@ -5,6 +5,8 @@
 */
 var libAsyncWaterfall = require('async/waterfall');
 
+var libRenameSoftDeletedConflicts = require('./Meadow-CollisionRename.js');
+
 /**
 * Meadow Behavior - Create
 *
@@ -14,51 +16,39 @@ var meadowBehaviorCreate = function(pMeadow, pQuery, fCallBack)
 {
 	libAsyncWaterfall(
 		[
-			// Step 0: If GUID is specified, make sure the record does not already exist
+			// Step 0: Unique-constraint pre-flight. Single Read per constraint
+			// (AutoGUID + any user-declared Unique/UniqueGroup columns) covers
+			// both behaviors that used to live here:
+			//   - soft-deleted collisions get the conflicting columns renamed
+			//     so the new INSERT can take the slot (the soft-delete /
+			//     dialect-specific WHERE-Deleted=0 partial-index workaround
+			//     downstream consumers used to need)
+			//   - live AutoGUID collisions return the legacy "Record with
+			//     GUID X already exists!" error before the INSERT fires
+			// No-op when the schema declares no Unique/UniqueGroup columns
+			// AND no Deleted-tracking column. Live conflicts on user-declared
+			// Unique columns still defer to the DB unique-index error.
 			function (fStageComplete)
 			{
-				// Make sure the user submitted a record
-				if (!pQuery.query.records)
+				// Reject missing records here — the old Step 0 owned this
+				// error and downstream steps assume pQuery.query.records[0]
+				// exists. Same string and trailing-args shape as before so
+				// existing callers' expectations are preserved.
+				if (!pQuery.query.records || !pQuery.query.records[0])
 				{
 					return fStageComplete('No record submitted', pQuery, false);
 				}
 
-				if (pQuery.query.records[0][pMeadow.defaultGUIdentifier] &&
-					pQuery.query.records[0][pMeadow.defaultGUIdentifier].length >= 5) //see Foxhound mysql build create query: GUID min len must be 5
+				libRenameSoftDeletedConflicts(pMeadow, pQuery.query.records[0], function (pPreflightError)
 				{
-					var tmpGUIDRecord = pQuery.query.records[0][pMeadow.defaultGUIdentifier];
-
-					var tmpQueryRead = pQuery.clone().addFilter(pMeadow.defaultGUIdentifier, tmpGUIDRecord)
-												 .setDisableDeleteTracking(true); //this check is to guarantee uniqueness across the entire table, so always do this
-
-					if (pMeadow.rawQueries.checkQuery('Read'))
+					if (pPreflightError)
 					{
-						tmpQueryRead.parameters.queryOverride = pMeadow.rawQueries.getQuery('Read');
+						pMeadow.fable.log.warn('Error during the unique-constraint pre-flight',
+							{ Error: pPreflightError, Message: pPreflightError && pPreflightError.message });
+						return fStageComplete(pPreflightError, pQuery, false);
 					}
-					pMeadow.provider.Read(tmpQueryRead, function()
-						{
-							var tmpError = tmpQueryRead.error;
-
-							if (!tmpError &&
-								tmpQueryRead.result.value.length > 0)
-							{
-								tmpError = 'Record with GUID ' + tmpGUIDRecord + ' already exists!';
-							}
-
-							if (tmpError)
-							{
-								return fStageComplete(tmpError, tmpQueryRead, tmpQueryRead, null);
-							}
-							else
-							{
-								return fStageComplete();
-							}
-						});
-				}
-				else
-				{
 					return fStageComplete();
-				}
+				});
 			},
 			// Step 1: Create the record in the data source
 			function (fStageComplete)

package/source/providers/Meadow-Provider-RetoldDataBeacon.js

@@ -43,10 +43,22 @@ var MeadowProvider = function ()
 				return fCallback();
 			}
 
-			var tmpPath = pQuery.query.body;
-			if (tmpPath && tmpPath.charAt(0) !== '/')
+			// Build the path with the connection hash prefix so the remote
+			// databeacon's hash-namespaced route receives the request.
+			var tmpHash = tmpConn._TargetConnectionHash || '';
+			var tmpRelative = pQuery.query.body || '';
+			var tmpPath;
+			if (tmpHash)
 			{
-				tmpPath = '/1.0/' + tmpPath;
+				tmpPath = '/1.0/' + tmpHash + '/' + tmpRelative;
+			}
+			else if (tmpRelative.charAt(0) !== '/')
+			{
+				tmpPath = '/1.0/' + tmpRelative;
+			}
+			else
+			{
+				tmpPath = tmpRelative;
 			}
 
 			var tmpBody = null;

package/test/Meadow-Provider-DGraph_tests.js

@@ -94,6 +94,13 @@ var _AnimalDefault = (
 		Type: 'Unclassified'
 	});
 
+// Per-request timeout cap. A stuck Alpha (e.g. /alter accepted by the
+// kernel but never answered while DGraph finishes initializing) used to
+// silently consume the whole 30s mocha hook budget here. With this
+// cap, a hang surfaces as a clear callback error in ~10s and the hook
+// fails fast with a useful message instead of hitting the mocha timeout.
+var DGRAPH_HTTP_TIMEOUT_MS = 10000;
+
 // Helper to drop all DGraph data via the HTTP API
 var dropAllDGraphData = function (fCallback)
 {
@@ -103,7 +110,8 @@ var dropAllDGraphData = function (fCallback)
 		port: 38080,
 		path: '/alter',
 		method: 'POST',
-		headers: { 'Content-Type': 'application/json' }
+		headers: { 'Content-Type': 'application/json' },
+		timeout: DGRAPH_HTTP_TIMEOUT_MS
 	};
 	var tmpReq = http.request(tmpOptions, function (pRes)
 	{
@@ -111,6 +119,7 @@ var dropAllDGraphData = function (fCallback)
 		pRes.on('end', function () { fCallback(); });
 	});
 	tmpReq.on('error', function (pError) { fCallback(pError); });
+	tmpReq.on('timeout', function () { tmpReq.destroy(new Error(`DGraph /alter (drop_all) timed out after ${DGRAPH_HTTP_TIMEOUT_MS}ms`)); });
 	tmpReq.write(JSON.stringify({ drop_all: true }));
 	tmpReq.end();
 };
@@ -159,7 +168,8 @@ var applyDGraphSchema = function (fCallback)
 		port: 38080,
 		path: '/alter',
 		method: 'POST',
-		headers: { 'Content-Type': 'application/octet-stream' }
+		headers: { 'Content-Type': 'application/octet-stream' },
+		timeout: DGRAPH_HTTP_TIMEOUT_MS
 	};
 	var tmpReq = http.request(tmpOptions, function (pRes)
 	{
@@ -167,6 +177,7 @@ var applyDGraphSchema = function (fCallback)
 		pRes.on('end', function () { fCallback(); });
 	});
 	tmpReq.on('error', function (pError) { fCallback(pError); });
+	tmpReq.on('timeout', function () { tmpReq.destroy(new Error(`DGraph /alter (schema apply) timed out after ${DGRAPH_HTTP_TIMEOUT_MS}ms`)); });
 	tmpReq.write(tmpSchema);
 	tmpReq.end();
 };

package/test/Meadow-Provider-MSSQL_tests.js

@@ -131,6 +131,13 @@ suite
 				(
 					function (fDone)
 					{
+						// Container-backed setup: connect + create-db + create-
+						// table + 5 inserts is ~9 sequential round trips. The
+						// global mocha timeout (5s) is too tight when the
+						// container is freshly started (cold connection adds
+						// 2-3s on its own under emulation). Match the DGraph
+						// hook's 30s budget.
+						this.timeout(30000);
 						// Only do this for the first test.
 						if (!_SpooledUp)
 						{

package/test/Meadow-Provider-SQLiteBrowser-Headless_tests.js

@@ -26,6 +26,7 @@ var Expect = Chai.expect;
 var libHTTP = require('http');
 var libFS = require('fs');
 var libPath = require('path');
+var libChildProcess = require('child_process');
 
 var _MeadowRoot = libPath.resolve(__dirname, '..');
 var _MeadowDistDir = libPath.join(_MeadowRoot, 'dist');
@@ -508,12 +509,37 @@ suite
 					));
 				}
 
-				// Verify sql.js dist exists
+				// Auto-bootstrap the sister package's sql.js dep if missing.
+				// This is monorepo dev tooling — `test-all-providers` is run by
+				// the maintainer from a fresh checkout, where transitive deps
+				// of sibling packages aren't installed by meadow's own
+				// `npm install`. Self-bootstrapping here avoids the manual
+				// `cd ../meadow-connection-sqlite-browser && npm install`
+				// step. If you want the same treatment for the sister's dist
+				// (currently still a manual `npm run build`), extend this hook
+				// to invoke quack build the same way.
 				if (!libFS.existsSync(libPath.join(_SqlJsDistDir, 'sql-wasm.js')))
 				{
-					return fDone(new Error(
-						'sql.js dist files not found. Run "npm install" in meadow-connection-sqlite-browser first.'
-					));
+					console.log(`  sql.js not found in ${_ConnectionPackageRoot}; running "npm install" there...`);
+					try
+					{
+						libChildProcess.execSync('npm install', {
+							cwd: _ConnectionPackageRoot,
+							stdio: 'inherit'
+						});
+					}
+					catch (pInstallError)
+					{
+						return fDone(new Error(
+							`Failed to npm-install sister package at ${_ConnectionPackageRoot}: ${pInstallError.message}`
+						));
+					}
+					if (!libFS.existsSync(libPath.join(_SqlJsDistDir, 'sql-wasm.js')))
+					{
+						return fDone(new Error(
+							`sql.js dist files still missing after install in ${_ConnectionPackageRoot}.`
+						));
+					}
 				}
 
 				// Start the test server

package/test/Meadow-Provider-SQLite_tests.js

@@ -965,5 +965,120 @@ suite
 				);
 			}
 		);
+		suite
+		(
+			'Soft-Deleted Collision Rename (DAL layer)',
+			function ()
+			{
+				// Schema for a separate Gadget table that exercises the rename
+				// at the meadow DAL layer (no meadow-endpoints in the loop).
+				// Uses a plain UNIQUE INDEX on Code — no `WHERE Deleted=0`
+				// partial-index syntax — so the rename is what keeps the slot
+				// reusable after a soft-delete.
+				var _GadgetSchema =
+				[
+					{ Column: 'IDGadget',       Type: 'AutoIdentity' },
+					{ Column: 'GUIDGadget',     Type: 'AutoGUID' },
+					{ Column: 'CreateDate',     Type: 'CreateDate' },
+					{ Column: 'CreatingIDUser', Type: 'CreateIDUser' },
+					{ Column: 'UpdateDate',     Type: 'UpdateDate' },
+					{ Column: 'UpdatingIDUser', Type: 'UpdateIDUser' },
+					{ Column: 'Deleted',        Type: 'Deleted' },
+					{ Column: 'DeleteDate',     Type: 'DeleteDate' },
+					{ Column: 'DeletingIDUser', Type: 'DeleteIDUser' },
+					{ Column: 'Code',           Type: 'String', Unique: true },
+					{ Column: 'Name',           Type: 'String' }
+				];
+				var _GadgetDefault =
+				{
+					IDGadget: 0,
+					GUIDGadget: '',
+					CreateDate: false,
+					CreatingIDUser: 0,
+					UpdateDate: false,
+					UpdatingIDUser: 0,
+					Deleted: 0,
+					DeleteDate: false,
+					DeletingIDUser: 0,
+					Code: '',
+					Name: ''
+				};
+
+				var newGadgetMeadow = function ()
+				{
+					return require('../source/Meadow.js').new(libFable, 'Gadget')
+						.setProvider('SQLite')
+						.setSchema(_GadgetSchema)
+						.setJsonSchema({ title: 'Gadget', type: 'object', properties: {}, required: [] })
+						.setDefaultIdentifier('IDGadget')
+						.setDefault(_GadgetDefault);
+				};
+
+				suiteSetup(function (fDone)
+				{
+					var tmpDB = libFable.MeadowSQLiteProvider.db;
+					tmpDB.exec(
+						'CREATE TABLE IF NOT EXISTS Gadget (' +
+						'  IDGadget INTEGER PRIMARY KEY AUTOINCREMENT,' +
+						'  GUIDGadget TEXT NOT NULL DEFAULT \'\',' +
+						'  CreateDate TEXT,' +
+						'  CreatingIDUser INTEGER NOT NULL DEFAULT 0,' +
+						'  UpdateDate TEXT,' +
+						'  UpdatingIDUser INTEGER NOT NULL DEFAULT 0,' +
+						'  Deleted INTEGER NOT NULL DEFAULT 0,' +
+						'  DeleteDate TEXT,' +
+						'  DeletingIDUser INTEGER NOT NULL DEFAULT 0,' +
+						'  Code TEXT NOT NULL DEFAULT \'\',' +
+						'  Name TEXT NOT NULL DEFAULT \'\'' +
+						');' +
+						'CREATE UNIQUE INDEX IF NOT EXISTS gadget_code_unique ON Gadget(Code);'
+					);
+					return fDone();
+				});
+
+				test
+				(
+					'Create → soft-delete → Create-with-same-Code: rename frees the slot at the DAL layer',
+					function (fDone)
+					{
+						var libRename = require('../source/behaviors/Meadow-CollisionRename.js');
+						var tmpMeadow = newGadgetMeadow().setIDUser(1);
+
+						var tmpFirstQuery = tmpMeadow.query.addRecord({ Code: 'orig', Name: 'first' });
+						tmpMeadow.doCreate(tmpFirstQuery, function (pCreateError, pQuery, pQueryRead, pFirstRecord)
+						{
+							Expect(pCreateError, pCreateError && pCreateError.message ? pCreateError.message : pCreateError).to.not.exist;
+							var tmpFirstID = pFirstRecord.IDGadget;
+							Expect(pFirstRecord.Code).to.equal('orig');
+							Expect(tmpFirstID).to.be.above(0);
+
+							var tmpDeleteQuery = tmpMeadow.query.addFilter('IDGadget', tmpFirstID);
+							tmpMeadow.doDelete(tmpDeleteQuery, function (pDeleteError, pDelQuery, pDelCount)
+							{
+								Expect(pDelCount).to.equal(1);
+
+								var tmpSecondQuery = newGadgetMeadow().setIDUser(1).query.addRecord({ Code: 'orig', Name: 'second' });
+								newGadgetMeadow().setIDUser(1).doCreate(tmpSecondQuery, function (pSecondError, pQuery2, pRead2, pSecond)
+								{
+									Expect(pSecondError, pSecondError && pSecondError.message ? pSecondError.message : pSecondError).to.not.exist;
+									Expect(pSecond.Code).to.equal('orig');
+									Expect(pSecond.IDGadget).to.not.equal(tmpFirstID);
+
+									// Direct DB inspection to verify the soft-deleted
+									// row's Code was renamed to the deterministic
+									// __mdsd_<16hex> shape, and that the suffix matches
+									// sha1("{IDRecord}:{Column}:{OriginalValue}").
+									var tmpRow = libFable.MeadowSQLiteProvider.db.prepare('SELECT IDGadget, Code, Deleted FROM Gadget WHERE IDGadget = ?').get(tmpFirstID);
+									Expect(tmpRow.Deleted).to.equal(1);
+									var tmpExpected = libRename.buildRenamedValue(tmpFirstID, 'Code', 'orig');
+									Expect(tmpRow.Code).to.equal(tmpExpected);
+									fDone();
+								});
+							});
+						});
+					}
+				);
+			}
+		);
 	}
 );