@mikro-orm/migrations 7.0.4 → 7.0.5-dev.0

package/Migrator.js

@@ -1,264 +1,265 @@
-import { t, Type, UnknownType } from '@mikro-orm/core';
+import { t, Type, UnknownType, } from '@mikro-orm/core';
 import { AbstractMigrator } from '@mikro-orm/core/migrations';
-import { DatabaseSchema, DatabaseTable } from '@mikro-orm/sql';
+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';
 /** Manages SQL database migrations: creation, execution, and rollback of schema changes. */
 export class Migrator extends AbstractMigrator {
-  #schemaGenerator;
-  #snapshotPath;
-  constructor(em) {
-    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);
+    #schemaGenerator;
+    #snapshotPath;
+    constructor(em) {
+        super(em);
+        this.#schemaGenerator = this.config.getExtension('@mikro-orm/schema-generator');
     }
-    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`);
+    static register(orm) {
+        orm.config.registerExtension('@mikro-orm/migrator', () => new Migrator(orm.em));
     }
-    return this.#snapshotPath;
-  }
-  async init() {
-    if (this.initialized) {
-      return;
+    createRunner() {
+        return new MigrationRunner(this.driver, this.options, this.config);
     }
-    await super.init();
-    const created = await this.#schemaGenerator.ensureDatabase();
-    /* v8 ignore next */
-    if (created) {
-      this.initServices();
+    createStorage() {
+        return new MigrationStorage(this.driver, this.options);
     }
-    await this.storage.ensureTable();
-  }
-  /**
-   * @inheritDoc
-   */
-  async create(path, blank = false, initial = false, name) {
-    await this.init();
-    if (initial) {
-      return this.createInitial(path, name, blank);
-    }
-    const diff = await this.getSchemaDiff(blank, initial);
-    if (diff.up.length === 0) {
-      return { fileName: '', code: '', diff };
+    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);
     }
-    const migration = await this.generator.generate(diff, path, name);
-    await this.storeCurrentSchema();
-    return {
-      fileName: migration[1],
-      code: migration[0],
-      diff,
-    };
-  }
-  async checkSchema() {
-    await this.init();
-    const diff = await this.getSchemaDiff(false, false);
-    return diff.up.length > 0;
-  }
-  /**
-   * @inheritDoc
-   */
-  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] });
+    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;
     }
-    return {
-      fileName: migration[1],
-      code: migration[0],
-      diff,
-    };
-  }
-  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).
-      }
+    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();
     }
-    return result;
-  }
-  getStorage() {
-    return this.storage;
-  }
-  /**
-   * Initial migration can be created only if:
-   * 1. no previous migrations were generated or executed
-   * 2. existing schema do not contain any of the tables defined by metadata
-   *
-   * If existing schema contains all of the tables already, we return true, based on that we mark the migration as already executed.
-   * If only some of the tables are present, exception is thrown.
-   */
-  async validateInitialMigration(blank) {
-    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');
+    /**
+     * @inheritDoc
+     */
+    async create(path, blank = false, initial = false, name) {
+        await this.init();
+        if (initial) {
+            return this.createInitial(path, name, blank);
+        }
+        const diff = await this.getSchemaDiff(blank, initial);
+        if (diff.up.length === 0) {
+            return { fileName: '', code: '', diff };
+        }
+        const migration = await this.generator.generate(diff, path, name);
+        await this.storeCurrentSchema();
+        return {
+            fileName: migration[1],
+            code: migration[0],
+            diff,
+        };
     }
-    const schema = await DatabaseSchema.create(this.em.getConnection(), this.em.getPlatform(), this.config);
-    const exists = new Set();
-    const expected = new Set();
-    [...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());
-        expected.add(schema ? `${schema}.${meta.collection}` : meta.collection);
-      });
-    schema.getTables().forEach(table => {
-      const schema = table.schema ?? this.em.getPlatform().getDefaultSchemaName();
-      const tableName = schema ? `${schema}.${table.name}` : table.name;
-      if (expected.has(tableName)) {
-        exists.add(table.schema ? `${table.schema}.${table.name}` : table.name);
-      }
-    });
-    if (expected.size === 0 && !blank) {
-      throw new Error('No entities found');
+    async checkSchema() {
+        await this.init();
+        const diff = await this.getSchemaDiff(false, false);
+        return diff.up.length > 0;
     }
-    if (exists.size > 0 && expected.size !== exists.size) {
-      throw new Error(
-        `Some tables already exist in your schema, remove them first to create the initial migration: ${[...exists].join(', ')}`,
-      );
+    /**
+     * @inheritDoc
+     */
+    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] });
+        }
+        return {
+            fileName: migration[1],
+            code: migration[0],
+            diff,
+        };
     }
-    return expected.size === exists.size;
-  }
-  async getSchemaFromSnapshot() {
-    if (!this.options.snapshot) {
-      return undefined;
+    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;
     }
-    const snapshotPath = await this.getSnapshotPath();
-    const { fs } = await import('@mikro-orm/core/fs-utils');
-    if (!fs.pathExists(snapshotPath)) {
-      return undefined;
+    getStorage() {
+        return this.storage;
     }
-    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, 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[cols[col].mappedType] ?? UnknownType);
-        table.addColumn(column);
-      });
-      return table;
-    });
-    schema.setTables(tableInstances);
-    schema.setNamespaces(new Set(namespaces));
-    if (rest.nativeEnums) {
-      schema.setNativeEnums(rest.nativeEnums);
+    /**
+     * Initial migration can be created only if:
+     * 1. no previous migrations were generated or executed
+     * 2. existing schema do not contain any of the tables defined by metadata
+     *
+     * If existing schema contains all of the tables already, we return true, based on that we mark the migration as already executed.
+     * If only some of the tables are present, exception is thrown.
+     */
+    async validateInitialMigration(blank) {
+        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();
+        [...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());
+            expected.add(schema ? `${schema}.${meta.collection}` : meta.collection);
+        });
+        schema.getTables().forEach(table => {
+            const schema = table.schema ?? this.em.getPlatform().getDefaultSchemaName();
+            const tableName = schema ? `${schema}.${table.name}` : table.name;
+            if (expected.has(tableName)) {
+                exists.add(table.schema ? `${table.schema}.${table.name}` : table.name);
+            }
+        });
+        if (expected.size === 0 && !blank) {
+            throw new Error('No entities found');
+        }
+        if (exists.size > 0 && expected.size !== exists.size) {
+            throw new Error(`Some tables already exist in your schema, remove them first to create the initial migration: ${[...exists].join(', ')}`);
+        }
+        return expected.size === exists.size;
     }
-    if (rest.views) {
-      schema.setViews(rest.views);
+    async getSchemaFromSnapshot() {
+        if (!this.options.snapshot) {
+            return undefined;
+        }
+        const snapshotPath = await this.getSnapshotPath();
+        const { fs } = await import('@mikro-orm/core/fs-utils');
+        if (!fs.pathExists(snapshotPath)) {
+            return undefined;
+        }
+        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, 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[cols[col].mappedType] ?? UnknownType);
+                table.addColumn(column);
+            });
+            return table;
+        });
+        schema.setTables(tableInstances);
+        schema.setNamespaces(new Set(namespaces));
+        if (rest.nativeEnums) {
+            schema.setNativeEnums(rest.nativeEnums);
+        }
+        if (rest.views) {
+            schema.setViews(rest.views);
+        }
+        return schema;
     }
-    return schema;
-  }
-  async storeCurrentSchema(schema) {
-    if (!this.options.snapshot) {
-      return;
+    async storeCurrentSchema(schema) {
+        if (!this.options.snapshot) {
+            return;
+        }
+        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));
     }
-    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;
+    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');
         }
-        // A chunk starting with \n indicates there was a blank line (grouping separator)
-        if (buf.startsWith('\n')) {
-          result.push('');
+        else if (initial) {
+            const dump = await this.#schemaGenerator.getCreateSchemaSQL({ wrap: false });
+            up.push(...splitStatements(dump));
         }
-        const trimmed = buf.trim();
-        if (trimmed) {
-          result.push(trimmed.endsWith(';') ? trimmed : trimmed + ';');
+        else {
+            const diff = await this.#schemaGenerator.getUpdateSchemaMigrationSQL({
+                wrap: false,
+                safe: this.options.safe,
+                dropTables: this.options.dropTables,
+                fromSchema: await this.getSchemaFromSnapshot(),
+            });
+            up.push(...splitStatements(diff.up));
+            down.push(...splitStatements(diff.down));
         }
-        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(...splitStatements(dump));
-    } else {
-      const diff = await this.#schemaGenerator.getUpdateSchemaMigrationSQL({
-        wrap: false,
-        safe: this.options.safe,
-        dropTables: this.options.dropTables,
-        fromSchema: await this.getSchemaFromSnapshot(),
-      });
-      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);
+            }
+        };
+        cleanUp(up);
+        cleanUp(down);
+        return { up, down };
     }
-    const cleanUp = diff => {
-      for (let i = diff.length - 1; i >= 0; i--) {
-        if (diff[i]) {
-          break;
-        }
-        /* v8 ignore next */
-        diff.splice(i, 1);
-      }
-    };
-    cleanUp(up);
-    cleanUp(down);
-    return { up, down };
-  }
 }

package/README.md

@@ -133,7 +133,7 @@ const author = await em.findOneOrFail(Author, 1, {
   populate: ['books'],
 });
 author.name = 'Jon Snow II';
-author.books.getItems().forEach(book => (book.title += ' (2nd ed.)'));
+author.books.getItems().forEach(book => book.title += ' (2nd ed.)');
 author.books.add(orm.em.create(Book, { title: 'New Book', author }));
 
 // Flush computes change sets and executes them in a single transaction

package/TSMigrationGenerator.d.ts

@@ -1,14 +1,11 @@
 import { MigrationGenerator } from './MigrationGenerator.js';
 /** Generates migration files in TypeScript format. */
 export declare class TSMigrationGenerator extends MigrationGenerator {
-  /**
-   * @inheritDoc
-   */
-  generateMigrationFile(
-    className: string,
-    diff: {
-      up: string[];
-      down: string[];
-    },
-  ): string;
+    /**
+     * @inheritDoc
+     */
+    generateMigrationFile(className: string, diff: {
+        up: string[];
+        down: string[];
+    }): string;
 }

package/TSMigrationGenerator.js

@@ -1,21 +1,21 @@
 import { MigrationGenerator } from './MigrationGenerator.js';
 /** Generates migration files in TypeScript format. */
 export class TSMigrationGenerator extends MigrationGenerator {
-  /**
-   * @inheritDoc
-   */
-  generateMigrationFile(className, diff) {
-    let ret = `import { Migration } from '@mikro-orm/migrations';\n\n`;
-    ret += `export class ${className} extends Migration {\n\n`;
-    ret += `  override up(): void | Promise<void> {\n`;
-    diff.up.forEach(sql => (ret += this.createStatement(sql, 4)));
-    ret += `  }\n\n`;
-    if (diff.down.length > 0) {
-      ret += `  override down(): void | Promise<void> {\n`;
-      diff.down.forEach(sql => (ret += this.createStatement(sql, 4)));
-      ret += `  }\n\n`;
+    /**
+     * @inheritDoc
+     */
+    generateMigrationFile(className, diff) {
+        let ret = `import { Migration } from '@mikro-orm/migrations';\n\n`;
+        ret += `export class ${className} extends Migration {\n\n`;
+        ret += `  override up(): void | Promise<void> {\n`;
+        diff.up.forEach(sql => (ret += this.createStatement(sql, 4)));
+        ret += `  }\n\n`;
+        if (diff.down.length > 0) {
+            ret += `  override down(): void | Promise<void> {\n`;
+            diff.down.forEach(sql => (ret += this.createStatement(sql, 4)));
+            ret += `  }\n\n`;
+        }
+        ret += `}\n`;
+        return ret;
     }
-    ret += `}\n`;
-    return ret;
-  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/migrations",
-  "version": "7.0.4",
+  "version": "7.0.5-dev.0",
   "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.4"
+    "@mikro-orm/sql": "7.0.5-dev.0"
   },
   "devDependencies": {
     "@mikro-orm/core": "^7.0.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.4"
+    "@mikro-orm/core": "7.0.5-dev.0"
   },
   "engines": {
     "node": ">= 22.17.0"