typeorm / typeorm / 19549987525

import { DataSource } from "../data-source/DataSource"

import { FindManyOptions } from "../find-options/FindManyOptions"

import { EntityTarget } from "../common/EntityTarget"

import { ObjectType } from "../common/ObjectType"

import { EntityNotFoundError } from "../error/EntityNotFoundError"

import { QueryRunnerProviderAlreadyReleasedError } from "../error/QueryRunnerProviderAlreadyReleasedError"

import { FindOneOptions } from "../find-options/FindOneOptions"

import { DeepPartial } from "../common/DeepPartial"

import { RemoveOptions } from "../repository/RemoveOptions"

import { SaveOptions } from "../repository/SaveOptions"

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 { QueryRunner } from "../query-runner/QueryRunner"

import { SelectQueryBuilder } from "../query-builder/SelectQueryBuilder"

import { QueryDeepPartialEntity } from "../query-builder/QueryPartialEntity"

import { EntityPersistExecutor } from "../persistence/EntityPersistExecutor"

import { ObjectId } from "../driver/mongodb/typings"

import { InsertResult } from "../query-builder/result/InsertResult"

import { UpdateResult } from "../query-builder/result/UpdateResult"

import { DeleteResult } from "../query-builder/result/DeleteResult"

import { FindOptionsWhere } from "../find-options/FindOptionsWhere"

import { IsolationLevel } from "../driver/types/IsolationLevel"

import { ObjectUtils } from "../util/ObjectUtils"

import { getMetadataArgsStorage } from "../globals"

import { UpsertOptions } from "../repository/UpsertOptions"

import { InstanceChecker } from "../util/InstanceChecker"

import { ObjectLiteral } from "../common/ObjectLiteral"

import { PickKeysByType } from "../common/PickKeysByType"

import { buildSqlTag } from "../util/SqlTagUtils"

