taon-typeorm 18.0.19 → 18.0.20

package/lib/typeorm/data-source/DataSource.js

@@ -1,30 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataSource = void 0;
-var tslib_1 = require("tslib");
-var DefaultNamingStrategy_1 = require("../naming-strategy/DefaultNamingStrategy");
-var error_1 = require("../error");
-var MigrationExecutor_1 = require("../migration/MigrationExecutor");
+const DefaultNamingStrategy_1 = require("../naming-strategy/DefaultNamingStrategy");
+const error_1 = require("../error");
+const MigrationExecutor_1 = require("../migration/MigrationExecutor");
 //#endregion
-var EntityMetadataValidator_1 = require("../metadata-builder/EntityMetadataValidator");
-var EntityManagerFactory_1 = require("../entity-manager/EntityManagerFactory");
-var DriverFactory_1 = require("../driver/DriverFactory");
-var ConnectionMetadataBuilder_1 = require("../connection/ConnectionMetadataBuilder");
-var SelectQueryBuilder_1 = require("../query-builder/SelectQueryBuilder");
-var UpdateQueryBuilder_1 = require("../query-builder//UpdateQueryBuilder");
-var DeleteQueryBuilder_1 = require("../query-builder//DeleteQueryBuilder");
-var SoftDeleteQueryBuilder_1 = require("../query-builder/SoftDeleteQueryBuilder");
-var InsertQueryBuilder_1 = require("../query-builder/InsertQueryBuilder");
-var RelationQueryBuilder_1 = require("../query-builder/RelationQueryBuilder");
-var LoggerFactory_1 = require("../logger/LoggerFactory");
-var QueryResultCacheFactory_1 = require("../cache/QueryResultCacheFactory");
-var RelationLoader_1 = require("../query-builder/RelationLoader");
-var ObjectUtils_1 = require("../util/ObjectUtils");
-var error_2 = require("../error");
-var RelationIdLoader_1 = require("../query-builder/RelationIdLoader");
-var DriverUtils_1 = require("../driver/DriverUtils");
-var InstanceChecker_1 = require("../util/InstanceChecker");
-var constants_1 = require("../constants");
+const EntityMetadataValidator_1 = require("../metadata-builder/EntityMetadataValidator");
+const EntityManagerFactory_1 = require("../entity-manager/EntityManagerFactory");
+const DriverFactory_1 = require("../driver/DriverFactory");
+const ConnectionMetadataBuilder_1 = require("../connection/ConnectionMetadataBuilder");
+const SelectQueryBuilder_1 = require("../query-builder/SelectQueryBuilder");
+const UpdateQueryBuilder_1 = require("../query-builder//UpdateQueryBuilder");
+const DeleteQueryBuilder_1 = require("../query-builder//DeleteQueryBuilder");
+const SoftDeleteQueryBuilder_1 = require("../query-builder/SoftDeleteQueryBuilder");
+const InsertQueryBuilder_1 = require("../query-builder/InsertQueryBuilder");
+const RelationQueryBuilder_1 = require("../query-builder/RelationQueryBuilder");
+const LoggerFactory_1 = require("../logger/LoggerFactory");
+const QueryResultCacheFactory_1 = require("../cache/QueryResultCacheFactory");
+const RelationLoader_1 = require("../query-builder/RelationLoader");
+const ObjectUtils_1 = require("../util/ObjectUtils");
+const error_2 = require("../error");
+const RelationIdLoader_1 = require("../query-builder/RelationIdLoader");
+const DriverUtils_1 = require("../driver/DriverUtils");
+const InstanceChecker_1 = require("../util/InstanceChecker");
+const constants_1 = require("../constants");
 /**
  * DataSource is a pre-defined connection configuration to a specific database.
  * You can have multiple data sources connected (with multiple connections in it),
@@ -33,30 +32,76 @@ var constants_1 = require("../constants");
  * Before, it was called `Connection`, but now `Connection` is deprecated
  * because `Connection` isn't the best name for what it's actually is.
  */
