@mikro-orm/migrations 7.0.0-dev.33 → 7.0.0-dev.330

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 5 */
+        /* 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/Migration.d.ts

@@ -1,12 +1,11 @@
-import { type Configuration, type RawQueryFragment, type Transaction } from '@mikro-orm/core';
-import type { AbstractSqlDriver, EntityManager, NativeQueryBuilder } from '@mikro-orm/knex';
+import { type AnyEntity, type Configuration, type EntityData, type RawQueryFragment, type Transaction } from '@mikro-orm/core';
+import type { AbstractSqlDriver, EntityManager, NativeQueryBuilder } from '@mikro-orm/sql';
 export type Query = string | NativeQueryBuilder | RawQueryFragment;
 export declare abstract class Migration {
+    #private;
     protected readonly driver: AbstractSqlDriver;
     protected readonly config: Configuration;
-    private readonly queries;
     protected ctx?: Transaction;
-    private em?;
     constructor(driver: AbstractSqlDriver, config: Configuration);
     abstract up(): Promise<void> | void;
     down(): Promise<void> | void;
@@ -18,7 +17,7 @@ export declare abstract class Migration {
      * Executes a raw SQL query. Accepts a string SQL, `raw()` SQL fragment, or a native query builder instance.
      * The `params` parameter is respected only if you use string SQL in the first parameter.
      */
-    execute(sql: Query, params?: unknown[]): Promise<import("@mikro-orm/core").EntityData<Partial<any>>[]>;
+    execute(sql: Query, params?: unknown[]): Promise<EntityData<AnyEntity>[]>;
     /**
      * Creates a cached `EntityManager` instance for this migration, which will respect
      * the current transaction context.

package/Migration.js

@@ -1,9 +1,9 @@
 export class Migration {
     driver;
     config;
-    queries = [];
+    #queries = [];
     ctx;
-    em;
+    #em;
     constructor(driver, config) {
         this.driver = driver;
         this.config = config;
@@ -15,10 +15,10 @@ export class Migration {
         return true;
     }
     addSql(sql) {
-        this.queries.push(sql);
+        this.#queries.push(sql);
     }
     reset() {
-        this.queries.length = 0;
+        this.#queries.length = 0;
         this.ctx = undefined;
     }
     setTransactionContext(ctx) {
@@ -36,13 +36,13 @@ export class Migration {
      * the current transaction context.
      */
     getEntityManager() {
-        if (!this.em) {
-            this.em = this.driver.createEntityManager();
-            this.em.setTransactionContext(this.ctx);
+        if (!this.#em) {
+            this.#em = this.driver.createEntityManager();
+            this.#em.setTransactionContext(this.ctx);
         }
-        return this.em;
+        return this.#em;
     }
     getQueries() {
-        return this.queries;
+        return this.#queries;
     }
 }

package/MigrationGenerator.d.ts

@@ -1,5 +1,5 @@
 import { type IMigrationGenerator, type MaybePromise, type MigrationsOptions, type NamingStrategy } from '@mikro-orm/core';
