@depup/typeorm 0.3.28-depup.0

package/metadata-builder/RelationJoinColumnBuilder.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationJoinColumnBuilder = void 0;
+const ColumnMetadata_1 = require("../metadata/ColumnMetadata");
+const UniqueMetadata_1 = require("../metadata/UniqueMetadata");
+const ForeignKeyMetadata_1 = require("../metadata/ForeignKeyMetadata");
+const error_1 = require("../error");
+const DriverUtils_1 = require("../driver/DriverUtils");
+const OrmUtils_1 = require("../util/OrmUtils");
+/**
+ * Builds join column for the many-to-one and one-to-one owner relations.
+ *
+ * Cases it should cover:
+ * 1. when join column is set with custom name and without referenced column name
+ * we need automatically set referenced column name - primary ids by default
+ * @JoinColumn({ name: "custom_name" })
+ *
+ * 2. when join column is set with only referenced column name
+ * we need automatically set join column name - relation name + referenced column name
+ * @JoinColumn({ referencedColumnName: "title" })
+ *
+ * 3. when join column is set without both referenced column name and join column name
+ * we need to automatically set both of them
+ * @JoinColumn()
+ *
+ * 4. when join column is not set at all (as in case of @ManyToOne relation)
+ * we need to create join column for it with proper referenced column name and join column name
+ *
+ * 5. when multiple join columns set none of referencedColumnName and name can be optional
+ * both options are required
+ * @JoinColumn([
+ *      { name: "category_title", referencedColumnName: "type" },
+ *      { name: "category_title", referencedColumnName: "name" },
+ * ])
+ *
+ * Since for many-to-one relations having JoinColumn decorator is not required,
+ * we need to go through each many-to-one relation without join column decorator set
+ * and create join column metadata args for them.
+ */
+class RelationJoinColumnBuilder {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(connection) {
+        this.connection = connection;
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Builds a foreign key of the many-to-one or one-to-one owner relations.
+     */
+    build(joinColumns, relation) {
+        const referencedColumns = this.collectReferencedColumns(joinColumns, relation);
+        const columns = this.collectColumns(joinColumns, relation, referencedColumns);
+        if (!referencedColumns.length || !relation.createForeignKeyConstraints)
+            return {
+                foreignKey: undefined,
+                columns,
+                uniqueConstraint: undefined,
+            }; // this case is possible for one-to-one non owning side and relations with createForeignKeyConstraints = false
+        const foreignKey = new ForeignKeyMetadata_1.ForeignKeyMetadata({
+            name: joinColumns[0]?.foreignKeyConstraintName,
+            entityMetadata: relation.entityMetadata,
+            referencedEntityMetadata: relation.inverseEntityMetadata,
+            namingStrategy: this.connection.namingStrategy,
+            columns,
+            referencedColumns,
+            onDelete: relation.onDelete,
+            onUpdate: relation.onUpdate,
+            deferrable: relation.deferrable,
+        });
+        // SQL requires UNIQUE/PK constraints on columns referenced by a FK
+        // Skip creating the unique constraint for the referenced columns if
+        // they are already contained in the PK of the referenced entity
+        if (columns.every((column) => column.isPrimary) ||
+            !relation.isOneToOne) {
+            return { foreignKey, columns, uniqueConstraint: undefined };
+        }
+        const uniqueConstraint = new UniqueMetadata_1.UniqueMetadata({
+            entityMetadata: relation.entityMetadata,
+            columns: foreignKey.columns,
+            args: {
+                name: this.connection.namingStrategy.relationConstraintName(relation.entityMetadata.tableName, foreignKey.columns.map((column) => column.databaseName)),
+                target: relation.entityMetadata.target,
+            },
+        });
+        uniqueConstraint.build(this.connection.namingStrategy);
+        return { foreignKey, columns, uniqueConstraint };
+    }
+    // -------------------------------------------------------------------------
+    // Protected Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Collects referenced columns from the given join column args.
+     */
+    collectReferencedColumns(joinColumns, relation) {
+        const hasAnyReferencedColumnName = joinColumns.find((joinColumnArgs) => !!joinColumnArgs.referencedColumnName);
+        const manyToOneWithoutJoinColumn = joinColumns.length === 0 && relation.isManyToOne;
+        const hasJoinColumnWithoutAnyReferencedColumnName = joinColumns.length > 0 && !hasAnyReferencedColumnName;
+        if (manyToOneWithoutJoinColumn ||
+            hasJoinColumnWithoutAnyReferencedColumnName) {
+            // covers case3 and case1
+            return relation.inverseEntityMetadata.primaryColumns;
+        }
+        else {
+            // cases with referenced columns defined
+            return joinColumns.map((joinColumn) => {
+                const referencedColumn = relation.inverseEntityMetadata.ownColumns.find((column) => column.propertyName ===
+                    joinColumn.referencedColumnName); // todo: can we also search in relations?
+                if (!referencedColumn)
+                    throw new error_1.TypeORMError(`Referenced column ${joinColumn.referencedColumnName} was not found in entity ${relation.inverseEntityMetadata.name}`);
+                return referencedColumn;
+            });
+        }
+    }
+    /**
+     * Collects columns from the given join column args.
+     */
+    collectColumns(joinColumns, relation, referencedColumns) {
+        return referencedColumns.map((referencedColumn) => {
+            // in the case if relation has join column with only name set we need this check
+            const joinColumnMetadataArg = joinColumns.find((joinColumn) => {
+                return ((!joinColumn.referencedColumnName ||
+                    joinColumn.referencedColumnName ===
+                        referencedColumn.propertyName) &&
+                    !!joinColumn.name);
+            });
+            const joinColumnName = joinColumnMetadataArg
+                ? joinColumnMetadataArg.name
+                : this.connection.namingStrategy.joinColumnName(relation.propertyName, referencedColumn.propertyName);
+            const relationalColumns = relation.embeddedMetadata
+                ? relation.embeddedMetadata.columns
+                : relation.entityMetadata.ownColumns;
+            let relationalColumn = relationalColumns.find((column) => column.databaseNameWithoutPrefixes === joinColumnName);
+            if (!relationalColumn) {
+                relationalColumn = new ColumnMetadata_1.ColumnMetadata({
+                    connection: this.connection,
+                    entityMetadata: relation.entityMetadata,
+                    embeddedMetadata: relation.embeddedMetadata,
+                    args: {
+                        target: "",
+                        mode: "virtual",
+                        propertyName: relation.propertyName,
+                        options: {
+                            name: joinColumnName,
+                            type: referencedColumn.type,
+                            length: !referencedColumn.length &&
+                                (DriverUtils_1.DriverUtils.isMySQLFamily(this.connection.driver) ||
+                                    this.connection.driver.options.type ===
+                                        "aurora-mysql") &&
+                                // some versions of mariadb support the column type and should not try to provide the length property
+                                this.connection.driver.normalizeType(referencedColumn) !== "uuid" &&
+                                (referencedColumn.generationStrategy ===
+                                    "uuid" ||
+                                    referencedColumn.type === "uuid")
+                                ? "36"
+                                : referencedColumn.length, // fix https://github.com/typeorm/typeorm/issues/3604
+                            width: referencedColumn.width,
+                            charset: referencedColumn.charset,
+                            collation: referencedColumn.collation,
+                            precision: referencedColumn.precision,
+                            scale: referencedColumn.scale,
+                            zerofill: referencedColumn.zerofill,
+                            unsigned: referencedColumn.unsigned,
+                            comment: referencedColumn.comment,
+                            enum: referencedColumn.enum,
+                            enumName: referencedColumn.enumName,
+                            primary: relation.isPrimary,
+                            nullable: relation.isNullable,
+                        },
+                    },
+                });
+                relation.entityMetadata.registerColumn(relationalColumn);
+            }
+            else if (relationalColumn.referencedColumn) {
+                // Clone the relational column to prevent modifying the original when multiple
+                // relations reference the same column. This ensures each relation gets its own
+                // copy with independent referencedColumn and type properties.
+                relationalColumn = OrmUtils_1.OrmUtils.cloneObject(relationalColumn);
+            }
+            relationalColumn.referencedColumn = referencedColumn; // its important to set it here because we need to set referenced column for user defined join column
+            relationalColumn.type = referencedColumn.type; // also since types of relational column and join column must be equal we override user defined column type
+            relationalColumn.relationMetadata = relation;
+            relationalColumn.build(this.connection);
+            return relationalColumn;
+        });
+    }
+}
+exports.RelationJoinColumnBuilder = RelationJoinColumnBuilder;
+
+//# sourceMappingURL=RelationJoinColumnBuilder.js.map

package/metadata-builder/RelationJoinColumnBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/metadata-builder/RelationJoinColumnBuilder.ts"],"names":[],"mappings":"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","file":"RelationJoinColumnBuilder.js","sourcesContent":["import { ColumnMetadata } from \"../metadata/ColumnMetadata\"\nimport { UniqueMetadata } from \"../metadata/UniqueMetadata\"\nimport { ForeignKeyMetadata } from \"../metadata/ForeignKeyMetadata\"\nimport { RelationMetadata } from \"../metadata/RelationMetadata\"\nimport { JoinColumnMetadataArgs } from \"../metadata-args/JoinColumnMetadataArgs\"\nimport { DataSource } from \"../data-source/DataSource\"\nimport { TypeORMError } from \"../error\"\nimport { DriverUtils } from \"../driver/DriverUtils\"\nimport { OrmUtils } from \"../util/OrmUtils\"\n\n/**\n * Builds join column for the many-to-one and one-to-one owner relations.\n *\n * Cases it should cover:\n * 1. when join column is set with custom name and without referenced column name\n * we need automatically set referenced column name - primary ids by default\n * @JoinColumn({ name: \"custom_name\" })\n *\n * 2. when join column is set with only referenced column name\n * we need automatically set join column name - relation name + referenced column name\n * @JoinColumn({ referencedColumnName: \"title\" })\n *\n * 3. when join column is set without both referenced column name and join column name\n * we need to automatically set both of them\n * @JoinColumn()\n *\n * 4. when join column is not set at all (as in case of @ManyToOne relation)\n * we need to create join column for it with proper referenced column name and join column name\n *\n * 5. when multiple join columns set none of referencedColumnName and name can be optional\n * both options are required\n * @JoinColumn([\n *      { name: \"category_title\", referencedColumnName: \"type\" },\n *      { name: \"category_title\", referencedColumnName: \"name\" },\n * ])\n *\n * Since for many-to-one relations having JoinColumn decorator is not required,\n * we need to go through each many-to-one relation without join column decorator set\n * and create join column metadata args for them.\n */\nexport class RelationJoinColumnBuilder {\n    // -------------------------------------------------------------------------\n    // Constructor\n    // -------------------------------------------------------------------------\n\n    constructor(private connection: DataSource) {}\n\n    // -------------------------------------------------------------------------\n    // Public Methods\n    // -------------------------------------------------------------------------\n\n    /**\n     * Builds a foreign key of the many-to-one or one-to-one owner relations.\n     */\n    build(\n        joinColumns: JoinColumnMetadataArgs[],\n        relation: RelationMetadata,\n    ): {\n        foreignKey: ForeignKeyMetadata | undefined\n        columns: ColumnMetadata[]\n        uniqueConstraint: UniqueMetadata | undefined\n    } {\n        const referencedColumns = this.collectReferencedColumns(\n            joinColumns,\n            relation,\n        )\n        const columns = this.collectColumns(\n            joinColumns,\n            relation,\n            referencedColumns,\n        )\n        if (!referencedColumns.length || !relation.createForeignKeyConstraints)\n            return {\n                foreignKey: undefined,\n                columns,\n                uniqueConstraint: undefined,\n            } // this case is possible for one-to-one non owning side and relations with createForeignKeyConstraints = false\n\n        const foreignKey = new ForeignKeyMetadata({\n            name: joinColumns[0]?.foreignKeyConstraintName,\n            entityMetadata: relation.entityMetadata,\n            referencedEntityMetadata: relation.inverseEntityMetadata,\n            namingStrategy: this.connection.namingStrategy,\n            columns,\n            referencedColumns,\n            onDelete: relation.onDelete,\n            onUpdate: relation.onUpdate,\n            deferrable: relation.deferrable,\n        })\n\n        // SQL requires UNIQUE/PK constraints on columns referenced by a FK\n        // Skip creating the unique constraint for the referenced columns if\n        // they are already contained in the PK of the referenced entity\n        if (\n            columns.every((column) => column.isPrimary) ||\n            !relation.isOneToOne\n        ) {\n            return { foreignKey, columns, uniqueConstraint: undefined }\n        }\n\n        const uniqueConstraint = new UniqueMetadata({\n            entityMetadata: relation.entityMetadata,\n            columns: foreignKey.columns,\n            args: {\n                name: this.connection.namingStrategy.relationConstraintName(\n                    relation.entityMetadata.tableName,\n                    foreignKey.columns.map((column) => column.databaseName),\n                ),\n                target: relation.entityMetadata.target,\n            },\n        })\n        uniqueConstraint.build(this.connection.namingStrategy)\n\n        return { foreignKey, columns, uniqueConstraint }\n    }\n\n    // -------------------------------------------------------------------------\n    // Protected Methods\n    // -------------------------------------------------------------------------\n\n    /**\n     * Collects referenced columns from the given join column args.\n     */\n    protected collectReferencedColumns(\n        joinColumns: JoinColumnMetadataArgs[],\n        relation: RelationMetadata,\n    ): ColumnMetadata[] {\n        const hasAnyReferencedColumnName = joinColumns.find(\n            (joinColumnArgs) => !!joinColumnArgs.referencedColumnName,\n        )\n        const manyToOneWithoutJoinColumn =\n            joinColumns.length === 0 && relation.isManyToOne\n        const hasJoinColumnWithoutAnyReferencedColumnName =\n            joinColumns.length > 0 && !hasAnyReferencedColumnName\n\n        if (\n            manyToOneWithoutJoinColumn ||\n            hasJoinColumnWithoutAnyReferencedColumnName\n        ) {\n            // covers case3 and case1\n            return relation.inverseEntityMetadata.primaryColumns\n        } else {\n            // cases with referenced columns defined\n            return joinColumns.map((joinColumn) => {\n                const referencedColumn =\n                    relation.inverseEntityMetadata.ownColumns.find(\n                        (column) =>\n                            column.propertyName ===\n                            joinColumn.referencedColumnName,\n                    ) // todo: can we also search in relations?\n                if (!referencedColumn)\n                    throw new TypeORMError(\n                        `Referenced column ${joinColumn.referencedColumnName} was not found in entity ${relation.inverseEntityMetadata.name}`,\n                    )\n\n                return referencedColumn\n            })\n        }\n    }\n\n    /**\n     * Collects columns from the given join column args.\n     */\n    private collectColumns(\n        joinColumns: JoinColumnMetadataArgs[],\n        relation: RelationMetadata,\n        referencedColumns: ColumnMetadata[],\n    ): ColumnMetadata[] {\n        return referencedColumns.map((referencedColumn) => {\n            // in the case if relation has join column with only name set we need this check\n            const joinColumnMetadataArg = joinColumns.find((joinColumn) => {\n                return (\n                    (!joinColumn.referencedColumnName ||\n                        joinColumn.referencedColumnName ===\n                            referencedColumn.propertyName) &&\n                    !!joinColumn.name\n                )\n            })\n            const joinColumnName = joinColumnMetadataArg\n                ? joinColumnMetadataArg.name\n                : this.connection.namingStrategy.joinColumnName(\n                      relation.propertyName,\n                      referencedColumn.propertyName,\n                  )\n\n            const relationalColumns = relation.embeddedMetadata\n                ? relation.embeddedMetadata.columns\n                : relation.entityMetadata.ownColumns\n            let relationalColumn = relationalColumns.find(\n                (column) =>\n                    column.databaseNameWithoutPrefixes === joinColumnName,\n            )\n            if (!relationalColumn) {\n                relationalColumn = new ColumnMetadata({\n                    connection: this.connection,\n                    entityMetadata: relation.entityMetadata,\n                    embeddedMetadata: relation.embeddedMetadata,\n                    args: {\n                        target: \"\",\n                        mode: \"virtual\",\n                        propertyName: relation.propertyName,\n                        options: {\n                            name: joinColumnName,\n                            type: referencedColumn.type,\n                            length:\n                                !referencedColumn.length &&\n                                (DriverUtils.isMySQLFamily(\n                                    this.connection.driver,\n                                ) ||\n                                    this.connection.driver.options.type ===\n                                        \"aurora-mysql\") &&\n                                // some versions of mariadb support the column type and should not try to provide the length property\n                                this.connection.driver.normalizeType(\n                                    referencedColumn,\n                                ) !== \"uuid\" &&\n                                (referencedColumn.generationStrategy ===\n                                    \"uuid\" ||\n                                    referencedColumn.type === \"uuid\")\n                                    ? \"36\"\n                                    : referencedColumn.length, // fix https://github.com/typeorm/typeorm/issues/3604\n                            width: referencedColumn.width,\n                            charset: referencedColumn.charset,\n                            collation: referencedColumn.collation,\n                            precision: referencedColumn.precision,\n                            scale: referencedColumn.scale,\n                            zerofill: referencedColumn.zerofill,\n                            unsigned: referencedColumn.unsigned,\n                            comment: referencedColumn.comment,\n                            enum: referencedColumn.enum,\n                            enumName: referencedColumn.enumName,\n                            primary: relation.isPrimary,\n                            nullable: relation.isNullable,\n                        },\n                    },\n                })\n                relation.entityMetadata.registerColumn(relationalColumn)\n            } else if (relationalColumn.referencedColumn) {\n                // Clone the relational column to prevent modifying the original when multiple\n                // relations reference the same column. This ensures each relation gets its own\n                // copy with independent referencedColumn and type properties.\n                relationalColumn = OrmUtils.cloneObject(relationalColumn)\n            }\n            relationalColumn.referencedColumn = referencedColumn // its important to set it here because we need to set referenced column for user defined join column\n            relationalColumn.type = referencedColumn.type // also since types of relational column and join column must be equal we override user defined column type\n            relationalColumn.relationMetadata = relation\n            relationalColumn.build(this.connection)\n            return relationalColumn\n        })\n    }\n}\n"],"sourceRoot":".."}