-var DataSource = /** @class */ (function () {
+class DataSource {
+    "@instanceof" = Symbol.for("DataSource");
+    SelectQueryBuilder = SelectQueryBuilder_1.SelectQueryBuilder;
+    UpdateQueryBuilder = UpdateQueryBuilder_1.UpdateQueryBuilder;
+    DeleteQueryBuilder = DeleteQueryBuilder_1.DeleteQueryBuilder;
+    SoftDeleteQueryBuilder = SoftDeleteQueryBuilder_1.SoftDeleteQueryBuilder;
+    InsertQueryBuilder = InsertQueryBuilder_1.InsertQueryBuilder;
+    RelationQueryBuilder = RelationQueryBuilder_1.RelationQueryBuilder;
+    // -------------------------------------------------------------------------
+    // Public Readonly Properties
+    // -------------------------------------------------------------------------
+    /**
+     * Connection name.
+     *
+     * @deprecated we don't need names anymore since we are going to drop all related methods relying on this property.
+     */
+    name;
+    /**
+     * Connection options.
+     */
+    options;
+    /**
+     * Indicates if DataSource is initialized or not.
+     */
+    isInitialized;
+    /**
+     * Database driver used by this connection.
+     */
+    driver;
+    /**
+     * EntityManager of this connection.
+     */
+    manager;
+    /**
+     * Naming strategy used in the connection.
+     */
+    namingStrategy;
+    /**
+     * Name for the metadata table
+     */
+    metadataTableName;
+    /**
+     * Logger used to log orm events.
+     */
+    logger;
+    /**
+     * Migration instances that are registered for this connection.
+     */
+    migrations = [];
+    /**
+     * Entity subscriber instances that are registered for this connection.
+     */
+    subscribers = [];
+    /**
+     * All entity metadatas that are registered for this connection.
+     */
+    entityMetadatas = [];
+    /**
+     * Used to work with query result cache.
+     */
+    queryResultCache;
+    /**
+     * Used to load relations and work with lazy relations.
+     */
+    relationLoader;
+    relationIdLoader;
     // -------------------------------------------------------------------------
     // Constructor
     // -------------------------------------------------------------------------
-    function DataSource(options) {
-        this["@instanceof"] = Symbol.for("DataSource");
-        this.SelectQueryBuilder = SelectQueryBuilder_1.SelectQueryBuilder;
-        this.UpdateQueryBuilder = UpdateQueryBuilder_1.UpdateQueryBuilder;
-        this.DeleteQueryBuilder = DeleteQueryBuilder_1.DeleteQueryBuilder;
-        this.SoftDeleteQueryBuilder = SoftDeleteQueryBuilder_1.SoftDeleteQueryBuilder;
-        this.InsertQueryBuilder = InsertQueryBuilder_1.InsertQueryBuilder;
-        this.RelationQueryBuilder = RelationQueryBuilder_1.RelationQueryBuilder;
-        /**
-         * Migration instances that are registered for this connection.
-         */
-        this.migrations = [];
-        /**
-         * Entity subscriber instances that are registered for this connection.
-         */
-        this.subscribers = [];
-        /**
-         * All entity metadatas that are registered for this connection.
-         */
-        this.entityMetadatas = [];
+    constructor(options) {
         this.name = options.name || "default";
         this.options = options;
         this.logger = new LoggerFactory_1.LoggerFactory().create(this.options.logger, this.options.logging);
@@ -72,59 +117,47 @@ var DataSource = /** @class */ (function () {
         this.relationIdLoader = new RelationIdLoader_1.RelationIdLoader(this);
         this.isInitialized = false;
     }
-    Object.defineProperty(DataSource.prototype, "isConnected", {
-        // -------------------------------------------------------------------------
-        // Public Accessors
-        // -------------------------------------------------------------------------
-        /**
-         Indicates if DataSource is initialized or not.
-         *
-         * @deprecated use .isInitialized instead
-         */
-        get: function () {
-            return this.isInitialized;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DataSource.prototype, "mongoManager", {
-        //#region @backend
-        /**
-         * Gets the mongodb entity manager that allows to perform mongodb-specific repository operations
-         * with any entity in this connection.
-         *
-         * Available only in mongodb connections.
-         */
-        get: function () {
-            if (!InstanceChecker_1.InstanceChecker.isMongoEntityManager(this.manager))
-                throw new error_2.TypeORMError("MongoEntityManager is only available for MongoDB databases.");
-            return this.manager;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DataSource.prototype, "sqljsManager", {
-        //#endregion
-        /**
-         * Gets a sql.js specific Entity Manager that allows to perform special load and save operations
-         *
-         * Available only in connection with the sqljs driver.
-         */
-        get: function () {
-            if (!InstanceChecker_1.InstanceChecker.isSqljsEntityManager(this.manager))
-                throw new error_2.TypeORMError("SqljsEntityManager is only available for Sqljs databases.");
-            return this.manager;
-        },
-        enumerable: false,
-        configurable: true
-    });
+    // -------------------------------------------------------------------------
+    // Public Accessors
+    // -------------------------------------------------------------------------
+    /**
+     Indicates if DataSource is initialized or not.
+     *
+     * @deprecated use .isInitialized instead
+     */
+    get isConnected() {
+        return this.isInitialized;
+    }
+    //#region @backend
+    /**
+     * Gets the mongodb entity manager that allows to perform mongodb-specific repository operations
+     * with any entity in this connection.
+     *
+     * Available only in mongodb connections.
+     */
+    get mongoManager() {
+        if (!InstanceChecker_1.InstanceChecker.isMongoEntityManager(this.manager))
+            throw new error_2.TypeORMError(`MongoEntityManager is only available for MongoDB databases.`);
+        return this.manager;
+    }
+    //#endregion
+    /**
+     * Gets a sql.js specific Entity Manager that allows to perform special load and save operations
+     *
+     * Available only in connection with the sqljs driver.
+     */
+    get sqljsManager() {
+        if (!InstanceChecker_1.InstanceChecker.isSqljsEntityManager(this.manager))
+            throw new error_2.TypeORMError(`SqljsEntityManager is only available for Sqljs databases.`);
+        return this.manager;
+    }
     // -------------------------------------------------------------------------
     // Public Methods
     // -------------------------------------------------------------------------
     /**
      * Updates current connection options with provided options.
      */
-    DataSource.prototype.setOptions = function (options) {
+    setOptions(options) {
         Object.assign(this.options, options);
         if (options.logger || options.logging) {
             this.logger = new LoggerFactory_1.LoggerFactory().create(options.logger || this.options.logger, options.logging || this.options.logging);
@@ -136,90 +169,47 @@ var DataSource = /** @class */ (function () {
             this.queryResultCache = new QueryResultCacheFactory_1.QueryResultCacheFactory(this).create();
         }
         return this;
-    };
+    }
     /**
      * Performs connection to the database.
      * This method should be called once on application bootstrap.
      * This method not necessarily creates database connection (depend on database type),
      * but it also can setup a connection pool with database to use.
      */
-    DataSource.prototype.initialize = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var error_3;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (this.isInitialized)
-                            throw new error_1.CannotConnectAlreadyConnectedError(this.name);
-                        // connect to the database via its driver
-                        return [4 /*yield*/, this.driver.connect()
-                            // connect to the cache-specific database if cache is enabled
-                        ];
-                    case 1:
-                        // connect to the database via its driver
-                        _a.sent();
-                        if (!this.queryResultCache) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.queryResultCache.connect()
-                            // set connected status for the current connection
-                        ];
-                    case 2:
-                        _a.sent();
-                        _a.label = 3;
-                    case 3:
-                        // set connected status for the current connection
-                        ObjectUtils_1.ObjectUtils.assign(this, { isInitialized: true });
-                        _a.label = 4;
-                    case 4:
-                        _a.trys.push([4, 13, , 15]);
-                        // build all metadatas registered in the current connection
-                        return [4 /*yield*/, this.buildMetadatas()];
-                    case 5:
-                        // build all metadatas registered in the current connection
-                        _a.sent();
-                        return [4 /*yield*/, this.driver.afterConnect()
-                            // if option is set - drop schema once connection is done
-                        ];
-                    case 6:
-                        _a.sent();
-                        if (!this.options.dropSchema) return [3 /*break*/, 8];
-                        return [4 /*yield*/, this.dropDatabase()
-                            // if option is set - automatically synchronize a schema
-                        ];
-                    case 7:
-                        _a.sent();
-                        _a.label = 8;
-                    case 8:
-                        if (!this.options.migrationsRun) return [3 /*break*/, 10];
-                        return [4 /*yield*/, this.runMigrations({
-                                transaction: this.options.migrationsTransactionMode,
-                            })
-                            // if option is set - automatically synchronize a schema
-                        ];
-                    case 9:
-                        _a.sent();
-                        _a.label = 10;
-                    case 10:
-                        if (!this.options.synchronize) return [3 /*break*/, 12];
-                        return [4 /*yield*/, this.synchronize()];
-                    case 11:
-                        _a.sent();
-                        _a.label = 12;
-                    case 12: return [3 /*break*/, 15];
-                    case 13:
-                        error_3 = _a.sent();
-                        // if for some reason build metadata fail (for example validation error during entity metadata check)
-                        // connection needs to be closed
-                        return [4 /*yield*/, this.close()];
-                    case 14:
-                        // if for some reason build metadata fail (for example validation error during entity metadata check)
-                        // connection needs to be closed
-                        _a.sent();
-                        throw error_3;
-                    case 15: return [2 /*return*/, this];
-                }
-            });
-        });
-    };
+    async initialize() {
+        if (this.isInitialized)
+            throw new error_1.CannotConnectAlreadyConnectedError(this.name);
+        // connect to the database via its driver
+        await this.driver.connect();
+        // connect to the cache-specific database if cache is enabled
+        if (this.queryResultCache)
+            await this.queryResultCache.connect();
+        // set connected status for the current connection
+        ObjectUtils_1.ObjectUtils.assign(this, { isInitialized: true });
+        try {
+            // build all metadatas registered in the current connection
+            await this.buildMetadatas();
+            await this.driver.afterConnect();
+            // if option is set - drop schema once connection is done
+            if (this.options.dropSchema)
+                await this.dropDatabase();
+            // if option is set - automatically synchronize a schema
+            if (this.options.migrationsRun)
+                await this.runMigrations({
+                    transaction: this.options.migrationsTransactionMode,
+                });
+            // if option is set - automatically synchronize a schema
+            if (this.options.synchronize)
+                await this.synchronize();
+        }
+        catch (error) {
+            // if for some reason build metadata fail (for example validation error during entity metadata check)
+            // connection needs to be closed
+            await this.close();
+            throw error;
+        }
+        return this;
+    }
     /**
      * Performs connection to the database.
      * This method should be called once on application bootstrap.
@@ -228,327 +218,204 @@ var DataSource = /** @class */ (function () {
      *
      * @deprecated use .initialize method instead
      */
-    DataSource.prototype.connect = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/, this.initialize()];
-            });
-        });
-    };
+    async connect() {
+        return this.initialize();
+    }
     /**
      * Closes connection with the database.
      * Once connection is closed, you cannot use repositories or perform any operations except opening connection again.
      */
-    DataSource.prototype.destroy = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this.isInitialized)
-                            throw new error_1.CannotExecuteNotConnectedError(this.name);
-                        return [4 /*yield*/, this.driver.disconnect()
-                            // disconnect from the cache-specific database if cache was enabled
-                        ];
-                    case 1:
-                        _a.sent();
-                        if (!this.queryResultCache) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.queryResultCache.disconnect()];
-                    case 2:
-                        _a.sent();
-                        _a.label = 3;
-                    case 3:
-                        ObjectUtils_1.ObjectUtils.assign(this, { isInitialized: false });
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async destroy() {
+        if (!this.isInitialized)
+            throw new error_1.CannotExecuteNotConnectedError(this.name);
+        await this.driver.disconnect();
+        // disconnect from the cache-specific database if cache was enabled
+        if (this.queryResultCache)
+            await this.queryResultCache.disconnect();
+        ObjectUtils_1.ObjectUtils.assign(this, { isInitialized: false });
+    }
     /**
      * Closes connection with the database.
      * Once connection is closed, you cannot use repositories or perform any operations except opening connection again.
      *
      * @deprecated use .destroy method instead
      */
