@mikro-orm/migrations 7.3.0-dev.2 → 7.3.0-dev.20

package/MigrationRunner.d.ts

@@ -9,6 +9,11 @@ export declare class MigrationRunner {
     protected readonly config: Configuration;
     constructor(driver: AbstractSqlDriver, options: MigrationsOptions, config: Configuration);
     run(migration: Migration, method: 'up' | 'down', afterRun?: (tx?: Transaction) => Promise<void>): Promise<void>;
+    /** Runs migrations with FK checks off, for drivers that ignore the switch inside a transaction (SQLite). */
+    runWithoutForeignKeys<T>(run: () => Promise<T>): Promise<T>;
+    private runWithForeignKeys;
+    private setForeignKeys;
+    private countForeignKeyViolations;
     private resetSessionSchema;
     setMasterMigration(trx: Transaction): void;
     unsetMasterMigration(): void;

package/MigrationRunner.js

@@ -1,4 +1,4 @@
-import { Utils } from '@mikro-orm/core';
+import { Utils, ValidationError } from '@mikro-orm/core';
 /** Executes individual migration files within optional transaction contexts. */
 export class MigrationRunner {
     driver;
@@ -8,6 +8,7 @@ export class MigrationRunner {
     #helper;
     #masterTransaction;
     #runSchema;
+    #foreignKeysOff = false;
     constructor(driver, options, config) {
         this.driver = driver;
         this.options = options;
@@ -23,16 +24,23 @@ export class MigrationRunner {
             if (this.#runSchema) {
                 throw new Error('Runtime schema (migrations.schema / migrator.up({ schema })) is only supported with transactional migrations');
             }
-            const queries = await this.getQueries(migration, method);
-            await Utils.runSerial(queries, sql => this.driver.execute(sql));
-            await afterRun?.();
+            await this.runWithForeignKeys(async () => {
+                const queries = await this.getQueries(migration, method);
+                await Utils.runSerial(queries, sql => this.driver.execute(sql));
+                await afterRun?.();
+            });
         }
         else {
             await this.#connection.transactional(async (tx) => {
                 migration.setTransactionContext(tx);
+                const violations = await this.countForeignKeyViolations(tx);
                 try {
                     const queries = await this.getQueries(migration, method);
                     await Utils.runSerial(queries, sql => this.driver.execute(sql, undefined, 'all', tx));
+                    const added = (await this.countForeignKeyViolations(tx)) - violations;
+                    if (added > 0) {
+                        throw new ValidationError(`Migration ${migration.name ?? migration.constructor.name} left ${added} rows that violate foreign keys`);
+                    }
                     await afterRun?.(tx);
                 }
                 finally {
@@ -41,6 +49,41 @@ export class MigrationRunner {
             }, { ctx: this.#masterTransaction });
         }
     }
+    /** Runs migrations with FK checks off, for drivers that ignore the switch inside a transaction (SQLite). */
+    async runWithoutForeignKeys(run) {
+        await this.setForeignKeys(false);
+        try {
+            return await run();
+        }
+        finally {
+            await this.setForeignKeys(true);
+        }
+    }
+    // a migration outside a transaction gets no `foreign_key_check`, so it runs with FK checks on
+    async runWithForeignKeys(run) {
+        if (!this.#foreignKeysOff) {
+            return run();
+        }
+        await this.setForeignKeys(true);
+        try {
+            await run();
+        }
+        finally {
+            await this.setForeignKeys(false);
+        }
+    }
+    async setForeignKeys(enabled) {
+        await this.driver.execute(enabled ? this.#helper.enableForeignKeysSQL() : this.#helper.disableForeignKeysSQL());
+        this.#foreignKeysOff = !enabled;
+    }
+    async countForeignKeyViolations(ctx) {
+        const sql = this.#helper.getForeignKeyCheckSQL();
+        // with FK checks on (caller-supplied transaction), the database enforces them itself
+        if (!this.#foreignKeysOff || !sql) {
+            return 0;
+        }
+        return (await this.driver.execute(sql, undefined, 'all', ctx)).length;
+    }
     async resetSessionSchema(ctx) {
         if (!this.#runSchema) {
             return;

package/Migrator.d.ts

@@ -13,6 +13,8 @@ export declare class Migrator extends AbstractMigrator<AbstractSqlDriver> {
     protected getDefaultGenerator(): IMigrationGenerator;
     private getSnapshotPath;
     protected init(): Promise<void>;
+    /** Runs the callback while holding the migration lock (if enabled and supported by the driver). */
+    private runLocked;
     /**
      * @inheritDoc
      */
@@ -27,6 +29,7 @@ export declare class Migrator extends AbstractMigrator<AbstractSqlDriver> {
      */
     createInitial(path?: string, name?: string, blank?: boolean): Promise<MigrationResult>;
     protected runMigrations(method: 'up' | 'down', options?: string | string[] | MigrateOptions): Promise<MigrationInfo[]>;
+    private runWithoutForeignKeys;
     /** Whether the introspected schema differs from the snapshot in any way the comparator turns into SQL. */
     private snapshotDiffers;
     getStorage(): MigrationStorage;

package/Migrator.js

@@ -63,6 +63,46 @@ export class Migrator extends AbstractMigrator {
             await this.storage.ensureTable();
         }
     }
+    /** Runs the callback while holding the migration lock (if enabled and supported by the driver). */
+    async runLocked(cb) {
+        const lock = this.options.lock ? this.driver.getPlatform().getSchemaHelper().getMigrationLockSQL() : undefined;
+        if (!lock) {
+            return cb();
+        }
+        const poolMax = this.config.get('pool').max;
+        if (poolMax != null && poolMax < 2) {
+            throw new Error('The migration lock needs at least 2 pooled connections, as it holds one for the whole run');
+        }
+        // the database has to exist before a connection can be reserved, creating it may reconnect
+        await this.#schemaGenerator.ensureDatabase();
+        const connection = this.driver.getConnection();
+        const name = this.options.tableName;
+        const deadline = Date.now() + (this.options.lockTimeout ?? Infinity);
+        // a session-level lock on a reserved connection spans all transactions of the run, while its queries keep using the pool
+        return connection
+            .getClient()
+            .connection()
+            .execute(async (db) => {
+            let waiting = false;
+            while (!(await connection.execute(lock.acquire, [name], 'get', db)).locked) {
+                if (Date.now() >= deadline) {
+                    throw new Error(`Timed out after ${this.options.lockTimeout} ms waiting for the migration lock`);
+                }
+                if (!waiting && !this.options.silent) {
+                    const logger = this.config.getLogger();
+                    logger.log('migrator', 'Waiting for the migration lock held by another run', { enabled: true });
+                }
+                waiting = true;
+                await new Promise(resolve => setTimeout(resolve, Math.min(500, deadline - Date.now())));
+            }
+            try {
+                return await cb();
+            }
+            finally {
+                await connection.execute(lock.release, [name], 'run', db);
+            }
+        });
+    }
     /**
      * @inheritDoc
      */
@@ -148,9 +188,9 @@ export class Migrator extends AbstractMigrator {
         };
     }
     async runMigrations(method, options) {
-        const result = await super.runMigrations(method, options);
+        const ctx = Utils.isObject(options) ? options.transaction : undefined;
+        const result = await this.runLocked(() => this.runWithoutForeignKeys(ctx, () => super.runMigrations(method, options)));
         if (result.length > 0 && this.options.snapshot && this.options.snapshotOnMigrate) {
-            const ctx = Utils.isObject(options) ? options.transaction : undefined;
             const { skipTables, skipViews } = this.config.get('schemaGenerator');
             const schema = await DatabaseSchema.create(this.em.getConnection(), this.em.getPlatform(), this.config, undefined, undefined, undefined, skipTables, skipViews, ctx);
             // keep the snapshot authored by `migration:create` when the migrated DB still matches it
@@ -169,6 +209,14 @@ export class Migrator extends AbstractMigrator {
         }
         return result;
     }
+    async runWithoutForeignKeys(ctx, run) {
+        // sqlite ignores `pragma foreign_keys` inside a transaction, so a table rebuild would run the FK actions of child rows
+        if (ctx || !this.options.transactional || !this.driver.getPlatform().getSchemaHelper().getForeignKeyCheckSQL()) {
+            return run();
+        }
+        await this.init(); // can recreate the runner, which holds the FK state
+        return this.runner.runWithoutForeignKeys(run);
+    }
     /** Whether the introspected schema differs from the snapshot in any way the comparator turns into SQL. */
     snapshotDiffers(snapshot, schema) {
         const comparator = new SchemaComparator(this.driver.getPlatform());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/migrations",
-  "version": "7.3.0-dev.2",
+  "version": "7.3.0-dev.20",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",
@@ -47,13 +47,13 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "@mikro-orm/sql": "7.3.0-dev.2"
+    "@mikro-orm/sql": "7.3.0-dev.20"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.2.1"
+    "@mikro-orm/core": "^7.2.7"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.3.0-dev.2"
+    "@mikro-orm/core": "7.3.0-dev.20"
   },
   "engines": {
     "node": ">= 22.17.0"