taon-typeorm 21.0.13 → 21.0.18

package/lib-prod/typeorm/migration/Migration.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migration = void 0;
+/**
+ * Represents entity of the migration in the database.
+ */
+class Migration {
+    // -------------------------------------------------------------------------
+    // Public Properties
+    // -------------------------------------------------------------------------
+    /**
+     * Migration id.
+     * Indicates order of the executed migrations.
+     */
+    id;
+    /**
+     * Timestamp of the migration.
+     */
+    timestamp;
+    /**
+     * Name of the migration (class name).
+     */
+    name;
+    /**
+     * Migration instance that needs to be run.
+     */
+    instance;
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(id, timestamp, name, instance) {
+        this.id = id;
+        this.timestamp = timestamp;
+        this.name = name;
+        this.instance = instance;
+    }
+}
+exports.Migration = Migration;
+//# sourceMappingURL=Migration.js.map

package/lib-prod/typeorm/migration/Migration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Migration.js","sourceRoot":"","sources":[""],"names":[],"mappings":";;;AAEA;;GAEG;AACH,MAAa,SAAS;IAClB,4EAA4E;IAC5E,oBAAoB;IACpB,4EAA4E;IAE5E;;;OAGG;IACH,EAAE,CAAoB;IAEtB;;OAEG;IACH,SAAS,CAAQ;IAEjB;;OAEG;IACH,IAAI,CAAQ;IAEZ;;OAEG;IACH,QAAQ,CAAqB;IAE7B,4EAA4E;IAC5E,cAAc;IACd,4EAA4E;IAE5E,YACI,EAAsB,EACtB,SAAiB,EACjB,IAAY,EACZ,QAA6B;QAE7B,IAAI,CAAC,EAAE,GAAG,EAAE,CAAA;QACZ,IAAI,CAAC,SAAS,GAAG,SAAS,CAAA;QAC1B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;IAC5B,CAAC;CACJ;AAzCD,8BAyCC"}

package/lib-prod/typeorm/migration/MigrationExecutor.d.ts

@@ -0,0 +1,99 @@
+import { DataSource } from "../data-source/DataSource";
+import { Migration } from "./Migration";
+import { QueryRunner } from "../query-runner/QueryRunner";
+/**
+ * Executes migrations: runs pending and reverts previously executed migrations.
+ */
+export declare class MigrationExecutor {
+    protected connection: DataSource;
+    protected queryRunner?: QueryRunner;
+    /**
+     * Indicates how migrations should be run in transactions.
+     *   all: all migrations are run in a single transaction
+     *   none: all migrations are run without a transaction
+     *   each: each migration is run in a separate transaction
+     */
+    transaction: "all" | "none" | "each";
+    /**
+     * Option to fake-run or fake-revert a migration, adding to the
+     * executed migrations table, but not actually running it. This feature is
+     * useful for when migrations are added after the fact or for
+     * interoperability between applications which are desired to each keep
+     * a consistent migration history.
+     */
+    fake: boolean;
+    private readonly migrationsDatabase?;
+    private readonly migrationsSchema?;
+    private readonly migrationsTable;
+    private readonly migrationsTableName;
+    constructor(connection: DataSource, queryRunner?: QueryRunner);
+    /**
+     * Tries to execute a single migration given.
+     */
+    executeMigration(migration: Migration): Promise<Migration>;
+    /**
+     * Returns an array of all migrations.
+     */
+    getAllMigrations(): Promise<Migration[]>;
+    /**
+     * Returns an array of all executed migrations.
+     */
+    getExecutedMigrations(): Promise<Migration[]>;
+    /**
+     * Returns an array of all pending migrations.
+     */
+    getPendingMigrations(): Promise<Migration[]>;
+    /**
+     * Inserts an executed migration.
+     */
+    insertMigration(migration: Migration): Promise<void>;
+    /**
+     * Deletes an executed migration.
+     */
+    deleteMigration(migration: Migration): Promise<void>;
+    /**
+     * Lists all migrations and whether they have been executed or not
+     * returns true if there are unapplied migrations
+     */
+    showMigrations(): Promise<boolean>;
+    /**
+     * Executes all pending migrations. Pending migrations are migrations that are not yet executed,
+     * thus not saved in the database.
+     */
+    executePendingMigrations(): Promise<Migration[]>;
+    /**
+     * Reverts last migration that were run.
+     */
+    undoLastMigration(): Promise<void>;
+    /**
+     * Creates table "migrations" that will store information about executed migrations.
+     */
+    protected createMigrationsTableIfNotExist(queryRunner: QueryRunner): Promise<void>;
+    /**
+     * Loads all migrations that were executed and saved into the database (sorts by id).
+     */
+    protected loadExecutedMigrations(queryRunner: QueryRunner): Promise<Migration[]>;
+    /**
+     * Gets all migrations that setup for this connection.
+     */
+    protected getMigrations(): Migration[];
+    protected checkForDuplicateMigrations(migrations: Migration[]): void;
+    /**
+     * Finds the latest migration (sorts by timestamp) in the given array of migrations.
+     */
+    protected getLatestTimestampMigration(migrations: Migration[]): Migration | undefined;
+    /**
+     * Finds the latest migration in the given array of migrations.
+     * PRE: Migration array must be sorted by descending id.
+     */
+    protected getLatestExecutedMigration(sortedMigrations: Migration[]): Migration | undefined;
+    /**
+     * Inserts new executed migration's data into migrations table.
+     */
+    protected insertExecutedMigration(queryRunner: QueryRunner, migration: Migration): Promise<void>;
+    /**
+     * Delete previously executed migration's data from the migrations table.
+     */
+    protected deleteExecutedMigration(queryRunner: QueryRunner, migration: Migration): Promise<void>;
+    protected withQueryRunner<T extends any>(callback: (queryRunner: QueryRunner) => T | Promise<T>): Promise<T>;
+}