-    DataSource.prototype.close = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/, this.destroy()];
-            });
-        });
-    };
+    async close() {
+        return this.destroy();
+    }
     /**
      * Creates database schema for all entities registered in this connection.
      * Can be used only after connection to the database is established.
      *
      * @param dropBeforeSync If set to true then it drops the database with all its tables and data
      */
-    DataSource.prototype.synchronize = function () {
-        return tslib_1.__awaiter(this, arguments, void 0, function (dropBeforeSync) {
-            var schemaBuilder;
-            if (dropBeforeSync === void 0) { dropBeforeSync = false; }
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this.isInitialized)
-                            throw new error_1.CannotExecuteNotConnectedError(this.name);
-                        if (!dropBeforeSync) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.dropDatabase()];
-                    case 1:
-                        _a.sent();
-                        _a.label = 2;
-                    case 2:
-                        schemaBuilder = this.driver.createSchemaBuilder();
-                        return [4 /*yield*/, schemaBuilder.build()];
-                    case 3:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async synchronize(dropBeforeSync = false) {
+        if (!this.isInitialized)
+            throw new error_1.CannotExecuteNotConnectedError(this.name);
+        if (dropBeforeSync)
+            await this.dropDatabase();
+        const schemaBuilder = this.driver.createSchemaBuilder();
+        await schemaBuilder.build();
+    }
     /**
      * Drops the database and all its data.
      * Be careful with this method on production since this method will erase all your database tables and their data.
      * Can be used only after connection to the database is established.
      */
     // TODO rename
-    DataSource.prototype.dropDatabase = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var queryRunner, databases_2, databases_1, databases_1_1, database, e_1_1;
-            var e_1, _a;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        queryRunner = this.createQueryRunner();
-                        _b.label = 1;
-                    case 1:
-                        _b.trys.push([1, , 14, 16]);
-                        if (!(this.driver.options.type === "mssql" ||
-                            DriverUtils_1.DriverUtils.isMySQLFamily(this.driver) ||
-                            this.driver.options.type === "aurora-mysql" ||
-                            DriverUtils_1.DriverUtils.isSQLiteFamily(this.driver))) return [3 /*break*/, 11];
-                        databases_2 = [];
-                        this.entityMetadatas.forEach(function (metadata) {
-                            if (metadata.database &&
-                                databases_2.indexOf(metadata.database) === -1)
-                                databases_2.push(metadata.database);
-                        });
-                        if (databases_2.length === 0 && this.driver.database) {
-                            databases_2.push(this.driver.database);
-                        }
-                        if (!(databases_2.length === 0)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, queryRunner.clearDatabase()];
-                    case 2:
-                        _b.sent();
-                        return [3 /*break*/, 10];
-                    case 3:
-                        _b.trys.push([3, 8, 9, 10]);
-                        databases_1 = tslib_1.__values(databases_2), databases_1_1 = databases_1.next();
-                        _b.label = 4;
-                    case 4:
-                        if (!!databases_1_1.done) return [3 /*break*/, 7];
-                        database = databases_1_1.value;
-                        return [4 /*yield*/, queryRunner.clearDatabase(database)];
-                    case 5:
-                        _b.sent();
-                        _b.label = 6;
-                    case 6:
-                        databases_1_1 = databases_1.next();
-                        return [3 /*break*/, 4];
-                    case 7: return [3 /*break*/, 10];
-                    case 8:
-                        e_1_1 = _b.sent();
-                        e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 10];
-                    case 9:
-                        try {
-                            if (databases_1_1 && !databases_1_1.done && (_a = databases_1.return)) _a.call(databases_1);
-                        }
-                        finally { if (e_1) throw e_1.error; }
-                        return [7 /*endfinally*/];
-                    case 10: return [3 /*break*/, 13];
-                    case 11: return [4 /*yield*/, queryRunner.clearDatabase()];
-                    case 12:
-                        _b.sent();
-                        _b.label = 13;
-                    case 13: return [3 /*break*/, 16];
-                    case 14: return [4 /*yield*/, queryRunner.release()];
-                    case 15:
-                        _b.sent();
-                        return [7 /*endfinally*/];
-                    case 16: return [2 /*return*/];
+    async dropDatabase() {
+        const queryRunner = this.createQueryRunner();
+        try {
+            if (this.driver.options.type === "mssql" ||
+                DriverUtils_1.DriverUtils.isMySQLFamily(this.driver) ||
+                this.driver.options.type === "aurora-mysql" ||
+                DriverUtils_1.DriverUtils.isSQLiteFamily(this.driver)) {
+                const databases = [];
+                this.entityMetadatas.forEach((metadata) => {
+                    if (metadata.database &&
+                        databases.indexOf(metadata.database) === -1)
+                        databases.push(metadata.database);
+                });
+                if (databases.length === 0 && this.driver.database) {
+                    databases.push(this.driver.database);
                 }
-            });
-        });
-    };
+                if (databases.length === 0) {
+                    await queryRunner.clearDatabase();
+                }
+                else {
+                    for (const database of databases) {
+                        await queryRunner.clearDatabase(database);
+                    }
+                }
+            }
+            else {
+                await queryRunner.clearDatabase();
+            }
+        }
+        finally {
+            await queryRunner.release();
+        }
+    }
     /**
      * Runs all pending migrations.
      * Can be used only after connection to the database is established.
      */
