typeorm 0.3.29-dev.cc07c90 → 1.0.0-beta.1

package/browser/migration/MigrationExecutor.js

@@ -1,17 +1,20 @@
-import { Table } from "../schema-builder/table/Table";
-import { Migration } from "./Migration";
-import { MssqlParameter } from "../driver/sqlserver/MssqlParameter";
-import { ForbiddenTransactionModeOverrideError, TypeORMError } from "../error";
-import { InstanceChecker } from "../util/InstanceChecker";
+"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");
+const MssqlParameter_1 = require("../driver/sqlserver/MssqlParameter");
+const error_1 = require("../error");
+const InstanceChecker_1 = require("../util/InstanceChecker");
 /**
  * Executes migrations: runs pending and reverts previously executed migrations.
  */
-export class MigrationExecutor {
+class MigrationExecutor {
     // -------------------------------------------------------------------------
     // Constructor
     // -------------------------------------------------------------------------
-    constructor(connection, queryRunner) {
-        this.connection = connection;
+    constructor(dataSource, queryRunner) {
+        this.dataSource = dataSource;
         this.queryRunner = queryRunner;
         // -------------------------------------------------------------------------
         // Public Properties
@@ -23,26 +26,27 @@ export class MigrationExecutor {
          *   each: each migration is run in a separate transaction
          */
         this.transaction = "all";
-        const { schema } = this.connection.driver.options;
-        const database = this.connection.driver.database;
+        const { schema } = this.dataSource.driver.options;
+        const database = this.dataSource.driver.database;
         this.migrationsDatabase = database;
         this.migrationsSchema = schema;
         this.migrationsTableName =
-            connection.options.migrationsTableName || "migrations";
-        this.migrationsTable = this.connection.driver.buildTableName(this.migrationsTableName, schema, database);
+            dataSource.options.migrationsTableName || "migrations";
+        this.migrationsTable = this.dataSource.driver.buildTableName(this.migrationsTableName, schema, database);
     }
     // -------------------------------------------------------------------------
     // Public Methods
     // -------------------------------------------------------------------------
     /**
      * Tries to execute a single migration given.
+     * @param migration
      */
     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.isRdbmsSchemaBuilder(schemaBuilder)) {
+            const schemaBuilder = this.dataSource.driver.createSchemaBuilder();
+            if (InstanceChecker_1.InstanceChecker.isRdbmsSchemaBuilder(schemaBuilder)) {
                 await schemaBuilder.createMetadataTableIfNecessary(queryRunner);
             }
             await queryRunner.beforeMigration();
@@ -53,17 +57,17 @@ export class MigrationExecutor {
         });
     }
     /**
-     * Returns an array of all migrations.
-     */
-    async getAllMigrations() {
-        return Promise.resolve(this.getMigrations());
-    }
-    /**
-     * Returns an array of all executed migrations.
+     * @returns An array of all executed migrations
      */
     async getExecutedMigrations() {
         return this.withQueryRunner(async (queryRunner) => {
-            await this.createMigrationsTableIfNotExist(queryRunner);
+            // There is no need to check if migrations table exists for MongoDB,
+            // as it's handled in loadExecutedMigrations
+            if (this.dataSource.driver.options.type !== "mongodb") {
+                const exist = await queryRunner.hasTable(this.migrationsTable);
+                if (!exist)
+                    return [];
+            }
             return await this.loadExecutedMigrations(queryRunner);
         });
     }
@@ -71,18 +75,22 @@ export class MigrationExecutor {
      * Returns an array of all pending migrations.
      */
     async getPendingMigrations() {
-        const allMigrations = await this.getAllMigrations();
+        const allMigrations = this.getMigrations();
         const executedMigrations = await this.getExecutedMigrations();
+        if (executedMigrations.length === 0)
+            return allMigrations;
         return allMigrations.filter((migration) => !executedMigrations.find((executedMigration) => executedMigration.name === migration.name));
     }
     /**
      * Inserts an executed migration.
+     * @param migration
      */
     insertMigration(migration) {
         return this.withQueryRunner((q) => this.insertExecutedMigration(q, migration));
     }
     /**
      * Deletes an executed migration.
+     * @param migration
      */
     deleteMigration(migration) {
         return this.withQueryRunner((q) => this.deleteExecutedMigration(q, migration));
@@ -93,7 +101,7 @@ export class MigrationExecutor {
      */
     async showMigrations() {
         let hasUnappliedMigrations = false;
-        const queryRunner = this.queryRunner || this.connection.createQueryRunner();
+        const queryRunner = this.queryRunner || this.dataSource.createQueryRunner();
         // create migrations table if its not created yet
         await this.createMigrationsTableIfNotExist(queryRunner);
         // get all migrations that are executed and saved in the database
@@ -103,11 +111,11 @@ export class MigrationExecutor {
         for (const migration of allMigrations) {
             const executedMigration = executedMigrations.find((executedMigration) => executedMigration.name === migration.name);
             if (executedMigration) {
-                this.connection.logger.logSchemaBuild(`[X] ${executedMigration.id} ${migration.name}`);
+                this.dataSource.logger.logSchemaBuild(`[X] ${executedMigration.id} ${migration.name}`);
             }
             else {
                 hasUnappliedMigrations = true;
-                this.connection.logger.logSchemaBuild(`[ ] ${migration.name}`);
+                this.dataSource.logger.logSchemaBuild(`[ ] ${migration.name}`);
             }
         }
         // if query runner was created by us then release it
@@ -121,12 +129,12 @@ export class MigrationExecutor {
      * thus not saved in the database.
      */
     async executePendingMigrations() {
-        const queryRunner = this.queryRunner || this.connection.createQueryRunner();
+        const queryRunner = this.queryRunner || this.dataSource.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.isRdbmsSchemaBuilder(schemaBuilder)) {
+        const schemaBuilder = this.dataSource.driver.createSchemaBuilder();
+        if (InstanceChecker_1.InstanceChecker.isRdbmsSchemaBuilder(schemaBuilder)) {
             await schemaBuilder.createMetadataTableIfNecessary(queryRunner);
         }
         // get all migrations that are executed and saved in the database
@@ -151,18 +159,18 @@ export class MigrationExecutor {
         });
         // if no migrations are pending then nothing to do here
         if (!pendingMigrations.length) {
-            this.connection.logger.logSchemaBuild(`No migrations are pending`);
+            this.dataSource.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.`);
+        this.dataSource.logger.logSchemaBuild(`${executedMigrations.length} migrations are already loaded in the database.`);
+        this.dataSource.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.`);
+            this.dataSource.logger.logSchemaBuild(`${lastTimeExecutedMigration.name} is the last executed migration. It was executed on ${new Date(lastTimeExecutedMigration.timestamp).toString()}.`);
+        this.dataSource.logger.logSchemaBuild(`${pendingMigrations.length} migrations are new migrations must be executed.`);
         if (this.transaction === "all") {
             // If we desire to run all migrations in a single transaction
             // but there is a migration that explicitly overrides the transaction mode
@@ -171,8 +179,8 @@ export class MigrationExecutor {
             // however to keep the interface more rigid, we fail those too
             const migrationsOverridingTransactionMode = pendingMigrations.filter((migration) => !(migration.instance?.transaction === undefined));
             if (migrationsOverridingTransactionMode.length > 0) {
-                const error = new ForbiddenTransactionModeOverrideError(migrationsOverridingTransactionMode);
-                this.connection.logger.logMigration(`Migrations failed, error: ${error.message}`);
+                const error = new error_1.ForbiddenTransactionModeOverrideError(migrationsOverridingTransactionMode);
+                this.dataSource.logger.logMigration(`Migrations failed, error: ${error.message}`);
                 throw error;
             }
         }
@@ -223,7 +231,7 @@ export class MigrationExecutor {
                     .instance.up(queryRunner)
                     .catch((error) => {
                     // informative log about migration failure
-                    this.connection.logger.logMigration(`Migration "${migration.name}" failed, error: ${error?.message}`);
+                    this.dataSource.logger.logMigration(`Migration "${migration.name}" failed, error: ${error?.message}`);
                     throw error;
                 })
                     .then(async () => {
@@ -238,7 +246,7 @@ export class MigrationExecutor {
                     .then(() => {
                     // informative log about migration success
                     successMigrations.push(migration);
-                    this.connection.logger.logSchemaBuild(`Migration ${migration.name} has been ${this.fake ? "(fake) " : ""}executed successfully.`);
+                    this.dataSource.logger.logSchemaBuild(`Migration ${migration.name} has been ${this.fake ? "(fake) " : ""}executed successfully.`);
                 });
             }
             // commit transaction if we started it
@@ -269,12 +277,12 @@ export class MigrationExecutor {
      * Reverts last migration that were run.
      */
     async undoLastMigration() {
-        const queryRunner = this.queryRunner || this.connection.createQueryRunner();
+        const queryRunner = this.queryRunner || this.dataSource.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.isRdbmsSchemaBuilder(schemaBuilder)) {
+        const schemaBuilder = this.dataSource.driver.createSchemaBuilder();
+        if (InstanceChecker_1.InstanceChecker.isRdbmsSchemaBuilder(schemaBuilder)) {
             await schemaBuilder.createMetadataTableIfNecessary(queryRunner);
         }
         // get all migrations that are executed and saved in the database
@@ -283,7 +291,7 @@ export class MigrationExecutor {
         const lastTimeExecutedMigration = this.getLatestExecutedMigration(executedMigrations);
         // if no migrations found in the database then nothing to revert
         if (!lastTimeExecutedMigration) {
-            this.connection.logger.logSchemaBuild(`No migrations were found in the database. Nothing to revert!`);
+            this.dataSource.logger.logSchemaBuild(`No migrations were found in the database. Nothing to revert!`);
             // if query runner was created by us then release it
             if (!this.queryRunner)
                 await queryRunner.release();
@@ -295,11 +303,11 @@ export class MigrationExecutor {
         const migrationToRevert = allMigrations.find((migration) => migration.name === lastTimeExecutedMigration.name);
         // if no migrations found in the database then nothing to revert
         if (!migrationToRevert)
-            throw new 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.`);
+            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...`);
+        this.dataSource.logger.logSchemaBuild(`${executedMigrations.length} migrations are already loaded in the database.`);
+        this.dataSource.logger.logSchemaBuild(`${lastTimeExecutedMigration.name} is the last executed migration. It was executed on ${new Date(lastTimeExecutedMigration.timestamp).toString()}.`);
+        this.dataSource.logger.logSchemaBuild(`Now reverting it...`);
         // start transaction if its not started yet
         let transactionStartedByUs = false;
         if (this.transaction !== "none" && !queryRunner.isTransactionActive) {
@@ -313,7 +321,7 @@ export class MigrationExecutor {
                 await queryRunner.afterMigration();
             }
             await this.deleteExecutedMigration(queryRunner, migrationToRevert);
-            this.connection.logger.logSchemaBuild(`Migration ${migrationToRevert.name} has been ${this.fake ? "(fake) " : ""}reverted successfully.`);
+            this.dataSource.logger.logSchemaBuild(`Migration ${migrationToRevert.name} has been ${this.fake ? "(fake) " : ""}reverted successfully.`);
             // commit transaction if we started it
             if (transactionStartedByUs)
                 await queryRunner.commitTransaction();
@@ -340,23 +348,24 @@ export class MigrationExecutor {
     // -------------------------------------------------------------------------
     /**
      * Creates table "migrations" that will store information about executed migrations.
+     * @param queryRunner
      */
     async createMigrationsTableIfNotExist(queryRunner) {
         // If driver is mongo no need to create
-        if (this.connection.driver.options.type === "mongodb") {
+        if (this.dataSource.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({
+            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
+                        type: this.dataSource.driver.normalizeType({
+                            type: this.dataSource.driver.mappedDataTypes
                                 .migrationId,
                         }),
                         isGenerated: true,
@@ -366,8 +375,8 @@ export class MigrationExecutor {
                     },
                     {
                         name: "timestamp",
-                        type: this.connection.driver.normalizeType({
-                            type: this.connection.driver.mappedDataTypes
+                        type: this.dataSource.driver.normalizeType({
+                            type: this.dataSource.driver.mappedDataTypes
                                 .migrationTimestamp,
                         }),
                         isPrimary: false,
@@ -375,8 +384,8 @@ export class MigrationExecutor {
                     },
                     {
                         name: "name",
-                        type: this.connection.driver.normalizeType({
-                            type: this.connection.driver.mappedDataTypes
+                        type: this.dataSource.driver.normalizeType({
+                            type: this.dataSource.driver.mappedDataTypes
                                 .migrationName,
                         }),
                         isNullable: false,
@@ -387,9 +396,10 @@ export class MigrationExecutor {
     }
     /**
      * Loads all migrations that were executed and saved into the database (sorts by id).
+     * @param queryRunner
      */
     async loadExecutedMigrations(queryRunner) {
-        if (this.connection.driver.options.type === "mongodb") {
+        if (this.dataSource.driver.options.type === "mongodb") {
             const mongoRunner = queryRunner;
             return mongoRunner
                 .cursor(this.migrationsTableName, {})
@@ -397,14 +407,14 @@ export class MigrationExecutor {
                 .toArray();
         }
         else {
-            const migrationsRaw = await this.connection.manager
+            const migrationsRaw = await this.dataSource.manager
                 .createQueryBuilder(queryRunner)
                 .select()
-                .orderBy(this.connection.driver.escape("id"), "DESC")
+                .orderBy(this.dataSource.driver.escape("id"), "DESC")
                 .from(this.migrationsTable, this.migrationsTableName)
                 .getRawMany();
             return migrationsRaw.map((migrationRaw) => {
-                return new Migration(parseInt(migrationRaw["id"]), parseInt(migrationRaw["timestamp"]), migrationRaw["name"]);
+                return new Migration_1.Migration(parseInt(migrationRaw["id"]), parseInt(migrationRaw["timestamp"]), migrationRaw["name"]);
             });
         }
     }
@@ -412,13 +422,13 @@ export class MigrationExecutor {
      * Gets all migrations that setup for this connection.
      */
     getMigrations() {
-        const migrations = this.connection.migrations.map((migration) => {
+        const migrations = this.dataSource.migrations.map((migration) => {
             const migrationClassName = migration.name || migration.constructor.name;
             const migrationTimestamp = parseInt(migrationClassName.substr(-13), 10);
             if (!migrationTimestamp || isNaN(migrationTimestamp)) {
-                throw new TypeORMError(`${migrationClassName} migration name is wrong. Migration class name should have a JavaScript timestamp appended.`);
+                throw new error_1.TypeORMError(`${migrationClassName} migration name is wrong. Migration class name should have a JavaScript timestamp appended.`);
             }
-            return new Migration(undefined, migrationTimestamp, migrationClassName, migration);
+            return new Migration_1.Migration(undefined, migrationTimestamp, migrationClassName, migration);
         });
         this.checkForDuplicateMigrations(migrations);
         // sort them by timestamp
@@ -433,6 +443,7 @@ export class MigrationExecutor {
     }
     /**
      * Finds the latest migration (sorts by timestamp) in the given array of migrations.
+     * @param migrations
      */
     getLatestTimestampMigration(migrations) {
         const sortedMigrations = migrations
@@ -443,32 +454,35 @@ export class MigrationExecutor {
     /**
      * Finds the latest migration in the given array of migrations.
      * PRE: Migration array must be sorted by descending id.
+     * @param sortedMigrations
      */
     getLatestExecutedMigration(sortedMigrations) {
         return sortedMigrations.length > 0 ? sortedMigrations[0] : undefined;
     }
     /**
      * Inserts new executed migration's data into migrations table.
+     * @param queryRunner
+     * @param migration
      */
     async insertExecutedMigration(queryRunner, migration) {
         const values = {};
-        if (this.connection.driver.options.type === "mssql") {
-            values["timestamp"] = new MssqlParameter(migration.timestamp, this.connection.driver.normalizeType({
-                type: this.connection.driver.mappedDataTypes
+        if (this.dataSource.driver.options.type === "mssql") {
+            values["timestamp"] = new MssqlParameter_1.MssqlParameter(migration.timestamp, this.dataSource.driver.normalizeType({
+                type: this.dataSource.driver.mappedDataTypes
                     .migrationTimestamp,
             }));
-            values["name"] = new MssqlParameter(migration.name, this.connection.driver.normalizeType({
-                type: this.connection.driver.mappedDataTypes.migrationName,
+            values["name"] = new MssqlParameter_1.MssqlParameter(migration.name, this.dataSource.driver.normalizeType({
+                type: this.dataSource.driver.mappedDataTypes.migrationName,
             }));
         }
         else {
             values["timestamp"] = migration.timestamp;
             values["name"] = migration.name;
         }
-        if (this.connection.driver.options.type === "mongodb") {
+        if (this.dataSource.driver.options.type === "mongodb") {
             const mongoRunner = queryRunner;
             await mongoRunner.databaseConnection
-                .db(this.connection.driver.database)
+                .db(this.dataSource.driver.database)
                 .collection(this.migrationsTableName)
                 .insertOne(values);
         }
@@ -483,26 +497,28 @@ export class MigrationExecutor {
     }
     /**
      * Delete previously executed migration's data from the migrations table.
+     * @param queryRunner
+     * @param migration
      */
     async deleteExecutedMigration(queryRunner, migration) {
         const conditions = {};
-        if (this.connection.driver.options.type === "mssql") {
-            conditions["timestamp"] = new MssqlParameter(migration.timestamp, this.connection.driver.normalizeType({
-                type: this.connection.driver.mappedDataTypes
+        if (this.dataSource.driver.options.type === "mssql") {
+            conditions["timestamp"] = new MssqlParameter_1.MssqlParameter(migration.timestamp, this.dataSource.driver.normalizeType({
+                type: this.dataSource.driver.mappedDataTypes
                     .migrationTimestamp,
             }));
-            conditions["name"] = new MssqlParameter(migration.name, this.connection.driver.normalizeType({
-                type: this.connection.driver.mappedDataTypes.migrationName,
+            conditions["name"] = new MssqlParameter_1.MssqlParameter(migration.name, this.dataSource.driver.normalizeType({
+                type: this.dataSource.driver.mappedDataTypes.migrationName,
             }));
         }
         else {
             conditions["timestamp"] = migration.timestamp;
             conditions["name"] = migration.name;
         }
-        if (this.connection.driver.options.type === "mongodb") {
+        if (this.dataSource.driver.options.type === "mongodb") {
             const mongoRunner = queryRunner;
             await mongoRunner.databaseConnection
-                .db(this.connection.driver.database)
+                .db(this.dataSource.driver.database)
                 .collection(this.migrationsTableName)
                 .deleteOne(conditions);
         }
@@ -518,7 +534,7 @@ export class MigrationExecutor {
         }
     }
     async withQueryRunner(callback) {
-        const queryRunner = this.queryRunner || this.connection.createQueryRunner();
+        const queryRunner = this.queryRunner || this.dataSource.createQueryRunner();
         try {
             return await callback(queryRunner);
         }
@@ -529,5 +545,5 @@ export class MigrationExecutor {
         }
     }
 }
-
-//# sourceMappingURL=MigrationExecutor.js.map
+exports.MigrationExecutor = MigrationExecutor;
+//# sourceMappingURL=MigrationExecutor.js.map