BaseEntity.ts

import { Repository } from "./Repository"
import { FindOptionsWhere } from "../find-options/FindOptionsWhere"
import { DeepPartial } from "../common/DeepPartial"
import { SaveOptions } from "./SaveOptions"
import { FindOneOptions } from "../find-options/FindOneOptions"
import { RemoveOptions } from "./RemoveOptions"
import { FindManyOptions } from "../find-options/FindManyOptions"
import { DataSource } from "../data-source"
import { SelectQueryBuilder } from "../query-builder/SelectQueryBuilder"
import { InsertResult } from "../query-builder/result/InsertResult"
import { UpdateResult } from "../query-builder/result/UpdateResult"
import { DeleteResult } from "../query-builder/result/DeleteResult"
import { ObjectID } from "../driver/mongodb/typings"
import { ObjectUtils } from "../util/ObjectUtils"
import { QueryDeepPartialEntity } from "../query-builder/QueryPartialEntity"
import { UpsertOptions } from "./UpsertOptions"
import { EntityTarget } from "../common/EntityTarget"

/**
 * Base abstract entity for all entities, used in ActiveRecord patterns.
 */
export class BaseEntity {
    // -------------------------------------------------------------------------
    // Private Static Properties
    // -------------------------------------------------------------------------

    /**
     * DataSource used in all static methods of the BaseEntity.
     */
    private static dataSource: DataSource | null

    // -------------------------------------------------------------------------
    // Public Methods
    // -------------------------------------------------------------------------

    /**
     * Checks if entity has an id.
     * If entity composite compose ids, it will check them all.
     */
    hasId(): boolean {
        const baseEntity = this.constructor as typeof BaseEntity
        return baseEntity.getRepository().hasId(this)
    }

    /**
     * Saves current entity in the database.
     * If entity does not exist in the database then inserts, otherwise updates.
     */
    save(options?: SaveOptions): Promise<this> {
        const baseEntity = this.constructor as typeof BaseEntity
        return baseEntity.getRepository().save(this, options)
    }

    /**
     * Removes current entity from the database.
     */
    remove(options?: RemoveOptions): Promise<this> {
        const baseEntity = this.constructor as typeof BaseEntity
        return baseEntity.getRepository().remove(this, options) as Promise<this>
    }

    /**
     * Records the delete date of current entity.
     */
    softRemove(options?: SaveOptions): Promise<this> {
        const baseEntity = this.constructor as typeof BaseEntity
        return baseEntity.getRepository().softRemove(this, options)
    }

    /**
     * Recovers a given entity in the database.
     */
    recover(options?: SaveOptions): Promise<this> {
        const baseEntity = this.constructor as typeof BaseEntity
        return baseEntity.getRepository().recover(this, options)
    }

    /**
     * Reloads entity data from the database.
     */
    async reload(): Promise<void> {
        const baseEntity = this.constructor as typeof BaseEntity
        const id = baseEntity.getRepository().metadata.getEntityIdMap(this)
        if (!id) {
            throw new Error(
                `Entity doesn't have id-s set, cannot reload entity`,
            )
        }
        const reloadedEntity: BaseEntity = await baseEntity
            .getRepository()
            .findOneByOrFail(id)

        ObjectUtils.assign(this, reloadedEntity)
    }

    // -------------------------------------------------------------------------
    // Public Static Methods
    // -------------------------------------------------------------------------

    /**
     * Sets DataSource to be used by entity.
     */
    static useDataSource(dataSource: DataSource | null) {
        this.dataSource = dataSource
    }

