@yandjin-mikro-orm/migrations 6.1.4-rc-sti-changes-1

package/JSMigrationGenerator.d.ts

@@ -0,0 +1,10 @@
+import { MigrationGenerator } from './MigrationGenerator';
+export declare class JSMigrationGenerator extends MigrationGenerator {
+    /**
+     * @inheritDoc
+     */
+    generateMigrationFile(className: string, diff: {
+        up: string[];
+        down: string[];
+    }): string;
+}

package/JSMigrationGenerator.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSMigrationGenerator = void 0;
+const MigrationGenerator_1 = require("./MigrationGenerator");
+class JSMigrationGenerator extends MigrationGenerator_1.MigrationGenerator {
+    /**
+     * @inheritDoc
+     */
+    generateMigrationFile(className, diff) {
+        let ret = `'use strict';\n`;
+        ret += `Object.defineProperty(exports, '__esModule', { value: true });\n`;
+        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));
+        ret += `  }\n\n`;
+        /* istanbul ignore else */
+        if (diff.down.length > 0) {
+            ret += `  async down() {\n`;
+            diff.down.forEach(sql => ret += this.createStatement(sql, 4));
+            ret += `  }\n\n`;
+        }
+        ret += `}\n`;
+        ret += `exports.${className} = ${className};\n`;
+        return ret;
+    }
+}
+exports.JSMigrationGenerator = JSMigrationGenerator;

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Martin Adámek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Migration.d.ts

@@ -0,0 +1,29 @@
+import type { Configuration, Transaction } from "@yandjin-mikro-orm/core";
+import type { AbstractSqlDriver, Knex, EntityManager } from "@yandjin-mikro-orm/knex";
+export type Query = string | Knex.QueryBuilder | Knex.Raw;
+export declare abstract class Migration {
+    protected readonly driver: AbstractSqlDriver;
+    protected readonly config: Configuration;
+    private readonly queries;
+    protected ctx?: Transaction<Knex.Transaction>;
+    private em?;
+    constructor(driver: AbstractSqlDriver, config: Configuration);
+    abstract up(): Promise<void>;
+    down(): Promise<void>;
+    isTransactional(): boolean;
+    addSql(sql: Query): void;
+    reset(): void;
+    setTransactionContext(ctx: Transaction): void;
+    /**
+     * Executes a raw SQL query. Accepts a string SQL or a knex 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("@yandjin-mikro-orm/core").EntityData<Partial<any>>[]>;
+    getKnex(): Knex<any, any[]>;
+    /**
+     * Creates a cached `EntityManager` instance for this migration, which will respect
+     * the current transaction context.
+     */
+    getEntityManager(): EntityManager;
+    getQueries(): Query[];
+}

package/Migration.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migration = void 0;
+class Migration {
+    driver;
+    config;
+    queries = [];
+    ctx;
+    em;
+    constructor(driver, config) {
+        this.driver = driver;
+        this.config = config;
+    }
+    async down() {
+        throw new Error("This migration cannot be reverted");
+    }
+    isTransactional() {
+        return true;
+    }
+    addSql(sql) {
+        this.queries.push(sql);
+    }
+    reset() {
+        this.queries.length = 0;
+        this.ctx = undefined;
+    }
+    setTransactionContext(ctx) {
+        this.ctx = ctx;
+    }
+    /**
+     * Executes a raw SQL query. Accepts a string SQL or a knex query builder instance.
+     * The `params` parameter is respected only if you use string SQL in the first parameter.
+     */
+    async execute(sql, params) {
+        return this.driver.execute(sql, params, "all", this.ctx);
+    }
+    getKnex() {
+        return this.driver.getConnection("write").getKnex();
+    }
+    /**
+     * Creates a cached `EntityManager` instance for this migration, which will respect
+     * the current transaction context.
+     */
+    getEntityManager() {
+        if (!this.em) {
+            this.em = this.driver.createEntityManager();
+            this.em.setTransactionContext(this.ctx);
+        }
+        return this.em;
+    }
+    getQueries() {
+        return this.queries;
+    }
+}
+exports.Migration = Migration;

package/MigrationGenerator.d.ts

@@ -0,0 +1,26 @@
+import { type IMigrationGenerator, type MigrationsOptions, type NamingStrategy } from "@yandjin-mikro-orm/core";
+import type { AbstractSqlDriver } from "@yandjin-mikro-orm/knex";
+export declare abstract class MigrationGenerator implements IMigrationGenerator {
+    protected readonly driver: AbstractSqlDriver;
+    protected readonly namingStrategy: NamingStrategy;
+    protected readonly options: MigrationsOptions;
+    constructor(driver: AbstractSqlDriver, namingStrategy: NamingStrategy, options: MigrationsOptions);
+    /**
+     * @inheritDoc
+     */
+    generate(diff: {
+        up: string[];
+        down: string[];
+    }, path?: string, name?: string): Promise<[string, string]>;
+    /**
+     * @inheritDoc
+     */
+    createStatement(sql: string, padLeft: number): string;
+    /**
+     * @inheritDoc
+     */
+    abstract generateMigrationFile(className: string, diff: {
+        up: string[];
+        down: string[];
+    }): string;
+}

