workers-qb/dist/index.d.ts

Zero dependencies Query Builder for Cloudflare Workers

declare enum OrderTypes {
    ASC = "ASC",
    DESC = "DESC"
}
declare enum FetchTypes {
    ONE = "ONE",
    ALL = "ALL"
}
declare enum ConflictTypes {
    ROLLBACK = "ROLLBACK",
    ABORT = "ABORT",
    FAIL = "FAIL",
    IGNORE = "IGNORE",
    REPLACE = "REPLACE"
}
declare enum JoinTypes {
    INNER = "INNER",
    LEFT = "LEFT",
    CROSS = "CROSS"
}

declare class Raw {
    isRaw: boolean;
    content: any;
    constructor(content: any);
}
declare class Query<Result = any, IsAsync extends boolean = true> {
    executeMethod: (query: Query<Result, IsAsync>) => MaybeAsync<IsAsync, Result>;
    query: string;
    arguments?: Primitive[];
    fetchType?: FetchTypes;
    constructor(executeMethod: (query: Query<Result, IsAsync>) => MaybeAsync<IsAsync, Result>, query: string, args?: Primitive[], fetchType?: FetchTypes);
    execute(): MaybeAsync<IsAsync, Result>;
    toObject(): RawQuery;
}
declare class QueryWithExtra<GenericResultWrapper, Result = any, IsAsync extends boolean = true> extends Query<Result, IsAsync> {
    private countQuery;
    constructor(executeMethod: (query: Query<Result, IsAsync>) => MaybeAsync<IsAsync, Result>, query: string, countQuery: string, args?: Primitive[], fetchType?: FetchTypes);
    count(): MaybeAsync<IsAsync, CountResult<GenericResultWrapper>>;
}
declare function trimQuery(query: string): string;