-    DataSource.prototype.runMigrations = function (options) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var migrationExecutor, successMigrations;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this.isInitialized)
-                            throw new error_1.CannotExecuteNotConnectedError(this.name);
-                        migrationExecutor = new MigrationExecutor_1.MigrationExecutor(this);
-                        migrationExecutor.transaction =
-                            (options && options.transaction) || "all";
-                        migrationExecutor.fake = (options && options.fake) || false;
-                        return [4 /*yield*/, migrationExecutor.executePendingMigrations()];
-                    case 1:
-                        successMigrations = _a.sent();
-                        return [2 /*return*/, successMigrations];
-                }
-            });
-        });
-    };
+    async runMigrations(options) {
+        if (!this.isInitialized)
+            throw new error_1.CannotExecuteNotConnectedError(this.name);
+        const migrationExecutor = new MigrationExecutor_1.MigrationExecutor(this);
+        migrationExecutor.transaction =
+            (options && options.transaction) || "all";
+        migrationExecutor.fake = (options && options.fake) || false;
+        const successMigrations = await migrationExecutor.executePendingMigrations();
+        return successMigrations;
+    }
     /**
      * Reverts last executed migration.
      * Can be used only after connection to the database is established.
      */
-    DataSource.prototype.undoLastMigration = function (options) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var migrationExecutor;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this.isInitialized)
-                            throw new error_1.CannotExecuteNotConnectedError(this.name);
-                        migrationExecutor = new MigrationExecutor_1.MigrationExecutor(this);
-                        migrationExecutor.transaction =
-                            (options && options.transaction) || "all";
-                        migrationExecutor.fake = (options && options.fake) || false;
-                        return [4 /*yield*/, migrationExecutor.undoLastMigration()];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async undoLastMigration(options) {
+        if (!this.isInitialized)
+            throw new error_1.CannotExecuteNotConnectedError(this.name);
+        const migrationExecutor = new MigrationExecutor_1.MigrationExecutor(this);
+        migrationExecutor.transaction =
+            (options && options.transaction) || "all";
+        migrationExecutor.fake = (options && options.fake) || false;
+        await migrationExecutor.undoLastMigration();
+    }
     /**
      * Lists all migrations and whether they have been run.
      * Returns true if there are pending migrations
      */
