@warlock.js/cascade 4.9.1 → 4.10.0

package/CHANGELOG.md

@@ -4,6 +4,13 @@ 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

package/cjs/index.cjs

@@ -21639,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
 /**
@@ -21763,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.
@@ -22348,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.