jg-tanstack-query

import { canQueryLoadMore } from 'jg-tanstack-query';

canQueryLoadMore({ isError: false, hasNextPage: true }); // true

import { clearQueryCache, createIndexedDbPersister, createQueryClient } from 'jg-tanstack-query';

const queryClient = createQueryClient();
const persister = createIndexedDbPersister({
  databaseName: 'app-query-cache',
  storeName: 'queries',
  key: 'query-client',
});

export const signOut = async (): Promise<void> => {
  await clearQueryCache(queryClient, persister);
};

import { createIndexedDbPersister } from 'jg-tanstack-query';

export const persister = createIndexedDbPersister({
  databaseName: 'app-query-cache',
  storeName: 'queries',
  key: 'query-client',
});

import { createQueryClient } from 'jg-tanstack-query';

export const queryClient = createQueryClient();

import { isQueryLoading } from 'jg-tanstack-query';

isQueryLoading({ isError: false, isPending: true }); // true

import { isQueryLoadingMore } from 'jg-tanstack-query';

isQueryLoadingMore({ isError: false, isFetchingNextPage: true }); // true

import { isQueryReadyForInitialDisplay } from 'jg-tanstack-query';

isQueryReadyForInitialDisplay({ isError: false, isStale: true, isFetchedAfterMount: false }); // false

import { isQueryResultDataAvailable } from 'jg-tanstack-query';

isQueryResultDataAvailable([{ isError: false }, { isError: false, isPending: true }]); // false

import { createElement } from 'react';
import { createIndexedDbPersister, createQueryClient, PersistedQueryProvider } from 'jg-tanstack-query';

declare const App: () => null;

const client = createQueryClient();
const persister = createIndexedDbPersister({
  databaseName: 'app-query-cache',
  storeName: 'queries',
  key: 'query-client',
});

export const Root = () =>
  createElement(PersistedQueryProvider, { client, persister, buster: 'v1' }, createElement(App));

import { useQuery } from '@tanstack/react-query';
import { useQueryBoundary } from 'jg-tanstack-query';

declare const fetchProject: (id: string) => Promise<{ name: string }>;

export const useProjectBoundary = (projectId: string) => {
  const project = useQuery({
    queryKey: ['project', projectId],
    queryFn: () => fetchProject(projectId),
  });
  const boundary = useQueryBoundary({ queries: [project], resolutionKey: projectId });
  return { project, boundary };
};

import { useQuery } from '@tanstack/react-query';
import { useSeededInfiniteQuery } from 'jg-tanstack-query';

type IPage = { items: string[]; nextCursor: string | null };
declare const fetchScreen: () => Promise<{ activity: IPage }>;
declare const fetchActivity: (cursor: string, signal: AbortSignal) => Promise<IPage>;

export const useActivity = () => {
  const screen = useQuery({ queryKey: ['dashboard'], queryFn: fetchScreen });
  return useSeededInfiniteQuery<IPage, string | null>({
    queryKey: ['dashboard', 'activity'],
    firstPage: screen.data?.activity,
    firstPageUpdatedAt: screen.dataUpdatedAt,
    initialPageParam: null,
    getNextPageParam: (page) => page.nextCursor,
    continuationQueryFn: (cursor, signal) => fetchActivity(cursor as string, signal),
  });
};

const DEFAULT_QUERY_MAX_AGE_SECONDS: 864000

const ERRORS: { FIRST_PAGE_NOT_READY: "FIRST_PAGE_NOT_READY" }

type IIndexedDbPersisterOptions = {
    databaseName: string;
    storeName: string;
    key: string;
};

type IPersistedQueryProviderProps = {
    client: QueryClient;
    persister: Persister;
    buster: string;
    maxAgeSeconds?: number;
    children?: ReactNode;
};

type IQueryBoundaryQuery = IQueryExecutionState & IQueryInitialResolutionState & {
    data: unknown;
    error?: unknown;
    isFetching?: boolean | undefined;
    isRefetching?: boolean | undefined;
    refetch?: (() => unknown) | undefined;
    fetchNextPage?: (() => unknown) | undefined;
};

type IQueryBoundaryState<TQuery extends IQueryBoundaryQuery> = {
    canRenderContent: boolean;
    isLoaderVisible: boolean;
    hasError: boolean;
    errorPresentation: IQueryErrorPresentation;
    failedQueries: TQuery[];
    loadMoreQuery: TQuery | undefined;
    retryFailed: () => Promise<void>;
};

type IQueryClientOptions = {
    maxAgeSeconds?: number;
};

type IQueryErrorPresentation = 'blocking' | 'retained';

type IQueryExecutionState = {
    isError: boolean;
    isLoading?: boolean | undefined;
    isPending?: boolean | undefined;
    hasNextPage?: boolean | undefined;
    isFetchingNextPage?: boolean | undefined;
};

type IQueryInitialResolutionState = {
    isError: boolean;
    isFetchedAfterMount: boolean;
    isStale: boolean;
};

type ISeededInfiniteQueryResult<TPage, TPageParam> = {
    data: InfiniteData<TPage, TPageParam> | undefined;
    error: Error | null;
    fetchNextPage: () => Promise<unknown>;
    hasNextPage: boolean;
    isError: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isFetchingNextPage: boolean;
    isLoading: boolean;
    isPending: boolean;
    isReady: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isSuccess: boolean;
    refetch: () => Promise<unknown>;
};

type IUseQueryBoundaryOptions<TQuery extends IQueryBoundaryQuery> = {
    queries: readonly TQuery[];
    resolutionKey: string;
    isInitialResolutionApproved?: boolean | undefined;
    isAccessDenied?: ((error: unknown) => boolean) | undefined;
};

type IUseSeededInfiniteQueryOptions<TPage, TPageParam> = {
    queryKey: QueryKey;
    firstPage: TPage | undefined;
    firstPageUpdatedAt: number;
    initialPageParam: TPageParam;
    getNextPageParam: (lastPage: TPage, pages: TPage[]) => TPageParam | undefined | null;
    continuationQueryFn: (pageParam: TPageParam, signal: AbortSignal) => Promise<TPage>;
    gcTimeSeconds?: number | undefined;
    maxPages?: number | undefined;
    meta?: QueryMeta | undefined;
};