-    DataSource.prototype.showMigrations = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var migrationExecutor;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this.isInitialized) {
-                            throw new error_1.CannotExecuteNotConnectedError(this.name);
-                        }
-                        migrationExecutor = new MigrationExecutor_1.MigrationExecutor(this);
-                        return [4 /*yield*/, migrationExecutor.showMigrations()];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
+    async showMigrations() {
+        if (!this.isInitialized) {
+            throw new error_1.CannotExecuteNotConnectedError(this.name);
+        }
+        const migrationExecutor = new MigrationExecutor_1.MigrationExecutor(this);
+        return await migrationExecutor.showMigrations();
+    }
     /**
      * Checks if entity metadata exist for the given entity class, target name or table name.
      */
-    DataSource.prototype.hasMetadata = function (target) {
+    hasMetadata(target) {
         return !!this.findMetadata(target);
-    };
+    }
     /**
      * Gets entity metadata for the given entity class or schema name.
      */
-    DataSource.prototype.getMetadata = function (target) {
-        var metadata = this.findMetadata(target);
+    getMetadata(target) {
+        let metadata = this.findMetadata(target);
         metadata = metadata || this.findMetadata(target[constants_1.OrignalClassKey]);
         if (!metadata) {
             throw new error_1.EntityMetadataNotFoundError(target);
         }
         return metadata;
-    };
+    }
     /**
      * Gets repository for the given entity.
      */