package/lib-prod/typeorm/migration/MigrationExecutor.js

@@ -0,0 +1,525 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationExecutor = void 0;
+const Table_1 = require("../schema-builder/table/Table");
+const Migration_1 = require("./Migration");
+//#region @backend
+const MssqlParameter_1 = require("../driver/sqlserver/MssqlParameter");
+//#endregion
+const error_1 = require("../error");
+const InstanceChecker_1 = require("../util/InstanceChecker");
+/**
+ * Executes migrations: runs pending and reverts previously executed migrations.
+ */
+class MigrationExecutor {
+    connection;
+    queryRunner;
+    // -------------------------------------------------------------------------
+    // Public Properties
+    // -------------------------------------------------------------------------
+    /**
+     * Indicates how migrations should be run in transactions.
+     *   all: all migrations are run in a single transaction
+     *   none: all migrations are run without a transaction
+     *   each: each migration is run in a separate transaction
+     */
+    transaction = "all";
+    /**
+     * Option to fake-run or fake-revert a migration, adding to the
+     * executed migrations table, but not actually running it. This feature is
+     * useful for when migrations are added after the fact or for
+     * interoperability between applications which are desired to each keep
+     * a consistent migration history.
+     */
+    fake;
+    // -------------------------------------------------------------------------
+    // Private Properties
+    // -------------------------------------------------------------------------
+    migrationsDatabase;
+    migrationsSchema;
+    migrationsTable;
+    migrationsTableName;
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(connection, queryRunner) {
+        this.connection = connection;
+        this.queryRunner = queryRunner;
+        const { schema } = this.connection.driver.options;
+        const database = this.connection.driver.database;
+        this.migrationsDatabase = database;
+        this.migrationsSchema = schema;
+        this.migrationsTableName =
+            connection.options.migrationsTableName || "migrations";
+        this.migrationsTable = this.connection.driver.buildTableName(this.migrationsTableName, schema, database);
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Tries to execute a single migration given.
+     */
+    async executeMigration(migration) {
+        return this.withQueryRunner(async (queryRunner) => {
+            await this.createMigrationsTableIfNotExist(queryRunner);
+            // create typeorm_metadata table if it's not created yet
+            const schemaBuilder = this.connection.driver.createSchemaBuilder();
+            if (InstanceChecker_1.InstanceChecker.isRdbmsSchemaBuilder(schemaBuilder)) {
+                await schemaBuilder.createMetadataTableIfNecessary(queryRunner);
+            }
+            await queryRunner.beforeMigration();
+            await migration.instance.up(queryRunner);
+            await queryRunner.afterMigration();
+            await this.insertExecutedMigration(queryRunner, migration);
+            return migration;
+        });
+    }
+    /**
+     * Returns an array of all migrations.
+     */
+    async getAllMigrations() {
+        return Promise.resolve(this.getMigrations());
+    }
+    /**
+     * Returns an array of all executed migrations.
+     */
+    async getExecutedMigrations() {
+        return this.withQueryRunner(async (queryRunner) => {
+            await this.createMigrationsTableIfNotExist(queryRunner);
+            return await this.loadExecutedMigrations(queryRunner);
+        });
+    }
+    /**
+     * Returns an array of all pending migrations.
+     */
+    async getPendingMigrations() {
+        const allMigrations = await this.getAllMigrations();
+        const executedMigrations = await this.getExecutedMigrations();
+        return allMigrations.filter((migration) => !executedMigrations.find((executedMigration) => executedMigration.name === migration.name));
+    }
+    /**
+     * Inserts an executed migration.
+     */
+    insertMigration(migration) {
+        return this.withQueryRunner((q) => this.insertExecutedMigration(q, migration));
+    }
+    /**
+     * Deletes an executed migration.
+     */
+    deleteMigration(migration) {
+        return this.withQueryRunner((q) => this.deleteExecutedMigration(q, migration));
+    }
+    /**
+     * Lists all migrations and whether they have been executed or not
+     * returns true if there are unapplied migrations
+     */
+    async showMigrations() {
+        let hasUnappliedMigrations = false;
+        const queryRunner = this.queryRunner || this.connection.createQueryRunner();
+        // create migrations table if its not created yet
+        await this.createMigrationsTableIfNotExist(queryRunner);
+        // get all migrations that are executed and saved in the database
+        const executedMigrations = await this.loadExecutedMigrations(queryRunner);
+        // get all user's migrations in the source code
+        const allMigrations = this.getMigrations();
+        for (const migration of allMigrations) {
+            const executedMigration = executedMigrations.find((executedMigration) => executedMigration.name === migration.name);
+            if (executedMigration) {
+                this.connection.logger.logSchemaBuild(`[X] ${migration.name}`);
+            }
+            else {
+                hasUnappliedMigrations = true;
+                this.connection.logger.logSchemaBuild(`[ ] ${migration.name}`);
+            }
+        }
+        // if query runner was created by us then release it
+        if (!this.queryRunner) {
+            await queryRunner.release();
+        }
+        return hasUnappliedMigrations;
+    }
+    /**
+     * Executes all pending migrations. Pending migrations are migrations that are not yet executed,
+     * thus not saved in the database.
+     */
+    async executePendingMigrations() {
+        const queryRunner = this.queryRunner || this.connection.createQueryRunner();
+        // create migrations table if it's not created yet
+        await this.createMigrationsTableIfNotExist(queryRunner);
+        // create the typeorm_metadata table if it's not created yet
+        const schemaBuilder = this.connection.driver.createSchemaBuilder();
+        if (InstanceChecker_1.InstanceChecker.isRdbmsSchemaBuilder(schemaBuilder)) {
+            await schemaBuilder.createMetadataTableIfNecessary(queryRunner);
+        }
+        // get all migrations that are executed and saved in the database
+        const executedMigrations = await this.loadExecutedMigrations(queryRunner);
+        // get the time when last migration was executed
+        let lastTimeExecutedMigration = this.getLatestTimestampMigration(executedMigrations);
+        // get all user's migrations in the source code
+        const allMigrations = this.getMigrations();
+        // variable to store all migrations we did successfully
+        const successMigrations = [];
+        // find all migrations that needs to be executed
+        const pendingMigrations = allMigrations.filter((migration) => {
+            // check if we already have executed migration
+            const executedMigration = executedMigrations.find((executedMigration) => executedMigration.name === migration.name);
+            if (executedMigration)
+                return false;
+            // migration is new and not executed. now check if its timestamp is correct
+            // if (lastTimeExecutedMigration && migration.timestamp < lastTimeExecutedMigration.timestamp)
+            //     throw new TypeORMError(`New migration found: ${migration.name}, however this migration's timestamp is not valid. Migration's timestamp should not be older then migrations already executed in the database.`);
+            // every check is passed means that migration was not run yet and we need to run it
+            return true;
+        });
+        // if no migrations are pending then nothing to do here
+        if (!pendingMigrations.length) {
+            this.connection.logger.logSchemaBuild(`No migrations are pending`);
+            // if query runner was created by us then release it
+            if (!this.queryRunner)
+                await queryRunner.release();
+            return [];
+        }
+        // log information about migration execution
+        this.connection.logger.logSchemaBuild(`${executedMigrations.length} migrations are already loaded in the database.`);
+        this.connection.logger.logSchemaBuild(`${allMigrations.length} migrations were found in the source code.`);
+        if (lastTimeExecutedMigration)
+            this.connection.logger.logSchemaBuild(`${lastTimeExecutedMigration.name} is the last executed migration. It was executed on ${new Date(lastTimeExecutedMigration.timestamp).toString()}.`);
+        this.connection.logger.logSchemaBuild(`${pendingMigrations.length} migrations are new migrations must be executed.`);
+        // start transaction if its not started yet
+        let transactionStartedByUs = false;
+        if (this.transaction === "all" && !queryRunner.isTransactionActive) {
+            await queryRunner.startTransaction();
+            transactionStartedByUs = true;
+        }
+        // run all pending migrations in a sequence
+        try {
+            for (const migration of pendingMigrations) {
+                if (this.fake) {
+                    // directly insert migration record into the database if it is fake
+                    await this.insertExecutedMigration(queryRunner, migration);
+                    // nothing else needs to be done, continue to next migration
+                    continue;
+                }
+                if (this.transaction === "each" &&
+                    !queryRunner.isTransactionActive) {
+                    await queryRunner.startTransaction();
+                    transactionStartedByUs = true;
+                }
+                await migration
+                    .instance.up(queryRunner)
+                    .catch((error) => {
+                    // informative log about migration failure
+                    this.connection.logger.logMigration(`Migration "${migration.name}" failed, error: ${error?.message}`);
+                    throw error;
+                })
+                    .then(async () => {
+                    // now when migration is executed we need to insert record about it into the database
+                    await this.insertExecutedMigration(queryRunner, migration);
+                    // commit transaction if we started it
+                    if (this.transaction === "each" &&
+                        transactionStartedByUs)
+                        await queryRunner.commitTransaction();
+                })
+                    .then(() => {
+                    // informative log about migration success
+                    successMigrations.push(migration);
+                    this.connection.logger.logSchemaBuild(`Migration ${migration.name} has been ${this.fake ? "(fake)" : ""} executed successfully.`);
+                });
+            }
+            // commit transaction if we started it
+            if (this.transaction === "all" && transactionStartedByUs)
+                await queryRunner.commitTransaction();
+        }
+        catch (err) {
+            // rollback transaction if we started it
+            if (transactionStartedByUs) {
+                try {
+                    // we throw original error even if rollback thrown an error
+                    await queryRunner.rollbackTransaction();
+                }
+                catch (rollbackError) { }
+            }
+            throw err;
+        }
+        finally {
+            // if query runner was created by us then release it
+            if (!this.queryRunner)
+                await queryRunner.release();
+        }
+        return successMigrations;
+    }
+    /**
+     * Reverts last migration that were run.
+     */
+    async undoLastMigration() {
+        const queryRunner = this.queryRunner || this.connection.createQueryRunner();
+        // create migrations table if it's not created yet
+        await this.createMigrationsTableIfNotExist(queryRunner);
+        // create typeorm_metadata table if it's not created yet
+        const schemaBuilder = this.connection.driver.createSchemaBuilder();
+        if (InstanceChecker_1.InstanceChecker.isRdbmsSchemaBuilder(schemaBuilder)) {
+            await schemaBuilder.createMetadataTableIfNecessary(queryRunner);
+        }
+        // get all migrations that are executed and saved in the database
+        const executedMigrations = await this.loadExecutedMigrations(queryRunner);
+        // get the time when last migration was executed
+        let lastTimeExecutedMigration = this.getLatestExecutedMigration(executedMigrations);
+        // if no migrations found in the database then nothing to revert
+        if (!lastTimeExecutedMigration) {
+            this.connection.logger.logSchemaBuild(`No migrations was found in the database. Nothing to revert!`);
+            return;
+        }
+        // get all user's migrations in the source code
+        const allMigrations = this.getMigrations();
+        // find the instance of the migration we need to remove
+        const migrationToRevert = allMigrations.find((migration) => migration.name === lastTimeExecutedMigration.name);
+        // if no migrations found in the database then nothing to revert
+        if (!migrationToRevert)
+            throw new error_1.TypeORMError(`No migration ${lastTimeExecutedMigration.name} was found in the source code. Make sure you have this migration in your codebase and its included in the connection options.`);
+        // log information about migration execution
+        this.connection.logger.logSchemaBuild(`${executedMigrations.length} migrations are already loaded in the database.`);
+        this.connection.logger.logSchemaBuild(`${lastTimeExecutedMigration.name} is the last executed migration. It was executed on ${new Date(lastTimeExecutedMigration.timestamp).toString()}.`);
+        this.connection.logger.logSchemaBuild(`Now reverting it...`);
+        // start transaction if its not started yet
+        let transactionStartedByUs = false;
+        if (this.transaction !== "none" && !queryRunner.isTransactionActive) {
+            await queryRunner.startTransaction();
+            transactionStartedByUs = true;
+        }
+        try {
+            if (!this.fake) {
+                await queryRunner.beforeMigration();
+                await migrationToRevert.instance.down(queryRunner);
+                await queryRunner.afterMigration();
+            }
+            await this.deleteExecutedMigration(queryRunner, migrationToRevert);
+            this.connection.logger.logSchemaBuild(`Migration ${migrationToRevert.name} has been ${this.fake ? "(fake)" : ""} reverted successfully.`);
+            // commit transaction if we started it
+            if (transactionStartedByUs)
+                await queryRunner.commitTransaction();
+        }
+        catch (err) {
+            // rollback transaction if we started it
+            if (transactionStartedByUs) {
+                try {
+                    // we throw original error even if rollback thrown an error
+                    await queryRunner.rollbackTransaction();
+                }
+                catch (rollbackError) { }
+            }
+            throw err;
+        }
+        finally {
+            // if query runner was created by us then release it
+            if (!this.queryRunner)
+                await queryRunner.release();
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Protected Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Creates table "migrations" that will store information about executed migrations.
+     */
+    async createMigrationsTableIfNotExist(queryRunner) {
+        // If driver is mongo no need to create
+        if (this.connection.driver.options.type === "mongodb") {
+            return;
+        }
+        const tableExist = await queryRunner.hasTable(this.migrationsTable); // todo: table name should be configurable
+        if (!tableExist) {
+            await queryRunner.createTable(new Table_1.Table({
+                database: this.migrationsDatabase,
+                schema: this.migrationsSchema,
+                name: this.migrationsTable,
+                columns: [
+                    {
+                        name: "id",
+                        type: this.connection.driver.normalizeType({
+                            type: this.connection.driver.mappedDataTypes
+                                .migrationId,
+                        }),
+                        isGenerated: true,
+                        generationStrategy: "increment",
+                        isPrimary: true,
+                        isNullable: false,
+                    },
+                    {
+                        name: "timestamp",
+                        type: this.connection.driver.normalizeType({
+                            type: this.connection.driver.mappedDataTypes
+                                .migrationTimestamp,
+                        }),
+                        isPrimary: false,
+                        isNullable: false,
+                    },
+                    {
+                        name: "name",
+                        type: this.connection.driver.normalizeType({
+                            type: this.connection.driver.mappedDataTypes
+                                .migrationName,
+                        }),
+                        isNullable: false,
+                    },
+                ],
+            }));
+        }
+    }
+    /**
+     * Loads all migrations that were executed and saved into the database (sorts by id).
+     */
+    async loadExecutedMigrations(queryRunner) {
+        if (this.connection.driver.options.type === "mongodb") {
+            //#region @backendFunc
+            const mongoRunner = queryRunner;
+            return await mongoRunner.databaseConnection
+                .db(this.connection.driver.database)
+                .collection(this.migrationsTableName)
+                .find()
+                .sort({ _id: -1 })
+                .toArray();
+            //#endregion
+        }
+        else {
+            const migrationsRaw = await this.connection.manager
+                .createQueryBuilder(queryRunner)
+                .select()
+                .orderBy(this.connection.driver.escape("id"), "DESC")
+                .from(this.migrationsTable, this.migrationsTableName)
+                .getRawMany();
+            return migrationsRaw.map((migrationRaw) => {
+                return new Migration_1.Migration(parseInt(migrationRaw["id"]), parseInt(migrationRaw["timestamp"]), migrationRaw["name"]);
+            });
+        }
+    }
+    /**
+     * Gets all migrations that setup for this connection.
+     */
+    getMigrations() {
+        const migrations = this.connection.migrations.map((migration) => {
+            const migrationClassName = migration.name || migration.constructor.name;
+            const migrationTimestamp = parseInt(migrationClassName.substr(-13), 10);
+            if (!migrationTimestamp || isNaN(migrationTimestamp)) {
+                throw new error_1.TypeORMError(`${migrationClassName} migration name is wrong. Migration class name should have a JavaScript timestamp appended.`);
+            }
+            return new Migration_1.Migration(undefined, migrationTimestamp, migrationClassName, migration);
+        });
+        this.checkForDuplicateMigrations(migrations);
+        // sort them by timestamp
+        return migrations.sort((a, b) => a.timestamp - b.timestamp);
+    }
+    checkForDuplicateMigrations(migrations) {
+        const migrationNames = migrations.map((migration) => migration.name);
+        const duplicates = Array.from(new Set(migrationNames.filter((migrationName, index) => migrationNames.indexOf(migrationName) < index)));
+        if (duplicates.length > 0) {
+            throw Error(`Duplicate migrations: ${duplicates.join(", ")}`);
+        }
+    }
+    /**
+     * Finds the latest migration (sorts by timestamp) in the given array of migrations.
+     */
+    getLatestTimestampMigration(migrations) {
+        const sortedMigrations = migrations
+            .map((migration) => migration)
+            .sort((a, b) => (a.timestamp - b.timestamp) * -1);
+        return sortedMigrations.length > 0 ? sortedMigrations[0] : undefined;
+    }
+    /**
+     * Finds the latest migration in the given array of migrations.
+     * PRE: Migration array must be sorted by descending id.
+     */
+    getLatestExecutedMigration(sortedMigrations) {
+        return sortedMigrations.length > 0 ? sortedMigrations[0] : undefined;
+    }
+    /**
+     * Inserts new executed migration's data into migrations table.
+     */
+    async insertExecutedMigration(queryRunner, migration) {
+        const values = {};
+        if (this.connection.driver.options.type === "mssql") {
+            //#region @backend
+            values["timestamp"] = new MssqlParameter_1.MssqlParameter(migration.timestamp, this.connection.driver.normalizeType({
+                type: this.connection.driver.mappedDataTypes
+                    .migrationTimestamp,
+            }));
+            values["name"] = new MssqlParameter_1.MssqlParameter(migration.name, this.connection.driver.normalizeType({
+                type: this.connection.driver.mappedDataTypes.migrationName,
+            }));
+            //#endregion
+        }
+        else {
+            values["timestamp"] = migration.timestamp;
+            values["name"] = migration.name;
+        }
+        if (this.connection.driver.options.type === "mongodb") {
+            //#region @backend
+            const mongoRunner = queryRunner;
+            await mongoRunner.databaseConnection
+                .db(this.connection.driver.database)
+                .collection(this.migrationsTableName)
+                .insertOne(values);
+            //#endregion
+        }
+        else {
+            const qb = queryRunner.manager.createQueryBuilder();
+            await qb
+                .insert()
+                .into(this.migrationsTable)
+                .values(values)
+                .execute();
+        }
+    }
+    /**
+     * Delete previously executed migration's data from the migrations table.
+     */
+    async deleteExecutedMigration(queryRunner, migration) {
+        const conditions = {};
+        if (this.connection.driver.options.type === "mssql") {
+            //#region @backend
+            conditions["timestamp"] = new MssqlParameter_1.MssqlParameter(migration.timestamp, this.connection.driver.normalizeType({
+                type: this.connection.driver.mappedDataTypes
+                    .migrationTimestamp,
+            }));
+            conditions["name"] = new MssqlParameter_1.MssqlParameter(migration.name, this.connection.driver.normalizeType({
+                type: this.connection.driver.mappedDataTypes.migrationName,
+            }));
+            //#endregion
+        }
+        else {
+            conditions["timestamp"] = migration.timestamp;
+            conditions["name"] = migration.name;
+        }
+        if (this.connection.driver.options.type === "mongodb") {
+            //#region @backend
+            const mongoRunner = queryRunner;
+            await mongoRunner.databaseConnection
+                .db(this.connection.driver.database)
+                .collection(this.migrationsTableName)
+                .deleteOne(conditions);
+            //#endregion
+        }
+        else {
+            const qb = queryRunner.manager.createQueryBuilder();
+            await qb
+                .delete()
+                .from(this.migrationsTable)
+                .where(`${qb.escape("timestamp")} = :timestamp`)
+                .andWhere(`${qb.escape("name")} = :name`)
+                .setParameters(conditions)
+                .execute();
+        }
+    }
+    async withQueryRunner(callback) {
+        const queryRunner = this.queryRunner || this.connection.createQueryRunner();
+        try {
+            return callback(queryRunner);
+        }
+        finally {
+            if (!this.queryRunner) {
+                await queryRunner.release();
+            }
+        }
+    }
+}
+exports.MigrationExecutor = MigrationExecutor;
+//# sourceMappingURL=MigrationExecutor.js.map