@cytools/vue-query/dist/index.d.ts

Introducing elegant way of making api requests and asynchronous functions with the composition api in Vue

import { ComputedRef, UnwrapRef } from '@vue/composition-api';
import { Ref, ComputedRef as ComputedRef$1 } from 'vue-demi';

declare enum QueryStatus {
    IDLE = "idle",
    ERROR = "error",
    LOADING = "loading",
    SUCCESS = "success"
}

/**
 * Internal dependencies.
 */

interface QueryData<TData, TError = any> {
    data: TData | null;
    error: TError | null;
    status: QueryStatus;
    isFetching: boolean;
}

/**
 * Internal dependencies.
 */

declare let queryDataClone: <T>(value: T) => T;
declare const changeQueryDataCloneMethod: (newCloneFunction: (data: any) => any) => (data: any) => any;
declare class Query<TData, TError = any> {
    protected queryData: {
        value: QueryData<TData, TError>;
    };
    constructor({ data, error, isFetching, status, }?: Partial<QueryData<TData, TError>>);
    update(queryData: Partial<QueryData<TData>>): this;
    updateData(callback: (data: TData | null) => TData | null): this;
    get data(): TData | null;
    get status(): QueryStatus;
    get error(): TError | null;
    get isIdle(): boolean;
    get isError(): boolean;
    get isLoading(): boolean;
    get isSuccess(): true | TData | null;
    get isFetching(): boolean;
}

declare type QueryCallback<TData> = (...data: any) => Promise<TData>;
declare type QueryOptions<TData, TError> = {
    manual: boolean;
    keysNotToWait: string[];
    defaultData: TData | null;
    keepPreviousData: boolean;
    timesToRetryOnError: number;
    keyChangeRefetchWaitTime: number;
    onError: (error: TError) => void;
    timeToWaitBeforeRetryingOnError: number;
    onSuccess: (data: TData | null | undefined) => void;
    onDataReceive: (data: TData | null | undefined) => void;
};
declare function useQuery<TData, TError = any>(key: string | Array<string | Ref | {
    [key: string]: Ref;
}>, callback?: QueryCallback<TData> | null, { manual, onError, keysNotToWait, defaultData, onSuccess, keepPreviousData, timesToRetryOnError, onDataReceive, keyChangeRefetchWaitTime, timeToWaitBeforeRetryingOnError, }?: Partial<QueryOptions<TData, TError>>): {
    refetch: (callbackVariables?: any[]) => Promise<void>;
    fetchFromCacheOrRefetch: (callbackVariables?: any[], canRefetch?: boolean) => Promise<TData | null>;
    updateQueryData: (updateQueryDataCB: (data: TData | null) => TData) => Query<TData, TError>;
    data: ComputedRef<TData | null>;
    status: ComputedRef<QueryStatus>;
    error: ComputedRef<TError | null>;
    isIdle: ComputedRef<boolean>;
    isError: ComputedRef<boolean>;
    isLoading: ComputedRef<boolean>;
    isSuccess: ComputedRef<true | TData | null>;
    isFetching: ComputedRef<boolean>;
};

declare enum MutationStatus {
    IDLE = "idle",
    ERROR = "error",
    LOADING = "loading",
    SUCCESS = "success"
}

declare type MutationCallback<TData, TVariables> = (...variables: TVariables[]) => Promise<TData>;
declare type MutationOptions<TData, TVariables> = {
    onMutate: (...variables: TVariables[]) => Promise<TData | null>;
    onError: (error: any, variables: TVariables[], context?: any) => void;
    onSuccess: (result: TData, variables: TVariables[], context?: any) => void;
};
declare function useMutation<TData = any, TVariables = undefined>(callback: MutationCallback<TData, TVariables>, { onError, onSuccess, onMutate, }?: Partial<MutationOptions<TData, TVariables>>): {
    data: ComputedRef<TData | null>;
    error: ComputedRef<null>;
    isIdle: ComputedRef<boolean>;
    isError: ComputedRef<boolean>;
    isSuccess: ComputedRef<boolean>;
    isLoading: ComputedRef<boolean>;
    mutate: (...variables: TVariables[]) => Promise<{
        data: ComputedRef<TData | null>;
        error: ComputedRef<null>;
        isIdle: ComputedRef<boolean>;
        isError: ComputedRef<boolean>;
        isSuccess: ComputedRef<boolean>;
        isLoading: ComputedRef<boolean>;
    } | undefined>;
    status: ComputedRef<MutationStatus>;
};