package/MigrationGenerator.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationGenerator = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+const fs_extra_1 = require("fs-extra");
+class MigrationGenerator {
+    driver;
+    namingStrategy;
+    options;
+    constructor(driver, namingStrategy, options) {
+        this.driver = driver;
+        this.namingStrategy = namingStrategy;
+        this.options = options;
+    }
+    /**
+     * @inheritDoc
+     */
+    async generate(diff, path, name) {
+        /* istanbul ignore next */
+        const defaultPath = this.options.emit === "ts" && this.options.pathTs
+            ? this.options.pathTs
+            : this.options.path;
+        path = core_1.Utils.normalizePath(this.driver.config.get("baseDir"), path ?? defaultPath);
+        await (0, fs_extra_1.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 = this.generateMigrationFile(className, diff);
+        await (0, fs_extra_1.writeFile)(path + "/" + fileName, ret, { flush: true });
+        return [ret, fileName];
+    }
+    /**
+     * @inheritDoc
+     */
+    createStatement(sql, padLeft) {
+        if (sql) {
+            const padding = " ".repeat(padLeft);
+            return `${padding}this.addSql('${sql.replace(/['\\]/g, "\\'")}');\n`;
+        }
+        return "\n";
+    }
+}
+exports.MigrationGenerator = MigrationGenerator;

package/MigrationRunner.d.ts

@@ -0,0 +1,16 @@
+import { type Configuration, type MigrationsOptions, type Transaction } from "@yandjin-mikro-orm/core";
+import type { AbstractSqlDriver } from "@yandjin-mikro-orm/knex";
+import type { Migration } from "./Migration";
+export declare class MigrationRunner {
+    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;
+    unsetMasterMigration(): void;
+    private getQueries;
+}

package/MigrationRunner.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationRunner = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+class MigrationRunner {
+    driver;
+    options;
+    config;
+    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();
+    }
+    async run(migration, method) {
+        migration.reset();
+        if (!this.options.transactional || !migration.isTransactional()) {
+            const queries = await this.getQueries(migration, method);
+            await core_1.Utils.runSerial(queries, (sql) => this.driver.execute(sql));
+        }
+        else {
+            await this.connection.transactional(async (tx) => {
+                migration.setTransactionContext(tx);
+                const queries = await this.getQueries(migration, method);
+                await core_1.Utils.runSerial(queries, (sql) => this.driver.execute(sql, undefined, "all", tx));
+            }, { ctx: this.masterTransaction });
+        }
+    }
+    setMasterMigration(trx) {
+        this.masterTransaction = trx;
+    }
+    unsetMasterMigration() {
+        delete this.masterTransaction;
+    }
+    async getQueries(migration, method) {
+        await migration[method]();
+        let queries = migration.getQueries();
+        if (this.options.disableForeignKeys) {
+            const charset = this.config.get("charset");
+            queries.unshift(...this.helper.getSchemaBeginning(charset).split("\n"));
+            queries.push(...this.helper.getSchemaEnd().split("\n"));
+        }
+        queries = queries.filter((sql) => !core_1.Utils.isString(sql) || sql.trim().length > 0);
+        return queries;
+    }
+}
+exports.MigrationRunner = MigrationRunner;

package/MigrationStorage.d.ts

@@ -0,0 +1,31 @@
+import type { MigrationsOptions, Transaction } from "@yandjin-mikro-orm/core";
+import type { AbstractSqlDriver } from "@yandjin-mikro-orm/knex";
+import type { MigrationParams, UmzugStorage } from "umzug";
+import type { MigrationRow } from "./typings";
+export declare class MigrationStorage implements UmzugStorage {
+    protected readonly driver: AbstractSqlDriver;
+    protected readonly options: MigrationsOptions;
+    private readonly connection;
+    private readonly helper;
+    private masterTransaction?;
+    constructor(driver: AbstractSqlDriver, options: MigrationsOptions);
+    executed(): Promise<string[]>;
+    logMigration(params: MigrationParams<any>): Promise<void>;
+    unlogMigration(params: MigrationParams<any>): Promise<void>;
+    getExecutedMigrations(): Promise<MigrationRow[]>;
+    ensureTable(): Promise<void>;
+    setMasterMigration(trx: Transaction): void;
+    unsetMasterMigration(): void;
+    /**
+     * @internal
+     */
+    getMigrationName(name: string): string;
+    /**
+     * @internal
+     */
+    getTableName(): {
+        tableName: string;
+        schemaName: string;
+    };
+    private get knex();
+}

