firebird-query/lib/esm/types/index.d.ts

node-firebird plugin for easy and safe query building.

import Firebird from "node-firebird";
export type TxIsolation = "READ_COMMITTED" | "READ_COMMITTED_READ_ONLY" | "READ_UNCOMMITTED" | "REPEATABLE_READ" | "SERIALIZABLE";
type Prettify<T> = {
    [K in keyof T]: T[K];
} & {};
export type TxReturnType = {
    queryRaw: <T>(strings: TemplateStringsArray, ...params: QueryParam[]) => {
        getQuery: () => string;
        execute: () => Promise<T[]>;
        paginated: (take: number, page?: number) => Promise<any>;
    };
    insertOne: <T extends {
        [key: string]: any;
    }>(params: InsertOneParams<T>) => {
        getQuery: () => string;
        execute: () => Promise<T>;
    };
    insertMany: <T extends {
        [key: string]: any;
    }>(params: InsertParams<T>) => {
        getQuery: () => string;
        execute: () => Promise<string>;
    };
    updateOne: <T>(params: UpdateOneParams<T>) => {
        getQuery: () => string;
        execute: () => Promise<T>;
    };
    updateOrInsert: <T>(params: UpdateOrInsertParams<T>) => {
        getQuery: () => string;
        execute: () => Promise<T>;
    };
    deleteOne: <T>(params: DeleteOneParams<T>) => {
        getQuery: () => string;
        execute: () => Promise<T>;
    };
    commit: () => Promise<void>;
    rollback: () => Promise<void>;
    commitRetaining: () => Promise<void>;
    rollbackRetaining: () => Promise<void>;
};
export type PrimitiveValue = null | undefined | boolean | string | number | Date;
type NumberOperators = {
    ne?: number;
    gt?: number;
    gte?: number;
    lt?: number;
    lte?: number;
    between?: {
        from: number;
        to: number;
    };
    IN?: number[];
    notIN?: number[];
};
type DateOperators = {
    ne?: Date;
    gt?: Date;
    gte?: Date;
    lt?: Date;
    lte?: Date;
    between?: {
        from: Date;
        to: Date;
    };
    IN?: Date[];
    notIN?: Date[];
};
type StringOperators = {
    ne?: string;
    IN?: string[];
    notIN?: string[];
    startsWith?: string;
    endsWith?: string;
    contains?: string;
};
type WhereConditions = Prettify<NumberOperators | DateOperators | StringOperators>;
type keyOmit<T, U extends keyof any> = Prettify<T & {
    [P in U]?: never;
}>;
export type WhereObject = keyOmit<{
    [key: string]: PrimitiveValue | WhereConditions | ManuallyEscapedStatement;
}, "OR"> | keyOmit<{
    [key: string]: PrimitiveValue | WhereConditions | ManuallyEscapedStatement;
}, "AND"> | {
    OR?: WhereObject[];
} | {
    AND?: WhereObject[];
};
export type ManuallyEscapedStatement = (escapeFn: typeof Firebird.escape) => string;
export type QueryParam = PrimitiveValue | WhereObject | ManuallyEscapedStatement;
export type InsertOneParams<T extends {
    [key: string]: any;
}> = {
    tableName: string;
    rowValues: Record<string, PrimitiveValue>;
    returning?: (keyof T | string)[];
};
export type InsertParams<T> = {
    tableName: string;
    rowValues: Array<{
        [k in keyof T]: PrimitiveValue;
    }>;
    columnNames: Array<keyof T>;
};
export type UpdateOneParams<T> = {
    tableName: string;
    rowValues: {
        [k in string]: any;
    };
    where: WhereObject;
    returning?: ReadonlyArray<keyof T | string>;
};
export type UpdateOrInsertParams<T> = {
    tableName: string;
    rowValues: {
        [k in string]: any;
    };
    returning?: ReadonlyArray<keyof T | string>;
};
export type DeleteOneParams<T> = {
    tableName: string;
    where: WhereObject;
    returning?: ReadonlyArray<keyof T | string>;
};
export declare class FirebirdQuery {
    private readonly options;
    private conn;
    private queryLogger?;
    private defaultIsolationLevel;
    constructor(poolOptions?: Firebird.Options & {
        maxConnections?: number;
    }, fqOptions?: {
        queryLogger?: ((query: string) => void);
        defaultIsolationLevel?: TxIsolation;
    });
    private get db();
    private manageQuery;
    get queryRaw(): <T>(strings: TemplateStringsArray, ...params: QueryParam[]) => {
        getQuery: () => string;
        execute: () => Promise<T[]>;
        paginated: (take: number, page?: number) => Promise<T[]>;
    };
    get insertOne(): <T extends {
        [key: string]: any;
    }>(params: InsertOneParams<T>) => {
        getQuery: () => string;
        execute: () => Promise<T>;
    };
    get insertMany(): <T extends {
        [key: string]: any;
    }>(params: InsertParams<T>) => {
        getQuery: () => string;
        execute: () => Promise<string>;
    };
    get updateOne(): <T>(params: UpdateOneParams<T>) => {
        getQuery: () => string;
        execute: () => Promise<T>;
    };
    get updateOrInsert(): <T>(params: UpdateOrInsertParams<T>) => {
        getQuery: () => string;
        execute: () => Promise<T>;
    };
    get deleteOne(): <T>(params: DeleteOneParams<T>) => {
        getQuery: () => string;
        execute: () => Promise<T>;
    };
    destroy(): Promise<void>;
    initTransaction<T>(cb: (tx: TxReturnType) => T, isolation?: TxIsolation): Promise<T>;
    private handleRawQuery;
    private handleInsertOne;
    private handleInsertMany;
    private handleUpdateOne;
    private handleUpdateOrInsert;
    private handleDeleteOne;
    private txHandler;
}
export {};
//# sourceMappingURL=index.d.ts.map