@warlock.js/cascade 5.19.1 → 5.21.0

package/esm/migration/migration-runner.mjs

@@ -2,12 +2,27 @@ import { dataSourceRegistry } from "../data-source/data-source-registry.mjs";
 import { parseCreatedAt } from "./parse-created-at.mjs";
 import { sortMigrations, sortMigrationsForRollback } from "./migration-order.mjs";
 import { SQLGrammar } from "./sql-grammar.mjs";
-import { colors } from "@mongez/copper";
 import { log } from "@warlock.js/logger";
+import { colors } from "@mongez/copper";
 import fs from "fs";
 import path from "path";
 
 //#region ../cascade/src/migration/migration-runner.ts
+/** Name of the lock document Mongo migrations claim inside the migrations collection. */
+const MIGRATION_LOCK_NAME = "__warlock_migration_lock__";
+const MIGRATION_LOCK_KEY = "warlock:migrations";
+const MIGRATION_LOCK_TTL_MS = 600 * 1e3;
+const MIGRATION_LOCK_WAIT_MS = 60 * 1e3;
+const MIGRATION_LOCK_RETRY_MS = 1e3;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+* Derive a migration name from a file path: drop everything after the first dot
+* and strip a trailing `-migration` / `_migration` suffix. Shared by every CLI
+* so the same file is recorded under the same name.
+*/
+function inferMigrationName(file) {
+	return (path.basename(file).split(".")[0] ?? "").replace(/-migration$/, "").replace(/_migration$/, "");
+}
 /**
 * Migration runner that executes migrations.
 *
@@ -47,8 +62,8 @@ var MigrationRunner = class {
 	migrations = [];
 	/** Data source to use */
 	dataSource;
-	/** Cached migration driver */
-	cachedMigrationDriver;
+	/** Cached migration drivers, one per data source */
+	migrationDrivers = /* @__PURE__ */ new Map();
 	/** Table name for tracking migrations */
 	migrationsTable;
 	/** Whether to log operations */
