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

package/entity-manager/EntityManager.js

@@ -7,14 +7,11 @@ const NoNeedToReleaseEntityManagerError_1 = require("../error/NoNeedToReleaseEnt
 const MongoRepository_1 = require("../repository/MongoRepository");
 const TreeRepository_1 = require("../repository/TreeRepository");
 const Repository_1 = require("../repository/Repository");
-const FindOptionsUtils_1 = require("../find-options/FindOptionsUtils");
 const PlainObjectToNewEntityTransformer_1 = require("../query-builder/transformer/PlainObjectToNewEntityTransformer");
 const PlainObjectToDatabaseEntityTransformer_1 = require("../query-builder/transformer/PlainObjectToDatabaseEntityTransformer");
 const error_1 = require("../error");
-const AbstractRepository_1 = require("../repository/AbstractRepository");
 const EntityPersistExecutor_1 = require("../persistence/EntityPersistExecutor");
 const ObjectUtils_1 = require("../util/ObjectUtils");
-const globals_1 = require("../globals");
 const InstanceChecker_1 = require("../util/InstanceChecker");
 const SqlTagUtils_1 = require("../util/SqlTagUtils");
 const OrmUtils_1 = require("../util/OrmUtils");
@@ -23,10 +20,17 @@ const OrmUtils_1 = require("../util/OrmUtils");
  * whatever entity type are you passing.
  */
 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
@@ -44,7 +48,7 @@ class EntityManager {
          * Plain to object transformer used in create and merge operations.
          */
         this.plainObjectToEntityTransformer = new PlainObjectToNewEntityTransformer_1.PlainObjectToNewEntityTransformer();
-        this.connection = connection;
+        this.dataSource = dataSource;
         if (queryRunner) {
             this.queryRunner = queryRunner;
             // dynamic: this.queryRunner = manager;
@@ -54,6 +58,8 @@ class EntityManager {
     /**
      * 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"
@@ -69,7 +75,7 @@ class EntityManager {
             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);
@@ -92,11 +98,12 @@ 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.
@@ -104,10 +111,12 @@ 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 } = (0, SqlTagUtils_1.buildSqlTag)({
-            driver: this.connection.driver,
+            driver: this.dataSource.driver,
             strings: strings,
             expressions: values,
         });
@@ -115,41 +124,50 @@ 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))
@@ -160,10 +178,13 @@ 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;
     }
@@ -172,10 +193,12 @@ 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_1.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);
@@ -183,6 +206,9 @@ class EntityManager {
     }
     /**
      * Saves a given entity in the database.
+     * @param targetOrEntity
+     * @param maybeEntityOrOptions
+     * @param maybeOptions
      */
     save(targetOrEntity, maybeEntityOrOptions, maybeOptions) {
         // normalize mixed parameters
@@ -204,12 +230,15 @@ class EntityManager {
         if (Array.isArray(entity) && entity.length === 0)
             return Promise.resolve(entity);
         // execute save operation
-        return new EntityPersistExecutor_1.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
@@ -229,12 +258,15 @@ class EntityManager {
         if (Array.isArray(entity) && entity.length === 0)
             return Promise.resolve(entity);
         // execute save operation
-        return new EntityPersistExecutor_1.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
@@ -256,12 +288,15 @@ class EntityManager {
         if (Array.isArray(entity) && entity.length === 0)
             return Promise.resolve(entity);
         // execute soft-remove operation
-        return new EntityPersistExecutor_1.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
@@ -283,7 +318,7 @@ class EntityManager {
         if (Array.isArray(entity) && entity.length === 0)
             return Promise.resolve(entity);
         // execute recover operation
-        return new EntityPersistExecutor_1.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);
     }
@@ -293,6 +328,8 @@ 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()
@@ -302,7 +339,7 @@ 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 = {
@@ -323,18 +360,23 @@ 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).
@@ -342,25 +384,36 @@ 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_1.OrmUtils.isCriteriaNullOrEmpty(criteria)) {
             return Promise.reject(new error_1.TypeORMError(`Empty criteria(s) are not allowed for the update method.`));
         }
         if (OrmUtils_1.OrmUtils.isPrimitiveCriteria(criteria)) {
-            return this.createQueryBuilder()
+            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();
         }
     }
     /**
@@ -369,12 +422,16 @@ 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).
@@ -382,6 +439,8 @@ 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
@@ -396,10 +455,11 @@ 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();
         }
     }
@@ -409,6 +469,7 @@ 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();
@@ -419,6 +480,8 @@ 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
@@ -433,10 +496,11 @@ 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();
         }
     }
@@ -446,6 +510,8 @@ 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
@@ -460,28 +526,32 @@ 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_1.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();
@@ -489,50 +559,65 @@ 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_1.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 error_1.TypeORMError(`Column "${columnName}" was not found in table "${metadata.name}"`);
@@ -541,25 +626,29 @@ class EntityManager {
         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_1.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();
@@ -568,11 +657,12 @@ 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_1.FindOptionsUtils.extractFindManyOptionsAlias(options) ||
-            metadata.name)
+        const metadata = this.dataSource.getMetadata(entityClass);
+        return this.createQueryBuilder(entityClass, metadata.name)
             .setFindOptions(options || {})
             .getManyAndCount();
     }
@@ -580,48 +670,28 @@ 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,
@@ -631,9 +701,11 @@ 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({
@@ -642,29 +714,11 @@ 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) => {
@@ -677,6 +731,8 @@ 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) => {
@@ -690,13 +746,16 @@ 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)
@@ -705,9 +764,13 @@ 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 error_1.TypeORMError(`Column ${propertyPath} was not found in ${metadata.targetName} entity.`);
@@ -716,7 +779,7 @@ class EntityManager {
         // 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")
@@ -727,9 +790,13 @@ 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 error_1.TypeORMError(`Column ${propertyPath} was not found in ${metadata.targetName} entity.`);
@@ -738,7 +805,7 @@ class EntityManager {
         // 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")
@@ -752,6 +819,7 @@ 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
@@ -759,7 +827,7 @@ 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") {
+        if (this.dataSource.driver.options.type === "mongodb") {
             const newRepository = new MongoRepository_1.MongoRepository(target, this, this.queryRunner);
             this.repositories.set(target, newRepository);
             return newRepository;
@@ -775,11 +843,12 @@ 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 error_1.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)
@@ -791,14 +860,16 @@ class EntityManager {
     }
     /**
      * 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;
@@ -807,38 +878,6 @@ class EntityManager {
             ...otherRepositoryProperties,
         });
     }
-    /**
-     * Gets custom entity repository marked with @EntityRepository decorator.
-     *
-     * @deprecated use Repository.extend to create custom repositories
-     */
-    getCustomRepository(customRepository) {
-        const entityRepositoryMetadataArgs = (0, globals_1.getMetadataArgsStorage)().entityRepositories.find((repository) => {
-            return (repository.target ===
-                (typeof customRepository === "function"
-                    ? customRepository
-                    : customRepository.constructor));
-        });
-        if (!entityRepositoryMetadataArgs)
-            throw new error_1.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_1.AbstractRepository) {
-            if (!entityRepositoryInstance["manager"])
-                entityRepositoryInstance["manager"] = this;
-        }
-        else {
-            if (!entityMetadata)
-                throw new error_1.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,
@@ -851,5 +890,4 @@ class EntityManager {
     }
 }
 exports.EntityManager = EntityManager;
-
-//# sourceMappingURL=EntityManager.js.map
+//# sourceMappingURL=EntityManager.js.map