/**
 * External dependencies.
 */

declare abstract class Cache<TData> {
    abstract put(key: string, data: TData | null): this;
    abstract get(key: string): ComputedRef$1<TData | null>;
    abstract remove(key: string): this;
    abstract count(): number;
    abstract clear(): this;
    abstract getCacheKeys(): string[];
}

/**
 * Internal dependencies.
 */

interface QueryClientConfig<TData, TError> {
    cache: Cache<Query<TData, TError>>;
}

/**
 * Internal dependencies.
 */

declare type QueryKey = string | any[];
declare class QueryClient<TData, TError = any> {
    protected cache: Cache<Query<TData, TError>>;
    constructor(config: QueryClientConfig<TData, TError>);
    addQuery(key: QueryKey, queryData: Partial<QueryData<TData, TError>>): ComputedRef<Query<TData, TError> | null>;
    removeQuery(key: QueryKey): this;
    getQuery(key: QueryKey): ComputedRef<Query<TData, TError> | null>;
    getQueriesWithStartingKey(key: string | any[]): ComputedRef<({
        key: string;
        query: Query<TData, TError>;
    })[]>;
    updateQueryDataForQueriesWithStartingKey(key: QueryKey, callback: CallableFunction): void;
    reset(): Cache<Query<TData, TError>>;
    protected convertKey(key: string | any[]): string;
}

declare function useQueryClient<TData = any, TError = any>(): {
    queryClient: QueryClient<TData, TError>;
};

declare function usePaginateQuery<TData, TError = any>(key: string | Array<string | Ref | {
    [key: string]: Ref;
}>, callback?: QueryCallback<{
    data: TData;
    hasNextPage: boolean;
}> | null, options?: Partial<QueryOptions<{
    data: TData;
    hasNextPage: boolean;
}, TError>>): {
    fetchPrevPage: () => Promise<void>;
    fetchNextPage: () => Promise<void>;
    hasMorePages: ComputedRef<boolean>;
    data: ComputedRef<{
        data: UnwrapRef<TData>;
        hasNextPage: boolean;
    } | null>;
    currentPage: ComputedRef<number>;
    isNextButtonActive: ComputedRef<boolean>;
    isPrevButtonActive: ComputedRef<boolean>;
    isSuccess: ComputedRef<ComputedRef<true | {
        data: TData;
        hasNextPage: boolean;
    } | null>>;
    canShowPaginationButtons: ComputedRef<boolean>;
    refetch: (callbackVariables?: any[]) => Promise<void>;
    fetchFromCacheOrRefetch: (callbackVariables?: any[], canRefetch?: boolean) => Promise<{
        data: TData;
        hasNextPage: boolean;
    } | null>;
    updateQueryData: (updateQueryDataCB: (data: {
        data: TData;
        hasNextPage: boolean;
    } | null) => {
        data: TData;
        hasNextPage: boolean;
    }) => Query<{
        data: TData;
        hasNextPage: boolean;
    }, TError>;
    status: ComputedRef<QueryStatus>;
    error: ComputedRef<TError | null>;
    isIdle: ComputedRef<boolean>;
    isError: ComputedRef<boolean>;
    isLoading: ComputedRef<boolean>;
    isFetching: ComputedRef<boolean>;
};

export { changeQueryDataCloneMethod, queryDataClone, useMutation, usePaginateQuery, useQuery, useQueryClient };