@mikro-orm/migrations 7.0.0-rc.1 → 7.0.0-rc.3

package/JSMigrationGenerator.js

@@ -9,12 +9,12 @@ export class JSMigrationGenerator extends MigrationGenerator {
         ret += `const { Migration } = require('@mikro-orm/migrations');\n\n`;
         ret += `class ${className} extends Migration {\n\n`;
         ret += `  async up() {\n`;
-        diff.up.forEach(sql => ret += this.createStatement(sql, 4));
+        diff.up.forEach(sql => (ret += this.createStatement(sql, 4)));
         ret += `  }\n\n`;
         /* v8 ignore next */
         if (diff.down.length > 0) {
             ret += `  async down() {\n`;
-            diff.down.forEach(sql => ret += this.createStatement(sql, 4));
+            diff.down.forEach(sql => (ret += this.createStatement(sql, 4)));
             ret += `  }\n\n`;
         }
         ret += `}\n`;

package/MigrationGenerator.js

@@ -1,5 +1,3 @@
-import { fs } from '@mikro-orm/core/fs-utils';
-import { writeFile } from 'node:fs/promises';
 export class MigrationGenerator {
     driver;
     namingStrategy;
@@ -13,15 +11,16 @@ export class MigrationGenerator {
      * @inheritDoc
      */
     async generate(diff, path, name) {
+        const { fs } = await import('@mikro-orm/core/fs-utils');
         /* v8 ignore next */
         const defaultPath = this.options.emit === 'ts' && this.options.pathTs ? this.options.pathTs : this.options.path;
         path = fs.normalizePath(this.driver.config.get('baseDir'), path ?? defaultPath);
         fs.ensureDir(path);
-        const timestamp = new Date().toISOString().replace(/[-T:]|\.\d{3}z$/ig, '');
+        const timestamp = new Date().toISOString().replace(/[-T:]|\.\d{3}z$/gi, '');
         const className = this.namingStrategy.classToMigrationName(timestamp, name);
         const fileName = `${this.options.fileName(timestamp, name)}.${this.options.emit}`;
         const ret = await this.generateMigrationFile(className, diff);
-        await writeFile(path + '/' + fileName, ret, { flush: true });
+        await fs.writeFile(path + '/' + fileName, ret, { flush: true });
         return [ret, fileName];
     }
     /**

package/MigrationStorage.d.ts

@@ -1,8 +1,7 @@
 import { type MigrationsOptions, type Transaction, type EntitySchema } from '@mikro-orm/core';
 import { type AbstractSqlDriver } from '@mikro-orm/sql';
-import type { MigrationParams, UmzugStorage } from 'umzug';
 import type { MigrationRow } from './typings.js';
-export declare class MigrationStorage implements UmzugStorage {
+export declare class MigrationStorage {
     protected readonly driver: AbstractSqlDriver;
     protected readonly options: MigrationsOptions;
     private readonly connection;
@@ -11,8 +10,12 @@ export declare class MigrationStorage implements UmzugStorage {
     private readonly platform;
     constructor(driver: AbstractSqlDriver, options: MigrationsOptions);
     executed(): Promise<string[]>;
-    logMigration(params: MigrationParams<any>): Promise<void>;
-    unlogMigration(params: MigrationParams<any>): Promise<void>;
+    logMigration(params: {
+        name: string;
+    }): Promise<void>;
+    unlogMigration(params: {
+        name: string;
+    }): Promise<void>;
     getExecutedMigrations(): Promise<MigrationRow[]>;
     ensureTable(): Promise<void>;
     setMasterMigration(trx: Transaction): void;

package/MigrationStorage.js

@@ -1,6 +1,5 @@
 import { defineEntity, p } from '@mikro-orm/core';
 import { DatabaseTable, } from '@mikro-orm/sql';
-import { parse } from 'node:path';
 export class MigrationStorage {
     driver;
     options;
@@ -32,12 +31,13 @@ export class MigrationStorage {
     }
     async getExecutedMigrations() {
         const { entity, schemaName } = this.getTableName();
-        const res = await this.driver.createQueryBuilder(entity, this.masterTransaction)
+        const res = await this.driver
+            .createQueryBuilder(entity, this.masterTransaction)
             .withSchema(schemaName)
             .orderBy({ id: 'asc' })
             .execute('all', false);
         return res.map(row => {
-            if (typeof row.executed_at === 'string') {
+            if (typeof row.executed_at === 'string' || typeof row.executed_at === 'number') {
                 row.executed_at = new Date(row.executed_at);
             }
             return row;
@@ -88,12 +88,7 @@ export class MigrationStorage {
      * @internal
      */
     getMigrationName(name) {
-        const parsedName = parse(name);
-        if (['.js', '.ts'].includes(parsedName.ext)) {
-            // strip extension
-            return parsedName.name;
-        }
-        return name;
+        return name.replace(/\.[jt]s$/, '');
     }
     /**
      * @internal

package/Migrator.d.ts

@@ -1,32 +1,18 @@
-import { type MigrationParams, type RunnableMigration } from 'umzug';
-import { type Constructor, type IMigrator, type MaybePromise, type MigratorEvent, type MikroORM } from '@mikro-orm/core';
-import { DatabaseSchema, type EntityManager } from '@mikro-orm/sql';
-import type { Migration } from './Migration.js';
+import { type IMigrationGenerator, type IMigrationRunner, type IMigratorStorage, type MigrateOptions, type MigrationInfo, type MikroORM } from '@mikro-orm/core';
+import { AbstractMigrator } from '@mikro-orm/core/migrations';
+import { type AbstractSqlDriver, DatabaseSchema, type EntityManager } from '@mikro-orm/sql';
 import { MigrationStorage } from './MigrationStorage.js';
-import type { MigrateOptions, MigrationResult, MigrationRow, UmzugMigration } from './typings.js';
-export declare class Migrator implements IMigrator {
-    private readonly em;
-    private umzug;
-    private runner;
-    private storage;
-    private generator;
-    private readonly driver;
+import type { MigrationResult } from './typings.js';
+export declare class Migrator extends AbstractMigrator<AbstractSqlDriver> {
     private readonly schemaGenerator;
-    private readonly config;
-    private readonly options;
-    private readonly absolutePath;
-    private readonly snapshotPath;
+    private snapshotPath?;
     constructor(em: EntityManager);
-    /**
-     * Checks if `src` folder exists, it so, tries to adjust the migrations and seeders paths automatically to use it.
-     * If there is a `dist` or `build` folder, it will be used for the JS variant (`path` option), while the `src` folder will be
-     * used for the TS variant (`pathTs` option).
-     *
-     * If the default folder exists (e.g. `/migrations`), the config will respect that, so this auto-detection should not
-     * break existing projects, only help with the new ones.
-     */
-    private detectSourceFolder;
     static register(orm: MikroORM): void;
+    protected createRunner(): IMigrationRunner;
+    protected createStorage(): IMigratorStorage;
+    protected getDefaultGenerator(): IMigrationGenerator;
+    private getSnapshotPath;
+    protected init(): Promise<void>;
     /**
      * @inheritDoc
      */
@@ -36,15 +22,8 @@ export declare class Migrator implements IMigrator {
      * @inheritDoc
      */
     createInitial(path?: string, name?: string, blank?: boolean): Promise<MigrationResult>;
-    /**
-     * @inheritDoc
-     */
-    on(eventName: MigratorEvent, listener: (event: UmzugMigration) => MaybePromise<void>): this;
-    /**
-     * @inheritDoc
-     */
-    off(eventName: MigratorEvent, listener: (event: UmzugMigration) => MaybePromise<void>): this;
-    private createUmzug;
+    protected runMigrations(method: 'up' | 'down', options?: string | string[] | MigrateOptions): Promise<MigrationInfo[]>;
+    getStorage(): MigrationStorage;
     /**
      * Initial migration can be created only if:
      * 1. no previous migrations were generated or executed
@@ -54,32 +33,7 @@ export declare class Migrator implements IMigrator {
      * If only some of the tables are present, exception is thrown.
      */
     private validateInitialMigration;
-    /**
-     * @inheritDoc
-     */
-    getExecuted(): Promise<MigrationRow[]>;
-    private ensureDatabase;
-    /**
-     * @inheritDoc
-     */
-    getPending(): Promise<UmzugMigration[]>;
-    /**
-     * @inheritDoc
-     */
-    up(options?: string | string[] | MigrateOptions): Promise<UmzugMigration[]>;
-    /**
-     * @inheritDoc
-     */
-    down(options?: string | string[] | MigrateOptions): Promise<UmzugMigration[]>;
-    getStorage(): MigrationStorage;
-    protected resolve(params: MigrationParams<any>): RunnableMigration<any>;
-    protected getSchemaFromSnapshot(): DatabaseSchema | undefined;
-    protected storeCurrentSchema(): Promise<void>;
-    protected initialize(MigrationClass: Constructor<Migration>, name: string): RunnableMigration<any>;
+    protected getSchemaFromSnapshot(): Promise<DatabaseSchema | undefined>;
+    protected storeCurrentSchema(schema?: DatabaseSchema): Promise<void>;
     private getSchemaDiff;
-    private getMigrationFilename;
-    private prefix;
-    private runMigrations;
-    private runInTransaction;
-    private ensureMigrationsDirExists;
 }

package/Migrator.js

@@ -1,82 +1,65 @@
-import { Umzug, } from 'umzug';
-import { basename, join } from 'node:path';
-import { existsSync, writeFileSync } from 'node:fs';
-import { t, Type, UnknownType, Utils, } from '@mikro-orm/core';
-import { fs } from '@mikro-orm/core/fs-utils';
+import { t, Type, UnknownType, } from '@mikro-orm/core';
+import { AbstractMigrator } from '@mikro-orm/core/migrations';
 import { DatabaseSchema, DatabaseTable, } from '@mikro-orm/sql';
 import { MigrationRunner } from './MigrationRunner.js';
 import { MigrationStorage } from './MigrationStorage.js';
 import { TSMigrationGenerator } from './TSMigrationGenerator.js';
 import { JSMigrationGenerator } from './JSMigrationGenerator.js';
-export class Migrator {
-    em;
-    umzug;
-    runner;
-    storage;
-    generator;
-    driver;
+export class Migrator extends AbstractMigrator {
     schemaGenerator;
-    config;
-    options;
-    absolutePath;
     snapshotPath;
     constructor(em) {
-        this.em = em;
-        this.driver = this.em.getDriver();
-        this.config = this.em.config;
-        this.options = this.config.get('migrations');
+        super(em);
         this.schemaGenerator = this.config.getExtension('@mikro-orm/schema-generator');
-        this.detectSourceFolder();
-        /* v8 ignore next */
-        const key = (this.config.get('preferTs', Utils.detectTypeScriptSupport()) && this.options.pathTs) ? 'pathTs' : 'path';
-        this.absolutePath = fs.absolutePath(this.options[key], this.config.get('baseDir'));
-        // for snapshots, we always want to use the path based on `emit` option, regardless of whether we run in TS context
-        /* v8 ignore next */
-        const snapshotPath = this.options.emit === 'ts' && this.options.pathTs ? this.options.pathTs : this.options.path;
-        const absoluteSnapshotPath = fs.absolutePath(snapshotPath, this.config.get('baseDir'));
-        const dbName = basename(this.config.get('dbName'));
-        const snapshotName = this.options.snapshotName ?? `.snapshot-${dbName}`;
-        this.snapshotPath = fs.normalizePath(absoluteSnapshotPath, `${snapshotName}.json`);
-        this.createUmzug();
     }
-    /**
-     * Checks if `src` folder exists, it so, tries to adjust the migrations and seeders paths automatically to use it.
-     * If there is a `dist` or `build` folder, it will be used for the JS variant (`path` option), while the `src` folder will be
-     * used for the TS variant (`pathTs` option).
-     *
-     * If the default folder exists (e.g. `/migrations`), the config will respect that, so this auto-detection should not
-     * break existing projects, only help with the new ones.
-     */
-    detectSourceFolder() {
-        const baseDir = this.config.get('baseDir');
-        const defaultPath = './migrations';
-        if (!fs.pathExists(baseDir + '/src')) {
-            this.options.path ??= defaultPath;
+    static register(orm) {
+        orm.config.registerExtension('@mikro-orm/migrator', () => new Migrator(orm.em));
+    }
+    createRunner() {
+        return new MigrationRunner(this.driver, this.options, this.config);
+    }
+    createStorage() {
+        return new MigrationStorage(this.driver, this.options);
+    }
+    getDefaultGenerator() {
+        if (this.options.emit === 'js' || this.options.emit === 'cjs') {
+            return new JSMigrationGenerator(this.driver, this.config.getNamingStrategy(), this.options);
+        }
+        return new TSMigrationGenerator(this.driver, this.config.getNamingStrategy(), this.options);
+    }
+    async getSnapshotPath() {
+        if (!this.snapshotPath) {
+            const { fs } = await import('@mikro-orm/core/fs-utils');
+            // for snapshots, we always want to use the path based on `emit` option, regardless of whether we run in TS context
+            /* v8 ignore next */
+            const snapshotPath = this.options.emit === 'ts' && this.options.pathTs ? this.options.pathTs : this.options.path;
+            const absoluteSnapshotPath = fs.absolutePath(snapshotPath, this.config.get('baseDir'));
+            const dbName = this.config.get('dbName').replace(/\\/g, '/').split('/').pop().replace(/:/g, '');
+            const snapshotName = this.options.snapshotName ?? `.snapshot-${dbName}`;
+            this.snapshotPath = fs.normalizePath(absoluteSnapshotPath, `${snapshotName}.json`);
+        }
+        return this.snapshotPath;
+    }
+    async init() {
+        if (this.initialized) {
             return;
         }
-        const exists = fs.pathExists(`${baseDir}/${defaultPath}`);
-        const distDir = fs.pathExists(baseDir + '/dist');
-        const buildDir = fs.pathExists(baseDir + '/build');
-        // if neither `dist` nor `build` exist, we use the `src` folder as it might be a JS project without building, but with `src` folder
+        await super.init();
+        const created = await this.schemaGenerator.ensureDatabase();
         /* v8 ignore next */
-        const path = distDir ? './dist' : (buildDir ? './build' : './src');
-        // only if the user did not provide any values and if the default path does not exist
-        if (!this.options.path && !this.options.pathTs && !exists) {
-            this.options.path = `${path}/migrations`;
-            this.options.pathTs = './src/migrations';
+        if (created) {
+            this.initServices();
         }
-    }
-    static register(orm) {
-        orm.config.registerExtension('@mikro-orm/migrator', () => new Migrator(orm.em));
+        await this.storage.ensureTable();
     }
     /**
      * @inheritDoc
      */
     async create(path, blank = false, initial = false, name) {
+        await this.init();
         if (initial) {
             return this.createInitial(path, name, blank);
         }
-        this.ensureMigrationsDirExists();
         const diff = await this.getSchemaDiff(blank, initial);
         if (diff.up.length === 0) {
             return { fileName: '', code: '', diff };
@@ -90,7 +73,7 @@ export class Migrator {
         };
     }
     async checkSchema() {
-        this.ensureMigrationsDirExists();
+        await this.init();
         const diff = await this.getSchemaDiff(false, false);
         return diff.up.length > 0;
     }
@@ -98,13 +81,13 @@ export class Migrator {
      * @inheritDoc
      */
     async createInitial(path, name, blank = false) {
-        this.ensureMigrationsDirExists();
+        await this.init();
         const schemaExists = await this.validateInitialMigration(blank);
         const diff = await this.getSchemaDiff(blank, true);
         const migration = await this.generator.generate(diff, path, name);
         await this.storeCurrentSchema();
         if (schemaExists && !blank) {
-            await this.storage.logMigration({ name: migration[1], context: null });
+            await this.storage.logMigration({ name: migration[1] });
         }
         return {
             fileName: migration[1],
@@ -112,57 +95,21 @@ export class Migrator {
             diff,
         };
     }
-    /**
-     * @inheritDoc
-     */
-    on(eventName, listener) {
-        this.umzug.on(eventName, listener);
-        return this;
-    }
-    /**
-     * @inheritDoc
-     */
-    off(eventName, listener) {
-        this.umzug.off(eventName, listener);
-        return this;
-    }
-    createUmzug() {
-        this.runner = new MigrationRunner(this.driver, this.options, this.config);
-        this.storage = new MigrationStorage(this.driver, this.options);
-        let migrations = {
-            glob: join(this.absolutePath, this.options.glob).replace(/\\/g, '/'),
-            resolve: (params) => this.resolve(params),
-        };
-        if (this.options.migrationsList) {
-            migrations = this.options.migrationsList.map(migration => {
-                if (typeof migration === 'function') {
-                    return this.initialize(migration, migration.name);
-                }
-                return this.initialize(migration.class, migration.name);
-            });
-        }
-        this.umzug = new Umzug({
-            storage: this.storage,
-            logger: undefined,
-            migrations,
-        });
-        /* v8 ignore else */
-        if (!this.options.silent) {
-            const logger = this.config.getLogger();
-            this.umzug.on('migrating', event => logger.log('migrator', `Processing '${event.name}'`, { enabled: true }));
-            this.umzug.on('migrated', event => logger.log('migrator', `Applied '${event.name}'`, { enabled: true }));
-            this.umzug.on('reverting', event => logger.log('migrator', `Processing '${event.name}'`, { enabled: true }));
-            this.umzug.on('reverted', event => logger.log('migrator', `Reverted '${event.name}'`, { enabled: true }));
-        }
-        if (this.options.generator) {
-            this.generator = new this.options.generator(this.driver, this.config.getNamingStrategy(), this.options);
-        }
-        else if (this.options.emit === 'js' || this.options.emit === 'cjs') {
-            this.generator = new JSMigrationGenerator(this.driver, this.config.getNamingStrategy(), this.options);
-        }
-        else {
-            this.generator = new TSMigrationGenerator(this.driver, this.config.getNamingStrategy(), this.options);
+    async runMigrations(method, options) {
+        const result = await super.runMigrations(method, options);
+        if (result.length > 0 && this.options.snapshot) {
+            const schema = await DatabaseSchema.create(this.em.getConnection(), this.em.getPlatform(), this.config);
+            try {
+                await this.storeCurrentSchema(schema);
+            }
+            catch {
+                // Silently ignore for read-only filesystems (production).
+            }
         }
+        return result;
+    }
+    getStorage() {
+        return this.storage;
     }
     /**
      * Initial migration can be created only if:
@@ -202,62 +149,16 @@ export class Migrator {
         }
         return expected.size === exists.size;
     }
-    /**
-     * @inheritDoc
-     */
-    async getExecuted() {
-        await this.ensureDatabase();
-        return this.storage.getExecutedMigrations();
-    }
-    async ensureDatabase() {
-        this.ensureMigrationsDirExists();
-        const created = await this.schemaGenerator.ensureDatabase();
-        /* v8 ignore next */
-        if (created) {
-            this.createUmzug();
+    async getSchemaFromSnapshot() {
+        if (!this.options.snapshot) {
+            return undefined;
         }
-        await this.storage.ensureTable();
-    }
-    /**
-     * @inheritDoc
-     */
-    async getPending() {
-        await this.ensureDatabase();
-        return this.umzug.pending();
-    }
-    /**
-     * @inheritDoc
-     */
-    async up(options) {
-        return this.runMigrations('up', options);
-    }
-    /**
-     * @inheritDoc
-     */
-    async down(options) {
-        return this.runMigrations('down', options);
-    }
-    getStorage() {
-        return this.storage;
-    }
-    resolve(params) {
-        const createMigrationHandler = async (method) => {
-            const migration = await fs.dynamicImport(params.path);
-            const MigrationClass = Object.values(migration).find(cls => typeof cls === 'function' && typeof cls.constructor === 'function');
-            const instance = new MigrationClass(this.driver, this.config);
-            await this.runner.run(instance, method);
-        };
-        return {
-            name: this.storage.getMigrationName(params.name),
-            up: () => createMigrationHandler('up'),
-            down: () => createMigrationHandler('down'),
-        };
-    }
-    getSchemaFromSnapshot() {
-        if (!this.options.snapshot || !existsSync(this.snapshotPath)) {
+        const snapshotPath = await this.getSnapshotPath();
+        const { fs } = await import('@mikro-orm/core/fs-utils');
+        if (!fs.pathExists(snapshotPath)) {
             return undefined;
         }
-        const data = fs.readJSONSync(this.snapshotPath);
+        const data = fs.readJSONSync(snapshotPath);
         const schema = new DatabaseSchema(this.driver.getPlatform(), this.config.get('schema'));
         const { tables, namespaces, ...rest } = data;
         const tableInstances = tables.map((tbl) => {
@@ -275,20 +176,14 @@ export class Migrator {
         Object.assign(schema, { tables: tableInstances, namespaces: new Set(namespaces), ...rest });
         return schema;
     }
-    async storeCurrentSchema() {
+    async storeCurrentSchema(schema) {
         if (!this.options.snapshot) {
             return;
         }
-        const schema = this.schemaGenerator.getTargetSchema();
-        writeFileSync(this.snapshotPath, JSON.stringify(schema, null, 2));
-    }
-    initialize(MigrationClass, name) {
-        const instance = new MigrationClass(this.driver, this.config);
-        return {
-            name: this.storage.getMigrationName(name),
-            up: () => this.runner.run(instance, 'up'),
-            down: () => this.runner.run(instance, 'down'),
-        };
+        const snapshotPath = await this.getSnapshotPath();
+        schema ??= this.schemaGenerator.getTargetSchema();
+        const { fs } = await import('@mikro-orm/core/fs-utils');
+        await fs.writeFile(snapshotPath, JSON.stringify(schema, null, 2));
     }
     async getSchemaDiff(blank, initial) {
         const up = [];
@@ -331,7 +226,7 @@ export class Migrator {
                 wrap: false,
                 safe: this.options.safe,
                 dropTables: this.options.dropTables,
-                fromSchema: this.getSchemaFromSnapshot(),
+                fromSchema: await this.getSchemaFromSnapshot(),
             });
             up.push(...splitStatements(diff.up));
             down.push(...splitStatements(diff.down));
@@ -341,6 +236,7 @@ export class Migrator {
                 if (diff[i]) {
                     break;
                 }
+                /* v8 ignore next */
                 diff.splice(i, 1);
             }
         };
@@ -348,47 +244,4 @@ export class Migrator {
         cleanUp(down);
         return { up, down };
     }
-    getMigrationFilename(name) {
-        name = name.replace(/\.[jt]s$/, '');
-        return name.match(/^\d{14}$/) ? this.options.fileName(name) : name;
-    }
-    prefix(options) {
-        if (typeof options === 'string' || Array.isArray(options)) {
-            return { migrations: Utils.asArray(options).map(name => this.getMigrationFilename(name)) };
-        }
-        if (!options) {
-            return {};
-        }
-        if (options.migrations) {
-            options.migrations = options.migrations.map(name => this.getMigrationFilename(name));
-        }
-        if (options.transaction) {
-            delete options.transaction;
-        }
-        ['from', 'to'].filter(k => options[k]).forEach(k => options[k] = this.getMigrationFilename(options[k]));
-        return options;
-    }
-    async runMigrations(method, options) {
-        await this.ensureDatabase();
-        if (!this.options.transactional || !this.options.allOrNothing) {
-            return this.umzug[method](this.prefix(options));
-        }
-        if (Utils.isObject(options) && options.transaction) {
-            return this.runInTransaction(options.transaction, method, options);
-        }
-        return this.driver.getConnection().transactional(trx => this.runInTransaction(trx, method, options));
-    }
-    async runInTransaction(trx, method, options) {
-        this.runner.setMasterMigration(trx);
-        this.storage.setMasterMigration(trx);
-        const ret = await this.umzug[method](this.prefix(options));
-        this.runner.unsetMasterMigration();
-        this.storage.unsetMasterMigration();
-        return ret;
-    }
-    ensureMigrationsDirExists() {
-        if (!this.options.migrationsList) {
-            fs.ensureDir(this.absolutePath);
-        }
-    }
 }

package/TSMigrationGenerator.js

@@ -7,11 +7,11 @@ export class TSMigrationGenerator extends MigrationGenerator {
         let ret = `import { Migration } from '@mikro-orm/migrations';\n\n`;
         ret += `export class ${className} extends Migration {\n\n`;
         ret += `  override async up(): Promise<void> {\n`;
-        diff.up.forEach(sql => ret += this.createStatement(sql, 4));
+        diff.up.forEach(sql => (ret += this.createStatement(sql, 4)));
         ret += `  }\n\n`;
         if (diff.down.length > 0) {
             ret += `  override async down(): Promise<void> {\n`;
-            diff.down.forEach(sql => ret += this.createStatement(sql, 4));
+            diff.down.forEach(sql => (ret += this.createStatement(sql, 4)));
             ret += `  }\n\n`;
         }
         ret += `}\n`;