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

package/browser/entity-manager/EntityManager.js

@@ -1,29 +1,36 @@
-import { EntityNotFoundError } from "../error/EntityNotFoundError";
-import { QueryRunnerProviderAlreadyReleasedError } from "../error/QueryRunnerProviderAlreadyReleasedError";
-import { NoNeedToReleaseEntityManagerError } from "../error/NoNeedToReleaseEntityManagerError";
-import { MongoRepository } from "../repository/MongoRepository";
-import { TreeRepository } from "../repository/TreeRepository";
-import { Repository } from "../repository/Repository";
-import { FindOptionsUtils } from "../find-options/FindOptionsUtils";
-import { PlainObjectToNewEntityTransformer } from "../query-builder/transformer/PlainObjectToNewEntityTransformer";
-import { PlainObjectToDatabaseEntityTransformer } from "../query-builder/transformer/PlainObjectToDatabaseEntityTransformer";
-import { CustomRepositoryCannotInheritRepositoryError, CustomRepositoryNotFoundError, TreeRepositoryNotSupportedError, TypeORMError, } from "../error";
-import { AbstractRepository } from "../repository/AbstractRepository";
-import { EntityPersistExecutor } from "../persistence/EntityPersistExecutor";
-import { ObjectUtils } from "../util/ObjectUtils";
-import { getMetadataArgsStorage } from "../globals";
-import { InstanceChecker } from "../util/InstanceChecker";
-import { buildSqlTag } from "../util/SqlTagUtils";
-import { OrmUtils } from "../util/OrmUtils";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityManager = void 0;
+const EntityNotFoundError_1 = require("../error/EntityNotFoundError");
+const QueryRunnerProviderAlreadyReleasedError_1 = require("../error/QueryRunnerProviderAlreadyReleasedError");
+const NoNeedToReleaseEntityManagerError_1 = require("../error/NoNeedToReleaseEntityManagerError");
+const MongoRepository_1 = require("../repository/MongoRepository");
+const TreeRepository_1 = require("../repository/TreeRepository");
+const Repository_1 = require("../repository/Repository");
+const PlainObjectToNewEntityTransformer_1 = require("../query-builder/transformer/PlainObjectToNewEntityTransformer");
+const PlainObjectToDatabaseEntityTransformer_1 = require("../query-builder/transformer/PlainObjectToDatabaseEntityTransformer");
+const error_1 = require("../error");
+const EntityPersistExecutor_1 = require("../persistence/EntityPersistExecutor");
+const ObjectUtils_1 = require("../util/ObjectUtils");
+const InstanceChecker_1 = require("../util/InstanceChecker");
+const SqlTagUtils_1 = require("../util/SqlTagUtils");
+const OrmUtils_1 = require("../util/OrmUtils");
 /**
  * Entity manager supposed to work with any entity, automatically find its repository and call its methods,
  * whatever entity type are you passing.
  */