    /**
     * Gets current entity's Repository.
     */
    static getRepository<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
    ): Repository<T> {
        const dataSource = (this as typeof BaseEntity).dataSource
        if (!dataSource)
            throw new Error(`DataSource is not set for this entity.`)
        return dataSource.getRepository<T>(this)
    }

    /**
     * Returns object that is managed by this repository.
     * If this repository manages entity from schema,
     * then it returns a name of that schema instead.
     */
    static get target(): EntityTarget<any> {
        return this.getRepository().target
    }

    /**
     * Checks entity has an id.
     * If entity composite compose ids, it will check them all.
     */
    static hasId(entity: BaseEntity): boolean {
        return this.getRepository().hasId(entity)
    }

    /**
     * Gets entity mixed id.
     */
    static getId<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        entity: T,
    ): any {
        return this.getRepository<T>().getId(entity)
    }

    /**
     * Creates a new query builder that can be used to build a SQL query.
     */
    static createQueryBuilder<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        alias?: string,
    ): SelectQueryBuilder<T> {
        return this.getRepository<T>().createQueryBuilder(alias)
    }

    /**
     * Creates a new entity instance.
     */
    static create<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
    ): T

    /**
     * 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.
     */
    static create<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        entityLikeArray: DeepPartial<T>[],
    ): T[]

    /**
     * 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.
     */
    static create<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        entityLike: DeepPartial<T>,
    ): T

    /**
     * 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.
     */
    static create<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        entityOrEntities?: any,
    ) {
        return this.getRepository<T>().create(entityOrEntities)
    }

    /**
     * Merges multiple entities (or entity-like objects) into a given entity.
     */
    static merge<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        mergeIntoEntity: T,
        ...entityLikes: DeepPartial<T>[]
    ): T {
        return this.getRepository<T>().merge(
            mergeIntoEntity,
            ...entityLikes,
        ) as T
    }

    /**
     * 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.
     *
     * Note that given entity-like object must have an entity id / primary key to find entity by.
     * Returns undefined if entity with given id was not found.
     */
    static preload<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        entityLike: DeepPartial<T>,
    ): Promise<T | undefined> {
        const thisRepository = this.getRepository() as Repository<T>
        return thisRepository.preload(entityLike)
    }

    /**
     * Saves all given entities in the database.
     * If entities do not exist in the database then inserts, otherwise updates.
     */
    static save<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        entities: DeepPartial<T>[],
        options?: SaveOptions,
    ): Promise<T[]>

    /**
     * Saves a given entity in the database.
     * If entity does not exist in the database then inserts, otherwise updates.
     */
    static save<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        entity: DeepPartial<T>,
        options?: SaveOptions,
    ): Promise<T>

    /**
     * Saves one or many given entities.
     */
    static save<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        entityOrEntities: DeepPartial<T> | DeepPartial<T>[],
        options?: SaveOptions,
    ) {
        return this.getRepository<T>().save(entityOrEntities as any, options)
    }

    /**
     * Removes a given entities from the database.
     */
    static remove<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        entities: T[],
        options?: RemoveOptions,
    ): Promise<T[]>

    /**
     * Removes a given entity from the database.
     */
    static remove<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        entity: T,
        options?: RemoveOptions,
    ): Promise<T>

    /**
     * Removes one or many given entities.
     */
    static remove<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        entityOrEntities: T | T[],
        options?: RemoveOptions,
    ) {
        return this.getRepository<T>().remove(entityOrEntities as any, options)
    }

    /**
     * Records the delete date of all given entities.
     */
    static softRemove<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        entities: T[],
        options?: SaveOptions,
    ): Promise<T[]>

    /**
     * Records the delete date of a given entity.
     */
    static softRemove<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        entity: T,
        options?: SaveOptions,
    ): Promise<T>

    /**
     * Records the delete date of one or many given entities.
     */
    static softRemove<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        entityOrEntities: T | T[],
        options?: SaveOptions,
    ) {
        return this.getRepository<T>().softRemove(
            entityOrEntities as any,
            options,
        )
    }

    /**
     * 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.
     */
    static insert<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        entity: QueryDeepPartialEntity<T> | QueryDeepPartialEntity<T>[],
    ): Promise<InsertResult> {
        return this.getRepository<T>().insert(entity)
    }

    /**
     * Updates entity partially. Entity can be found by a given conditions.
     * 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.
     */
    static update<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        criteria:
            | string
            | string[]
            | number
            | number[]
            | Date
            | Date[]
            | ObjectID
            | ObjectID[]
            | FindOptionsWhere<T>,
        partialEntity: QueryDeepPartialEntity<T>,
    ): Promise<UpdateResult> {
        return this.getRepository<T>().update(criteria, partialEntity)
    }

    /**
     * Inserts a given entity into the database, unless a unique constraint conflicts then updates the entity
     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
     * Executes fast and efficient INSERT ... ON CONFLICT DO UPDATE/ON DUPLICATE KEY UPDATE query.
     */
    static upsert<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        entityOrEntities:
            | QueryDeepPartialEntity<T>
            | QueryDeepPartialEntity<T>[],
        conflictPathsOrOptions: string[] | UpsertOptions<T>,
    ): Promise<InsertResult> {
        return this.getRepository<T>().upsert(
            entityOrEntities,
            conflictPathsOrOptions,
        )
    }

    /**
     * Deletes entities by a given criteria.
     * Unlike remove 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.
     */
    static delete<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        criteria:
            | string
            | string[]
            | number
            | number[]
            | Date
            | Date[]
            | ObjectID
            | ObjectID[]
            | FindOptionsWhere<T>,
    ): Promise<DeleteResult> {
        return this.getRepository<T>().delete(criteria)
    }

    /**
     * Counts entities that match given options.
     */
    static count<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        options?: FindManyOptions<T>,
    ): Promise<number> {
        return this.getRepository<T>().count(options)
    }

    /**
     * Counts entities that match given WHERE conditions.
     */
    static countBy<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        where: FindOptionsWhere<T>,
    ): Promise<number> {
        return this.getRepository<T>().countBy(where)
    }

    /**
     * Finds entities that match given options.
     */
    static find<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        options?: FindManyOptions<T>,
    ): Promise<T[]> {
        return this.getRepository<T>().find(options)
    }

    /**
     * Finds entities that match given WHERE conditions.
     */
    static findBy<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        where: FindOptionsWhere<T>,
    ): Promise<T[]> {
        return this.getRepository<T>().findBy(where)
    }

    /**
     * Finds entities that match given find options.
     * Also counts all entities that match given conditions,
     * but ignores pagination settings (from and take options).
     */
    static findAndCount<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        options?: FindManyOptions<T>,
    ): Promise<[T[], number]> {
        return this.getRepository<T>().findAndCount(options)
    }

    /**
     * Finds entities that match given WHERE conditions.
     * Also counts all entities that match given conditions,
     * but ignores pagination settings (from and take options).
     */
    static findAndCountBy<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        where: FindOptionsWhere<T>,
    ): Promise<[T[], number]> {
        return this.getRepository<T>().findAndCountBy(where)
    }

    /**
     * Finds entities by ids.
     * Optionally find options can be applied.
     *
     * @deprecated use `findBy` method instead in conjunction with `In` operator, for example:
     *
     * .findBy({
     *     id: In([1, 2, 3])
     * })
     */
    static findByIds<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        ids: any[],
    ): Promise<T[]> {
        return this.getRepository<T>().findByIds(ids)
    }

    /**
     * Finds first entity that matches given conditions.
     */
    static findOne<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        options: FindOneOptions<T>,
    ): Promise<T | null> {
        return this.getRepository<T>().findOne(options)
    }

    /**
     * Finds first entity that matches given conditions.
     */
    static findOneBy<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        where: FindOptionsWhere<T>,
    ): Promise<T | null> {
        return this.getRepository<T>().findOneBy(where)
    }

    /**
     * Finds first entity that matches given options.
     *
     * @deprecated use `findOneBy` method instead in conjunction with `In` operator, for example:
     *
     * .findOneBy({
     *     id: 1 // where "id" is your primary column name
     * })
     */
    static findOneById<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        id: string | number | Date | ObjectID,
    ): Promise<T | null> {
        return this.getRepository<T>().findOneById(id)
    }

    /**
     * Finds first entity that matches given conditions.
     */
    static findOneOrFail<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        options: FindOneOptions<T>,
    ): Promise<T> {
        return this.getRepository<T>().findOneOrFail(options)
    }

    /**
     * Finds first entity that matches given conditions.
     */
    static findOneByOrFail<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        where: FindOptionsWhere<T>,
    ): Promise<T> {
        return this.getRepository<T>().findOneByOrFail(where)
    }

    /**
     * Executes a raw SQL query and returns a raw database results.
     * Raw query execution is supported only by relational databases (MongoDB is not supported).
     */
    static query<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
        query: string,
        parameters?: any[],
    ): Promise<any> {
        return this.getRepository<T>().query(query, parameters)
    }

    /**
     * Clears all the data from the given table/collection (truncates/drops it).
     */
    static clear<T extends BaseEntity>(
        this: { new (): T } & typeof BaseEntity,
    ): Promise<void> {
        return this.getRepository<T>().clear()
    }
}