package/MigrationStorage.js

@@ -0,0 +1,132 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationStorage = void 0;
+const path = __importStar(require("path"));
+class MigrationStorage {
+    driver;
+    options;
+    connection;
+    helper;
+    masterTransaction;
+    constructor(driver, options) {
+        this.driver = driver;
+        this.options = options;
+        this.connection = this.driver.getConnection();
+        this.helper = this.driver.getPlatform().getSchemaHelper();
+    }
+    async executed() {
+        const migrations = await this.getExecutedMigrations();
+        return migrations.map(({ name }) => `${this.getMigrationName(name)}`);
+    }
+    async logMigration(params) {
+        const { tableName, schemaName } = this.getTableName();
+        const name = this.getMigrationName(params.name);
+        await this.driver.nativeInsert(tableName, { name }, { schema: schemaName, ctx: this.masterTransaction });
+    }
+    async unlogMigration(params) {
+        const { tableName, schemaName } = this.getTableName();
+        const withoutExt = this.getMigrationName(params.name);
+        const names = [withoutExt, withoutExt + ".js", withoutExt + ".ts"];
+        const qb = this.knex
+            .delete()
+            .from(tableName)
+            .withSchema(schemaName)
+            .where("name", "in", [params.name, ...names]);
+        if (this.masterTransaction) {
+            qb.transacting(this.masterTransaction);
+        }
+        await this.connection.execute(qb);
+    }
+    async getExecutedMigrations() {
+        const { tableName, schemaName } = this.getTableName();
+        const qb = this.knex
+            .select("*")
+            .from(tableName)
+            .withSchema(schemaName)
+            .orderBy("id", "asc");
+        if (this.masterTransaction) {
+            qb.transacting(this.masterTransaction);
+        }
+        const res = await this.connection.execute(qb);
+        return res.map((row) => {
+            if (typeof row.executed_at === "string") {
+                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 { 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);
+        if (schemaName && !schemas.includes(schemaName)) {
+            await this.knex.schema.createSchema(schemaName);
+        }
+        await this.knex.schema
+            .createTable(tableName, (table) => {
+            table.increments();
+            table.string("name");
+            table.dateTime("executed_at").defaultTo(this.knex.fn.now());
+        })
+            .withSchema(schemaName);
+    }
+    setMasterMigration(trx) {
+        this.masterTransaction = trx;
+    }
+    unsetMasterMigration() {
+        delete this.masterTransaction;
+    }
+    /**
+     * @internal
+     */
+    getMigrationName(name) {
+        const parsedName = path.parse(name);
+        if ([".js", ".ts"].includes(parsedName.ext)) {
+            // strip extension
+            return parsedName.name;
+        }
+        return name;
+    }
+    /**
+     * @internal
+     */
+    getTableName() {
+        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 };
+    }
+    get knex() {
+        return this.connection.getKnex();
+    }
+}
+exports.MigrationStorage = MigrationStorage;

package/Migrator.d.ts

@@ -0,0 +1,68 @@
+import { type MigrationParams, type RunnableMigration } from "umzug";
+import { type Constructor, type IMigrator, type MikroORM } from "@yandjin-mikro-orm/core";
+import { DatabaseSchema, type EntityManager } from "@yandjin-mikro-orm/knex";
+import type { Migration } from "./Migration";
+import { MigrationStorage } from "./MigrationStorage";
+import type { MigrateOptions, MigrationResult, MigrationRow, UmzugMigration } from "./typings";
+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;
+    constructor(em: EntityManager);
+    static register(orm: MikroORM): void;
+    /**
+     * @inheritDoc
+     */
+    createMigration(path?: string, blank?: boolean, initial?: boolean, name?: string): Promise<MigrationResult>;
+    checkMigrationNeeded(): Promise<boolean>;
+    /**
+     * @inheritDoc
+     */
+    createInitialMigration(path?: string, name?: string): Promise<MigrationResult>;
+    private createUmzug;
+    /**
+     * 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.
+     */
+    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(): Promise<DatabaseSchema | undefined>;
+    protected storeCurrentSchema(): Promise<void>;
+    protected initialize(MigrationClass: Constructor<Migration>, name: string): RunnableMigration<any>;
+    private getSchemaDiff;
+    private getMigrationFilename;
+    private prefix;
+    private runMigrations;
+    private runInTransaction;
+    private ensureMigrationsDirExists;
+}