-export class EntityManager {
+class EntityManager {
+    /**
+     * DataSource used by this entity manager.
+     * @deprecated since 1.0.0. Use {@link dataSource} instance instead.
+     */
+    get connection() {
+        return this.dataSource;
+    }
     // -------------------------------------------------------------------------
     // Constructor
     // -------------------------------------------------------------------------
-    constructor(connection, queryRunner) {
+    constructor(dataSource, queryRunner) {
         this["@instanceof"] = Symbol.for("EntityManager");
         // -------------------------------------------------------------------------
         // Protected Properties
@@ -40,17 +47,19 @@ export class EntityManager {
         /**
          * Plain to object transformer used in create and merge operations.
          */
-        this.plainObjectToEntityTransformer = new PlainObjectToNewEntityTransformer();
-        this.connection = connection;
+        this.plainObjectToEntityTransformer = new PlainObjectToNewEntityTransformer_1.PlainObjectToNewEntityTransformer();
+        this.dataSource = dataSource;
         if (queryRunner) {
             this.queryRunner = queryRunner;
             // dynamic: this.queryRunner = manager;
-            ObjectUtils.assign(this.queryRunner, { manager: this });
+            ObjectUtils_1.ObjectUtils.assign(this.queryRunner, { manager: this });
         }
     }
     /**
      * Wraps given function execution (and all operations made there) in a transaction.
      * All database operations must be executed using provided entity manager.
+     * @param isolationOrRunInTransaction
+     * @param runInTransactionParam
      */
     async transaction(isolationOrRunInTransaction, runInTransactionParam) {
         const isolation = typeof isolationOrRunInTransaction === "string"
@@ -60,13 +69,13 @@ export class EntityManager {
             ? isolationOrRunInTransaction
             : runInTransactionParam;
         if (!runInTransaction) {
-            throw new TypeORMError(`Transaction method requires callback in second parameter if isolation level is supplied.`);
+            throw new error_1.TypeORMError(`Transaction method requires callback in second parameter if isolation level is supplied.`);
         }
         if (this.queryRunner && this.queryRunner.isReleased)
-            throw new QueryRunnerProviderAlreadyReleasedError();
+            throw new QueryRunnerProviderAlreadyReleasedError_1.QueryRunnerProviderAlreadyReleasedError();
         // if query runner is already defined in this class, it means this entity manager was already created for a single connection
         // if its not defined we create a new query runner - single connection where we'll execute all our operations
-        const queryRunner = this.queryRunner || this.connection.createQueryRunner();
+        const queryRunner = this.queryRunner || this.dataSource.createQueryRunner();
         try {
             await queryRunner.startTransaction(isolation);
             const result = await runInTransaction(queryRunner.manager);
@@ -89,11 +98,12 @@ export class EntityManager {
     }
     /**
      * Executes raw SQL query and returns raw database results.
-     *
+     * @param query
+     * @param parameters
      * @see [Official docs](https://typeorm.io/docs/Working%20with%20Entity%20Manager/entity-manager-api/) for examples.
      */
     async query(query, parameters) {
-        return this.connection.query(query, parameters, this.queryRunner);
+        return this.dataSource.query(query, parameters, this.queryRunner);
     }
     /**
      * Tagged template function that executes raw SQL query and returns raw database results.
@@ -101,10 +111,12 @@ export class EntityManager {
      * Raw query execution is supported only by relational databases (MongoDB is not supported).
      * Note: Don't call this as a regular function, it is meant to be used with backticks to tag a template literal.
      * Example: entityManager.sql`SELECT * FROM table_name WHERE id = ${id}`
+     * @param strings
+     * @param values
      */
     async sql(strings, ...values) {
-        const { query, parameters } = buildSqlTag({
-            driver: this.connection.driver,
+        const { query, parameters } = (0, SqlTagUtils_1.buildSqlTag)({
+            driver: this.dataSource.driver,
             strings: strings,
             expressions: values,
         });
@@ -112,41 +124,50 @@ export class EntityManager {
     }
     /**
      * Creates a new query builder that can be used to build a SQL query.
+     * @param entityClass
+     * @param alias
+     * @param queryRunner
      */
     createQueryBuilder(entityClass, alias, queryRunner) {
         if (alias) {
-            return this.connection.createQueryBuilder(entityClass, alias, queryRunner || this.queryRunner);
+            return this.dataSource.createQueryBuilder(entityClass, alias, queryRunner || this.queryRunner);
         }
         else {
-            return this.connection.createQueryBuilder(entityClass ||
+            return this.dataSource.createQueryBuilder(entityClass ||
                 queryRunner ||
                 this.queryRunner);
         }
     }
     /**
      * Checks if entity has an id by its Function type or schema name.
+     * @param targetOrEntity
+     * @param maybeEntity
      */
     hasId(targetOrEntity, maybeEntity) {
         const target = arguments.length === 2 ? targetOrEntity : targetOrEntity.constructor;
         const entity = arguments.length === 2 ? maybeEntity : targetOrEntity;
-        const metadata = this.connection.getMetadata(target);
+        const metadata = this.dataSource.getMetadata(target);
         return metadata.hasId(entity);
     }
     /**
      * Gets entity mixed id.
+     * @param targetOrEntity
+     * @param maybeEntity
      */
     getId(targetOrEntity, maybeEntity) {
         const target = arguments.length === 2 ? targetOrEntity : targetOrEntity.constructor;
         const entity = arguments.length === 2 ? maybeEntity : targetOrEntity;
-        const metadata = this.connection.getMetadata(target);
+        const metadata = this.dataSource.getMetadata(target);
         return metadata.getEntityIdMixedMap(entity);
     }
     /**
      * Creates a new entity instance or instances.
      * Can copy properties from the given object into new entities.
+     * @param entityClass
+     * @param plainObjectOrObjects
      */
     create(entityClass, plainObjectOrObjects) {
-        const metadata = this.connection.getMetadata(entityClass);
+        const metadata = this.dataSource.getMetadata(entityClass);
         if (!plainObjectOrObjects)
             return metadata.create(this.queryRunner);
         if (Array.isArray(plainObjectOrObjects))
@@ -157,10 +178,13 @@ export class EntityManager {
     }
     /**
      * Merges two entities into one new entity.
+     * @param entityClass
+     * @param mergeIntoEntity
+     * @param entityLikes
      */
     merge(entityClass, mergeIntoEntity, ...entityLikes) {
         // todo: throw exception if entity manager is released
-        const metadata = this.connection.getMetadata(entityClass);
+        const metadata = this.dataSource.getMetadata(entityClass);
         entityLikes.forEach((object) => this.plainObjectToEntityTransformer.transform(mergeIntoEntity, object, metadata));
         return mergeIntoEntity;
     }
@@ -169,10 +193,12 @@ export class EntityManager {
      * it loads it (and everything related to it), replaces all values with the new ones from the given object
      * and returns this new entity. This new entity is actually a loaded from the db entity with all properties
      * replaced from the new object.
+     * @param entityClass
+     * @param entityLike
      */
     async preload(entityClass, entityLike) {
-        const metadata = this.connection.getMetadata(entityClass);
-        const plainObjectToDatabaseEntityTransformer = new PlainObjectToDatabaseEntityTransformer(this.connection.manager);
+        const metadata = this.dataSource.getMetadata(entityClass);
+        const plainObjectToDatabaseEntityTransformer = new PlainObjectToDatabaseEntityTransformer_1.PlainObjectToDatabaseEntityTransformer(this.dataSource.manager);
         const transformedEntity = await plainObjectToDatabaseEntityTransformer.transform(entityLike, metadata);
         if (transformedEntity)
             return this.merge(entityClass, transformedEntity, entityLike);
@@ -180,12 +206,15 @@ export class EntityManager {
     }
     /**
      * Saves a given entity in the database.
+     * @param targetOrEntity
+     * @param maybeEntityOrOptions
+     * @param maybeOptions
      */
     save(targetOrEntity, maybeEntityOrOptions, maybeOptions) {
         // normalize mixed parameters
         let target = arguments.length > 1 &&
             (typeof targetOrEntity === "function" ||
-                InstanceChecker.isEntitySchema(targetOrEntity) ||
+                InstanceChecker_1.InstanceChecker.isEntitySchema(targetOrEntity) ||
                 typeof targetOrEntity === "string")
             ? targetOrEntity
             : undefined;
@@ -195,24 +224,27 @@ export class EntityManager {
         const options = target
             ? maybeOptions
             : maybeEntityOrOptions;
-        if (InstanceChecker.isEntitySchema(target))
+        if (InstanceChecker_1.InstanceChecker.isEntitySchema(target))
             target = target.options.name;
         // if user passed empty array of entities then we don't need to do anything
         if (Array.isArray(entity) && entity.length === 0)
             return Promise.resolve(entity);
         // execute save operation
-        return new EntityPersistExecutor(this.connection, this.queryRunner, "save", target, entity, options)
+        return new EntityPersistExecutor_1.EntityPersistExecutor(this.dataSource, this.queryRunner, "save", target, entity, options)
             .execute()
             .then(() => entity);
     }
     /**
      * Removes a given entity from the database.
+     * @param targetOrEntity
+     * @param maybeEntityOrOptions
+     * @param maybeOptions
      */
     remove(targetOrEntity, maybeEntityOrOptions, maybeOptions) {
         // normalize mixed parameters
         const target = arguments.length > 1 &&
             (typeof targetOrEntity === "function" ||
-                InstanceChecker.isEntitySchema(targetOrEntity) ||
+                InstanceChecker_1.InstanceChecker.isEntitySchema(targetOrEntity) ||
                 typeof targetOrEntity === "string")
             ? targetOrEntity
             : undefined;
@@ -226,18 +258,21 @@ export class EntityManager {
         if (Array.isArray(entity) && entity.length === 0)
             return Promise.resolve(entity);
         // execute save operation
-        return new EntityPersistExecutor(this.connection, this.queryRunner, "remove", target, entity, options)
+        return new EntityPersistExecutor_1.EntityPersistExecutor(this.dataSource, this.queryRunner, "remove", target, entity, options)
             .execute()
             .then(() => entity);
     }
     /**
      * Records the delete date of one or many given entities.
+     * @param targetOrEntity
+     * @param maybeEntityOrOptions
+     * @param maybeOptions
      */
     softRemove(targetOrEntity, maybeEntityOrOptions, maybeOptions) {
         // normalize mixed parameters
         let target = arguments.length > 1 &&
             (typeof targetOrEntity === "function" ||
-                InstanceChecker.isEntitySchema(targetOrEntity) ||
+                InstanceChecker_1.InstanceChecker.isEntitySchema(targetOrEntity) ||
                 typeof targetOrEntity === "string")
             ? targetOrEntity
             : undefined;
@@ -247,24 +282,27 @@ export class EntityManager {
         const options = target
             ? maybeOptions
             : maybeEntityOrOptions;
-        if (InstanceChecker.isEntitySchema(target))
+        if (InstanceChecker_1.InstanceChecker.isEntitySchema(target))
             target = target.options.name;
         // if user passed empty array of entities then we don't need to do anything
         if (Array.isArray(entity) && entity.length === 0)
             return Promise.resolve(entity);
         // execute soft-remove operation
-        return new EntityPersistExecutor(this.connection, this.queryRunner, "soft-remove", target, entity, options)
+        return new EntityPersistExecutor_1.EntityPersistExecutor(this.dataSource, this.queryRunner, "soft-remove", target, entity, options)
             .execute()
             .then(() => entity);
     }
     /**
      * Recovers one or many given entities.
+     * @param targetOrEntity
+     * @param maybeEntityOrOptions
+     * @param maybeOptions
      */
     recover(targetOrEntity, maybeEntityOrOptions, maybeOptions) {
         // normalize mixed parameters
         let target = arguments.length > 1 &&
             (typeof targetOrEntity === "function" ||
-                InstanceChecker.isEntitySchema(targetOrEntity) ||
+                InstanceChecker_1.InstanceChecker.isEntitySchema(targetOrEntity) ||
                 typeof targetOrEntity === "string")
             ? targetOrEntity
             : undefined;
@@ -274,13 +312,13 @@ export class EntityManager {
         const options = target
             ? maybeOptions
             : maybeEntityOrOptions;
-        if (InstanceChecker.isEntitySchema(target))
+        if (InstanceChecker_1.InstanceChecker.isEntitySchema(target))
             target = target.options.name;
         // if user passed empty array of entities then we don't need to do anything
         if (Array.isArray(entity) && entity.length === 0)
             return Promise.resolve(entity);
         // execute recover operation
-        return new EntityPersistExecutor(this.connection, this.queryRunner, "recover", target, entity, options)
+        return new EntityPersistExecutor_1.EntityPersistExecutor(this.dataSource, this.queryRunner, "recover", target, entity, options)
             .execute()
             .then(() => entity);
     }
@@ -290,6 +328,8 @@ export class EntityManager {
      * Executes fast and efficient INSERT query.
      * Does not check if entity exist in the database, so query will fail if duplicate entity is being inserted.
      * You can execute bulk inserts using this method.
+     * @param target
+     * @param entity
      */
     async insert(target, entity) {
         return this.createQueryBuilder()
@@ -299,7 +339,7 @@ export class EntityManager {
             .execute();
     }
     async upsert(target, entityOrEntities, conflictPathsOrOptions) {
-        const metadata = this.connection.getMetadata(target);
+        const metadata = this.dataSource.getMetadata(target);
         let options;
         if (Array.isArray(conflictPathsOrOptions)) {
             options = {
@@ -320,18 +360,23 @@ export class EntityManager {
             ? options.conflictPaths
             : Object.keys(options.conflictPaths));
         const overwriteColumns = metadata.columns.filter((col) => !conflictColumns.includes(col) &&
+            col.isUpdate !== false &&
+            !col.generatedType &&
             entities.some((entity) => typeof col.getEntityValue(entity) !== "undefined"));
-        return this.createQueryBuilder()
+        const upsertType = options.upsertType || this.dataSource.driver.supportedUpsertTypes[0];
+        const qb = this.createQueryBuilder()
             .insert()
             .into(target)
             .values(entities)
             .orUpdate([...conflictColumns, ...overwriteColumns].map((col) => col.databaseName), conflictColumns.map((col) => col.databaseName), {
             skipUpdateIfNoValuesChanged: options.skipUpdateIfNoValuesChanged,
             indexPredicate: options.indexPredicate,
-            upsertType: options.upsertType ||
-                this.connection.driver.supportedUpsertTypes[0],
-        })
-            .execute();
+            upsertType,
+        });
+        if (options.returning !== undefined) {
+            qb.returning(options.returning);
+        }
+        return qb.execute();
     }
     /**
      * Updates entity partially. Entity can be found by a given condition(s).
@@ -339,25 +384,36 @@ export class EntityManager {
      * Executes fast and efficient UPDATE query.
      * Does not check if entity exist in the database.
      * Condition(s) cannot be empty.
+     * @param target
+     * @param criteria
+     * @param partialEntity
+     * @param options
      */
-    update(target, criteria, partialEntity) {
+    update(target, criteria, partialEntity, options) {
         // if user passed empty criteria or empty list of criterias, then throw an error
-        if (OrmUtils.isCriteriaNullOrEmpty(criteria)) {
-            return Promise.reject(new TypeORMError(`Empty criteria(s) are not allowed for the update method.`));
+        if (OrmUtils_1.OrmUtils.isCriteriaNullOrEmpty(criteria)) {
+            return Promise.reject(new error_1.TypeORMError(`Empty criteria(s) are not allowed for the update method.`));
         }
-        if (OrmUtils.isPrimitiveCriteria(criteria)) {
-            return this.createQueryBuilder()
+        if (OrmUtils_1.OrmUtils.isPrimitiveCriteria(criteria)) {
+            const qb = this.createQueryBuilder()
                 .update(target)
                 .set(partialEntity)
-                .whereInIds(criteria)
-                .execute();
+                .whereInIds(criteria);
+            if (options?.returning !== undefined) {
+                qb.returning(options.returning);
+            }
+            return qb.execute();
         }
         else {
-            return this.createQueryBuilder()
+            const normalizedCriteria = OrmUtils_1.OrmUtils.normalizeWhereCriteria(criteria, this.dataSource.options.invalidWhereValuesBehavior);
+            const qb = this.createQueryBuilder()
                 .update(target)
                 .set(partialEntity)
-                .where(criteria)
-                .execute();
+                .where(normalizedCriteria);
+            if (options?.returning !== undefined) {
+                qb.returning(options.returning);
+            }
+            return qb.execute();
         }
     }
     /**
@@ -366,12 +422,16 @@ export class EntityManager {
      * Executes fast and efficient UPDATE query without WHERE clause.
      *
      * WARNING! This method updates ALL rows in the target table.
+     * @param target
+     * @param partialEntity
+     * @param options
      */
-    updateAll(target, partialEntity) {
-        return this.createQueryBuilder()
-            .update(target)
-            .set(partialEntity)
-            .execute();
+    updateAll(target, partialEntity, options) {
+        const qb = this.createQueryBuilder().update(target).set(partialEntity);
+        if (options?.returning !== undefined) {
+            qb.returning(options.returning);
+        }
+        return qb.execute();
     }
     /**
      * Deletes entities by a given condition(s).
@@ -379,13 +439,15 @@ export class EntityManager {
      * Executes fast and efficient DELETE query.
      * Does not check if entity exist in the database.
      * Condition(s) cannot be empty.
+     * @param targetOrEntity
+     * @param criteria
      */
     delete(targetOrEntity, criteria) {
         // if user passed empty criteria or empty list of criterias, then throw an error
-        if (OrmUtils.isCriteriaNullOrEmpty(criteria)) {
-            return Promise.reject(new TypeORMError(`Empty criteria(s) are not allowed for the delete method.`));
+        if (OrmUtils_1.OrmUtils.isCriteriaNullOrEmpty(criteria)) {
+            return Promise.reject(new error_1.TypeORMError(`Empty criteria(s) are not allowed for the delete method.`));
         }
-        if (OrmUtils.isPrimitiveCriteria(criteria)) {
+        if (OrmUtils_1.OrmUtils.isPrimitiveCriteria(criteria)) {
             return this.createQueryBuilder()
                 .delete()
                 .from(targetOrEntity)
@@ -393,10 +455,11 @@ export class EntityManager {
                 .execute();
         }
         else {
+            const normalizedCriteria = OrmUtils_1.OrmUtils.normalizeWhereCriteria(criteria, this.dataSource.options.invalidWhereValuesBehavior);
             return this.createQueryBuilder()
                 .delete()
                 .from(targetOrEntity)
-                .where(criteria)
+                .where(normalizedCriteria)
                 .execute();
         }
     }
@@ -406,6 +469,7 @@ export class EntityManager {
      * Executes fast and efficient DELETE query without WHERE clause.
      *
      * WARNING! This method deletes ALL rows in the target table.
+     * @param targetOrEntity
      */
     deleteAll(targetOrEntity) {
         return this.createQueryBuilder().delete().from(targetOrEntity).execute();
@@ -416,13 +480,15 @@ export class EntityManager {
      * Executes fast and efficient UPDATE query.
      * Does not check if entity exist in the database.
      * Condition(s) cannot be empty.
+     * @param targetOrEntity
+     * @param criteria
      */
     softDelete(targetOrEntity, criteria) {
         // if user passed empty criteria or empty list of criterias, then throw an error
-        if (OrmUtils.isCriteriaNullOrEmpty(criteria)) {
-            return Promise.reject(new TypeORMError(`Empty criteria(s) are not allowed for the softDelete method.`));
+        if (OrmUtils_1.OrmUtils.isCriteriaNullOrEmpty(criteria)) {
+            return Promise.reject(new error_1.TypeORMError(`Empty criteria(s) are not allowed for the softDelete method.`));
         }
-        if (OrmUtils.isPrimitiveCriteria(criteria)) {
+        if (OrmUtils_1.OrmUtils.isPrimitiveCriteria(criteria)) {
             return this.createQueryBuilder()
                 .softDelete()
                 .from(targetOrEntity)
@@ -430,10 +496,11 @@ export class EntityManager {
                 .execute();
         }
         else {
+            const normalizedCriteria = OrmUtils_1.OrmUtils.normalizeWhereCriteria(criteria, this.dataSource.options.invalidWhereValuesBehavior);
             return this.createQueryBuilder()
                 .softDelete()
                 .from(targetOrEntity)
-                .where(criteria)
+                .where(normalizedCriteria)
                 .execute();
         }
     }
@@ -443,13 +510,15 @@ export class EntityManager {
      * Executes fast and efficient UPDATE query.
      * Does not check if entity exist in the database.
      * Condition(s) cannot be empty.
+     * @param targetOrEntity
+     * @param criteria
      */
     restore(targetOrEntity, criteria) {
         // if user passed empty criteria or empty list of criterias, then throw an error
-        if (OrmUtils.isCriteriaNullOrEmpty(criteria)) {
-            return Promise.reject(new TypeORMError(`Empty criteria(s) are not allowed for the restore method.`));
+        if (OrmUtils_1.OrmUtils.isCriteriaNullOrEmpty(criteria)) {
+            return Promise.reject(new error_1.TypeORMError(`Empty criteria(s) are not allowed for the restore method.`));
         }
-        if (OrmUtils.isPrimitiveCriteria(criteria)) {
+        if (OrmUtils_1.OrmUtils.isPrimitiveCriteria(criteria)) {
             return this.createQueryBuilder()
                 .restore()
                 .from(targetOrEntity)
@@ -457,28 +526,32 @@ export class EntityManager {
                 .execute();
         }
         else {
+            const normalizedCriteria = OrmUtils_1.OrmUtils.normalizeWhereCriteria(criteria, this.dataSource.options.invalidWhereValuesBehavior);
             return this.createQueryBuilder()
                 .restore()
                 .from(targetOrEntity)
-                .where(criteria)
+                .where(normalizedCriteria)
                 .execute();
         }
     }
     /**
      * Checks whether any entity exists with the given options.
+     * @param entityClass
+     * @param options
      */
     async exists(entityClass, options) {
-        const metadata = this.connection.getMetadata(entityClass);
-        return this.createQueryBuilder(entityClass, FindOptionsUtils.extractFindManyOptionsAlias(options) ||
-            metadata.name)
+        const metadata = this.dataSource.getMetadata(entityClass);
+        return this.createQueryBuilder(entityClass, metadata.name)
             .setFindOptions(options || {})
             .getExists();
     }
     /**
      * Checks whether any entity exists with the given conditions.
+     * @param entityClass
+     * @param where
      */
     async existsBy(entityClass, where) {
-        const metadata = this.connection.getMetadata(entityClass);
+        const metadata = this.dataSource.getMetadata(entityClass);
         return this.createQueryBuilder(entityClass, metadata.name)
             .setFindOptions({ where })
             .getExists();
@@ -486,77 +559,96 @@ export class EntityManager {
     /**
      * Counts entities that match given options.
      * Useful for pagination.
+     * @param entityClass
+     * @param options
      */
     async count(entityClass, options) {
-        const metadata = this.connection.getMetadata(entityClass);
-        return this.createQueryBuilder(entityClass, FindOptionsUtils.extractFindManyOptionsAlias(options) ||
-            metadata.name)
+        const metadata = this.dataSource.getMetadata(entityClass);
+        return this.createQueryBuilder(entityClass, metadata.name)
             .setFindOptions(options || {})
             .getCount();
     }
     /**
      * Counts entities that match given conditions.
      * Useful for pagination.
+     * @param entityClass
+     * @param where
      */
     async countBy(entityClass, where) {
-        const metadata = this.connection.getMetadata(entityClass);
+        const metadata = this.dataSource.getMetadata(entityClass);
         return this.createQueryBuilder(entityClass, metadata.name)
             .setFindOptions({ where })
             .getCount();
     }
     /**
      * Return the SUM of a column
+     * @param entityClass
+     * @param columnName
+     * @param where
      */
     sum(entityClass, columnName, where) {
         return this.callAggregateFun(entityClass, "SUM", columnName, where);
     }
     /**
      * Return the AVG of a column
+     * @param entityClass
+     * @param columnName
+     * @param where
      */
     average(entityClass, columnName, where) {
         return this.callAggregateFun(entityClass, "AVG", columnName, where);
     }
     /**
      * Return the MIN of a column
+     * @param entityClass
+     * @param columnName
+     * @param where
      */
     minimum(entityClass, columnName, where) {
         return this.callAggregateFun(entityClass, "MIN", columnName, where);
     }
     /**
      * Return the MAX of a column
+     * @param entityClass
+     * @param columnName
+     * @param where
      */
     maximum(entityClass, columnName, where) {
         return this.callAggregateFun(entityClass, "MAX", columnName, where);
     }
     async callAggregateFun(entityClass, fnName, columnName, where = {}) {
-        const metadata = this.connection.getMetadata(entityClass);
+        const metadata = this.dataSource.getMetadata(entityClass);
         const column = metadata.columns.find((item) => item.propertyPath === columnName);
         if (!column) {
-            throw new TypeORMError(`Column "${columnName}" was not found in table "${metadata.name}"`);
+            throw new error_1.TypeORMError(`Column "${columnName}" was not found in table "${metadata.name}"`);
         }
         const qb = this.createQueryBuilder(entityClass, metadata.name);
         qb.setFindOptions({ where });
         const alias = qb.alias;
         const result = await qb
-            .select(`${fnName}(${this.connection.driver.escape(alias)}.${this.connection.driver.escape(column.databaseName)})`, fnName)
+            .select(`${fnName}(${this.dataSource.driver.escape(alias)}.${this.dataSource.driver.escape(column.databaseName)})`, fnName)
+            .setOption("disable-global-order")
             .getRawOne();
         return result[fnName] === null ? null : parseFloat(result[fnName]);
     }
     /**
      * Finds entities that match given find options.
+     * @param entityClass
+     * @param options
      */
     async find(entityClass, options) {
-        const metadata = this.connection.getMetadata(entityClass);
-        return this.createQueryBuilder(entityClass, FindOptionsUtils.extractFindManyOptionsAlias(options) ||
-            metadata.name)
+        const metadata = this.dataSource.getMetadata(entityClass);
+        return this.createQueryBuilder(entityClass, metadata.name)
             .setFindOptions(options || {})
             .getMany();
     }
     /**
      * Finds entities that match given find options.
+     * @param entityClass
+     * @param where
      */
     async findBy(entityClass, where) {
-        const metadata = this.connection.getMetadata(entityClass);
+        const metadata = this.dataSource.getMetadata(entityClass);
         return this.createQueryBuilder(entityClass, metadata.name)
             .setFindOptions({ where: where })
             .getMany();
@@ -565,11 +657,12 @@ export class EntityManager {
      * Finds entities that match given find options.
      * Also counts all entities that match given conditions,
      * but ignores pagination settings (from and take options).
+     * @param entityClass
+     * @param options
      */
     async findAndCount(entityClass, options) {
-        const metadata = this.connection.getMetadata(entityClass);
-        return this.createQueryBuilder(entityClass, FindOptionsUtils.extractFindManyOptionsAlias(options) ||
-            metadata.name)
+        const metadata = this.dataSource.getMetadata(entityClass);
+        return this.createQueryBuilder(entityClass, metadata.name)
             .setFindOptions(options || {})
             .getManyAndCount();
     }
@@ -577,48 +670,28 @@ export class EntityManager {
      * Finds entities that match given WHERE conditions.
      * Also counts all entities that match given conditions,
      * but ignores pagination settings (from and take options).
+     * @param entityClass
+     * @param where
      */
     async findAndCountBy(entityClass, where) {
-        const metadata = this.connection.getMetadata(entityClass);
+        const metadata = this.dataSource.getMetadata(entityClass);
         return this.createQueryBuilder(entityClass, metadata.name)
             .setFindOptions({ where })
             .getManyAndCount();
     }
-    /**
-     * Finds entities with ids.
-     * Optionally find options or conditions can be applied.
-     *
-     * @deprecated use `findBy` method instead in conjunction with `In` operator, for example:
-     *
-     * .findBy({
-     *     id: In([1, 2, 3])
-     * })
-     */
-    async findByIds(entityClass, ids) {
-        // if no ids passed, no need to execute a query - just return an empty array of values
-        if (!ids.length)
-            return Promise.resolve([]);
-        const metadata = this.connection.getMetadata(entityClass);
-        return this.createQueryBuilder(entityClass, metadata.name)
-            .andWhereInIds(ids)
-            .getMany();
-    }
     /**
      * Finds first entity by a given find options.
      * If entity was not found in the database - returns null.
+     * @param entityClass
+     * @param options
      */
     async findOne(entityClass, options) {
-        const metadata = this.connection.getMetadata(entityClass);
-        // prepare alias for built query
-        let alias = metadata.name;
-        if (options && options.join) {
-            alias = options.join.alias;
-        }
+        const metadata = this.dataSource.getMetadata(entityClass);
         if (!options.where) {
             throw new Error(`You must provide selection conditions in order to find a single row.`);
         }
         // create query builder and apply find options
-        return this.createQueryBuilder(entityClass, alias)
+        return this.createQueryBuilder(entityClass, metadata.name)
             .setFindOptions({
             ...options,
             take: 1,
@@ -628,9 +701,11 @@ export class EntityManager {
     /**
      * Finds first entity that matches given where condition.
      * If entity was not found in the database - returns null.
+     * @param entityClass
+     * @param where
      */
     async findOneBy(entityClass, where) {
-        const metadata = this.connection.getMetadata(entityClass);
+        const metadata = this.dataSource.getMetadata(entityClass);
         // create query builder and apply find options
         return this.createQueryBuilder(entityClass, metadata.name)
             .setFindOptions({
@@ -639,34 +714,16 @@ export class EntityManager {
         })
             .getOne();
     }
-    /**
-     * Finds first entity that matches given id.
-     * If entity was not found in the database - returns null.
-     *
-     * @deprecated use `findOneBy` method instead in conjunction with `In` operator, for example:
-     *
-     * .findOneBy({
-     *     id: 1 // where "id" is your primary column name
-     * })
-     */
-    async findOneById(entityClass, id) {
-        const metadata = this.connection.getMetadata(entityClass);
-        // create query builder and apply find options
-        return this.createQueryBuilder(entityClass, metadata.name)
-            .setFindOptions({
-            take: 1,
-        })
-            .whereInIds(metadata.ensureEntityIdMap(id))
-            .getOne();
-    }
     /**
      * Finds first entity by a given find options.
      * If entity was not found in the database - rejects with error.
+     * @param entityClass
+     * @param options
      */
     async findOneOrFail(entityClass, options) {
         return this.findOne(entityClass, options).then((value) => {
             if (value === null) {
-                return Promise.reject(new EntityNotFoundError(entityClass, options));
+                return Promise.reject(new EntityNotFoundError_1.EntityNotFoundError(entityClass, options));
             }
             return Promise.resolve(value);
         });
@@ -674,11 +731,13 @@ export class EntityManager {
     /**
      * Finds first entity that matches given where condition.
      * If entity was not found in the database - rejects with error.
+     * @param entityClass
+     * @param where
      */
     async findOneByOrFail(entityClass, where) {
         return this.findOneBy(entityClass, where).then((value) => {
             if (value === null) {
-                return Promise.reject(new EntityNotFoundError(entityClass, where));
+                return Promise.reject(new EntityNotFoundError_1.EntityNotFoundError(entityClass, where));
             }
             return Promise.resolve(value);
         });
@@ -687,13 +746,16 @@ export class EntityManager {
      * Clears all the data from the given table (truncates/drops it).
      *
      * Note: this method uses TRUNCATE and may not work as you expect in transactions on some platforms.
+     * @param entityClass
+     * @param options
+     * @param options.cascade
      * @see https://stackoverflow.com/a/5972738/925151
      */
-    async clear(entityClass) {
-        const metadata = this.connection.getMetadata(entityClass);
-        const queryRunner = this.queryRunner || this.connection.createQueryRunner();
+    async clear(entityClass, options) {
+        const metadata = this.dataSource.getMetadata(entityClass);
+        const queryRunner = this.queryRunner || this.dataSource.createQueryRunner();
         try {
-            return await queryRunner.clearTable(metadata.tablePath); // await is needed here because we are using finally
+            return await queryRunner.clearTable(metadata.tablePath, options);
         }
         finally {
             if (!this.queryRunner)
@@ -702,18 +764,22 @@ export class EntityManager {
     }
     /**
      * Increments some column by provided value of the entities matched given conditions.
+     * @param entityClass
+     * @param conditions
+     * @param propertyPath
+     * @param value
      */
     async increment(entityClass, conditions, propertyPath, value) {
-        const metadata = this.connection.getMetadata(entityClass);
+        const metadata = this.dataSource.getMetadata(entityClass);
         const column = metadata.findColumnWithPropertyPath(propertyPath);
         if (!column)
-            throw new TypeORMError(`Column ${propertyPath} was not found in ${metadata.targetName} entity.`);
+            throw new error_1.TypeORMError(`Column ${propertyPath} was not found in ${metadata.targetName} entity.`);
         if (isNaN(Number(value)))
-            throw new TypeORMError(`Value "${value}" is not a number.`);
+            throw new error_1.TypeORMError(`Value "${value}" is not a number.`);
         // convert possible embedded path "social.likes" into object { social: { like: () => value } }
         const values = propertyPath
             .split(".")
-            .reduceRight((value, key) => ({ [key]: value }), () => this.connection.driver.escape(column.databaseName) +
+            .reduceRight((value, key) => ({ [key]: value }), () => this.dataSource.driver.escape(column.databaseName) +
             " + " +
             value);
         return this.createQueryBuilder(entityClass, "entity")
@@ -724,18 +790,22 @@ export class EntityManager {
     }
     /**
      * Decrements some column by provided value of the entities matched given conditions.
+     * @param entityClass
+     * @param conditions
+     * @param propertyPath
+     * @param value
      */
     async decrement(entityClass, conditions, propertyPath, value) {
-        const metadata = this.connection.getMetadata(entityClass);
+        const metadata = this.dataSource.getMetadata(entityClass);
         const column = metadata.findColumnWithPropertyPath(propertyPath);
         if (!column)
-            throw new TypeORMError(`Column ${propertyPath} was not found in ${metadata.targetName} entity.`);
+            throw new error_1.TypeORMError(`Column ${propertyPath} was not found in ${metadata.targetName} entity.`);
         if (isNaN(Number(value)))
-            throw new TypeORMError(`Value "${value}" is not a number.`);
+            throw new error_1.TypeORMError(`Value "${value}" is not a number.`);
         // convert possible embedded path "social.likes" into object { social: { like: () => value } }
         const values = propertyPath
             .split(".")
-            .reduceRight((value, key) => ({ [key]: value }), () => this.connection.driver.escape(column.databaseName) +
+            .reduceRight((value, key) => ({ [key]: value }), () => this.dataSource.driver.escape(column.databaseName) +
             " - " +
             value);
         return this.createQueryBuilder(entityClass, "entity")
@@ -749,6 +819,7 @@ export class EntityManager {
      * If single database connection mode is used, then repository is obtained from the
      * repository aggregator, where each repository is individually created for this entity manager.
      * When single database connection is not used, repository is being obtained from the connection.
+     * @param target
      */
     getRepository(target) {
         // find already created repository instance and return it if found
@@ -756,13 +827,13 @@ export class EntityManager {
         if (repoFromMap)
             return repoFromMap;
         // if repository was not found then create it, store its instance and return it
-        if (this.connection.driver.options.type === "mongodb") {
-            const newRepository = new MongoRepository(target, this, this.queryRunner);
+        if (this.dataSource.driver.options.type === "mongodb") {
+            const newRepository = new MongoRepository_1.MongoRepository(target, this, this.queryRunner);
             this.repositories.set(target, newRepository);
             return newRepository;
         }
         else {
-            const newRepository = new Repository(target, this, this.queryRunner);
+            const newRepository = new Repository_1.Repository(target, this, this.queryRunner);
             this.repositories.set(target, newRepository);
             return newRepository;
         }
@@ -772,30 +843,33 @@ export class EntityManager {
      * If single database connection mode is used, then repository is obtained from the
      * repository aggregator, where each repository is individually created for this entity manager.
      * When single database connection is not used, repository is being obtained from the connection.
+     * @param target
      */
     getTreeRepository(target) {
         // tree tables aren't supported by some drivers (mongodb)
-        if (this.connection.driver.treeSupport === false)
-            throw new TreeRepositoryNotSupportedError(this.connection.driver);
+        if (this.dataSource.driver.treeSupport === false)
+            throw new error_1.TreeRepositoryNotSupportedError(this.dataSource.driver);
         // find already created repository instance and return it if found
         const repository = this.treeRepositories.find((repository) => repository.target === target);
         if (repository)
             return repository;
         // check if repository is real tree repository
-        const newRepository = new TreeRepository(target, this, this.queryRunner);
+        const newRepository = new TreeRepository_1.TreeRepository(target, this, this.queryRunner);
         this.treeRepositories.push(newRepository);
         return newRepository;
     }
     /**
      * Gets mongodb repository for the given entity class.
+     * @param target
      */
     getMongoRepository(target) {
-        return this.connection.getMongoRepository(target);
+        return this.dataSource.getMongoRepository(target);
     }
     /**
      * Creates a new repository instance out of a given Repository and
      * sets current EntityManager instance to it. Used to work with custom repositories
      * in transactions.
+     * @param repository
      */
     withRepository(repository) {
         const repositoryConstructor = repository.constructor;
@@ -804,38 +878,6 @@ export class EntityManager {
             ...otherRepositoryProperties,
         });
     }
-    /**
-     * Gets custom entity repository marked with @EntityRepository decorator.
-     *
-     * @deprecated use Repository.extend to create custom repositories
-     */
-    getCustomRepository(customRepository) {
-        const entityRepositoryMetadataArgs = getMetadataArgsStorage().entityRepositories.find((repository) => {
-            return (repository.target ===
-                (typeof customRepository === "function"
-                    ? customRepository
-                    : customRepository.constructor));
-        });
-        if (!entityRepositoryMetadataArgs)
-            throw new CustomRepositoryNotFoundError(customRepository);
-        const entityMetadata = entityRepositoryMetadataArgs.entity
-            ? this.connection.getMetadata(entityRepositoryMetadataArgs.entity)
-            : undefined;
-        const entityRepositoryInstance = new entityRepositoryMetadataArgs.target(this, entityMetadata);
-        // NOTE: dynamic access to protected properties. We need this to prevent unwanted properties in those classes to be exposed,
-        // however we need these properties for internal work of the class
-        if (entityRepositoryInstance instanceof AbstractRepository) {
-            if (!entityRepositoryInstance["manager"])
-                entityRepositoryInstance["manager"] = this;
-        }
-        else {
-            if (!entityMetadata)
-                throw new CustomRepositoryCannotInheritRepositoryError(customRepository);
-            entityRepositoryInstance["manager"] = this;
-            entityRepositoryInstance["metadata"] = entityMetadata;
-        }
-        return entityRepositoryInstance;
-    }
     /**
      * Releases all resources used by entity manager.
      * This is used when entity manager is created with a single query runner,
@@ -843,9 +885,9 @@ export class EntityManager {
      */
     async release() {
         if (!this.queryRunner)
-            throw new NoNeedToReleaseEntityManagerError();
+            throw new NoNeedToReleaseEntityManagerError_1.NoNeedToReleaseEntityManagerError();
         return this.queryRunner.release();
     }
 }
-
-//# sourceMappingURL=EntityManager.js.map
+exports.EntityManager = EntityManager;
+//# sourceMappingURL=EntityManager.js.map