-    DataSource.prototype.getRepository = function (target) {
+    getRepository(target) {
         return this.manager.getRepository(target);
-    };
+    }
     /**
      * Gets tree repository for the given entity class or name.
      * Only tree-type entities can have a TreeRepository, like ones decorated with @Tree decorator.
      */
-    DataSource.prototype.getTreeRepository = function (target) {
+    getTreeRepository(target) {
         return this.manager.getTreeRepository(target);
-    };
+    }
     //#region @backend
     /**
      * Gets mongodb-specific repository for the given entity class or name.
      * Works only if connection is mongodb-specific.
      */
-    DataSource.prototype.getMongoRepository = function (target) {
+    getMongoRepository(target) {
         if (!(this.driver.options.type === "mongodb"))
-            throw new error_2.TypeORMError("You can use getMongoRepository only for MongoDB connections.");
+            throw new error_2.TypeORMError(`You can use getMongoRepository only for MongoDB connections.`);
         return this.manager.getRepository(target);
-    };
+    }
     //#endregion
     /**
      * Gets custom entity repository marked with @EntityRepository decorator.
      *
      * @deprecated use Repository.extend function to create a custom repository
      */
-    DataSource.prototype.getCustomRepository = function (customRepository) {
+    getCustomRepository(customRepository) {
         return this.manager.getCustomRepository(customRepository);
-    };
-    DataSource.prototype.transaction = function (isolationOrRunInTransaction, runInTransactionParam) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/, this.manager.transaction(isolationOrRunInTransaction, runInTransactionParam)];
-            });
-        });
-    };
+    }
+    async transaction(isolationOrRunInTransaction, runInTransactionParam) {
+        return this.manager.transaction(isolationOrRunInTransaction, runInTransactionParam);
+    }
     /**
      * Executes raw SQL query and returns raw database results.
      */
-    DataSource.prototype.query = function (query, parameters, queryRunner) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var usedQueryRunner;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        //#region @backend
-                        if (InstanceChecker_1.InstanceChecker.isMongoEntityManager(this.manager))
-                            throw new error_2.TypeORMError("Queries aren't supported by MongoDB.");
-                        //#endregion
-                        if (queryRunner && queryRunner.isReleased)
-                            throw new error_1.QueryRunnerProviderAlreadyReleasedError();
-                        usedQueryRunner = queryRunner || this.createQueryRunner();
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, , 3, 6]);
-                        return [4 /*yield*/, usedQueryRunner.query(query, parameters)]; // await is needed here because we are using finally
-                    case 2: return [2 /*return*/, _a.sent()]; // await is needed here because we are using finally
-                    case 3:
-                        if (!!queryRunner) return [3 /*break*/, 5];
-                        return [4 /*yield*/, usedQueryRunner.release()];
-                    case 4:
-                        _a.sent();
-                        _a.label = 5;
-                    case 5: return [7 /*endfinally*/];
-                    case 6: return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async query(query, parameters, queryRunner) {
+        //#region @backend
+        if (InstanceChecker_1.InstanceChecker.isMongoEntityManager(this.manager))
+            throw new error_2.TypeORMError(`Queries aren't supported by MongoDB.`);
+        //#endregion
+        if (queryRunner && queryRunner.isReleased)
+            throw new error_1.QueryRunnerProviderAlreadyReleasedError();
+        const usedQueryRunner = queryRunner || this.createQueryRunner();
+        try {
+            return await usedQueryRunner.query(query, parameters); // await is needed here because we are using finally
+        }
+        finally {
+            if (!queryRunner)
+                await usedQueryRunner.release();
+        }
+    }
     /**
      * Creates a new query builder that can be used to build a SQL query.
      */
