@mikro-orm/migrations 7.2.7-dev.8 → 7.2.7

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

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

@@ -148,9 +148,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.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 +169,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.2.7-dev.8",
+  "version": "7.2.7",
   "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.2.7-dev.8"
+    "@mikro-orm/sql": "7.2.7"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.2.6"
+    "@mikro-orm/core": "^7.2.7"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.2.7-dev.8"
+    "@mikro-orm/core": "7.2.7"
   },
   "engines": {
     "node": ">= 22.17.0"