-import type { AbstractSqlDriver } from '@mikro-orm/knex';
+import type { AbstractSqlDriver } from '@mikro-orm/sql';
 export declare abstract class MigrationGenerator implements IMigrationGenerator {
     protected readonly driver: AbstractSqlDriver;
     protected readonly namingStrategy: NamingStrategy;

package/MigrationGenerator.js

@@ -1,5 +1,3 @@
-import { Utils, } from '@mikro-orm/core';
-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 = Utils.normalizePath(this.driver.config.get('baseDir'), path ?? defaultPath);
-        Utils.ensureDir(path);
-        const timestamp = new Date().toISOString().replace(/[-T:]|\.\d{3}z$/ig, '');
+        path = fs.normalizePath(this.driver.config.get('baseDir'), path ?? defaultPath);
+        fs.ensureDir(path);
+        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/MigrationRunner.d.ts

@@ -1,13 +1,11 @@
 import { type Configuration, type MigrationsOptions, type Transaction } from '@mikro-orm/core';
-import type { AbstractSqlDriver } from '@mikro-orm/knex';
+import type { AbstractSqlDriver } from '@mikro-orm/sql';
 import type { Migration } from './Migration.js';
 export declare class MigrationRunner {
+    #private;
     protected readonly driver: AbstractSqlDriver;
     protected readonly options: MigrationsOptions;
     protected readonly config: Configuration;
-    private readonly connection;
-    private readonly helper;
-    private masterTransaction?;
     constructor(driver: AbstractSqlDriver, options: MigrationsOptions, config: Configuration);
     run(migration: Migration, method: 'up' | 'down'): Promise<void>;
     setMasterMigration(trx: Transaction): void;

package/MigrationRunner.js

@@ -3,15 +3,15 @@ export class MigrationRunner {
     driver;
     options;
     config;
-    connection;
-    helper;
-    masterTransaction;
+    #connection;
+    #helper;
+    #masterTransaction;
     constructor(driver, options, config) {
         this.driver = driver;
         this.options = options;
         this.config = config;
-        this.connection = this.driver.getConnection();
-        this.helper = this.driver.getPlatform().getSchemaHelper();
+        this.#connection = this.driver.getConnection();
+        this.#helper = this.driver.getPlatform().getSchemaHelper();
     }
     async run(migration, method) {
         migration.reset();
@@ -20,26 +20,26 @@ export class MigrationRunner {
             await Utils.runSerial(queries, sql => this.driver.execute(sql));
         }
         else {
-            await this.connection.transactional(async (tx) => {
+            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));
-            }, { ctx: this.masterTransaction });
+            }, { ctx: this.#masterTransaction });
         }
     }
     setMasterMigration(trx) {
-        this.masterTransaction = trx;
+        this.#masterTransaction = trx;
     }
     unsetMasterMigration() {
-        delete this.masterTransaction;
+        this.#masterTransaction = 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'));
-        queries.push(...this.helper.getSchemaEnd(this.options.disableForeignKeys).split('\n'));
-        queries = queries.filter(sql => !Utils.isString(sql) || sql.trim().length > 0);
+        queries.unshift(...this.#helper.getSchemaBeginning(charset, this.options.disableForeignKeys).split('\n'));
+        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

@@ -1,18 +1,18 @@
-import type { MigrationsOptions, Transaction } from '@mikro-orm/core';
-import { type AbstractSqlDriver } from '@mikro-orm/knex';
-import type { MigrationParams, UmzugStorage } from 'umzug';
+import { type MigrationsOptions, type Transaction, type EntitySchema } from '@mikro-orm/core';
+import { type AbstractSqlDriver } from '@mikro-orm/sql';
 import type { MigrationRow } from './typings.js';
-export declare class MigrationStorage implements UmzugStorage {
+export declare class MigrationStorage {
+    #private;
     protected readonly driver: AbstractSqlDriver;
     protected readonly options: MigrationsOptions;
-    private readonly connection;
-    private readonly helper;
-    private masterTransaction?;
-    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;
@@ -27,5 +27,6 @@ export declare class MigrationStorage implements UmzugStorage {
     getTableName(): {
         tableName: string;
         schemaName: string;
+        entity: EntitySchema;
     };
 }

package/MigrationStorage.js

@@ -1,98 +1,94 @@
-import { DatabaseTable, } from '@mikro-orm/knex';
-import * as path from 'node:path';
+import { defineEntity, p } from '@mikro-orm/core';
+import { DatabaseTable, } from '@mikro-orm/sql';
 export class MigrationStorage {
     driver;
     options;
-    connection;
-    helper;
-    masterTransaction;
-    platform;
+    #connection;
+    #helper;
+    #masterTransaction;
+    #platform;
     constructor(driver, options) {
         this.driver = driver;
         this.options = options;
-        this.connection = this.driver.getConnection();
-        this.platform = this.driver.getPlatform();
-        this.helper = this.platform.getSchemaHelper();
+        this.#connection = this.driver.getConnection();
+        this.#platform = this.driver.getPlatform();
+        this.#helper = this.#platform.getSchemaHelper();
     }
     async executed() {
         const migrations = await this.getExecutedMigrations();
-        return migrations.map(({ name }) => `${this.getMigrationName(name)}`);
+        return migrations.map(({ name }) => this.getMigrationName(name));
     }
     async logMigration(params) {
-        const { tableName, schemaName } = this.getTableName();
+        const { entity } = this.getTableName();
         const name = this.getMigrationName(params.name);
-        await this.driver.nativeInsert(tableName, { name }, { schema: schemaName, ctx: this.masterTransaction });
+        await this.driver.nativeInsert(entity, { name }, { ctx: this.#masterTransaction });
     }
     async unlogMigration(params) {
-        const { tableName, schemaName } = this.getTableName();
+        const { entity } = this.getTableName();
         const withoutExt = this.getMigrationName(params.name);
         const names = [withoutExt, withoutExt + '.js', withoutExt + '.ts'];
-        await this.driver.nativeDelete(tableName, { name: { $in: [params.name, ...names] } }, { schema: schemaName, ctx: this.masterTransaction });
+        await this.driver.nativeDelete(entity, { name: { $in: [params.name, ...names] } }, { ctx: this.#masterTransaction });
     }
     async getExecutedMigrations() {
-        const { tableName, schemaName } = this.getTableName();
-        const res = await this.driver.createQueryBuilder(tableName, this.masterTransaction)
+        const { entity, schemaName } = this.getTableName();
+        const res = await this.driver
+            .createQueryBuilder(entity, this.#masterTransaction)
             .withSchema(schemaName)
             .orderBy({ id: 'asc' })
-            .execute();
+            .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;
         });
     }
     async ensureTable() {
-        const tables = await this.connection.execute(this.helper.getListTablesSQL(), [], 'all', this.masterTransaction);
+        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))) {
             return;
         }
-        const schemas = await this.helper.getNamespaces(this.connection);
+        const schemas = await this.#helper.getNamespaces(this.#connection);
         if (schemaName && !schemas.includes(schemaName)) {
-            const sql = this.helper.getCreateNamespaceSQL(schemaName);
-            await this.connection.execute(sql);
+            const sql = this.#helper.getCreateNamespaceSQL(schemaName);
+            await this.#connection.execute(sql);
         }
-        const table = new DatabaseTable(this.platform, tableName, schemaName);
+        const table = new DatabaseTable(this.#platform, tableName, schemaName);
         table.addColumn({
             name: 'id',
-            type: this.platform.getIntegerTypeDeclarationSQL({ autoincrement: true, unsigned: true }),
-            mappedType: this.platform.getMappedType('number'),
+            type: this.#platform.getIntegerTypeDeclarationSQL({ autoincrement: true, unsigned: true }),
+            mappedType: this.#platform.getMappedType('number'),
             primary: true,
             autoincrement: true,
         });
         table.addColumn({
             name: 'name',
-            type: this.platform.getVarcharTypeDeclarationSQL({}),
-            mappedType: this.platform.getMappedType('string'),
+            type: this.#platform.getVarcharTypeDeclarationSQL({}),
+            mappedType: this.#platform.getMappedType('string'),
         });
-        const length = this.platform.getDefaultDateTimeLength();
+        const length = this.#platform.getDefaultDateTimeLength();
         table.addColumn({
             name: 'executed_at',
-            type: this.platform.getDateTimeTypeDeclarationSQL({ length }),
-            mappedType: this.platform.getMappedType('datetime'),
-            default: this.platform.getCurrentTimestampSQL(length),
+            type: this.#platform.getDateTimeTypeDeclarationSQL({ length }),
+            mappedType: this.#platform.getMappedType('datetime'),
+            default: this.#platform.getCurrentTimestampSQL(length),
             length,
         });
-        const sql = this.helper.createTable(table);
-        await this.connection.execute(sql.join(';\n'), [], 'run', this.masterTransaction);
+        const sql = this.#helper.createTable(table);
+        await this.#connection.execute(sql.join(';\n'), [], 'run', this.#masterTransaction);
     }
     setMasterMigration(trx) {
-        this.masterTransaction = trx;
+        this.#masterTransaction = trx;
     }
     unsetMasterMigration() {
-        delete this.masterTransaction;
+        this.#masterTransaction = undefined;
     }
     /**
      * @internal
      */
     getMigrationName(name) {
-        const parsedName = path.parse(name);
-        if (['.js', '.ts'].includes(parsedName.ext)) {
-            // strip extension
-            return parsedName.name;
-        }
-        return name;
+        return name.replace(/\.[jt]s$/, '');
     }
     /**
      * @internal
@@ -101,6 +97,17 @@ export class MigrationStorage {
         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());
-        return { tableName, schemaName };
+        const entity = defineEntity({
+            name: 'Migration',
+            tableName,
+            schema: schemaName,
+            properties: {
+                id: p.integer().primary().fieldNames('id'),
+                name: p.string().fieldNames('name'),
+                executedAt: p.datetime().defaultRaw('current_timestamp').fieldNames('executed_at'),
+            },
+        }).init();
+        entity.meta.sync();
+        return { tableName, schemaName, entity };
     }
 }

package/Migrator.d.ts

@@ -1,41 +1,28 @@
-import { type MigrationParams, type RunnableMigration } from 'umzug';
-import { type Constructor, type IMigrator, type MikroORM, type MigratorEvent, type MaybePromise } from '@mikro-orm/core';
-import { DatabaseSchema, type EntityManager } from '@mikro-orm/knex';
-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;
-    private readonly schemaGenerator;
-    private readonly config;
-    private readonly options;
-    private readonly absolutePath;
-    private readonly snapshotPath;
+import type { MigrationResult } from './typings.js';
+export declare class Migrator extends AbstractMigrator<AbstractSqlDriver> {
+    #private;
     constructor(em: EntityManager);
     static register(orm: MikroORM): void;
+    protected createRunner(): IMigrationRunner;
+    protected createStorage(): IMigratorStorage;
+    protected getDefaultGenerator(): IMigrationGenerator;
+    private getSnapshotPath;
+    protected init(): Promise<void>;
     /**
      * @inheritDoc
      */
-    createMigration(path?: string, blank?: boolean, initial?: boolean, name?: string): Promise<MigrationResult>;
-    checkMigrationNeeded(): Promise<boolean>;
+    create(path?: string, blank?: boolean, initial?: boolean, name?: string): Promise<MigrationResult>;
+    checkSchema(): Promise<boolean>;
     /**
      * @inheritDoc
      */
-    createInitialMigration(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;
+    createInitial(path?: string, name?: string, blank?: boolean): Promise<MigrationResult>;
+    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
@@ -45,32 +32,7 @@ export declare class Migrator implements IMigrator {
      * If only some of the tables are present, exception is thrown.
      */
     private validateInitialMigration;
-    /**
-     * @inheritDoc
-     */
-    getExecutedMigrations(): Promise<MigrationRow[]>;
-    private ensureDatabase;
-    /**
-     * @inheritDoc
-     */
-    getPendingMigrations(): 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,53 +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 { DatabaseSchema, DatabaseTable, SqlSchemaGenerator, } from '@mikro-orm/knex';
+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;
-    schemaGenerator;
-    config;
-    options;
-    absolutePath;
-    snapshotPath;
+export class Migrator extends AbstractMigrator {
+    #schemaGenerator;
+    #snapshotPath;
     constructor(em) {
-        this.em = em;
-        this.driver = this.em.getDriver();
-        this.schemaGenerator = new SqlSchemaGenerator(this.em);
-        this.config = this.em.config;
-        this.options = this.config.get('migrations');
-        /* v8 ignore next */
-        const key = (this.config.get('preferTs', Utils.detectTypeScriptSupport()) && this.options.pathTs) ? 'pathTs' : 'path';
-        this.absolutePath = Utils.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 = Utils.absolutePath(snapshotPath, this.config.get('baseDir'));
-        const dbName = basename(this.config.get('dbName'));
-        const snapshotName = this.options.snapshotName ?? `.snapshot-${dbName}`;
-        this.snapshotPath = Utils.normalizePath(absoluteSnapshotPath, `${snapshotName}.json`);
-        this.createUmzug();
+        super(em);
+        this.#schemaGenerator = this.config.getExtension('@mikro-orm/schema-generator');
     }
     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;
+        }
+        await super.init();
+        const created = await this.#schemaGenerator.ensureDatabase();
+        /* v8 ignore next */
+        if (created) {
+            this.initServices();
+        }
+        await this.storage.ensureTable();
+    }
     /**
      * @inheritDoc
      */
-    async createMigration(path, blank = false, initial = false, name) {
+    async create(path, blank = false, initial = false, name) {
+        await this.init();
         if (initial) {
-            return this.createInitialMigration(path, name, blank);
+            return this.createInitial(path, name, blank);
         }
-        this.ensureMigrationsDirExists();
         const diff = await this.getSchemaDiff(blank, initial);
         if (diff.up.length === 0) {
             return { fileName: '', code: '', diff };
@@ -60,22 +72,22 @@ export class Migrator {
             diff,
         };
     }
-    async checkMigrationNeeded() {
-        this.ensureMigrationsDirExists();
+    async checkSchema() {
+        await this.init();
         const diff = await this.getSchemaDiff(false, false);
         return diff.up.length > 0;
     }
     /**
      * @inheritDoc
      */
-    async createInitialMigration(path, name, blank = false) {
-        this.ensureMigrationsDirExists();
+    async createInitial(path, name, blank = false) {
+        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],
@@ -83,56 +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,
-        });
-        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:
@@ -143,15 +120,15 @@ export class Migrator {
      * If only some of the tables are present, exception is thrown.
      */
     async validateInitialMigration(blank) {
-        const executed = await this.getExecutedMigrations();
-        const pending = await this.getPendingMigrations();
+        const executed = await this.getExecuted();
+        const pending = await this.getPending();
         if (executed.length > 0 || pending.length > 0) {
             throw new Error('Initial migration cannot be created, as some migrations already exist');
         }
         const schema = await DatabaseSchema.create(this.em.getConnection(), this.em.getPlatform(), this.config);
         const exists = new Set();
         const expected = new Set();
-        Object.values(this.em.getMetadata().getAll())
+        [...this.em.getMetadata().getAll().values()]
             .filter(meta => meta.tableName && !meta.embeddable && !meta.virtual)
             .forEach(meta => {
             const schema = meta.schema ?? this.config.get('schema', this.em.getPlatform().getDefaultSchemaName());
@@ -172,120 +149,111 @@ export class Migrator {
         }
         return expected.size === exists.size;
     }
-    /**
-     * @inheritDoc
-     */
-    async getExecutedMigrations() {
-        await this.ensureDatabase();
-        return this.storage.getExecutedMigrations();
-    }
-    async ensureDatabase() {
-        this.ensureMigrationsDirExists();
-        const created = await this.schemaGenerator.ensureDatabase();
-        /* v8 ignore next 3 */
-        if (created) {
-            this.createUmzug();
+    async getSchemaFromSnapshot() {
+        if (!this.options.snapshot) {
+            return undefined;
         }
-        await this.storage.ensureTable();
-    }
-    /**
-     * @inheritDoc
-     */
-    async getPendingMigrations() {
-        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 Utils.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 = Utils.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) => {
-            const table = new DatabaseTable(this.driver.getPlatform(), tbl.name);
-            const { columns, ...restTable } = tbl;
-            Object.assign(table, restTable);
-            Object.keys(columns).forEach(col => {
-                const column = { ...columns[col] };
+            const table = new DatabaseTable(this.driver.getPlatform(), tbl.name, tbl.schema);
+            table.nativeEnums = tbl.nativeEnums ?? {};
+            table.comment = tbl.comment;
+            if (tbl.indexes) {
+                table.setIndexes(tbl.indexes);
+            }
+            if (tbl.checks) {
+                table.setChecks(tbl.checks);
+            }
+            if (tbl.foreignKeys) {
+                table.setForeignKeys(tbl.foreignKeys);
+            }
+            const cols = tbl.columns;
+            Object.keys(cols).forEach(col => {
+                const column = { ...cols[col] };
                 /* v8 ignore next */
-                column.mappedType = Type.getType(t[columns[col].mappedType] ?? UnknownType);
+                column.mappedType = Type.getType(t[cols[col].mappedType] ?? UnknownType);
                 table.addColumn(column);
             });
             return table;
         });
-        Object.assign(schema, { tables: tableInstances, namespaces: new Set(namespaces), ...rest });
+        schema.setTables(tableInstances);
+        schema.setNamespaces(new Set(namespaces));
+        if (rest.nativeEnums) {
+            schema.setNativeEnums(rest.nativeEnums);
+        }
+        if (rest.views) {
+            schema.setViews(rest.views);
+        }
         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 = [];
         const down = [];
+        // Split SQL by statement boundaries (semicolons followed by newline) rather than
+        // just newlines, to preserve multiline statements like view definitions.
+        // Blank lines (from double newlines) are preserved as empty strings for grouping.
+        // Splits inside single-quoted string literals are re-merged (GH #7185).
+        const splitStatements = (sql) => {
+            const result = [];
+            let buf = '';
+            for (const chunk of sql.split(/;\n/)) {
+                buf += (buf ? ';\n' : '') + chunk;
+                // odd number of single quotes means we're inside a string literal
+                if (buf.split(`'`).length % 2 === 0) {
+                    continue;
+                }
+                // A chunk starting with \n indicates there was a blank line (grouping separator)
+                if (buf.startsWith('\n')) {
+                    result.push('');
+                }
+                const trimmed = buf.trim();
+                if (trimmed) {
+                    result.push(trimmed.endsWith(';') ? trimmed : trimmed + ';');
+                }
+                buf = '';
+            }
+            return result;
+        };
         if (blank) {
             up.push('select 1');
             down.push('select 1');
         }
         else if (initial) {
-            const dump = await this.schemaGenerator.getCreateSchemaSQL({ wrap: false });
-            up.push(...dump.split('\n'));
+            const dump = await this.#schemaGenerator.getCreateSchemaSQL({ wrap: false });
+            up.push(...splitStatements(dump));
         }
         else {
-            const diff = await this.schemaGenerator.getUpdateSchemaMigrationSQL({
+            const diff = await this.#schemaGenerator.getUpdateSchemaMigrationSQL({
                 wrap: false,
                 safe: this.options.safe,
                 dropTables: this.options.dropTables,
-                fromSchema: this.getSchemaFromSnapshot(),
+                fromSchema: await this.getSchemaFromSnapshot(),
             });
-            up.push(...diff.up.split('\n'));
-            down.push(...diff.down.split('\n'));
+            up.push(...splitStatements(diff.up));
+            down.push(...splitStatements(diff.down));
         }
         const cleanUp = (diff) => {
             for (let i = diff.length - 1; i >= 0; i--) {
                 if (diff[i]) {
                     break;
                 }
+                /* v8 ignore next */
                 diff.splice(i, 1);
             }
         };
@@ -293,47 +261,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 (Utils.isString(options) || 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) {
-            Utils.ensureDir(this.absolutePath);
-        }
-    }
 }

package/README.md

@@ -2,14 +2,14 @@
   <a href="https://mikro-orm.io"><img src="https://raw.githubusercontent.com/mikro-orm/mikro-orm/master/docs/static/img/logo-readme.svg?sanitize=true" alt="MikroORM" /></a>
 </h1>
 
-TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL and SQLite (including libSQL) databases. 
+TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL, SQLite (including libSQL), MSSQL and Oracle databases. 
 
 > Heavily inspired by [Doctrine](https://www.doctrine-project.org/) and [Hibernate](https://hibernate.org/).
 
-[![NPM version](https://img.shields.io/npm/v/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
-[![NPM dev version](https://img.shields.io/npm/v/@mikro-orm/core/next.svg)](https://www.npmjs.com/package/@mikro-orm/core)
+[![NPM version](https://img.shields.io/npm/v/@mikro-orm/core.svg)](https://npmx.dev/package/@mikro-orm/core)
+[![NPM dev version](https://img.shields.io/npm/v/@mikro-orm/core/next.svg)](https://npmx.dev/package/@mikro-orm/core)
 [![Chat on discord](https://img.shields.io/discord/1214904142443839538?label=discord&color=blue)](https://discord.gg/w8bjxFHS7X)
-[![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
+[![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://npmx.dev/package/@mikro-orm/core)
 [![Coverage Status](https://img.shields.io/coveralls/mikro-orm/mikro-orm.svg)](https://coveralls.io/r/mikro-orm/mikro-orm?branch=master)
 [![Build Status](https://github.com/mikro-orm/mikro-orm/workflows/tests/badge.svg?branch=master)](https://github.com/mikro-orm/mikro-orm/actions?workflow=tests)
 
@@ -181,6 +181,7 @@ yarn add @mikro-orm/core @mikro-orm/mysql         # for mysql/mariadb
 yarn add @mikro-orm/core @mikro-orm/mariadb       # for mysql/mariadb
 yarn add @mikro-orm/core @mikro-orm/postgresql    # for postgresql
 yarn add @mikro-orm/core @mikro-orm/mssql         # for mssql
+yarn add @mikro-orm/core @mikro-orm/oracledb      # for oracle
 yarn add @mikro-orm/core @mikro-orm/sqlite        # for sqlite
 yarn add @mikro-orm/core @mikro-orm/libsql        # for libsql
 ```
@@ -381,6 +382,8 @@ See also the list of contributors who [participated](https://github.com/mikro-or
 
 Please ⭐️ this repository if this project helped you!
 
+> If you'd like to support my open-source work, consider sponsoring me directly at [github.com/sponsors/b4nan](https://github.com/sponsors/b4nan).
+
 ## 📝 License
 
 Copyright © 2018 [Martin Adámek](https://github.com/b4nan).

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`;

package/index.d.ts

@@ -9,4 +9,4 @@ export * from './MigrationGenerator.js';
 export * from './JSMigrationGenerator.js';
 export * from './TSMigrationGenerator.js';
 export * from './MigrationStorage.js';
-export * from './typings.js';
+export type * from './typings.js';

package/index.js

@@ -9,4 +9,3 @@ export * from './MigrationGenerator.js';
 export * from './JSMigrationGenerator.js';
 export * from './TSMigrationGenerator.js';
 export * from './MigrationStorage.js';
-export * from './typings.js';

package/package.json

@@ -1,62 +1,61 @@
 {
   "name": "@mikro-orm/migrations",
-  "type": "module",
-  "version": "7.0.0-dev.33",
+  "version": "7.0.0-dev.330",
   "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.",
-  "exports": {
-    "./package.json": "./package.json",
-    ".": "./index.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
-  },
   "keywords": [
-    "orm",
+    "data-mapper",
+    "ddd",
+    "entity",
+    "identity-map",
+    "javascript",
+    "js",
+    "mariadb",
+    "mikro-orm",
     "mongo",
     "mongodb",
     "mysql",
-    "mariadb",
+    "orm",
     "postgresql",
     "sqlite",
     "sqlite3",
     "ts",
     "typescript",
-    "js",
-    "javascript",
-    "entity",
-    "ddd",
-    "mikro-orm",
-    "unit-of-work",
-    "data-mapper",
-    "identity-map"
+    "unit-of-work"
   ],
-  "author": "Martin Adámek",
-  "license": "MIT",
+  "homepage": "https://mikro-orm.io",
   "bugs": {
     "url": "https://github.com/mikro-orm/mikro-orm/issues"
   },
-  "homepage": "https://mikro-orm.io",
-  "engines": {
-    "node": ">= 22.11.0"
+  "license": "MIT",
+  "author": "Martin Adámek",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
+  },
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./index.js"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
-    "build": "yarn clean && yarn compile && yarn copy",
+    "build": "yarn compile && yarn copy",
     "clean": "yarn run -T rimraf ./dist",
     "compile": "yarn run -T tsc -p tsconfig.build.json",
     "copy": "node ../../scripts/copy.mjs"
   },
-  "publishConfig": {
-    "access": "public"
-  },
   "dependencies": {
-    "@mikro-orm/knex": "7.0.0-dev.33",
-    "umzug": "3.8.2"
+    "@mikro-orm/sql": "7.0.0-dev.330"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.5.7"
+    "@mikro-orm/core": "^6.6.9"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.33"
+    "@mikro-orm/core": "7.0.0-dev.330"
+  },
+  "engines": {
+    "node": ">= 22.17.0"
   }
 }

package/typings.d.ts

@@ -1 +1 @@
-export { UmzugMigration, MigrateOptions, MigrationResult, MigrationRow } from '@mikro-orm/core';
+export type { MigrationInfo, MigrateOptions, MigrationResult, MigrationRow } from '@mikro-orm/core';