@mikro-orm/migrations 7.0.0-dev.32 → 7.0.0-dev.321

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,5 +1,5 @@
 import { type Configuration, type RawQueryFragment, type Transaction } from '@mikro-orm/core';
-import type { AbstractSqlDriver, EntityManager, NativeQueryBuilder } from '@mikro-orm/knex';
+import type { AbstractSqlDriver, EntityManager, NativeQueryBuilder } from '@mikro-orm/sql';
 export type Query = string | NativeQueryBuilder | RawQueryFragment;
 export declare abstract class Migration {
     protected readonly driver: AbstractSqlDriver;

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,5 +1,5 @@
 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 {
     protected readonly driver: AbstractSqlDriver;

package/MigrationRunner.js

@@ -39,7 +39,7 @@ export class MigrationRunner {
         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 = queries.filter(sql => typeof sql !== 'string' || sql.trim().length > 0);
         return queries;
     }
 }

package/MigrationStorage.d.ts

@@ -1,8 +1,7 @@
-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 {
     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;
@@ -27,5 +30,6 @@ export declare class MigrationStorage implements UmzugStorage {
     getTableName(): {
         tableName: string;
         schemaName: string;
+        entity: EntitySchema;
     };
 }

package/MigrationStorage.js

@@ -1,5 +1,5 @@
-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;
@@ -16,27 +16,28 @@ export class MigrationStorage {
     }
     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;
@@ -87,12 +88,7 @@ export class MigrationStorage {
      * @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,29 @@
-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;
+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);
     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 +33,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;
 }