@mikro-orm/migrations 7.1.0-dev.3 → 7.1.0-dev.30

package/MigrationRunner.d.ts

@@ -8,8 +8,11 @@ export declare class MigrationRunner {
     protected readonly options: MigrationsOptions;
     protected readonly config: Configuration;
     constructor(driver: AbstractSqlDriver, options: MigrationsOptions, config: Configuration);
-    run(migration: Migration, method: 'up' | 'down'): Promise<void>;
+    run(migration: Migration, method: 'up' | 'down', afterRun?: (tx?: Transaction) => Promise<void>): Promise<void>;
+    private resetSessionSchema;
     setMasterMigration(trx: Transaction): void;
     unsetMasterMigration(): void;
+    setRunSchema(schema?: string): void;
+    unsetRunSchema(): void;
     private getQueries;
 }

package/MigrationRunner.js

@@ -7,6 +7,7 @@ export class MigrationRunner {
     #connection;
     #helper;
     #masterTransaction;
+    #runSchema;
     constructor(driver, options, config) {
         this.driver = driver;
         this.options = options;
@@ -14,31 +15,64 @@ export class MigrationRunner {
         this.#connection = this.driver.getConnection();
         this.#helper = this.driver.getPlatform().getSchemaHelper();
     }
-    async run(migration, method) {
+    async run(migration, method, afterRun) {
         migration.reset();
         if (!this.options.transactional || !migration.isTransactional()) {
+            // Without a pinned transaction the set/reset statements may land on different pooled
+            // connections than the DDL, so refuse rather than silently running in the default schema.
+            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?.();
         }
         else {
             await this.#connection.transactional(async (tx) => {
                 migration.setTransactionContext(tx);
-                const queries = await this.getQueries(migration, method);
-                await Utils.runSerial(queries, sql => this.driver.execute(sql, undefined, 'all', tx));
+                try {
+                    const queries = await this.getQueries(migration, method);
+                    await Utils.runSerial(queries, sql => this.driver.execute(sql, undefined, 'all', tx));
+                    await afterRun?.(tx);
+                }
+                finally {
+                    await this.resetSessionSchema(tx);
+                }
             }, { ctx: this.#masterTransaction });
         }
     }
+    async resetSessionSchema(ctx) {
+        if (!this.#runSchema) {
+            return;
+        }
+        const sql = this.#helper.getResetSchemaSQL(this.config.get('dbName'));
+        /* v8 ignore next 3 */
+        if (!sql) {
+            return;
+        }
+        // best-effort — surfacing a reset failure would mask the real migration error
+        await this.driver.execute(sql, undefined, 'all', ctx).catch(() => void 0);
+    }
     setMasterMigration(trx) {
         this.#masterTransaction = trx;
     }
     unsetMasterMigration() {
         this.#masterTransaction = undefined;
     }
+    setRunSchema(schema) {
+        this.#runSchema = this.#helper.resolveMigrationSchema(schema);
+    }
+    unsetRunSchema() {
+        this.#runSchema = undefined;
+    }
     async getQueries(migration, method) {
         await migration[method]();
         const charset = this.config.get('charset');
         let queries = migration.getQueries();
         queries.unshift(...this.#helper.getSchemaBeginning(charset, this.options.disableForeignKeys).split('\n'));
+        if (this.#runSchema) {
+            queries.unshift(this.#helper.getSetSchemaSQL(this.#runSchema));
+        }
         queries.push(...this.#helper.getSchemaEnd(this.options.disableForeignKeys).split('\n'));
         queries = queries.filter(sql => typeof sql !== 'string' || sql.trim().length > 0);
         return queries;

package/MigrationStorage.d.ts

@@ -10,14 +10,16 @@ export declare class MigrationStorage {
     executed(): Promise<string[]>;
     logMigration(params: {
         name: string;
-    }): Promise<void>;
+    }, tx?: Transaction): Promise<void>;
     unlogMigration(params: {
         name: string;
-    }): Promise<void>;
+    }, tx?: Transaction): Promise<void>;
     getExecutedMigrations(): Promise<MigrationRow[]>;
     ensureTable(): Promise<void>;
     setMasterMigration(trx: Transaction): void;
     unsetMasterMigration(): void;
+    setRunSchema(schema?: string): void;
+    unsetRunSchema(): void;
     /**
      * @internal
      */
@@ -30,4 +32,5 @@ export declare class MigrationStorage {
         schemaName: string;
         entity: EntitySchema;
     };
+    private resolveTableName;
 }

package/MigrationStorage.js

@@ -7,7 +7,9 @@ export class MigrationStorage {
     #connection;
     #helper;
     #masterTransaction;
+    #runSchema;
     #platform;
+    #ensuredSchemas = new Set();
     constructor(driver, options) {
         this.driver = driver;
         this.options = options;
@@ -19,18 +21,21 @@ export class MigrationStorage {
         const migrations = await this.getExecutedMigrations();
         return migrations.map(({ name }) => this.getMigrationName(name));
     }
-    async logMigration(params) {
+    async logMigration(params, tx) {
+        await this.ensureTable();
         const { entity } = this.getTableName();
         const name = this.getMigrationName(params.name);
-        await this.driver.nativeInsert(entity, { name }, { ctx: this.#masterTransaction });
+        await this.driver.nativeInsert(entity, { name }, { ctx: tx ?? this.#masterTransaction });
     }
-    async unlogMigration(params) {
+    async unlogMigration(params, tx) {
+        await this.ensureTable();
         const { entity } = this.getTableName();
         const withoutExt = this.getMigrationName(params.name);
         const names = [withoutExt, withoutExt + '.js', withoutExt + '.ts'];
-        await this.driver.nativeDelete(entity, { name: { $in: [params.name, ...names] } }, { ctx: this.#masterTransaction });
+        await this.driver.nativeDelete(entity, { name: { $in: [params.name, ...names] } }, { ctx: tx ?? this.#masterTransaction });
     }
     async getExecutedMigrations() {
+        await this.ensureTable();
         const { entity, schemaName } = this.getTableName();
         const res = await this.driver
             .createQueryBuilder(entity, this.#masterTransaction)
@@ -45,15 +50,20 @@ export class MigrationStorage {
         });
     }
     async ensureTable() {
-        const tables = await this.#connection.execute(this.#helper.getListTablesSQL(), [], 'all', this.#masterTransaction);
-        const { tableName, schemaName } = this.getTableName();
-        if (tables.find(t => t.table_name === tableName && (!t.schema_name || t.schema_name === schemaName))) {
+        const { tableName, schemaName } = this.resolveTableName();
+        // `\x00` can't appear in SQL identifiers — unambiguous pair encoding
+        const cacheKey = `${schemaName ?? ''}\x00${tableName}`;
+        if (this.#ensuredSchemas.has(cacheKey)) {
             return;
         }
-        const schemas = await this.#helper.getNamespaces(this.#connection);
+        if (await this.#helper.tableExists(this.#connection, tableName, schemaName, this.#masterTransaction)) {
+            this.#ensuredSchemas.add(cacheKey);
+            return;
+        }
+        const schemas = await this.#helper.getNamespaces(this.#connection, this.#masterTransaction);
         if (schemaName && !schemas.includes(schemaName)) {
             const sql = this.#helper.getCreateNamespaceSQL(schemaName);
-            await this.#connection.execute(sql);
+            await this.#connection.execute(sql, [], 'run', this.#masterTransaction);
         }
         const table = new DatabaseTable(this.#platform, tableName, schemaName);
         table.addColumn({
@@ -78,6 +88,7 @@ export class MigrationStorage {
         });
         const sql = this.#helper.createTable(table);
         await this.#connection.execute(sql.join(';\n'), [], 'run', this.#masterTransaction);
+        this.#ensuredSchemas.add(cacheKey);
     }
     setMasterMigration(trx) {
         this.#masterTransaction = trx;
@@ -85,6 +96,12 @@ export class MigrationStorage {
     unsetMasterMigration() {
         this.#masterTransaction = undefined;
     }
+    setRunSchema(schema) {
+        this.#runSchema = this.#helper.resolveMigrationSchema(schema);
+    }
+    unsetRunSchema() {
+        this.#runSchema = undefined;
+    }
     /**
      * @internal
      */
@@ -95,9 +112,7 @@ export class MigrationStorage {
      * @internal
      */
     getTableName() {
-        const parts = this.options.tableName.split('.');
-        const tableName = parts.length > 1 ? parts[1] : parts[0];
-        const schemaName = parts.length > 1 ? parts[0] : this.driver.config.get('schema', this.driver.getPlatform().getDefaultSchemaName());
+        const { tableName, schemaName } = this.resolveTableName();
         const entity = defineEntity({
             name: 'Migration',
             tableName,
@@ -111,4 +126,14 @@ export class MigrationStorage {
         entity.meta.sync();
         return { tableName, schemaName, entity };
     }
+    resolveTableName() {
+        const parts = this.options.tableName.split('.');
+        const tableName = parts.length > 1 ? parts[1] : parts[0];
+        const schemaName = this.#runSchema ??
+            this.options.schema ??
+            (parts.length > 1
+                ? parts[0]
+                : this.driver.config.get('schema', this.driver.getPlatform().getDefaultSchemaName()));
+        return { tableName, schemaName };
+    }
 }

package/Migrator.d.ts

@@ -17,7 +17,9 @@ export declare class Migrator extends AbstractMigrator<AbstractSqlDriver> {
      * @inheritDoc
      */
     create(path?: string, blank?: boolean, initial?: boolean, name?: string): Promise<MigrationResult>;
-    getPending(): Promise<MigrationInfo[]>;
+    getPending(options?: {
+        schema?: string;
+    }): Promise<MigrationInfo[]>;
     private hasSnapshot;
     checkSchema(): Promise<boolean>;
     /**

package/Migrator.js

@@ -51,7 +51,14 @@ export class Migrator extends AbstractMigrator {
         if (created) {
             this.initServices();
         }
-        await this.storage.ensureTable();
+        // Defer tracking-table creation when wildcard-schema fan-out is enabled — pre-creating
+        // here would land in the default schema and leave a stray `mikro_orm_migrations` after
+        // `migrator.up({ schema })` against a virgin DB. For the standard flow, eager creation
+        // keeps the per-call query log clean (no `tableExists`/`getNamespaces`/`create` probe
+        // on first storage access).
+        if (!this.options.includeWildcardSchema) {
+            await this.storage.ensureTable();
+        }
     }
     /**
      * @inheritDoc
@@ -74,23 +81,30 @@ export class Migrator extends AbstractMigrator {
             diff,
         };
     }
-    async getPending() {
+    async getPending(options) {
         if (!(await this.hasSnapshot())) {
-            return super.getPending();
+            return super.getPending(options);
         }
         await this.initPaths();
         const all = await this.discoverMigrations();
-        // probe the DB via `ensureTable` — if it fails, the DB is unreachable and
-        // we treat every discovered migration as pending; otherwise let errors
-        // from `storage.executed()` propagate so real bugs are not swallowed
+        const schema = options?.schema ?? this.options.schema;
+        this.storage.setRunSchema?.(schema);
         try {
-            await this.storage.ensureTable();
+            // probe the DB via `ensureTable` — if it fails, the DB is unreachable and
+            // we treat every discovered migration as pending; otherwise let errors
+            // from `storage.executed()` propagate so real bugs are not swallowed
+            try {
+                await this.storage.ensureTable();
+            }
+            catch {
+                return all.map(m => ({ name: m.name, path: m.path }));
+            }
+            const executed = new Set(await this.storage.executed());
+            return all.filter(m => !executed.has(m.name)).map(m => ({ name: m.name, path: m.path }));
         }
-        catch {
-            return all.map(m => ({ name: m.name, path: m.path }));
+        finally {
+            this.storage.unsetRunSchema?.();
         }
-        const executed = new Set(await this.storage.executed());
-        return all.filter(m => !executed.has(m.name)).map(m => ({ name: m.name, path: m.path }));
     }
     async hasSnapshot() {
         if (!this.options.snapshot) {
@@ -197,9 +211,12 @@ export class Migrator extends AbstractMigrator {
         const data = fs.readJSONSync(snapshotPath);
         const schema = new DatabaseSchema(this.driver.getPlatform(), this.config.get('schema'));
         const { tables, namespaces, ...rest } = data;
+        // share schema-level native enums by reference; fall back to per-table copy on older snapshots
+        const sharedNativeEnums = rest.nativeEnums ?? {};
+        const hasSharedNativeEnums = Object.keys(sharedNativeEnums).length > 0;
         const tableInstances = tables.map((tbl) => {
             const table = new DatabaseTable(this.driver.getPlatform(), tbl.name, tbl.schema);
-            table.nativeEnums = tbl.nativeEnums ?? {};
+            table.nativeEnums = hasSharedNativeEnums ? sharedNativeEnums : (tbl.nativeEnums ?? {});
             table.comment = tbl.comment;
             if (tbl.indexes) {
                 table.setIndexes(tbl.indexes);
@@ -271,7 +288,10 @@ export class Migrator extends AbstractMigrator {
             down.push('select 1');
         }
         else if (initial) {
-            const dump = await this.#schemaGenerator.getCreateSchemaSQL({ wrap: false });
+            const dump = await this.#schemaGenerator.getCreateSchemaSQL({
+                wrap: false,
+                includeWildcardSchema: this.options.includeWildcardSchema,
+            });
             up.push(...splitStatements(dump));
         }
         else {
@@ -280,6 +300,7 @@ export class Migrator extends AbstractMigrator {
                 safe: this.options.safe,
                 dropTables: this.options.dropTables,
                 fromSchema: await this.getSchemaFromSnapshot(),
+                includeWildcardSchema: this.options.includeWildcardSchema,
             });
             up.push(...splitStatements(diff.up));
             down.push(...splitStatements(diff.down));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/migrations",
-  "version": "7.1.0-dev.3",
+  "version": "7.1.0-dev.30",
   "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.1.0-dev.3"
+    "@mikro-orm/sql": "7.1.0-dev.30"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.0.11"
+    "@mikro-orm/core": "^7.0.15"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.3"
+    "@mikro-orm/core": "7.1.0-dev.30"
   },
   "engines": {
     "node": ">= 22.17.0"