-    DataSource.prototype.createQueryBuilder = function (entityOrRunner, alias, queryRunner) {
+    createQueryBuilder(entityOrRunner, alias, queryRunner) {
         //#region @backend
         if (InstanceChecker_1.InstanceChecker.isMongoEntityManager(this.manager))
-            throw new error_2.TypeORMError("Query Builder is not supported by MongoDB.");
+            throw new error_2.TypeORMError(`Query Builder is not supported by MongoDB.`);
         //#endregion
         if (alias) {
             alias = DriverUtils_1.DriverUtils.buildAlias(this.driver, alias);
-            var metadata = this.getMetadata(entityOrRunner);
+            const metadata = this.getMetadata(entityOrRunner);
             return new SelectQueryBuilder_1.SelectQueryBuilder(this, queryRunner)
                 .select(alias)
                 .from(metadata.target, alias);
@@ -556,7 +423,7 @@ var DataSource = /** @class */ (function () {
         else {
             return new SelectQueryBuilder_1.SelectQueryBuilder(this, entityOrRunner);
         }
-    };
+    }
     /**
      * Creates a query runner used for perform queries on a single database connection.
      * Using query runners you can control your queries to execute using single database connection and
@@ -567,39 +434,38 @@ var DataSource = /** @class */ (function () {
      * If you perform writes you must use master database,
      * if you perform reads you can use slave databases.
      */
-    DataSource.prototype.createQueryRunner = function (mode) {
-        if (mode === void 0) { mode = "master"; }
-        var queryRunner = this.driver.createQueryRunner(mode);
-        var manager = this.createEntityManager(queryRunner);
+    createQueryRunner(mode = "master") {
+        const queryRunner = this.driver.createQueryRunner(mode);
+        const manager = this.createEntityManager(queryRunner);
         Object.assign(queryRunner, { manager: manager });
         return queryRunner;
-    };
+    }
     /**
      * Gets entity metadata of the junction table (many-to-many table).
      */
-    DataSource.prototype.getManyToManyMetadata = function (entityTarget, relationPropertyPath) {
-        var relationMetadata = this.getMetadata(entityTarget).findRelationWithPropertyPath(relationPropertyPath);
+    getManyToManyMetadata(entityTarget, relationPropertyPath) {
+        const relationMetadata = this.getMetadata(entityTarget).findRelationWithPropertyPath(relationPropertyPath);
         if (!relationMetadata)
-            throw new error_2.TypeORMError("Relation \"".concat(relationPropertyPath, "\" was not found in ").concat(entityTarget, " entity."));
+            throw new error_2.TypeORMError(`Relation "${relationPropertyPath}" was not found in ${entityTarget} entity.`);
         if (!relationMetadata.isManyToMany)
-            throw new error_2.TypeORMError("Relation \"".concat(entityTarget, "#").concat(relationPropertyPath, "\" does not have a many-to-many relationship.") +
-                "You can use this method only on many-to-many relations.");
+            throw new error_2.TypeORMError(`Relation "${entityTarget}#${relationPropertyPath}" does not have a many-to-many relationship.` +
+                `You can use this method only on many-to-many relations.`);
         return relationMetadata.junctionEntityMetadata;
-    };
+    }
     /**
      * Creates an Entity Manager for the current connection with the help of the EntityManagerFactory.
      */
-    DataSource.prototype.createEntityManager = function (queryRunner) {
+    createEntityManager(queryRunner) {
         return new EntityManagerFactory_1.EntityManagerFactory().create(this, queryRunner);
-    };
+    }
     // -------------------------------------------------------------------------
     // Protected Methods
     // -------------------------------------------------------------------------
     /**
      * Finds exist entity metadata by the given entity class, target name or table name.
      */
-    DataSource.prototype.findMetadata = function (target) {
-        return this.entityMetadatas.find(function (metadata) {
+    findMetadata(target) {
+        return this.entityMetadatas.find((metadata) => {
             if (metadata.target === target)
                 return true;
             if (InstanceChecker_1.InstanceChecker.isEntitySchema(target)) {
@@ -626,61 +492,37 @@ var DataSource = /** @class */ (function () {
             }
             return false;
         });
-    };
+    }
     /**
      * Builds metadatas for all registered classes inside this connection.
      */
-    DataSource.prototype.buildMetadatas = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var connectionMetadataBuilder, entityMetadataValidator, flattenedSubscribers, subscribers, flattenedEntities, entityMetadatas, flattenedMigrations, migrations, entityMetadatas_1, entityMetadatas_1_1, entityMetadata;
-            var e_2, _a;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        connectionMetadataBuilder = new ConnectionMetadataBuilder_1.ConnectionMetadataBuilder(this);
-                        entityMetadataValidator = new EntityMetadataValidator_1.EntityMetadataValidator();
-                        flattenedSubscribers = ObjectUtils_1.ObjectUtils.mixedListToArray(this.options.subscribers || []);
-                        return [4 /*yield*/, connectionMetadataBuilder.buildSubscribers(// @ts-ignore
-                            flattenedSubscribers)];
-                    case 1:
-                        subscribers = _b.sent();
-                        ObjectUtils_1.ObjectUtils.assign(this, { subscribers: subscribers });
-                        flattenedEntities = ObjectUtils_1.ObjectUtils.mixedListToArray(this.options.entities || []);
-                        return [4 /*yield*/, connectionMetadataBuilder.buildEntityMetadatas(// @ts-ignore
-                            flattenedEntities)];
-                    case 2:
-                        entityMetadatas = _b.sent();
-                        ObjectUtils_1.ObjectUtils.assign(this, { entityMetadatas: entityMetadatas });
-                        flattenedMigrations = ObjectUtils_1.ObjectUtils.mixedListToArray(this.options.migrations || []);
-                        return [4 /*yield*/, connectionMetadataBuilder.buildMigrations(// @ts-ignore
-                            flattenedMigrations)];
-                    case 3:
-                        migrations = _b.sent();
-                        ObjectUtils_1.ObjectUtils.assign(this, { migrations: migrations });
-                        // validate all created entity metadatas to make sure user created entities are valid and correct
-                        entityMetadataValidator.validateMany(this.entityMetadatas.filter(function (metadata) { return metadata.tableType !== "view"; }), this.driver);
-                        try {
-                            // set current data source to the entities
-                            for (entityMetadatas_1 = tslib_1.__values(entityMetadatas), entityMetadatas_1_1 = entityMetadatas_1.next(); !entityMetadatas_1_1.done; entityMetadatas_1_1 = entityMetadatas_1.next()) {
-                                entityMetadata = entityMetadatas_1_1.value;
-                                if (InstanceChecker_1.InstanceChecker.isBaseEntityConstructor(entityMetadata.target)) {
-                                    entityMetadata.target.useDataSource(this);
-                                }
-                            }
-                        }
-                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                        finally {
-                            try {
-                                if (entityMetadatas_1_1 && !entityMetadatas_1_1.done && (_a = entityMetadatas_1.return)) _a.call(entityMetadatas_1);
-                            }
-                            finally { if (e_2) throw e_2.error; }
-                        }
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    return DataSource;
-}());
+    async buildMetadatas() {
+        const connectionMetadataBuilder = new ConnectionMetadataBuilder_1.ConnectionMetadataBuilder(this);
+        const entityMetadataValidator = new EntityMetadataValidator_1.EntityMetadataValidator();
+        // create subscribers instances if they are not disallowed from high-level (for example they can disallowed from migrations run process)
+        const flattenedSubscribers = ObjectUtils_1.ObjectUtils.mixedListToArray(this.options.subscribers || []);
+        const subscribers = await connectionMetadataBuilder.buildSubscribers(// @ts-ignore
+        flattenedSubscribers);
+        ObjectUtils_1.ObjectUtils.assign(this, { subscribers: subscribers });
+        // build entity metadatas
+        const flattenedEntities = ObjectUtils_1.ObjectUtils.mixedListToArray(this.options.entities || []);
+        const entityMetadatas = await connectionMetadataBuilder.buildEntityMetadatas(// @ts-ignore
+        flattenedEntities);
+        ObjectUtils_1.ObjectUtils.assign(this, { entityMetadatas: entityMetadatas });
+        // create migration instances
+        const flattenedMigrations = ObjectUtils_1.ObjectUtils.mixedListToArray(this.options.migrations || []);
+        const migrations = await connectionMetadataBuilder.buildMigrations(// @ts-ignore
+        flattenedMigrations);
+        ObjectUtils_1.ObjectUtils.assign(this, { migrations: migrations });
+        // validate all created entity metadatas to make sure user created entities are valid and correct
+        entityMetadataValidator.validateMany(this.entityMetadatas.filter((metadata) => metadata.tableType !== "view"), this.driver);
+        // set current data source to the entities
+        for (let entityMetadata of entityMetadatas) {
+            if (InstanceChecker_1.InstanceChecker.isBaseEntityConstructor(entityMetadata.target)) {
+                entityMetadata.target.useDataSource(this);
+            }
+        }
+    }
+}
 exports.DataSource = DataSource;
 //# sourceMappingURL=DataSource.js.map