import { OrmUtils } from "../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 {

    readonly "@instanceof" = Symbol.for("EntityManager")

    // -------------------------------------------------------------------------

    // Public Properties

    // -------------------------------------------------------------------------

    /**

     * Connection used by this entity manager.

     */

    readonly connection: DataSource

    /**

     * Custom query runner to be used for operations in this entity manager.

     * Used only in non-global entity manager.

     */

    readonly queryRunner?: QueryRunner

    // -------------------------------------------------------------------------

    // Protected Properties

    // -------------------------------------------------------------------------

    /**

     * Once created and then reused by repositories.

     * Created as a future replacement for the #repositories to provide a bit more perf optimization.

     */

    protected repositories = new Map<EntityTarget<any>, Repository<any>>()

    /**

     * Once created and then reused by repositories.

     */

    protected treeRepositories: TreeRepository<any>[] = []

    /**

     * Plain to object transformer used in create and merge operations.

     */

    protected plainObjectToEntityTransformer =

        new PlainObjectToNewEntityTransformer()

    // -------------------------------------------------------------------------

    // Constructor

    // -------------------------------------------------------------------------

    constructor(connection: DataSource, queryRunner?: QueryRunner) {

        this.connection = connection

        if (queryRunner) {

            this.queryRunner = queryRunner

            // dynamic: this.queryRunner = manager;

            ObjectUtils.assign(this.queryRunner, { manager: this })

        }

    }

    // -------------------------------------------------------------------------

    // Public Methods

    // -------------------------------------------------------------------------

    /**

     * Wraps given function execution (and all operations made there) in a transaction.

     * All database operations must be executed using provided entity manager.

     */

    async transaction<T>(

        runInTransaction: (entityManager: EntityManager) => Promise<T>,

    ): Promise<T>

    /**

     * Wraps given function execution (and all operations made there) in a transaction.

     * All database operations must be executed using provided entity manager.

     */

    async transaction<T>(

        isolationLevel: IsolationLevel,

        runInTransaction: (entityManager: EntityManager) => Promise<T>,

    ): Promise<T>

    /**

     * Wraps given function execution (and all operations made there) in a transaction.

     * All database operations must be executed using provided entity manager.

     */

    async transaction<T>(

        isolationOrRunInTransaction:

            | IsolationLevel

            | ((entityManager: EntityManager) => Promise<T>),

        runInTransactionParam?: (entityManager: EntityManager) => Promise<T>,

    ): Promise<T> {

        const isolation =

            typeof isolationOrRunInTransaction === "string"

                ? isolationOrRunInTransaction

                : undefined

        const runInTransaction =

            typeof isolationOrRunInTransaction === "function"

                ? isolationOrRunInTransaction

                : runInTransactionParam

        if (this.queryRunner && this.queryRunner.isReleased)

        // 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()

        try {

            await queryRunner.startTransaction(isolation)

            const result = await runInTransaction(queryRunner.manager)

            await queryRunner.commitTransaction()

            return result

        } catch (err) {

            try {

                // we throw original error even if rollback thrown an error

                await queryRunner.rollbackTransaction()

            throw err

            if (!this.queryRunner)

                // if we used a new query runner provider then release it

                await queryRunner.release()

        }

    }

    /**

     * Executes raw SQL query and returns raw database results.

     *

     * @see [Official docs](https://typeorm.io/docs/Working%20with%20Entity%20Manager/entity-manager-api/) for examples.

     */

    async query<T = any>(query: string, parameters?: any[]): Promise<T> {

        return this.connection.query(query, parameters, this.queryRunner)

    }

    /**

     * Tagged template function that executes raw SQL query and returns raw database results.

     * Template expressions are automatically transformed into database parameters.

     * 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}`

     */

    async sql<T = any>(

        strings: TemplateStringsArray,

        ...values: unknown[]

    ): Promise<T> {

        const { query, parameters } = buildSqlTag({

            driver: this.connection.driver,

            strings: strings,

            expressions: values,

        })

        return await this.query(query, parameters)

    }

    /**

     * Creates a new query builder that can be used to build a SQL query.

     */

    createQueryBuilder<Entity extends ObjectLiteral>(

        entityClass: EntityTarget<Entity>,

        alias: string,

        queryRunner?: QueryRunner,

    ): SelectQueryBuilder<Entity>

    /**

     * Creates a new query builder that can be used to build a SQL query.

     */

    createQueryBuilder(queryRunner?: QueryRunner): SelectQueryBuilder<any>

    /**

     * Creates a new query builder that can be used to build a SQL query.

     */

    createQueryBuilder<Entity extends ObjectLiteral>(

        entityClass?: EntityTarget<Entity> | QueryRunner,

        alias?: string,

        queryRunner?: QueryRunner,

    ): SelectQueryBuilder<Entity> {

        if (alias) {

            return this.connection.createQueryBuilder(

                entityClass as EntityTarget<Entity>,

                alias,

                queryRunner || this.queryRunner,

            )

        } else {

            return this.connection.createQueryBuilder(

                (entityClass as QueryRunner | undefined) ||

                    queryRunner ||

                    this.queryRunner,

            )

        }

    }

    /**

     * Checks if entity has an id.

     */

    hasId(entity: any): boolean

    /**

     * Checks if entity of given schema name has an id.

     */

    hasId(target: Function | string, entity: any): boolean

    /**

     * Checks if entity has an id by its Function type or schema name.

     */

    hasId(targetOrEntity: any | Function | string, maybeEntity?: any): boolean {

        const target =

        const metadata = this.connection.getMetadata(target)

        return metadata.hasId(entity)

    }

    /**

     * Gets entity mixed id.

     */

    getId(entity: any): any

    /**

     * Gets entity mixed id.

     */

    getId(target: EntityTarget<any>, entity: any): any

    /**

     * Gets entity mixed id.

     */

    getId(targetOrEntity: any | EntityTarget<any>, maybeEntity?: any): any {

        const target =

        const metadata = this.connection.getMetadata(target)

        return metadata.getEntityIdMixedMap(entity)

    }

    /**

     * Creates a new entity instance and copies all entity properties from this object into a new entity.

     * Note that it copies only properties that present in entity schema.

     */

    create<Entity, EntityLike extends DeepPartial<Entity>>(

        entityClass: EntityTarget<Entity>,

        plainObject?: EntityLike,

    ): Entity

    /**

     * Creates a new entities and copies all entity properties from given objects into their new entities.

     * Note that it copies only properties that present in entity schema.

     */

    create<Entity, EntityLike extends DeepPartial<Entity>>(

        entityClass: EntityTarget<Entity>,

        plainObjects?: EntityLike[],

    ): Entity[]

    /**

     * Creates a new entity instance or instances.

     * Can copy properties from the given object into new entities.

     */

    create<Entity, EntityLike extends DeepPartial<Entity>>(

        entityClass: EntityTarget<Entity>,

        plainObjectOrObjects?: EntityLike | EntityLike[],

    ): Entity | Entity[] {

        const metadata = this.connection.getMetadata(entityClass)

        if (!plainObjectOrObjects) return metadata.create(this.queryRunner)

        if (Array.isArray(plainObjectOrObjects))

                (plainEntityLike) => this.create(entityClass, plainEntityLike),

            )

        const mergeIntoEntity = metadata.create(this.queryRunner)

        this.plainObjectToEntityTransformer.transform(

            mergeIntoEntity,

            plainObjectOrObjects,

            metadata,

            true,

        )

        return mergeIntoEntity

    }

    /**

     * Merges two entities into one new entity.

     */

    merge<Entity extends ObjectLiteral>(

        entityClass: EntityTarget<Entity>,

        mergeIntoEntity: Entity,

        ...entityLikes: DeepPartial<Entity>[]

    ): Entity {

        // todo: throw exception if entity manager is released

        const metadata = this.connection.getMetadata(entityClass)

        entityLikes.forEach((object) =>

            this.plainObjectToEntityTransformer.transform(

                mergeIntoEntity,

                object,

                metadata,

            ),

        )

        return mergeIntoEntity

    }

    /**

     * Creates a new entity from the given plain javascript object. If entity already exist in the database, then

     * 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.

     */

    async preload<Entity extends ObjectLiteral>(

        entityClass: EntityTarget<Entity>,

        entityLike: DeepPartial<Entity>,

    ): Promise<Entity | undefined> {

        const metadata = this.connection.getMetadata(entityClass)

        const plainObjectToDatabaseEntityTransformer =

            new PlainObjectToDatabaseEntityTransformer(this.connection.manager)

        const transformedEntity =

            await plainObjectToDatabaseEntityTransformer.transform(

                entityLike,

                metadata,

            )

        if (transformedEntity)

            return this.merge(

                entityClass as any,

                transformedEntity as Entity,

                entityLike,

            )

    /**

     * Saves all given entities in the database.

     * If entities do not exist in the database then inserts, otherwise updates.

     */

    save<Entity>(entities: Entity[], options?: SaveOptions): Promise<Entity[]>

    /**

     * Saves all given entities in the database.

     * If entities do not exist in the database then inserts, otherwise updates.

     */

    save<Entity>(entity: Entity, options?: SaveOptions): Promise<Entity>

    /**

     * Saves all given entities in the database.

     * If entities do not exist in the database then inserts, otherwise updates.

     */

    save<Entity, T extends DeepPartial<Entity>>(

        targetOrEntity: EntityTarget<Entity>,

        entities: T[],

        options: SaveOptions & { reload: false },

    ): Promise<T[]>

    /**

     * Saves all given entities in the database.

     * If entities do not exist in the database then inserts, otherwise updates.

     */

    save<Entity, T extends DeepPartial<Entity>>(

        targetOrEntity: EntityTarget<Entity>,

        entities: T[],

        options?: SaveOptions,

    ): Promise<(T & Entity)[]>

    /**

     * Saves a given entity in the database.

     * If entity does not exist in the database then inserts, otherwise updates.

     */

    save<Entity, T extends DeepPartial<Entity>>(

        targetOrEntity: EntityTarget<Entity>,

        entity: T,

        options: SaveOptions & { reload: false },

    ): Promise<T>

    /**

     * Saves a given entity in the database.

     * If entity does not exist in the database then inserts, otherwise updates.

     */

    save<Entity, T extends DeepPartial<Entity>>(

        targetOrEntity: EntityTarget<Entity>,

        entity: T,

        options?: SaveOptions,

    ): Promise<T & Entity>

    /**

     * Saves a given entity in the database.

     */

    save<Entity extends ObjectLiteral, T extends DeepPartial<Entity>>(

        targetOrEntity: (T | T[]) | EntityTarget<Entity>,

        maybeEntityOrOptions?: T | T[],

        maybeOptions?: SaveOptions,

    ): Promise<T | T[]> {

        // normalize mixed parameters

        let target =

            arguments.length > 1 &&

                typeof targetOrEntity === "string")

                ? (targetOrEntity as Function | string)

                : undefined

        const entity: T | T[] = target

            ? (maybeEntityOrOptions as T | T[])

            : (targetOrEntity as T | T[])

        const options = target

            ? maybeOptions

            : (maybeEntityOrOptions as SaveOptions)

        // 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,

        )

            .execute()

            .then(() => entity)

    }

    /**

     * Removes a given entity from the database.

     */

    remove<Entity>(entity: Entity, options?: RemoveOptions): Promise<Entity>

    /**

     * Removes a given entity from the database.

     */

    remove<Entity>(

        targetOrEntity: EntityTarget<Entity>,

        entity: Entity,

        options?: RemoveOptions,

    ): Promise<Entity>

    /**

     * Removes a given entity from the database.

     */

    remove<Entity>(entity: Entity[], options?: RemoveOptions): Promise<Entity>

    /**

     * Removes a given entity from the database.

     */

    remove<Entity>(

        targetOrEntity: EntityTarget<Entity>,

        entity: Entity[],

        options?: RemoveOptions,

    ): Promise<Entity[]>

    /**

     * Removes a given entity from the database.

     */

    remove<Entity extends ObjectLiteral>(

        targetOrEntity: (Entity | Entity[]) | EntityTarget<Entity>,

        maybeEntityOrOptions?: Entity | Entity[],

        maybeOptions?: RemoveOptions,

    ): Promise<Entity | Entity[]> {

        // normalize mixed parameters

        const target =

            arguments.length > 1 &&

                typeof targetOrEntity === "string")

                ? (targetOrEntity as Function | string)

        const entity: Entity | Entity[] = target

            ? (maybeEntityOrOptions as Entity | Entity[])

        const options = target

            ? maybeOptions

        // if user passed empty array of entities then we don't need to do anything

        // execute save operation

        return new EntityPersistExecutor(

            this.connection,

            this.queryRunner,

            "remove",

            target,

            entity,

            options,

        )

            .execute()

            .then(() => entity)

    }

    /**

     * Records the delete date of all given entities.

     */

    softRemove<Entity>(

        entities: Entity[],

        options?: SaveOptions,

    ): Promise<Entity[]>

    /**

     * Records the delete date of a given entity.

     */

    softRemove<Entity>(entity: Entity, options?: SaveOptions): Promise<Entity>

    /**

     * Records the delete date of all given entities.

     */

    softRemove<Entity, T extends DeepPartial<Entity>>(

        targetOrEntity: EntityTarget<Entity>,

        entities: T[],

        options?: SaveOptions,

    ): Promise<T[]>

    /**

     * Records the delete date of a given entity.

     */

    softRemove<Entity, T extends DeepPartial<Entity>>(

        targetOrEntity: EntityTarget<Entity>,

        entity: T,

        options?: SaveOptions,

    ): Promise<T>

    /**

     * Records the delete date of one or many given entities.

     */

    softRemove<Entity extends ObjectLiteral, T extends DeepPartial<Entity>>(

        targetOrEntity: (T | T[]) | EntityTarget<Entity>,

        maybeEntityOrOptions?: T | T[],

        maybeOptions?: SaveOptions,

    ): Promise<T | T[]> {

        // normalize mixed parameters

        let target =

            arguments.length > 1 &&

                typeof targetOrEntity === "string")

                ? (targetOrEntity as Function | string)

        const entity: T | T[] = target

            ? (maybeEntityOrOptions as T | T[])

        const options = target

            ? maybeOptions

        // if user passed empty array of entities then we don't need to do anything

        // execute soft-remove operation

        return new EntityPersistExecutor(

            this.connection,

            this.queryRunner,

            "soft-remove",

            target,

            entity,

            options,

        )

            .execute()

            .then(() => entity)

    }

    /**

     * Recovers all given entities.

     */

    recover<Entity>(

        entities: Entity[],

        options?: SaveOptions,

    ): Promise<Entity[]>

    /**

     * Recovers a given entity.

     */

    recover<Entity>(entity: Entity, options?: SaveOptions): Promise<Entity>

    /**

     * Recovers all given entities.

     */

    recover<Entity, T extends DeepPartial<Entity>>(

        targetOrEntity: EntityTarget<Entity>,

        entities: T[],

        options?: SaveOptions,

    ): Promise<T[]>

    /**

     * Recovers a given entity.

     */

    recover<Entity, T extends DeepPartial<Entity>>(

        targetOrEntity: EntityTarget<Entity>,

        entity: T,

        options?: SaveOptions,

    ): Promise<T>

    /**

     * Recovers one or many given entities.

     */

    recover<Entity extends ObjectLiteral, T extends DeepPartial<Entity>>(

        targetOrEntity: (T | T[]) | EntityTarget<Entity>,

        maybeEntityOrOptions?: T | T[],

        maybeOptions?: SaveOptions,

    ): Promise<T | T[]> {

        // normalize mixed parameters

        let target =

            arguments.length > 1 &&

            (typeof targetOrEntity === "function" ||

                InstanceChecker.isEntitySchema(targetOrEntity) ||

                typeof targetOrEntity === "string")

                ? (targetOrEntity as Function | string)

                : undefined

        const entity: T | T[] = target

            ? (maybeEntityOrOptions as T | T[])

            : (targetOrEntity as T | T[])

        const options = target

            ? maybeOptions

            : (maybeEntityOrOptions as SaveOptions)

        // if user passed empty array of entities then we don't need to do anything

        // execute recover operation

        return new EntityPersistExecutor(

            this.connection,

            this.queryRunner,

            "recover",

            target,

            entity,

            options,

        )

            .execute()

            .then(() => entity)

    }

    /**

     * Inserts a given entity into the database.

     * Unlike save method executes a primitive operation without cascades, relations and other operations included.

     * 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.

     */

    async insert<Entity extends ObjectLiteral>(

        target: EntityTarget<Entity>,

        entity:

            | QueryDeepPartialEntity<Entity>

            | QueryDeepPartialEntity<Entity>[],

    ): Promise<InsertResult> {

        return this.createQueryBuilder()

            .insert()

            .into(target)

            .values(entity)

            .execute()

    }

    async upsert<Entity extends ObjectLiteral>(

        target: EntityTarget<Entity>,

        entityOrEntities:

            | QueryDeepPartialEntity<Entity>

            | QueryDeepPartialEntity<Entity>[],

        conflictPathsOrOptions: string[] | UpsertOptions<Entity>,

    ): Promise<InsertResult> {

        const metadata = this.connection.getMetadata(target)

        let options: UpsertOptions<Entity>

        if (Array.isArray(conflictPathsOrOptions)) {

            options = {

                conflictPaths: conflictPathsOrOptions,

            }

            options = conflictPathsOrOptions

        }

        let entities: QueryDeepPartialEntity<Entity>[]

        if (!Array.isArray(entityOrEntities)) {

            entities = [entityOrEntities]

        } else {

            entities = entityOrEntities

        }

        const conflictColumns = metadata.mapPropertyPathsToColumns(

            Array.isArray(options.conflictPaths)

                ? options.conflictPaths

        )

        const overwriteColumns = metadata.columns.filter(

            (col) =>

                !conflictColumns.includes(col) &&

                entities.some(

                    (entity) =>

                        typeof col.getEntityValue(entity) !== "undefined",

                ),

        )

        return 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()

    }

    /**

     * Updates entity partially. Entity can be found by a given condition(s).

     * Unlike save method executes a primitive operation without cascades, relations and other operations included.

     * Executes fast and efficient UPDATE query.

     * Does not check if entity exist in the database.

     * Condition(s) cannot be empty.

     */

    update<Entity extends ObjectLiteral>(

        target: EntityTarget<Entity>,

        criteria:

            | string

            | string[]

            | number

            | number[]

            | Date

            | Date[]

            | ObjectId

            | ObjectId[]

            | any,

        partialEntity: QueryDeepPartialEntity<Entity>,

    ): Promise<UpdateResult> {

        // 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.isPrimitiveCriteria(criteria)) {

            return this.createQueryBuilder()

                .update(target)

                .set(partialEntity)

                .whereInIds(criteria)

                .execute()

        } else {

            return this.createQueryBuilder()

                .update(target)

                .set(partialEntity)

                .where(criteria)

                .execute()

        }

    }

    /**

     * Updates all entities of target type, setting fields from supplied partial entity.

     * This is a primitive operation without cascades, relations or other operations included.

     * Executes fast and efficient UPDATE query without WHERE clause.

     *

     * WARNING! This method updates ALL rows in the target table.

     */

    updateAll<Entity extends ObjectLiteral>(

        target: EntityTarget<Entity>,

        partialEntity: QueryDeepPartialEntity<Entity>,

    ): Promise<UpdateResult> {

        return this.createQueryBuilder()

            .update(target)

            .set(partialEntity)

            .execute()

    }

    /**

     * Deletes entities by a given condition(s).

     * Unlike save method executes a primitive operation without cascades, relations and other operations included.

     * Executes fast and efficient DELETE query.

     * Does not check if entity exist in the database.

     * Condition(s) cannot be empty.

     */

    delete<Entity extends ObjectLiteral>(

        targetOrEntity: EntityTarget<Entity>,

        criteria:

            | string

            | string[]

            | number

            | number[]

            | Date

            | Date[]

            | ObjectId

            | ObjectId[]

            | any,

    ): Promise<DeleteResult> {

        // 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.isPrimitiveCriteria(criteria)) {

            return this.createQueryBuilder()

                .delete()

                .from(targetOrEntity)

                .whereInIds(criteria)

                .execute()

        } else {

            return this.createQueryBuilder()

                .delete()

                .from(targetOrEntity)

                .where(criteria)

                .execute()

        }

    }

    /**

     * Deletes all entities of target type.

     * This is a primitive operation without cascades, relations or other operations included.

     * Executes fast and efficient DELETE query without WHERE clause.

     *

     * WARNING! This method deletes ALL rows in the target table.

     */

    deleteAll<Entity extends ObjectLiteral>(

        targetOrEntity: EntityTarget<Entity>,

    ): Promise<DeleteResult> {

        return this.createQueryBuilder().delete().from(targetOrEntity).execute()

    }

    /**

     * Records the delete date of entities by a given condition(s).

     * Unlike save method executes a primitive operation without cascades, relations and other operations included.

     * Executes fast and efficient UPDATE query.

     * Does not check if entity exist in the database.

     * Condition(s) cannot be empty.

     */

    softDelete<Entity extends ObjectLiteral>(

        targetOrEntity: EntityTarget<Entity>,

        criteria:

            | string

            | string[]

            | number

            | number[]

            | Date

            | Date[]

            | ObjectId

            | ObjectId[]

            | any,

    ): Promise<UpdateResult> {

        // if user passed empty criteria or empty list of criterias, then throw an error