nukak/querier/abstractQuerier.d.ts

flexible and efficient ORM, with declarative JSON syntax and smart type-safety

import type { IdValue, Querier, Query, QueryConflictPaths, QueryOne, QueryOptions, QuerySearch, QuerySelect, QueryUpdateResult, RelationKey, Repository, Type } from '../type/index.js';
/**
 * Base class for all database queriers.
 * It provides a standardized way to execute tasks serially to prevent race conditions on database connections.
 */
export declare abstract class AbstractQuerier implements Querier {
    /**
     * Internal promise used to queue database operations.
     * This ensures that each operation is executed serially, preventing race conditions
     * and ensuring that the database connection is used safely across concurrent calls.
     */
    private taskQueue;
    findOneById<E>(entity: Type<E>, id: IdValue<E>, q?: QueryOne<E>): Promise<E>;
    findOne<E>(entity: Type<E>, q: QueryOne<E>): Promise<E>;
    abstract findMany<E>(entity: Type<E>, q: Query<E>): Promise<E[]>;
    findManyAndCount<E>(entity: Type<E>, q: Query<E>): Promise<[E[], number]>;
    abstract count<E>(entity: Type<E>, q: QuerySearch<E>): Promise<number>;
    insertOne<E>(entity: Type<E>, payload: E): Promise<IdValue<E>>;
    abstract insertMany<E>(entity: Type<E>, payload: E[]): Promise<IdValue<E>[]>;
    updateOneById<E>(entity: Type<E>, id: IdValue<E>, payload: E): Promise<number>;
    abstract updateMany<E>(entity: Type<E>, q: QuerySearch<E>, payload: E): Promise<number>;
    abstract upsertOne<E>(entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E): Promise<QueryUpdateResult>;
    deleteOneById<E>(entity: Type<E>, id: IdValue<E>, opts?: QueryOptions): Promise<number>;
    abstract deleteMany<E>(entity: Type<E>, q: QuerySearch<E>, opts?: QueryOptions): Promise<number>;
    saveOne<E>(entity: Type<E>, payload: E): Promise<IdValue<E> | E[import("../type/entity.js").IdKey<E>]>;
    saveMany<E>(entity: Type<E>, payload: E[]): Promise<(Awaited<IdValue<E>> | Awaited<E[import("../type/entity.js").IdKey<E>]>)[]>;
    protected fillToManyRelations<E>(entity: Type<E>, payload: E[], select: QuerySelect<E>): Promise<void>;
    protected putChildrenInParents<E>(parents: E[], children: E[], parentIdKey: string, referenceKey: string, relKey: string): void;
    protected insertRelations<E>(entity: Type<E>, payload: E[]): Promise<void>;
    protected updateRelations<E>(entity: Type<E>, q: QuerySearch<E>, payload: E): Promise<void>;
    protected deleteRelations<E>(entity: Type<E>, ids: IdValue<E>[], opts?: QueryOptions): Promise<void>;
    protected saveRelation<E>(entity: Type<E>, payload: E, relKey: RelationKey<E>, isUpdate?: boolean): Promise<void>;
    getRepository<E>(entity: Type<E>): Repository<E>;
    abstract readonly hasOpenTransaction: boolean;
    transaction<T>(callback: () => Promise<T>): Promise<T>;
    releaseIfFree(): Promise<void>;
    /**
     * Schedules a task to be executed serially in the querier instance.
     * This is used by the @Serialized decorator to protect database-level operations.
     *
     * @param task - The async task to execute.
     * @returns A promise that resolves with the task's result.
     */
    protected serialize<T>(task: () => Promise<T>): Promise<T>;
    abstract beginTransaction(): Promise<void>;
    abstract commitTransaction(): Promise<void>;
    abstract rollbackTransaction(): Promise<void>;
    protected abstract internalRelease(): Promise<void>;
    release(): Promise<void>;
}