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

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;
+export class Migrator extends AbstractMigrator {
     schemaGenerator;
-    config;
-    options;
-    absolutePath;
     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,62 +149,16 @@ 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) => {
@@ -245,47 +176,67 @@ export class Migrator {
         Object.assign(schema, { tables: tableInstances, namespaces: new Set(namespaces), ...rest });
         return schema;
     }
-    async storeCurrentSchema() {
+    async storeCurrentSchema(schema) {
         if (!this.options.snapshot) {
             return;
         }
-        const schema = this.schemaGenerator.getTargetSchema();
-        writeFileSync(this.snapshotPath, JSON.stringify(schema, null, 2));
-    }
-    initialize(MigrationClass, name) {
-        const instance = new MigrationClass(this.driver, this.config);
-        return {
-            name: this.storage.getMigrationName(name),
-            up: () => this.runner.run(instance, 'up'),
-            down: () => this.runner.run(instance, 'down'),
-        };
+        const snapshotPath = await this.getSnapshotPath();
+        schema ??= this.schemaGenerator.getTargetSchema();
+        const { fs } = await import('@mikro-orm/core/fs-utils');
+        await fs.writeFile(snapshotPath, JSON.stringify(schema, null, 2));
     }
     async getSchemaDiff(blank, initial) {
         const up = [];
         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'));
+            up.push(...splitStatements(dump));
         }
         else {
             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 +244,4 @@ export class Migrator {
         cleanUp(down);
         return { up, down };
     }
-    getMigrationFilename(name) {
-        name = name.replace(/\.[jt]s$/, '');
-        return name.match(/^\d{14}$/) ? this.options.fileName(name) : name;
-    }
-    prefix(options) {
-        if (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.32",
+  "version": "7.0.0-dev.320",
   "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.32",
-    "umzug": "3.8.2"
+    "@mikro-orm/sql": "7.0.0-dev.320"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.5.7"
+    "@mikro-orm/core": "^6.6.9"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.32"
+    "@mikro-orm/core": "7.0.0-dev.320"
+  },
+  "engines": {
+    "node": ">= 22.17.0"
   }
 }