@warlock.js/cascade 4.9.0 → 4.9.2

package/CHANGELOG.md

@@ -4,6 +4,19 @@ All notable changes to `@warlock.js/cascade` are documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). `@warlock.js/*` packages are released in lockstep — every package shares the same version number, so a version below may list only the changes that affected this package.
 
+## 4.9.2
+
+### Fixed
+
+- `migrate:rollback` and `migrate:rollback --all` ran `down()` migrations in **apply order** instead of reverse. `getMigrationsToRollback` reversed the executed list and then re-sorted it ascending, which put it straight back into forward order and made the reverse dead code — so a rollback would drop a table before dropping the column added to it, failing with `relation "…" does not exist`. Any batch containing more than one migration was affected; single-migration batches hid it because one item has no order to get wrong
+- migration ordering now lives in `migration-order.ts` with an explicit `sortMigrationsForRollback`. The descending sort is required, not cosmetic: the executed list is read back ordered by `batch, name`, so it is alphabetical rather than chronological and simply *not* re-sorting after the reverse would have produced reverse-alphabetical order — a different wrong answer
+
+## 4.9.1
+
+### Fixed
+
+- `save({ merge })` silently dropped a `Date` written over a column that already held a `Date` — the dirty tracker's merge treated anything `typeof "object"` as mergeable and recursed into the `Date`, which has no own enumerable properties, so nothing was copied and the old value survived. The column never went dirty and `save()` returned `{ success: true, modifiedCount: 0 }` without issuing an `UPDATE`. Only plain objects deep-merge now; `Date`, `Map`, `Set`, `RegExp` and every other class instance replace, matching what `model.data` already did. Writing into an empty column always worked, so only overwrites were affected
+
 ## 4.9.0 - 2026-08-06
 
 ### Fixed

package/cjs/index.cjs

@@ -691,8 +691,17 @@ var DatabaseDirtyTracker = class {
 	/**
 	* Recursively merges source object into target object, performing a deep merge.
 	*
-	* For nested objects, the merge is recursive. For arrays and primitives, the source
-	* value replaces the target value. All values are cloned to prevent reference sharing.
+	* Only **plain** objects are merged recursively. Everything else — arrays,
+	* primitives, and class instances such as `Date` / `Map` / `Set` / `RegExp` —
+	* replaces the target value. All values are cloned to prevent reference sharing.
+	*
+	* The plain-object guard is load-bearing, not tidiness. A bare
+	* `typeof value === "object"` also matches a `Date`, and `Object.entries(date)`
+	* is `[]` — so merging a `Date` over a column that already held a `Date`
+	* recursed into it, copied nothing, and left the old value in the snapshot.
+	* The column then never went dirty and `save()` returned
+	* `{ success: true, modifiedCount: 0 }` without issuing an `UPDATE`. This is
+	* the same lesson `canBeFlatten` above already encodes.
 	*
 	* @param target - The object to merge into
 	* @param source - The object to merge from
@@ -700,7 +709,7 @@ var DatabaseDirtyTracker = class {
 	*/
 	mergeIntoRaw(target, source) {
 		for (const [key, value] of Object.entries(source)) {
-			if (value && typeof value === "object" && !Array.isArray(value) && target[key] && typeof target[key] === "object" && !Array.isArray(target[key])) {
+			if ((0, _mongez_supportive_is.isPlainObject)(value) && (0, _mongez_supportive_is.isPlainObject)(target[key])) {
 				this.mergeIntoRaw(target[key], value);
 				continue;
 			}
@@ -21630,6 +21639,37 @@ function compareCreatedAt(a, b) {
 	if (dateB) return 1;
 }
 
+//#endregion
+//#region ../cascade/src/migration/migration-order.ts
+/**
+* Comparator for applying migrations — oldest first.
+*
+* Priority:
+*   1. `createdAt` timestamp (older = earlier)
+*   2. Alphabetical by migration name (last resort)
+*/
+function sortMigrations(a, b) {
+	const byCreatedAt = compareCreatedAt(a.createdAt, b.createdAt);
+	if (byCreatedAt !== void 0) return byCreatedAt;
+	return a.migrationName.localeCompare(b.migrationName);
+}
+/**
+* Comparator for rolling migrations back — newest first, the exact inverse of
+* {@link sortMigrations}.
+*
+* A rollback has to undo migrations in the reverse of the order they were
+* applied, or a `down()` will hit schema its predecessor already removed —
+* dropping a table before dropping the column that was added to it.
+*
+* This must be an explicit descending sort rather than a `.reverse()` of the
+* executed list: that list is read back ordered by `batch, name`, so it is
+* alphabetical rather than chronological, and reversing it merely produces
+* reverse-alphabetical order.
+*/
+function sortMigrationsForRollback(a, b) {
+	return sortMigrations(b, a);
+}
+
 //#endregion
 //#region ../cascade/src/migration/sql-grammar.ts
 /**
@@ -21754,18 +21794,6 @@ var SQLGrammar = class {
 //#endregion
 //#region ../cascade/src/migration/migration-runner.ts
 /**
-* Comparator for sorting migration classes.
-*
-* Priority:
-*   1. `createdAt` timestamp (older = earlier)
-*   2. Alphabetical by migration name (last resort)
-*/
-function sortMigrations(a, b) {
-	const byCreatedAt = compareCreatedAt(a.createdAt, b.createdAt);
-	if (byCreatedAt !== void 0) return byCreatedAt;
-	return a.migrationName.localeCompare(b.migrationName);
-}
-/**
 * Migration runner that executes migrations.
 *
 * This is a pure executor - it doesn't discover migrations.
@@ -22339,13 +22367,24 @@ var MigrationRunner = class {
 		return this.migrations.filter((m) => !executedNames.has(m.migrationName)).sort(sortMigrations);
 	}
 	/**
-	* Get migrations to rollback.
+	* Get migrations to rollback, newest-first.
+	*
+	* A rollback must undo migrations in the exact inverse of the order `up`
+	* applied them, or a `down()` will hit schema its predecessor already
+	* removed — dropping a table before dropping the column added to it, say.
+	*
+	* The sort has to be explicitly **descending**. Reversing the executed list
+	* is not enough: `getExecutedMigrations` orders by `batch, name`, so the
+	* input is alphabetical rather than chronological, and reversing it only
+	* yields reverse-alphabetical order. (Sorting *ascending* here — which is
+	* what this method used to do after a `.reverse()` — silently restored the
+	* forward `up` order and made the reverse dead code.)
 	*/
 	async getMigrationsToRollback(batches) {
 		const executed = await this.getExecutedMigrations();
 		if (executed.length === 0) return [];
 		const batchNumbers = [...new Set(executed.map((r) => r.batch))].sort((a, b) => b - a).slice(0, batches);
-		return executed.filter((r) => batchNumbers.includes(r.batch)).reverse().map((r) => this.migrations.find((m) => m.migrationName === r.name)).filter((m) => !!m).sort(sortMigrations);
+		return executed.filter((r) => batchNumbers.includes(r.batch)).map((r) => this.migrations.find((m) => m.migrationName === r.name)).filter((m) => !!m).sort(sortMigrationsForRollback);
 	}
 	/**
 	* Get executed migration records.