@mussnad/frappe-react-query/dist/hooks/useDocument.d.ts

A React Query SDK for Frappe

import { GetDocListArgs } from '../types';
import { UseQueryOptions } from '@tanstack/react-query';
import { FrappeDoc, FrappeError } from '@mussnad/frappe-js-client/dist/frappe/types';
/**
 * Hook to fetch a document from the database
 *
 * @param doctype - The doctype to fetch
 * @param name - the name of the document to fetch
 * @param queryKey - The queryKey to use for caching the result - optional
 * @param options [Optional] UseQueryOptions options for fetching data
 *
 * @returns an object with the following properties: data, error, isFetching, and mutate
 *
 * @typeParam T - The type of the document
 *
 * @example
 *
 * const { data, error, isFetching, mutate } = useFrappeGetDoc('DocType', 'name')
 */
export declare const useFrappeGetDoc: <T extends FrappeDoc<object>>(doctype: string, name?: string, queryKey?: readonly any[], options?: UseQueryOptions<T, FrappeError>) => {
    data: T | undefined;
    error: FrappeError | null;
    isFetching: boolean;
    mutate: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T, FrappeError>>;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    isPlaceholderData: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FrappeError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T, FrappeError>>;
    fetchStatus: import('@tanstack/react-query').FetchStatus;
    promise: Promise<T>;
} | {
    data: T | undefined;
    error: FrappeError | null;
    isFetching: boolean;
    mutate: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T, FrappeError>>;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    isPlaceholderData: false;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FrappeError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T, FrappeError>>;
    fetchStatus: import('@tanstack/react-query').FetchStatus;
    promise: Promise<T>;
} | {
    data: T | undefined;
    error: FrappeError | null;
    isFetching: boolean;
    mutate: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T, FrappeError>>;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FrappeError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T, FrappeError>>;
    fetchStatus: import('@tanstack/react-query').FetchStatus;
    promise: Promise<T>;
} | {
    data: T | undefined;
    error: FrappeError | null;
    isFetching: boolean;
    mutate: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T, FrappeError>>;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FrappeError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T, FrappeError>>;
    fetchStatus: import('@tanstack/react-query').FetchStatus;
    promise: Promise<T>;
} | {
    data: T | undefined;
    error: FrappeError | null;
    isFetching: boolean;
    mutate: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T, FrappeError>>;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FrappeError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T, FrappeError>>;
    fetchStatus: import('@tanstack/react-query').FetchStatus;
    promise: Promise<T>;
} | {
    data: T | undefined;
    error: FrappeError | null;
    isFetching: boolean;
    mutate: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T, FrappeError>>;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    isPlaceholderData: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FrappeError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T, FrappeError>>;
    fetchStatus: import('@tanstack/react-query').FetchStatus;
    promise: Promise<T>;
};
/**
 * Hook to prefetch a document from the database
 * @param doctype - The doctype to fetch
 * @param name - The name of the document to fetch
 * @param queryKey - The queryKey to use for caching the result - optional
 *
 * @returns A function to prefetch the document
 *
 * @example
 *
 * const prefetch = useFrappePrefetchDoc('DocType', 'name')
 */
export declare const useFrappePrefetchDoc: <T extends FrappeDoc<object>>(doctype: string, name?: string, queryKey?: readonly any[]) => () => Promise<void>;
/**
 * Hook to fetch a list of documents from the database
 *
 * @param doctype Name of the doctype to fetch
 * @param args Arguments to pass (filters, pagination, etc)
 * @param queryKey Optional query key for caching
 * @param options [Optional] UseQueryOptions for React Query
 *
 * @returns an object with data, error, isFetching, and mutate properties
 *
 * @typeParam T - The type definition of the document object
 * @typeParam K - The type of the document for args
 *
 * @example
 *
 * const { data, error, isFetching, mutate } = useFrappeGetDocList('DocType', { filters: [{ field: 'name', operator: 'like', value: 'test' }] })
 */
