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

package/Migration.d.ts

@@ -2,11 +2,10 @@ import { type Configuration, type RawQueryFragment, type Transaction } from '@mi
 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;

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/MigrationRunner.d.ts

@@ -2,12 +2,10 @@ import { type Configuration, type MigrationsOptions, type Transaction } from '@m
 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,25 +20,25 @@ 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.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

@@ -2,12 +2,9 @@ import { type MigrationsOptions, type Transaction, type EntitySchema } from '@mi
 import { type AbstractSqlDriver } from '@mikro-orm/sql';
 import type { MigrationRow } from './typings.js';
 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: {

package/MigrationStorage.js

@@ -3,16 +3,16 @@ 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();
@@ -21,18 +21,18 @@ export class MigrationStorage {
     async logMigration(params) {
         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: this.#masterTransaction });
     }
     async unlogMigration(params) {
         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: this.#masterTransaction });
     }
     async getExecutedMigrations() {
         const { entity, schemaName } = this.getTableName();
         const res = await this.driver
-            .createQueryBuilder(entity, this.masterTransaction)
+            .createQueryBuilder(entity, this.#masterTransaction)
             .withSchema(schemaName)
             .orderBy({ id: 'asc' })
             .execute('all', false);
@@ -44,45 +44,45 @@ export class MigrationStorage {
         });
     }
     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

package/Migrator.d.ts

@@ -4,8 +4,7 @@ import { type AbstractSqlDriver, DatabaseSchema, type EntityManager } from '@mik
 import { MigrationStorage } from './MigrationStorage.js';
 import type { MigrationResult } from './typings.js';
 export declare class Migrator extends AbstractMigrator<AbstractSqlDriver> {
-    private readonly schemaGenerator;
-    private snapshotPath?;
+    #private;
     constructor(em: EntityManager);
     static register(orm: MikroORM): void;
     protected createRunner(): IMigrationRunner;

package/Migrator.js

@@ -6,11 +6,11 @@ import { MigrationStorage } from './MigrationStorage.js';
 import { TSMigrationGenerator } from './TSMigrationGenerator.js';
 import { JSMigrationGenerator } from './JSMigrationGenerator.js';
 export class Migrator extends AbstractMigrator {
-    schemaGenerator;
-    snapshotPath;
+    #schemaGenerator;
+    #snapshotPath;
     constructor(em) {
         super(em);
-        this.schemaGenerator = this.config.getExtension('@mikro-orm/schema-generator');
+        this.#schemaGenerator = this.config.getExtension('@mikro-orm/schema-generator');
     }
     static register(orm) {
         orm.config.registerExtension('@mikro-orm/migrator', () => new Migrator(orm.em));
@@ -28,7 +28,7 @@ export class Migrator extends AbstractMigrator {
         return new TSMigrationGenerator(this.driver, this.config.getNamingStrategy(), this.options);
     }
     async getSnapshotPath() {
-        if (!this.snapshotPath) {
+        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 */
@@ -36,16 +36,16 @@ export class Migrator extends AbstractMigrator {
             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`);
+            this.#snapshotPath = fs.normalizePath(absoluteSnapshotPath, `${snapshotName}.json`);
         }
-        return this.snapshotPath;
+        return this.#snapshotPath;
     }
     async init() {
         if (this.initialized) {
             return;
         }
         await super.init();
-        const created = await this.schemaGenerator.ensureDatabase();
+        const created = await this.#schemaGenerator.ensureDatabase();
         /* v8 ignore next */
         if (created) {
             this.initServices();
@@ -162,18 +162,35 @@ export class Migrator extends AbstractMigrator {
         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(schema) {
@@ -181,7 +198,7 @@ export class Migrator extends AbstractMigrator {
             return;
         }
         const snapshotPath = await this.getSnapshotPath();
-        schema ??= this.schemaGenerator.getTargetSchema();
+        schema ??= this.#schemaGenerator.getTargetSchema();
         const { fs } = await import('@mikro-orm/core/fs-utils');
         await fs.writeFile(snapshotPath, JSON.stringify(schema, null, 2));
     }
@@ -218,11 +235,11 @@ 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 });
             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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/migrations",
-  "version": "7.0.0-dev.321",
+  "version": "7.0.0-dev.323",
   "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.0.0-dev.321"
+    "@mikro-orm/sql": "7.0.0-dev.323"
   },
   "devDependencies": {
     "@mikro-orm/core": "^6.6.9"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.321"
+    "@mikro-orm/core": "7.0.0-dev.323"
   },
   "engines": {
     "node": ">= 22.17.0"