interface SelectExecuteOptions {
    lazy?: boolean;
}
declare class SelectBuilder<GenericResultWrapper, GenericResult = DefaultReturnObject, IsAsync extends boolean = true> {
    _debugger: boolean;
    _options: Partial<SelectAll>;
    _fetchAll: (params: SelectAll) => QueryWithExtra<GenericResultWrapper, any, IsAsync>;
    _fetchOne: (params: SelectOne) => QueryWithExtra<GenericResultWrapper, any, IsAsync>;
    constructor(options: Partial<SelectAll>, fetchAll: (params: SelectAll) => QueryWithExtra<GenericResultWrapper, any, IsAsync>, fetchOne: (params: SelectOne) => QueryWithExtra<GenericResultWrapper, any, IsAsync>);
    setDebugger(state: boolean): void;
    tableName(tableName: SelectAll['tableName']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
    fields(fields: SelectAll['fields']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
    where(conditions: string | Array<string>, params?: Primitive | Primitive[]): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
    whereIn<T extends string | Array<string>, P extends T extends Array<string> ? Primitive[][] : Primitive[]>(fields: T, values: P): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
    join(join: SelectAll['join']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
    groupBy(groupBy: SelectAll['groupBy']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
    having(conditions: string | Array<string>, params?: Primitive | Primitive[]): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
    orderBy(orderBy: SelectAll['orderBy']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
    offset(offset: SelectAll['offset']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
    limit(limit: SelectAll['limit']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
    _parseArray(fieldName: string, option: any, value: any): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
    getQueryAll<P extends SelectExecuteOptions = SelectExecuteOptions>(options?: P): Query<ArrayResult<GenericResultWrapper, GenericResult, IsAsync, P extends {
        lazy: true;
    } ? true : false>, IsAsync>;
    getQueryOne(): Query<OneResult<GenericResultWrapper, GenericResult>, IsAsync>;
    execute<P extends SelectExecuteOptions = SelectExecuteOptions>(options?: P): ArrayResult<GenericResultWrapper, GenericResult, IsAsync, P extends {
        lazy: true;
    } ? true : false>;
    all<P extends SelectExecuteOptions = SelectExecuteOptions>(options?: P): ArrayResult<GenericResultWrapper, GenericResult, IsAsync, P extends {
        lazy: true;
    } ? true : false>;
    one(): MaybeAsync<IsAsync, OneResult<GenericResultWrapper, GenericResult>>;
    count(): MaybeAsync<IsAsync, CountResult<GenericResultWrapper>>;
    getOptions(): SelectAll;
}

type OmitIndexSignature<ObjectType> = {
    [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType];
};
type PickIndexSignature<ObjectType> = {
    [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType];
};
type Simplify<T> = {
    [KeyType in keyof T]: T[KeyType];
} & {};
type SimpleMerge<Destination, Source> = {
    [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key];
} & Source;
type Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;

type Primitive = null | string | number | boolean | bigint | Raw | SelectAll | SelectBuilder<any, any, any>;
type QueryLoggerMeta = {
    duration?: number;
};
type QueryBuilderOptions<IsAsync extends boolean = true> = {
    logger?: (query: RawQuery, meta: QueryLoggerMeta) => MaybeAsync<IsAsync, void>;
};
type DefaultObject = Record<string, Primitive>;
type DefaultReturnObject = Record<string, null | string | number | boolean | bigint>;
type Where = {
    conditions: string | Array<string>;
    params?: Primitive | Primitive[];
} | string | Array<string>;
type Join = {
    type?: string | JoinTypes;
    table: string | SelectAll | SelectBuilder<any, any, any>;
    on: string;
    alias?: string;
};
type SelectOne = {
    tableName: string;
    fields?: string | Array<string>;
    where?: Where;
    join?: Join | Array<Join>;
    groupBy?: string | Array<string>;
    having?: Where;
    orderBy?: string | Array<string> | Record<string, string | OrderTypes>;
    offset?: number;
    subQueryPlaceholders?: Record<string, SelectAll>;
    subQueryTokenNextId?: number;
};
type RawQuery = {
    query: string;
    args?: Primitive[];
    fetchType?: FetchTypes;
};
type RawQueryFetchOne = Omit<RawQuery, 'fetchType'> & {
    fetchType: FetchTypes.ONE;
};
type RawQueryFetchAll = Omit<RawQuery, 'fetchType'> & {
    fetchType: FetchTypes.ALL;
};
type RawQueryWithoutFetching = Omit<RawQuery, 'fetchType'>;
type SelectAll = SelectOne & {
    limit?: number;
    lazy?: boolean;
};
type ConflictUpsert = {
    column: string | Array<string>;
    data: DefaultObject;
    where?: Where;
};
type Insert = {
    tableName: string;
    data: DefaultObject | Array<DefaultObject>;
    returning?: string | Array<string>;
    onConflict?: string | ConflictTypes | ConflictUpsert;
};
type InsertOne = Omit<Insert, 'data' | 'returning'> & {
    data: DefaultObject;
    returning: string | Array<string>;
};
type InsertMultiple = Omit<Insert, 'data' | 'returning'> & {
    data: Array<DefaultObject>;
    returning: string | Array<string>;
};
type InsertWithoutReturning = Omit<Insert, 'returning'>;
type test<I extends Insert = Insert> = I;
type Update = {
    tableName: string;
    data: DefaultObject;
    where?: Where;
    returning?: string | Array<string>;
    onConflict?: string | ConflictTypes;
};
type UpdateReturning = Omit<Update, 'returning'> & {
    returning: string | Array<string>;
};
type UpdateWithoutReturning = Omit<Update, 'returning'>;
type Delete = {
    tableName: string;
    where: Where;
    returning?: string | Array<string>;
    orderBy?: string | Array<string> | Record<string, string | OrderTypes>;
    limit?: number;
    offset?: number;
};
type DeleteReturning = Omit<Delete, 'returning'> & {
    returning: string | Array<string>;
};
type DeleteWithoutReturning = Omit<Delete, 'returning'>;
type D1Meta = {
    changed_db: boolean;
    changes: number;
    duration: number;
    last_row_id: string | number;
    rows_read: number;
    rows_written: number;
    served_by: string;
    size_after: number;
};
type D1Result = {
    changes?: number;
    duration: number;
    last_row_id?: string | number;
    served_by: string;
    rowsRead?: number;
    rowsWritten?: number;
    meta?: D1Meta;
    success: boolean;
};
type DOResult = {
    rowsRead: number;
    rowsWritten: number;
};
type PGResult = {
    command: string;
    lastRowId?: string | number;
    rowCount: number;
};
type IterableResult<ResultWrapper, Result, IsAsync extends boolean> = IsAsync extends true ? Promise<Merge<ResultWrapper, {
    results?: AsyncIterable<Result>;
}>> : Merge<ResultWrapper, {
    results?: Iterable<Result>;
}>;
type FullArrayResult<ResultWrapper, Result, IsAsync extends boolean> = IsAsync extends true ? Promise<Merge<ResultWrapper, {
    results?: Array<Result>;
}>> : Merge<ResultWrapper, {
    results?: Array<Result>;
}>;
type ArrayResult<ResultWrapper, Result, IsAsync extends boolean, IsLazy extends boolean = false> = IsLazy extends true ? IterableResult<ResultWrapper, Result, IsAsync> : FullArrayResult<ResultWrapper, Result, IsAsync>;
type OneResult<ResultWrapper, Result> = Merge<ResultWrapper, {
    results?: Result;
}>;
type CountResult<GenericResultWrapper> = OneResult<GenericResultWrapper, {
    total: number;
}>;
type AsyncType<T> = Promise<T>;
type SyncType<T> = T;
type MaybeAsync<IsAsync extends boolean, T> = IsAsync extends true ? AsyncType<T> : SyncType<T>;

declare function defaultLogger(query: RawQuery, meta: QueryLoggerMeta): any;
declare function asyncLoggerWrapper<Async extends boolean = true>(query: Query<any, Async> | Query<any, Async>[], loggerFunction: CallableFunction | undefined, innerFunction: () => any): Promise<any>;
declare function syncLoggerWrapper<Async extends boolean = false>(query: Query<any, Async> | Query<any, Async>[], loggerFunction: CallableFunction | undefined, innerFunction: () => any): any;

declare class QueryBuilder<GenericResultWrapper, IsAsync extends boolean = true> {
    protected options: QueryBuilderOptions<IsAsync>;
    loggerWrapper: typeof asyncLoggerWrapper;
    constructor(options?: QueryBuilderOptions<IsAsync>);
    setDebugger(state: boolean): void;
    execute(query: Query<any, IsAsync>): MaybeAsync<IsAsync, any>;
    batchExecute(queryArray: Query<any, IsAsync>[]): MaybeAsync<IsAsync, any[]>;
    lazyExecute(query: Query<any, IsAsync>): IsAsync extends true ? Promise<AsyncIterable<any>> : Iterable<any>;
    createTable<GenericResult = undefined>(params: {
        tableName: string;
        schema: string;
        ifNotExists?: boolean;
    }): Query<ArrayResult<GenericResultWrapper, GenericResult, IsAsync>, IsAsync>;
    dropTable<GenericResult = undefined>(params: {
        tableName: string;
        ifExists?: boolean;
    }): Query<ArrayResult<GenericResultWrapper, GenericResult, IsAsync>, IsAsync>;
    select<GenericResult = DefaultReturnObject>(tableName: string): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
    fetchOne<GenericResult = DefaultReturnObject>(params: SelectOne): QueryWithExtra<GenericResultWrapper, OneResult<GenericResultWrapper, GenericResult>, IsAsync>;
    fetchAll<GenericResult = DefaultReturnObject, P extends SelectAll = SelectAll>(params: P): QueryWithExtra<GenericResultWrapper, ArrayResult<GenericResultWrapper, GenericResult, IsAsync, P extends {
        lazy: true;
    } ? true : false>, IsAsync>;
    raw<GenericResult = DefaultReturnObject>(params: RawQueryFetchOne): Query<OneResult<GenericResultWrapper, GenericResult>, IsAsync>;
    raw<GenericResult = DefaultReturnObject>(params: RawQueryFetchAll): Query<ArrayResult<GenericResultWrapper, GenericResult, IsAsync>, IsAsync>;
    raw<GenericResult = DefaultReturnObject>(params: RawQueryWithoutFetching): Query<GenericResultWrapper, IsAsync>;
    insert<GenericResult = DefaultReturnObject>(params: InsertOne): Query<OneResult<GenericResultWrapper, GenericResult>, IsAsync>;
    insert<GenericResult = DefaultReturnObject>(params: InsertMultiple): Query<ArrayResult<GenericResultWrapper, GenericResult, IsAsync>, IsAsync>;
    insert<GenericResult = DefaultReturnObject>(params: InsertWithoutReturning): Query<GenericResultWrapper, IsAsync>;
    update<GenericResult = DefaultReturnObject>(params: UpdateReturning): Query<ArrayResult<GenericResultWrapper, GenericResult, IsAsync>, IsAsync>;
    update<GenericResult = DefaultReturnObject>(params: UpdateWithoutReturning): Query<GenericResultWrapper, IsAsync>;
    delete<GenericResult = DefaultReturnObject>(params: DeleteReturning): Query<ArrayResult<GenericResultWrapper, GenericResult, IsAsync>, IsAsync>;
    delete<GenericResult = DefaultReturnObject>(params: DeleteWithoutReturning): Query<GenericResultWrapper, IsAsync>;
    protected _parse_arguments(row: DefaultObject): Array<any>;
    protected _onConflict(resolution?: string | ConflictTypes | ConflictUpsert): string;
    protected _insert(params: Insert): string;
    protected _update(params: Update): string;
    protected _delete(params: Delete): string;
    protected _select(params: SelectAll, queryArgs?: any[]): string;
    protected _fields(value?: string | Array<string>): string;
    protected _where(value: Where | undefined, context?: {
        subQueryPlaceholders?: Record<string, SelectAll>;
        queryArgs: any[];
        toSQLCompiler?: (params: SelectAll, queryArgs: any[]) => string;
    }): string;
    protected _join(value: Join | Array<Join> | undefined, context: {
        subQueryPlaceholders?: Record<string, SelectAll>;
        queryArgs: any[];
        toSQLCompiler: (params: SelectAll, queryArgs: any[]) => string;
    }): string;
    protected _groupBy(value?: string | Array<string>): string;
    protected _having(value: Where | undefined, // Using Where type as Having structure is similar for conditions/params
    context: {
        subQueryPlaceholders?: Record<string, SelectAll>;
        queryArgs: any[];
        toSQLCompiler?: (params: SelectAll, queryArgs: any[]) => string;
    }): string;
    protected _orderBy(value?: string | Array<string> | Record<string, string | OrderTypes>): string;
    protected _limit(value?: number): string;
    protected _offset(value?: number): string;
    protected _returning(value?: string | Array<string>): string;
}

type MigrationEntry = {
    id: number;
    name: string;
    applied_at: Date;
};
type Migration = {
    name: string;
    sql: string;
};
type MigrationOptions = {
    migrations: Array<Migration>;
    tableName?: string;
};
declare class syncMigrationsBuilder<GenericResultWrapper> {
    _builder: QueryBuilder<GenericResultWrapper, false>;
    _migrations: Array<Migration>;
    _tableName: string;
    constructor(options: MigrationOptions, builder: QueryBuilder<GenericResultWrapper, false>);
    initialize(): void;
    getApplied(): Array<MigrationEntry>;
    getUnapplied(): Array<Migration>;
    apply(): Array<Migration>;
}
declare class asyncMigrationsBuilder<GenericResultWrapper> {
    _builder: QueryBuilder<GenericResultWrapper, true>;
    _migrations: Array<Migration>;
    _tableName: string;
    constructor(options: MigrationOptions, builder: QueryBuilder<GenericResultWrapper, true>);
    initialize(): Promise<void>;
    getApplied(): Promise<Array<MigrationEntry>>;
    getUnapplied(): Promise<Array<Migration>>;
    apply(): Promise<Array<Migration>>;
}

interface D1Database {
    prepare: any;
    batch: any;
    exec: any;
}
declare class D1QB extends QueryBuilder<D1Result> {
    db: any;
    constructor(db: D1Database, options?: QueryBuilderOptions);
    migrations(options: MigrationOptions): asyncMigrationsBuilder<D1Result>;
    execute(query: Query): Promise<any>;
    batchExecute(queryArray: Query[]): Promise<any>;
}

interface SqlStorage {
    exec: any;
    get databaseSize(): number;
    Cursor: any;
    Statement: any;
}
declare class DOQB extends QueryBuilder<DOResult, false> {
    db: SqlStorage;
    loggerWrapper: typeof syncLoggerWrapper;
    constructor(db: SqlStorage, options?: QueryBuilderOptions<false>);
    migrations(options: MigrationOptions): syncMigrationsBuilder<DOResult>;
    execute(query: Query<any, false>): any;
    lazyExecute(query: Query<any, false>): Iterable<any>;
}

declare class PGQB extends QueryBuilder<PGResult> {
    db: any;
    _migrationsBuilder: typeof asyncMigrationsBuilder;
    constructor(db: any, options?: QueryBuilderOptions);
    migrations(options: MigrationOptions): asyncMigrationsBuilder<PGResult>;
    connect(): Promise<void>;
    close(): Promise<void>;
    execute(query: Query): Promise<any>;
}

export { type ArrayResult, type AsyncType, ConflictTypes, type ConflictUpsert, type CountResult, type D1Meta, D1QB, type D1Result, DOQB, type DOResult, type DefaultObject, type DefaultReturnObject, type Delete, type DeleteReturning, type DeleteWithoutReturning, FetchTypes, type FullArrayResult, type Insert, type InsertMultiple, type InsertOne, type InsertWithoutReturning, type IterableResult, type Join, JoinTypes, type MaybeAsync, type Migration, type MigrationEntry, type MigrationOptions, type OneResult, OrderTypes, PGQB, type PGResult, type Primitive, Query, QueryBuilder, type QueryBuilderOptions, type QueryLoggerMeta, QueryWithExtra, Raw, type RawQuery, type RawQueryFetchAll, type RawQueryFetchOne, type RawQueryWithoutFetching, type SelectAll, type SelectOne, type SyncType, type Update, type UpdateReturning, type UpdateWithoutReturning, type Where, asyncLoggerWrapper, asyncMigrationsBuilder, defaultLogger, syncLoggerWrapper, syncMigrationsBuilder, type test, trimQuery };