export declare const useFrappeGetDocList: <T extends FrappeDoc<object>>(doctype: string, args?: GetDocListArgs<T>, queryKey?: readonly any[], options?: UseQueryOptions<T[], FrappeError>) => {
    data: T[] | undefined;
    error: FrappeError | null;
    isFetching: boolean;
    mutate: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T[], FrappeError>>;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    isPlaceholderData: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FrappeError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T[], FrappeError>>;
    fetchStatus: import('@tanstack/react-query').FetchStatus;
    promise: Promise<T[]>;
} | {
    data: T[] | undefined;
    error: FrappeError | null;
    isFetching: boolean;
    mutate: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T[], FrappeError>>;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    isPlaceholderData: false;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FrappeError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T[], FrappeError>>;
    fetchStatus: import('@tanstack/react-query').FetchStatus;
    promise: Promise<T[]>;
} | {
    data: T[] | undefined;
    error: FrappeError | null;
    isFetching: boolean;
    mutate: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T[], FrappeError>>;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FrappeError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T[], FrappeError>>;
    fetchStatus: import('@tanstack/react-query').FetchStatus;
    promise: Promise<T[]>;
} | {
    data: T[] | undefined;
    error: FrappeError | null;
    isFetching: boolean;
    mutate: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T[], FrappeError>>;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FrappeError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T[], FrappeError>>;
    fetchStatus: import('@tanstack/react-query').FetchStatus;
    promise: Promise<T[]>;
} | {
    data: T[] | undefined;
    error: FrappeError | null;
    isFetching: boolean;
    mutate: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T[], FrappeError>>;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FrappeError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T[], FrappeError>>;
    fetchStatus: import('@tanstack/react-query').FetchStatus;
    promise: Promise<T[]>;
} | {
    data: T[] | undefined;
    error: FrappeError | null;
    isFetching: boolean;
    mutate: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T[], FrappeError>>;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    isPlaceholderData: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: FrappeError | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<T[], FrappeError>>;
    fetchStatus: import('@tanstack/react-query').FetchStatus;
    promise: Promise<T[]>;
};
/**
 * Hook to prefetch a list of documents from the database
 * @param doctype - The doctype to fetch
 * @param args - The arguments to pass to the getDocList method
 * @param queryKey - The queryKey to use for caching the result - optional
 *
 * @returns A function to prefetch the list of documents
 *
 * @example
 *
 * const prefetch = useFrappePrefetchDocList('DocType', { filters: [{ field: 'name', operator: 'like', value: 'test' }] })
 */
export declare const useFrappePrefetchDocList: <T extends FrappeDoc<object>>(doctype: string, args?: GetDocListArgs<T>, queryKey?: readonly any[]) => () => Promise<void>;
/**
 * Hook to create a document in the database and maintain loading and error states
 * @returns Object with the following properties: loading, error, isCompleted and createDoc and reset functions
 *
 * @example
 *
 * const { createDoc, loading, error, isCompleted, reset } = useFrappeCreateDoc()
 */
export declare const useFrappeCreateDoc: <T extends FrappeDoc<object>>() => {
    /** Function to create a document in the database */
    createDoc: (doctype: string, doc: T) => Promise<T>;
    /** Will be true when the API request is pending.  */
    loading: boolean;
    /** Error object returned from API call */
    error: FrappeError | null | undefined;
    /** Will be true if document is created. Else false */
    isCompleted: boolean;
    /** Function to reset the state of the hook */
    reset: () => void;
};
/**
 * Hook to update a document in the database and maintain loading and error states
 * @returns Object with the following properties: loading, error, isCompleted and updateDoc and reset functions
 *
 * @example
 *
 * const { updateDoc, loading, error, isCompleted, reset } = useFrappeUpdateDoc()
 */
export declare const useFrappeUpdateDoc: <T extends FrappeDoc<object>>() => {
    /** Function to update a document in the database */
    updateDoc: (doctype: string, docname: string | null, doc: Partial<T>) => Promise<T>;
    /** Will be true when the API request is pending.  */
    loading: boolean;
    /** Error object returned from API call */
    error: FrappeError | null | undefined;
    /** Will be true if document is updated. Else false */
    isCompleted: boolean;
    /** Function to reset the state of the hook */
    reset: () => void;
};
/**
 * Hook to delete a document in the database and maintain loading and error states
 * @returns Object with the following properties: loading, error, isCompleted and deleteDoc and reset functions
 *
 * @example
 *
 * const { deleteDoc, loading, error, isCompleted, reset } = useFrappeDeleteDoc()
 */
export declare const useFrappeDeleteDoc: () => {
    /** Function to delete a document in the database. Returns a promise which resolves to an object with message "ok" if successful */
    deleteDoc: (doctype: string, docname?: string | null) => Promise<string>;
    /** Will be true when the API request is pending.  */
    loading: boolean;
    /** Error object returned from API call */
    error: FrappeError | null | undefined;
    /** Will be true if document is deleted. Else false */
    isCompleted: boolean;
    /** Function to reset the state of the hook */
    reset: () => void;
};