@fine-dev/fine-js/dist/main/d1.d.ts

Javascript client for Fine BaaS

import { Fetch } from "./types";
/** Utility types for extracting stuff from the schema */
type Trim<S extends string> = S extends ` ${infer R}` | `${infer R} ` ? Trim<R> : S;
type Split<S extends string, D extends string = ","> = S extends `${infer T}${D}${infer U}` ? [Trim<T>, ...Split<U, D>] : [Trim<S>];
type FilterKeys<T, L extends string[]> = L[number] extends keyof T ? L : never;
type ExtractInvalidKeys<T, S extends string> = Exclude<Split<S>[number], keyof T>;
type ExtractKeys<T, S extends string> = FilterKeys<T, Split<S>>[number];
type ExtractValues<T, S extends string> = ExtractKeys<T, S> extends never ? ParserError<`Invalid columns provided: ${ExtractInvalidKeys<T, S>}`> : {
    [K in Extract<ExtractKeys<T, S>, keyof T>]: T[K];
};
type ParserError<Message extends string> = {
    error: true;
} & Message;
type Table = Record<string, any>;
export type GenericSchema = Record<string, Table>;
type NotProvided = "NOT_PROVIDED";
type RTFromQuery<Query extends string, T extends Table> = Query extends NotProvided ? void : Query extends "*" ? T : ExtractValues<T, Query>;
type ListOrSingle<T> = T | T[];
type QueryFilterBuilder<T extends Table, RT> = (builder: D1FilterBuilder<T, T>) => D1FilterBuilder<T, RT>;
type MutationBuilderFn<T extends Table, RT = ParserError<"You must chain `select` to your query to receive results">> = (builder: D1FilterBuilder<T>) => D1FilterBuilder<T, RT>;
export default class D1RestClient<Schema extends GenericSchema = GenericSchema> {
    private baseUrl;
    private headers;
    fetch: Fetch;
    constructor({ baseUrl, headers, fetch: customFetch }: {
        baseUrl: string;
        headers?: HeadersInit;
        fetch?: Fetch;
    });
    table<TableName extends keyof Schema>(tableName: TableName): D1QueryBuilder<Schema[TableName]>;
    useQuery<TableName extends keyof Schema, RT = Schema[TableName]>(tableName: TableName, builderFn?: QueryFilterBuilder<Schema[TableName], RT>): {
        refetch: () => Promise<void>;
        data: Required<RT>[] | null;
        error: Error | null;
        isLoading: boolean;
    };
    useInsert<TableName extends keyof Schema>(tableName: TableName): {
        insert: <Query extends string = "NOT_PROVIDED", RT = RTFromQuery<Query, Schema[TableName]>>(values: ListOrSingle<Schema[TableName]>, returns?: Query) => Promise<Error | (Query extends "NOT_PROVIDED" ? Promise<ParserError<"You must chain `select` to your query to receive results">> : RT[])>;
        error: Error | null;
        isLoading: boolean;
    };
    useUpdate<TableName extends keyof Schema>(tableName: TableName): {
        update: <RT>(values: Partial<Schema[TableName]>, builderFn?: MutationBuilderFn<Schema[TableName], RT>) => Promise<Error | Required<RT>[] | undefined>;
        error: Error | null;
        isLoading: boolean;
    };
    useDelete<TableName extends keyof Schema>(tableName: TableName): {
        deleteRecord: <RT>(builderFn: MutationBuilderFn<Schema[TableName], RT>) => Promise<Error | Required<RT>[] | undefined>;
        error: Error | null;
        isLoading: boolean;
    };
    private useMutationState;
}
declare class D1QueryBuilder<T extends Table> {
    url: URL;
    headers: HeadersInit;
    fetch: Fetch;
    constructor(url: URL, { headers, fetch }: {
        headers?: HeadersInit;
        fetch: Fetch;
    });
    select<Query extends string = "*", ResultType = Query extends "*" ? T : ExtractValues<T, Query>>(query?: Query): Omit<D1FilterBuilder<T, ResultType>, "select">;
    insert(values: T | T[]): D1FilterBuilder<T, ParserError<"You must chain `select` to your query to receive results">>;
    update(values: Partial<T>): D1FilterBuilder<T, ParserError<"You must chain `select` to your query to receive results">>;
    delete(): D1FilterBuilder<T, ParserError<"You must chain `select` to your query to receive results">>;
}
declare class D1FilterBuilder<T extends Table, ResultType = ParserError<"You must chain `select` to your query to receive results">> {
    url: URL;
    headers: HeadersInit;
    fetch: Fetch;
    method: "GET" | "POST" | "PATCH" | "DELETE";
    body?: any;
    constructor({ url, headers, fetch, method, body }: {
        url: URL;
        headers: HeadersInit;
        fetch: Fetch;
        method: "GET" | "POST" | "PATCH" | "DELETE";
        body?: any;
    });
    eq<Col extends keyof T>(column: Col, value: T[Col]): this;
    neq<Col extends keyof T>(column: Col, value: T[Col]): this;
    gt<Col extends keyof T>(column: Col, value: T[Col]): this;
    lt<Col extends keyof T>(column: Col, value: T[Col]): this;
    like<Col extends keyof T>(column: Col, pattern: string): this;
    in<Col extends keyof T>(column: Col, values: T[Col][]): this;
    order(column: keyof T, { ascending }?: {
        ascending?: boolean | undefined;
    }): this;
    limit(count: number): this;
    offset(count: number): this;
    select<Query extends string = "*", RT = Query extends "*" ? T : ExtractValues<T, Query>>(query?: Query): D1FilterBuilder<T, RT>;
    then(resolve: (value: Required<ResultType>[]) => void, reject?: (reason?: any) => void): Promise<void>;
}
export {};
//# sourceMappingURL=d1.d.ts.map