package/migration/Migration.d.ts

@@ -0,0 +1,28 @@
+import { MigrationInterface } from "./MigrationInterface";
+/**
+ * Represents entity of the migration in the database.
+ */
+export declare class Migration {
+    /**
+     * Migration id.
+     * Indicates order of the executed migrations.
+     */
+    id: number | undefined;
+    /**
+     * Timestamp of the migration.
+     */
+    timestamp: number;
+    /**
+     * Name of the migration (class name).
+     */
+    name: string;
+    /**
+     * Migration instance that needs to be run.
+     */
+    instance?: MigrationInterface;
+    /**
+     * Whether to run this migration within a transaction
+     */
+    transaction?: boolean;
+    constructor(id: number | undefined, timestamp: number, name: string, instance?: MigrationInterface, transaction?: boolean);
+}

package/migration/Migration.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migration = void 0;
+/**
+ * Represents entity of the migration in the database.
+ */
+class Migration {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(id, timestamp, name, instance, transaction) {
+        this.id = id;
+        this.timestamp = timestamp;
+        this.name = name;
+        this.instance = instance;
+        this.transaction = transaction;
+    }
+}
+exports.Migration = Migration;
+
+//# sourceMappingURL=Migration.js.map

package/migration/Migration.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/migration/Migration.ts"],"names":[],"mappings":";;;AAEA;;GAEG;AACH,MAAa,SAAS;IA+BlB,4EAA4E;IAC5E,cAAc;IACd,4EAA4E;IAE5E,YACI,EAAsB,EACtB,SAAiB,EACjB,IAAY,EACZ,QAA6B,EAC7B,WAAqB;QAErB,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;QACxB,IAAI,CAAC,WAAW,GAAG,WAAW,CAAA;IAClC,CAAC;CACJ;AAhDD,8BAgDC","file":"Migration.js","sourcesContent":["import { MigrationInterface } from \"./MigrationInterface\"\n\n/**\n * Represents entity of the migration in the database.\n */\nexport class Migration {\n    // -------------------------------------------------------------------------\n    // Public Properties\n    // -------------------------------------------------------------------------\n\n    /**\n     * Migration id.\n     * Indicates order of the executed migrations.\n     */\n    id: number | undefined\n\n    /**\n     * Timestamp of the migration.\n     */\n    timestamp: number\n\n    /**\n     * Name of the migration (class name).\n     */\n    name: string\n\n    /**\n     * Migration instance that needs to be run.\n     */\n    instance?: MigrationInterface\n\n    /**\n     * Whether to run this migration within a transaction\n     */\n    transaction?: boolean\n\n    // -------------------------------------------------------------------------\n    // Constructor\n    // -------------------------------------------------------------------------\n\n    constructor(\n        id: number | undefined,\n        timestamp: number,\n        name: string,\n        instance?: MigrationInterface,\n        transaction?: boolean,\n    ) {\n        this.id = id\n        this.timestamp = timestamp\n        this.name = name\n        this.instance = instance\n        this.transaction = transaction\n    }\n}\n"],"sourceRoot":".."}

package/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 | undefined;
+    /**
+     * 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 | undefined);
+    /**
+     * 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>;
+}