@@ -68,7 +83,7 @@ var MigrationRunner = class {
 	*/
 	setDataSource(dataSource) {
 		this.dataSource = dataSource;
-		this.cachedMigrationDriver = void 0;
+		this.migrationDrivers.clear();
 		return this;
 	}
 	/**
@@ -81,9 +96,140 @@ var MigrationRunner = class {
 	/**
 	* Get the migration driver.
 	*/
-	getMigrationDriver() {
-		if (!this.cachedMigrationDriver) this.cachedMigrationDriver = this.getDataSource().driver.migrationDriver();
-		return this.cachedMigrationDriver;
+	getMigrationDriver(dataSource = this.getDataSource()) {
+		let driver = this.migrationDrivers.get(dataSource);
+		if (!driver) {
+			driver = dataSource.driver.migrationDriver();
+			this.migrationDrivers.set(dataSource, driver);
+		}
+		return driver;
+	}
+	/**
+	* Resolve a migration's declared data source (name or instance).
+	* Falls back to the runner's own data source when it declares none.
+	*/
+	resolveDataSource(declared) {
+		if (!declared) return this.getDataSource();
+		if (typeof declared === "string") return dataSourceRegistry.get(declared);
+		return declared;
+	}
+	/** Data source a registered migration class runs against. */
+	sourceOf(MigrationClass) {
+		return this.resolveDataSource(new MigrationClass().dataSource);
+	}
+	/** Distinct data sources across the registered migrations (runner's own included). */
+	getSources() {
+		const sources = new Set([this.getDataSource()]);
+		for (const MigrationClass of this.migrations) sources.add(this.sourceOf(MigrationClass));
+		return [...sources];
+	}
+	/**
+	* Resolve whether a migration runs in a transaction:
+	* 1. migration-level flag (instance, else the static from `Migration.create/alter`)
+	* 2. `CONCURRENTLY` statements cannot run in a transaction block
+	* 3. data-source config
+	* 4. driver default
+	*/
+	resolveTransactional(MigrationClass, migration, dataSource, statements = []) {
+		const explicit = migration.transactional ?? MigrationClass.transactional;
+		if (explicit !== void 0) return explicit;
+		if (statements.some((sql) => /\bCONCURRENTLY\b/i.test(sql))) return false;
+		return dataSource.migrations?.transactional ?? this.getMigrationDriver(dataSource).getDefaultTransactional();
+	}
+	/** Locks held by the run in progress (Mongo TTL heartbeat). */
+	activeLocks = [];
+	/** Extend every held lock's TTL; called between migrations. */
+	async refreshLocks() {
+		for (const lock of this.activeLocks) await lock.refresh();
+	}
+	/**
+	* Run `callback` while holding a migration lock on every given data source, so
+	* concurrent `migrate` invocations (replicas, init containers) serialize.
+	*/
+	async withLock(sources, callback) {
+		const held = [];
+		try {
+			for (const dataSource of sources) {
+				const lock = await this.acquireLock(dataSource);
+				if (lock) held.push(lock);
+			}
+			this.activeLocks = held;
+			return await callback();
+		} finally {
+			this.activeLocks = [];
+			for (const lock of held.reverse()) try {
+				await lock.release();
+			} catch (error) {
+				log.warn("database", "migration", `Failed to release migration lock: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+	}
+	/** Acquire the lock for one data source; `undefined` when its driver has no lock support. */
+	async acquireLock(dataSource) {
+		const driver = dataSource.driver;
+		if (driver.name === "postgres" && driver.getClient) {
+			const client = await driver.getClient().connect?.();
+			if (!client) return void 0;
+			try {
+				await client.query("SELECT pg_advisory_lock(hashtext($1))", [MIGRATION_LOCK_KEY]);
+			} catch (error) {
+				client.release();
+				throw error;
+			}
+			return {
+				refresh: async () => {},
+				release: async () => {
+					try {
+						await client.query("SELECT pg_advisory_unlock(hashtext($1))", [MIGRATION_LOCK_KEY]);
+					} finally {
+						client.release();
+					}
+				}
+			};
+		}
+		if (driver.getDatabase) {
+			await this.getMigrationDriver(dataSource).ensureMigrationsTable(this.migrationsTable);
+			const collection = driver.getDatabase().collection(this.migrationsTable);
+			const owner = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+			const deadline = Date.now() + MIGRATION_LOCK_WAIT_MS;
+			const claim = async () => {
+				const now = /* @__PURE__ */ new Date();
+				try {
+					await collection.findOneAndUpdate({
+						name: MIGRATION_LOCK_NAME,
+						$or: [{ expiresAt: { $lt: now } }, { owner }]
+					}, {
+						$set: {
+							owner,
+							expiresAt: new Date(now.getTime() + MIGRATION_LOCK_TTL_MS)
+						},
+						$setOnInsert: { batch: 0 }
+					}, { upsert: true });
+					return true;
+				} catch (error) {
+					if (error.code === 11e3) return false;
+					throw error;
+				}
+			};
+			while (!await claim()) {
+				if (Date.now() >= deadline) {
+					const holder = await collection.findOne({ name: MIGRATION_LOCK_NAME });
+					throw new Error(`Could not acquire the migration lock within ${MIGRATION_LOCK_WAIT_MS / 1e3}s; held by "${holder?.owner ?? "unknown"}" until ${holder?.expiresAt ?? "unknown"}.`);
+				}
+				await sleep(MIGRATION_LOCK_RETRY_MS);
+			}
+			return {
+				refresh: async () => {
+					await claim();
+				},
+				release: async () => {
+					await collection.deleteOne({
+						name: MIGRATION_LOCK_NAME,
+						owner
+					});
+				}
+			};
+		}
 	}
 	/**
 	* Register a migration.
@@ -103,7 +249,12 @@ var MigrationRunner = class {
 	register(MigrationClass) {
 		const name = MigrationClass.migrationName;
 		if (!name) throw new Error("Migration class must have a static 'migrationName' property set. Set it in CLI after importing: MigrationClass.migrationName = \"filename\";");
-		if (!this.migrations.some((m) => m.migrationName === name)) this.migrations.push(MigrationClass);
+		const existing = this.migrations.find((m) => m.migrationName === name);
+		if (existing) {
+			if (existing !== MigrationClass) throw new Error(`Duplicate migration name "${name}": two different migration classes resolve to the same name. Rename one of the files (or set a unique static 'migrationName').`);
+			return this;
+		}
+		this.migrations.push(MigrationClass);
 		return this;
 	}
 	/**
@@ -182,116 +333,144 @@ var MigrationRunner = class {
 	* ```
 	*/
 	async runAll(options = {}) {
+		if (options.dryRun) return this.runAllUnlocked(options);
+		return this.withLock(this.getSources(), () => this.runAllUnlocked(options));
+	}
+	async runAllUnlocked(options) {
 		const { dryRun = false, record = true } = options;
 		const results = [];
-		const pending = await this.getPendingMigrations();
+		const pending = await this.getPendingMigrations({ readOnly: dryRun });
 		if (pending.length === 0) {
 			log.warn("database", "migration", "Nothing to migrate.");
 			return results;
 		}
-		if (this.getDataSource().driver.supportsSqlSerialization === false) {
-			const batch = await this.getNextBatchNumber();
-			for (const MigrationClass of pending) {
-				const result = await this.runMigration(MigrationClass, "up", {
-					dryRun,
-					record,
-					batch
-				});
-				results.push(result);
-				if (!result.success) break;
-			}
-			return results;
-		}
-		log.info("database", "migration", `Found ${pending.length} pending migration(s). Generating SQL pool...`);
-		const nextBatch = await this.getNextBatchNumber();
-		const taggedStatements = [];
+		const sources = /* @__PURE__ */ new Set();
 		const migrationsData = [];
+		log.info("database", "migration", `Found ${pending.length} pending migration(s).`);
 		const extensionChecks = [];
 		for (const MigrationClass of pending) {
 			const migration = this.createMigrationInstance(MigrationClass);
 			const name = MigrationClass.migrationName;
+			const dataSource = this.resolveDataSource(migration.dataSource);
+			sources.add(dataSource);
+			if (dataSource.driver.supportsSqlSerialization === false) {
+				migrationsData.push({
+					MigrationClass,
+					migration,
+					name,
+					dataSource,
+					statements: [],
+					steps: [],
+					transactional: false,
+					direct: true
+				});
+				continue;
+			}
+			migration.setDriver(this.getMigrationDriver(dataSource));
+			migration.setMigrationDefaults(dataSource.migrationDefaults);
+			migration.setDryRun?.(dryRun);
 			await migration.up();
-			const upStatements = migration.toSQL();
+			const steps = migration.toSteps?.() ?? migration.toSQL();
+			const statements = steps.map((step) => typeof step === "string" ? step : "-- data step (withConnection) skipped");
+			migration.setDryRun?.(false);
 			migrationsData.push({
 				MigrationClass,
 				migration,
-				name
+				name,
+				dataSource,
+				statements,
+				steps,
+				transactional: !!dataSource.driver.transaction && this.resolveTransactional(MigrationClass, migration, dataSource, statements),
+				direct: false
 			});
-			for (const sql of upStatements) {
-				const statementType = SQLGrammar.classify(sql);
-				if (statementType === "CREATE_EXTENSION") {
-					const ext = SQLGrammar.extractExtensionName(sql);
-					if (ext) extensionChecks.push(this.informIfExtensionMissing(ext));
-				}
-				taggedStatements.push({
-					sql,
-					phase: SQLGrammar.phase(sql),
-					statementType,
-					createdAt: MigrationClass.createdAt,
-					migrationName: name
-				});
+			for (const sql of statements) if (SQLGrammar.classify(sql) === "CREATE_EXTENSION") {
+				const ext = SQLGrammar.extractExtensionName(sql);
+				if (ext) extensionChecks.push(this.informIfExtensionMissing(ext, dataSource));
 			}
 		}
 		await Promise.all(extensionChecks);
-		const sortedStatements = SQLGrammar.sort(taggedStatements);
 		if (dryRun) {
 			log.info("database", "migration", "Dry run enabled. Would execute the following statements:");
-			for (const statement of sortedStatements) {
-				console.log(`-- [${statement.statementType}] Phase ${statement.phase} [${statement.migrationName}]`);
-				console.log(statement.sql + ";\n");
+			for (const data of migrationsData) for (const sql of data.statements) {
+				console.log(`-- [${SQLGrammar.classify(sql)}] Phase ${SQLGrammar.phase(sql)} [${data.name}]`);
+				console.log(sql + ";\n");
 			}
 			return [];
 		}
-		const driver = this.getDataSource().driver;
-		let transactionFailed = false;
-		let errorMessage = "";
-		/** The migration name that owns the SQL statement that threw. */
-		let failingMigrationName;
-		const startTime = Date.now();
-		/**
-		* Execute all sorted statements, capturing which migration owns the
-		* statement that throws — so we report a precise culprit instead of
-		* blaming every migration in the batch.
-		*/
-		const executeStatements = async () => {
-			for (const statement of sortedStatements) try {
-				await driver.query(statement.sql);
-			} catch (err) {
-				failingMigrationName = statement.migrationName;
-				throw err;
-			}
-			if (record) for (const data of migrationsData) await this.recordMigration(data.name, nextBatch, data.MigrationClass.createdAt ? parseCreatedAt(data.MigrationClass.createdAt) : /* @__PURE__ */ new Date());
-		};
-		try {
-			if (driver.transaction) await driver.transaction(executeStatements);
-			else await executeStatements();
-		} catch (err) {
-			transactionFailed = true;
-			errorMessage = err instanceof Error ? err.message : String(err);
-		}
-		const durationMs = Date.now() - startTime;
+		const batches = /* @__PURE__ */ new Map();
+		for (const dataSource of sources) batches.set(dataSource, await this.getNextBatchNumber(dataSource));
+		const runs = [];
 		for (const data of migrationsData) {
-			const isCulprit = transactionFailed && data.name === failingMigrationName;
-			const wasSkipped = transactionFailed && !isCulprit;
-			results.push({
-				name: data.name,
-				table: data.migration.table,
-				direction: "up",
-				success: !transactionFailed,
-				error: isCulprit ? errorMessage : void 0,
-				durationMs: Math.round(durationMs / migrationsData.length),
-				executedAt: /* @__PURE__ */ new Date()
-			});
-			if (isCulprit) log.error("database", "migration", `${colors.magenta(data.name)}: ✗ Failed: ${errorMessage}`);
-			else if (wasSkipped) log.warn("database", "migration", `${colors.magenta(data.name)}: rolled back (batch transaction failed)`);
-			else log.success("database", "migration", `Migrated: ${colors.magenta(data.name)} successfully`);
+			const last = runs[runs.length - 1];
+			const lastFirst = last?.[0];
+			if (data.transactional && last && lastFirst?.transactional && lastFirst.dataSource === data.dataSource) last.push(data);
+			else runs.push([data]);
 		}
-		if (transactionFailed) {
-			log.error("database", "migration", `Batch execution failed. Rollback performed if transactional.`);
-			throw new Error("Migration batch failed: " + errorMessage);
+		for (const run of runs) {
+			const first = run[0];
+			if (!first) continue;
+			await this.refreshLocks();
+			const dataSource = first.dataSource;
+			const nextBatch = batches.get(dataSource);
+			const startTime = Date.now();
+			if (first.direct) {
+				const result = await this.runMigration(first.MigrationClass, "up", {
+					dryRun,
+					record,
+					batch: nextBatch
+				});
+				results.push(result);
+				if (!result.success) break;
+				continue;
+			}
+			const driver = dataSource.driver;
+			let failed = false;
+			let errorMessage = "";
+			/** The migration that owns the SQL statement that threw. */
+			let failingMigrationName;
+			const executeRun = async () => {
+				for (const data of run) {
+					for (const step of data.steps) try {
+						if (typeof step === "string") await driver.query(step);
+						else await step.data();
+					} catch (err) {
+						failingMigrationName = data.name;
+						throw err;
+					}
+					if (record) await this.recordMigration(data.name, nextBatch, data.MigrationClass.createdAt ? parseCreatedAt(data.MigrationClass.createdAt) : /* @__PURE__ */ new Date(), dataSource);
+				}
+			};
+			try {
+				if (first.transactional && driver.transaction) await driver.transaction(executeRun);
+				else await executeRun();
+			} catch (err) {
+				failed = true;
+				errorMessage = err instanceof Error ? err.message : String(err);
+			}
+			const durationMs = Date.now() - startTime;
+			for (const data of run) {
+				const isCulprit = failed && data.name === failingMigrationName;
+				const wasSkipped = failed && !isCulprit;
+				results.push({
+					name: data.name,
+					table: data.migration.table,
+					direction: "up",
+					success: !failed,
+					error: isCulprit ? errorMessage : void 0,
+					durationMs: Math.round(durationMs / run.length),
+					executedAt: /* @__PURE__ */ new Date()
+				});
+				if (isCulprit) log.error("database", "migration", `${colors.magenta(data.name)}: ✗ Failed: ${errorMessage}`);
+				else if (wasSkipped) log.warn("database", "migration", `${colors.magenta(data.name)}: rolled back (batch transaction failed)`);
+				else log.success("database", "migration", `Migrated: ${colors.magenta(data.name)} successfully`);
+			}
+			if (failed) {
+				log.error("database", "migration", `Batch execution failed. Rollback performed if transactional.`);
+				throw new Error("Migration batch failed: " + errorMessage);
+			}
 		}
 		const successCount = results.filter((r) => r.success).length;
-		log.success("database", "migration", `Migration bulk phase execution complete: ${successCount}/${pending.length} migrations processed successfully.`);
+		log.success("database", "migration", `Migration execution complete: ${successCount}/${pending.length} migrations processed successfully.`);
 		return results;
 	}
 	/**
@@ -300,17 +479,18 @@ var MigrationRunner = class {
 	*/
 	async exportSQL(options = {}) {
 		if (this.getDataSource().driver.supportsSqlSerialization === false) throw new Error("SQL export is not supported on this data source — its driver has no SQL dialect. Migrations on this driver execute native commands through the migration driver instead.");
-		const migrationsToExport = options.pendingOnly ? await this.getPendingMigrations() : this.migrations;
+		const migrationsToExport = options.pendingOnly ? await this.getPendingMigrations({ readOnly: true }) : this.migrations;
 		if (migrationsToExport.length === 0) {
 			log.warn("database", "migration", "No migrations to export.");
 			return;
 		}
 		log.info("database", "migration", `Exporting ${migrationsToExport.length} ${options.pendingOnly ? "pending " : ""}migration(s) to SQL files...`);
 		const upStatements = [];
-		const downStatements = [];
-		for (const MigrationClass of migrationsToExport) {
+		const downGroups = [];
+		for (const [index, MigrationClass] of migrationsToExport.entries()) {
 			const migration = this.createMigrationInstance(MigrationClass);
 			const name = MigrationClass.migrationName;
+			migration.setDryRun?.(true);
 			await migration.up();
 			for (const sql of migration.toSQL()) upStatements.push({
 				sql,
@@ -320,16 +500,25 @@ var MigrationRunner = class {
 				migrationName: name
 			});
 			await migration.down();
-			for (const sql of migration.toSQL()) downStatements.push({
+			const statements = [];
+			for (const sql of migration.toSQL()) statements.push({
 				sql,
 				phase: SQLGrammar.phase(sql),
 				statementType: SQLGrammar.classify(sql),
 				createdAt: MigrationClass.createdAt,
 				migrationName: name
 			});
+			downGroups.push({
+				createdAt: MigrationClass.createdAt,
+				index,
+				statements
+			});
 		}
 		const sortedUp = SQLGrammar.sort(upStatements);
-		const sortedDown = downStatements.reverse();
+		const sortedDown = downGroups.sort((a, b) => {
+			const byDate = (a.createdAt ?? "").localeCompare(b.createdAt ?? "");
+			return byDate !== 0 ? byDate : a.index - b.index;
+		}).reverse().flatMap((group) => group.statements);
 		const upSQLString = this.formatSQLForExport(sortedUp, options.compact);
 		const downSQLString = this.formatSQLForExport(sortedDown, options.compact);
 		const rootPath = process.cwd();
@@ -359,16 +548,24 @@ var MigrationRunner = class {
 	* @returns Results for each migration
 	*/
 	async rollbackBatches(batches, options = {}) {
+		if (options.dryRun) return this.rollbackBatchesUnlocked(batches, options);
+		return this.withLock(this.getSources(), () => this.rollbackBatchesUnlocked(batches, options));
+	}
+	async rollbackBatchesUnlocked(batches, options) {
 		const dryRun = options.dryRun ?? false;
 		const record = options.record ?? true;
 		const results = [];
-		const toRollback = await this.getMigrationsToRollback(batches);
+		const toRollback = await this.getMigrationsToRollback(batches, {
+			pruneMissing: options.pruneMissing,
+			readOnly: dryRun
+		});
 		if (toRollback.length === 0) {
 			log.warn("database", "migration", "Nothing to rollback.");
 			return results;
 		}
 		log.info("database", "migration", `Rolling back ${toRollback.length} migration(s).`);
 		for (const MigrationClass of toRollback) {
+			await this.refreshLocks();
 			const result = await this.runMigration(MigrationClass, "down", {
 				dryRun,
 				record
@@ -387,13 +584,7 @@ var MigrationRunner = class {
 	* @returns Results for each migration
 	*/
 	async rollbackAll(options = {}) {
-		const executed = await this.getExecutedMigrations();
-		if (executed.length === 0) {
-			log.warn("database", "migration", "Nothing to rollback.");
-			return [];
-		}
-		const maxBatch = Math.max(...executed.map((r) => r.batch));
-		return this.rollbackBatches(maxBatch, options);
+		return this.rollbackBatches(Number.POSITIVE_INFINITY, options);
 	}
 	/**
 	* Reset and re-run: rollback all then run all.
@@ -410,12 +601,15 @@ var MigrationRunner = class {
 	* Get status of all registered migrations.
 	*/
 	async status() {
-		const executed = await this.getExecutedMigrations();
-		const executedMap = new Map(executed.map((r) => [r.name, r]));
+		const executedBySource = /* @__PURE__ */ new Map();
+		for (const dataSource of this.getSources()) {
+			const executed = await this.getExecutedMigrations(dataSource, { readOnly: true });
+			executedBySource.set(dataSource, new Map(executed.map((r) => [r.name, r])));
+		}
 		return this.migrations.map((MigrationClass) => {
 			const instance = new MigrationClass();
 			const name = MigrationClass.migrationName;
-			const record = executedMap.get(name);
+			const record = executedBySource.get(this.sourceOf(MigrationClass))?.get(name);
 			return {
 				name,
 				table: instance.table,
@@ -435,9 +629,9 @@ var MigrationRunner = class {
 	* @example
 	* await this.informIfExtensionMissing("vector");
 	*/
-	async informIfExtensionMissing(extension) {
+	async informIfExtensionMissing(extension, dataSource = this.getDataSource()) {
 		try {
-			const migrationDriver = this.getMigrationDriver();
+			const migrationDriver = this.getMigrationDriver(dataSource);
 			if (!await migrationDriver.isExtensionAvailable(extension)) {
 				const hr = "─".repeat(60);
 				console.log(`\n${colors.yellow(hr)}`);
@@ -473,35 +667,38 @@ var MigrationRunner = class {
 		log.info("database", "migration", `${direction === "up" ? "Migrating" : "Rolling back"}: ${colors.magenta(name)}...`);
 		try {
 			if (!dryRun) {
-				const driver = this.getMigrationDriver();
+				const dataSource = this.resolveDataSource(migration.dataSource);
+				const driver = this.getMigrationDriver(dataSource);
 				migration.setDriver(driver);
-				migration.setMigrationDefaults(this.getDataSource().migrationDefaults);
-				const shouldUseTransaction = migration.transactional ?? this.getDataSource().migrations?.transactional ?? driver.getDefaultTransactional();
+				migration.setMigrationDefaults(dataSource.migrationDefaults);
 				if (direction === "up") await migration.up();
 				else await migration.down();
-				const databaseDriver = this.getDataSource().driver;
+				const databaseDriver = dataSource.driver;
 				const directExecution = databaseDriver.supportsSqlSerialization === false;
-				const sqlStatements = directExecution ? [] : migration.toSQL();
+				const steps = directExecution ? [] : migration.toSteps?.() ?? migration.toSQL();
+				const sqlStatements = steps.filter((step) => typeof step === "string");
+				const shouldUseTransaction = this.resolveTransactional(MigrationClass, migration, dataSource, sqlStatements);
 				const applyMigration = async () => {
 					if (directExecution) {
 						await migration.execute();
 						return;
 					}
-					for (const sql of sqlStatements) await databaseDriver.query(sql);
+					for (const step of steps) if (typeof step === "string") await databaseDriver.query(step);
+					else await step.data();
 				};
 				if (shouldUseTransaction && databaseDriver.transaction) await databaseDriver.transaction(async () => {
 					await applyMigration();
 					if (record) if (direction === "up") {
-						const batch = options.batch ?? await this.getNextBatchNumber();
-						await this.recordMigration(name, batch, MigrationClass.createdAt ? parseCreatedAt(MigrationClass.createdAt) : /* @__PURE__ */ new Date());
-					} else await this.removeMigrationRecord(name);
+						const batch = options.batch ?? await this.getNextBatchNumber(dataSource);
+						await this.recordMigration(name, batch, MigrationClass.createdAt ? parseCreatedAt(MigrationClass.createdAt) : /* @__PURE__ */ new Date(), dataSource);
+					} else await this.removeMigrationRecord(name, dataSource);
 				});
 				else {
 					await applyMigration();
 					if (record) if (direction === "up") {
-						const batch = options.batch ?? await this.getNextBatchNumber();
-						await this.recordMigration(name, batch, MigrationClass.createdAt ? parseCreatedAt(MigrationClass.createdAt) : /* @__PURE__ */ new Date());
-					} else await this.removeMigrationRecord(name);
+						const batch = options.batch ?? await this.getNextBatchNumber(dataSource);
+						await this.recordMigration(name, batch, MigrationClass.createdAt ? parseCreatedAt(MigrationClass.createdAt) : /* @__PURE__ */ new Date(), dataSource);
+					} else await this.removeMigrationRecord(name, dataSource);
 				}
 			}
 		} catch (err) {
@@ -532,8 +729,9 @@ var MigrationRunner = class {
 	*/
 	createMigrationInstance(MigrationClass) {
 		const migration = new MigrationClass();
-		migration.setDriver(this.getMigrationDriver());
-		migration.setMigrationDefaults(this.getDataSource().migrationDefaults);
+		const dataSource = this.resolveDataSource(migration.dataSource);
+		migration.setDriver(this.getMigrationDriver(dataSource));
+		migration.setMigrationDefaults(dataSource.migrationDefaults);
 		return migration;
 	}
 	/**
@@ -585,10 +783,13 @@ var MigrationRunner = class {
 	*
 	* @see listPendingMigrations
 	*/
-	async getPendingMigrations() {
-		const executed = await this.getExecutedMigrations();
-		const executedNames = new Set(executed.map((r) => r.name));
-		return this.migrations.filter((m) => !executedNames.has(m.migrationName)).sort(sortMigrations);
+	async getPendingMigrations(options = {}) {
+		const executedNames = /* @__PURE__ */ new Map();
+		for (const dataSource of this.getSources()) {
+			const executed = await this.getExecutedMigrations(dataSource, options);
+			executedNames.set(dataSource, new Set(executed.map((r) => r.name)));
+		}
+		return this.migrations.filter((m) => !executedNames.get(this.sourceOf(m))?.has(m.migrationName)).sort(sortMigrations);
 	}
 	/**
 	* Get migrations to rollback, newest-first.
@@ -604,30 +805,52 @@ var MigrationRunner = class {
 	* 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)).map((r) => this.migrations.find((m) => m.migrationName === r.name)).filter((m) => !!m).sort(sortMigrationsForRollback);
+	async getMigrationsToRollback(batches, options = {}) {
+		const migrations = [];
+		const batchOf = /* @__PURE__ */ new Map();
+		const orphans = [];
+		for (const dataSource of this.getSources()) {
+			const executed = await this.getExecutedMigrations(dataSource, { readOnly: options.readOnly });
+			if (executed.length === 0) continue;
+			const batchNumbers = [...new Set(executed.map((r) => r.batch))].sort((a, b) => b - a).slice(0, batches);
+			for (const record of executed) {
+				if (!batchNumbers.includes(record.batch)) continue;
+				const MigrationClass = this.migrations.find((m) => m.migrationName === record.name && this.sourceOf(m) === dataSource);
+				if (MigrationClass) {
+					migrations.push(MigrationClass);
+					batchOf.set(MigrationClass, record.batch);
+				} else orphans.push({
+					name: record.name,
+					dataSource
+				});
+			}
+		}
+		if (orphans.length > 0) {
+			if (!options.pruneMissing) throw new Error(`Cannot roll back: ${orphans.length} executed migration(s) have no registered file: ${orphans.map((o) => o.name).join(", ")}. They were renamed, deleted, or not matched by the migration pattern. Restore the file(s), or pass pruneMissing (--prune-missing) to delete those records.`);
+			if (!options.readOnly) for (const orphan of orphans) {
+				await this.removeMigrationRecord(orphan.name, orphan.dataSource);
+				log.warn("database", "migration", `Pruned orphaned migration record: ${orphan.name}`);
+			}
+		}
+		return migrations.sort((a, b) => (batchOf.get(b) ?? 0) - (batchOf.get(a) ?? 0) || sortMigrationsForRollback(a, b));
 	}
 	/**
 	* Get executed migration records.
 	*/
-	async getExecutedMigrations() {
-		const driver = this.getDataSource().driver;
-		try {
-			await this.getMigrationDriver().ensureMigrationsTable(this.migrationsTable);
-			return await driver.queryBuilder(this.migrationsTable).orderBy("batch", "asc").orderBy("name", "asc").get();
-		} catch {
-			return [];
-		}
+	async getExecutedMigrations(dataSource = this.getDataSource(), options = {}) {
+		const driver = dataSource.driver;
+		const migrationDriver = this.getMigrationDriver(dataSource);
+		if (options.readOnly) {
+			if (!await migrationDriver.tableExists(this.migrationsTable)) return [];
+		} else await migrationDriver.ensureMigrationsTable(this.migrationsTable);
+		return (await driver.queryBuilder(this.migrationsTable).orderBy("batch", "asc").orderBy("name", "asc").get()).filter((record) => record.name !== MIGRATION_LOCK_NAME);
 	}
 	/**
 	* Record a migration.
 	*/
-	async recordMigration(name, batch, createdAt) {
-		const driver = this.getDataSource().driver;
-		await this.getMigrationDriver().ensureMigrationsTable(this.migrationsTable);
+	async recordMigration(name, batch, createdAt, dataSource = this.getDataSource()) {
+		const driver = dataSource.driver;
+		await this.getMigrationDriver(dataSource).ensureMigrationsTable(this.migrationsTable);
 		await driver.insert(this.migrationsTable, {
 			name,
 			batch,
@@ -638,14 +861,14 @@ var MigrationRunner = class {
 	/**
 	* Remove a migration record.
 	*/
-	async removeMigrationRecord(name) {
-		await this.getDataSource().driver.delete(this.migrationsTable, { name });
+	async removeMigrationRecord(name, dataSource = this.getDataSource()) {
+		await dataSource.driver.delete(this.migrationsTable, { name });
 	}
 	/**
 	* Get next batch number.
 	*/
-	async getNextBatchNumber() {
-		const executed = await this.getExecutedMigrations();
+	async getNextBatchNumber(dataSource = this.getDataSource(), readOnly = false) {
+		const executed = await this.getExecutedMigrations(dataSource, { readOnly });
 		if (executed.length === 0) return 1;
 		return Math.max(...executed.map((r) => r.batch)) + 1;
 	}
@@ -653,5 +876,5 @@ var MigrationRunner = class {
 const migrationRunner = new MigrationRunner();
 
 //#endregion
-export { MigrationRunner, migrationRunner };
+export { MigrationRunner, inferMigrationName, migrationRunner };
 //# sourceMappingURL=migration-runner.mjs.map