@ainias42/tanstack-ids 0.0.1

package/src/QueryContext/useQueriesStore.ts

@@ -0,0 +1,150 @@
+import { ObjectHelper } from '@ainias42/js-helper';
+import { create } from 'zustand';
+import { immer } from 'zustand/middleware/immer';
+import { subscribeWithSelector } from 'zustand/middleware';
+import type { QueryClient } from '@tanstack/react-query';
+import type { URecord } from '@ainias42/js-helper';
+
+type QueryItem = {
+    keys: string[];
+    isFetching: boolean;
+    error: any;
+};
+
+function initialState() {
+    return {
+        lastContextId: 0,
+        contexts: {} as URecord<
+            number,
+            {
+                lastId: number;
+                items: URecord<number, QueryItem>;
+            }
+        >,
+        subContexts: {} as URecord<number, number[]>
+    };
+}
+
+export type QueriesStoreState = ReturnType<typeof actionsGenerator> & ReturnType<typeof initialState>;
+type SetState = (
+    newState: Partial<QueriesStoreState> | QueriesStoreState | ((state: QueriesStoreState) => QueriesStoreState | void),
+    replace?: boolean
+) => void;
+type GetState = () => Readonly<QueriesStoreState>;
+const actionsGenerator = (set: SetState, get: GetState) => ({
+    get,
+    clear() {
+        set({ ...initialState(), ...actionsGenerator(set, get) }, true);
+    },
+    generateContextId() {
+        let id = 0;
+        set(state => {
+            state.lastContextId++;
+            state.contexts[state.lastContextId] = {
+                lastId: 0,
+                items: {}
+            };
+            id = state.lastContextId;
+        });
+        return id;
+    },
+    setItem(contextId: number, itemId: number | undefined, item: QueryItem) {
+        let id = itemId;
+        set(state => {
+            const contextData = state.contexts[contextId];
+            if (!contextData) {
+                return;
+            }
+
+            if (!id) {
+                contextData.lastId++;
+                id = contextData.lastId;
+            }
+            contextData.items[id] = item;
+        });
+        return id;
+    },
+    removeItem(contextId: number, itemId: number | undefined) {
+        if (!itemId) {
+            return;
+        }
+        set(state => {
+            delete state.contexts[contextId]?.items[itemId];
+        });
+    },
+    isFetching(contextId: number): boolean {
+        const state = get();
+        return (
+            ObjectHelper.values(state.contexts[contextId]?.items ?? {}).some(item => item.isFetching) ||
+            (state.subContexts[contextId]?.some(id => state.isFetching(id)) ?? false)
+        );
+    },
+    isFetchingByScope(contextId: number, scope: { global: boolean; subContexts: boolean }): boolean {
+        const state = get();
+        return (
+            ((scope.global &&
+                ObjectHelper.values(state.contexts[contextId]?.items ?? {}).some(item => item.isFetching)) ||
+                (scope.subContexts && state.subContexts[contextId]?.some(id => state.isFetching(id)))) ??
+            false
+        );
+    },
+    getError(contextId: number): any {
+        const state = get();
+
+        const error = ObjectHelper.values(state.contexts[contextId]?.items ?? {}).find(item => item.error)?.error;
+        if (error) {
+            return error;
+        }
+        const subContextWithError = state.subContexts[contextId]?.find(childId => state.getError(childId));
+        if (subContextWithError) {
+            return state.getError(subContextWithError);
+        }
+        return undefined;
+    },
+    getAllKeys(contextId: number): Set<string> {
+        const state = get();
+
+        const keys = new Set(ObjectHelper.values(state.contexts[contextId]?.items ?? {}).flatMap(item => item.keys));
+
+        const subContext = state.subContexts[contextId];
+        if (subContext) {
+            for (const childId of subContext) {
+                const subKeys = state.getAllKeys(childId);
+                for (const key of subKeys) {
+                    keys.add(key);
+                }
+            }
+        }
+
+        return keys;
+    },
+    reload(queryClient: QueryClient, contextId: number) {
+        const state = get();
+
+        const keys = state.getAllKeys(contextId);
+        return queryClient.refetchQueries({
+            predicate: query => keys.has(query.queryHash)
+        });
+    },
+    addSubContext(parent: number, child: number) {
+        set(state => {
+            const newChildren = state.subContexts[parent] ?? [];
+            newChildren.push(child);
+            state.subContexts[parent] = newChildren;
+        });
+    },
+    removeSubContext(parent: number, child: number) {
+        set(state => {
+            state.subContexts[parent] = state.subContexts[parent]?.filter(id => id !== child);
+        });
+    }
+});
+
+export const useQueriesStore = create<QueriesStoreState>()(
+    subscribeWithSelector(
+        immer((set, get) => ({
+            ...initialState(),
+            ...actionsGenerator(set, get)
+        }))
+    )
+);

package/src/QueryContext/useQuerySubscribeToReload.ts

@@ -0,0 +1,23 @@
+import { QueriesContext } from '@/QueryContext/QueriesContext';
+import { useContext, useLayoutEffect, useRef } from 'react';
+import { useQueriesStore } from '@/QueryContext/useQueriesStore';
+
+export function useQueriesSubscribeToReload(keys: string[], isFetching: boolean, error: any) {
+    const contextId = useContext(QueriesContext);
+    const setItem = useQueriesStore(s => s.setItem);
+    const removeItem = useQueriesStore(s => s.removeItem);
+    const id = useRef<number | undefined>();
+
+    useLayoutEffect(() => {
+        id.current = setItem(contextId, id.current, {
+            keys,
+            error,
+            isFetching
+        });
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [contextId, error, isFetching, setItem, ...keys]);
+
+    useLayoutEffect(() => {
+        return () => removeItem(contextId, id.current);
+    }, [contextId, removeItem]);
+}

package/src/QueryContext/useScopedQueriesIsFetching.ts

@@ -0,0 +1,9 @@
+import { QueriesContext } from '@/QueryContext/QueriesContext';
+import { useContext } from 'react';
+import { useQueriesStore } from '@/QueryContext/useQueriesStore';
+
+export function useScopedQueriesIsFetching(scope: { global: boolean; subContexts: boolean }, contextId?: number) {
+    const context = useContext(QueriesContext);
+
+    return useQueriesStore(s => s.isFetchingByScope(contextId ?? context, scope));
+}

package/src/generateIdsQuery.ts

@@ -0,0 +1,286 @@
+import { ArrayHelper, JsonHelper } from '@ainias42/js-helper';
+import { NotFoundError } from '@/NotFoundError';
+import { create, windowScheduler } from '@yornaath/batshit';
+import { createInfiniteQuery, createQuery } from 'react-query-kit';
+import { generateQuery } from '@/generateQuery';
+import { hashKey, useQueries } from '@tanstack/react-query';
+import { hoistReactQueryKitAttributes } from '@/hoistReactQueryKitAttributes';
+import { useIndexedData } from '@/hooks/useIndexedData';
+import { useMemo, useRef } from 'react';
+import { useQueriesSubscribeToReload } from '@/QueryContext/useQuerySubscribeToReload';
+import type { CreateInfiniteQueryOptions, CreateQueryOptions } from 'react-query-kit';
+import type { QueriesResults } from '@tanstack/react-query/build/legacy/useQueries';
+import type { QueryClient, QueryFunctionContext, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import type { URecord } from '@ainias42/js-helper';
+
+export type Unpacked<T> = T extends (infer U)[] ? U : T;
+
+type DeepPartial<T> = T extends object
+    ? {
+        [P in keyof T]?: DeepPartial<T[P]>;
+    }
+    : T;
+
+export function generateIdsQuery<
+    IdType extends number | string | symbol,
+    Type extends {
+        id: IdType;
+    }
+>(
+    key: string,
+    fetcher: (ids: IdType[]) => Promise<Type[]> | Type[],
+    additionalQueryOptions?: Omit<CreateQueryOptions<Type, [IdType]>, 'queryKey' | 'fetcher'> & {
+        schedulerTime?: number;
+    }
+) {
+    const batch = create<URecord<IdType, Type>[], IdType, Type>({
+        fetcher: async ids => {
+            return [ArrayHelper.arrayToObject(await fetcher(ids), value => value.id)];
+        },
+        resolver: ([items], id) => {
+            const item = items?.[id];
+            if (item === undefined) {
+                throw new NotFoundError(id);
+            }
+            return item;
+        },
+        scheduler: windowScheduler(additionalQueryOptions?.schedulerTime ?? 15)
+    });
+
+    const useQueryHook = createQuery<Type, [IdType]>({
+        queryKey: [key],
+        fetcher: identifier => batch.fetch(identifier[0]),
+        ...additionalQueryOptions
+    });
+
+    function useManyHook(
+        ids: IdType[],
+        otherAdditionalQueryOptions: Omit<
+            UseQueryOptions<Type, unknown, Type, [string, [IdType]]>,
+            'context' | 'fetcher' | 'queryKey'
+        > & { reloadWithContext?: boolean } = {}
+    ) {
+        const queries = ids.map(id => ({
+            ...useQueryHook.getOptions([id]),
+            ...otherAdditionalQueryOptions
+        }));
+
+        const results = useQueries<Type[], QueriesResults<Type[]>>({
+            // @ts-expect-error wrong type in tanstack-query
+            queries
+        }) as UseQueryResult<Type, Error>[];
+
+        const oldData = useRef<typeof results>([]);
+        const isSame = JsonHelper.deepEqual(oldData.current, results, 1);
+
+        const returnData = useRef({} as URecord<IdType, Unpacked<typeof results>>);
+        if (!isSame) {
+            oldData.current = results;
+            returnData.current = {} as URecord<IdType, Unpacked<typeof results>>;
+            for (const [index, val] of results.entries()) {
+                const id = ids[index] as IdType;
+                returnData.current[id] = val;
+            }
+        }
+
+        const shouldReload = otherAdditionalQueryOptions.reloadWithContext ?? true;
+        const keys = shouldReload ? ids.map(id => hashKey(useQueryHook.getKey([id as DeepPartial<IdType>]))) : [];
+
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        const isFetching = useMemo(() => oldData.current.some(item => item.isFetching), [oldData.current]);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        const error = useMemo(() => oldData.current.find(item => item.error)?.error, [oldData.current]);
+
+        useQueriesSubscribeToReload(keys, isFetching, error);
+
+        return returnData.current;
+    }
+
+    function useOneHook(identifier: IdType) {
+        const result = useQueryHook({variables: [identifier]});
+        useQueriesSubscribeToReload(
+            [hashKey(useQueryHook.getKey([identifier as DeepPartial<IdType>]))],
+            result.isFetching,
+            result.error
+        );
+        return result;
+    }
+
+    function generateFilter<
+        Func extends (...args: any[]) => Promise<Type[]> | Type[],
+        FuncArguments extends Parameters<Func>['length'] extends 0
+            ? void
+            : Parameters<Func> = Parameters<Func>['length'] extends 0 ? void : Parameters<Func>,
+        ResultAsArray extends boolean = false
+    >(
+        queryClient: QueryClient,
+        filterFunc: Func,
+        additionalOptions?: Omit<CreateQueryOptions<IdType[], [FuncArguments]>, 'queryKey' | 'fetcher'> & {
+            resultAsArray?: ResultAsArray;
+            subKey?: string;
+        }
+    ) {
+        const queryHook = generateQuery(
+            `${key}-filter${additionalOptions?.subKey ? `-${additionalOptions.subKey}` : ''}`,
+            async (filter: FuncArguments) => {
+                const result = await filterFunc(filter);
+                return result.map(item => {
+                    queryClient.setQueryData(useQueryHook.getKey([item.id as DeepPartial<IdType>]), item);
+                    return item.id;
+                });
+            },
+            {
+                initialDataUpdatedAt: 0,
+                ...additionalOptions,
+                initialData: (additionalOptions?.initialData as IdType[]) ?? []
+            }
+        );
+
+        type QueryHookArgument = Parameters<typeof queryHook>[0];
+        type HookArgs = FuncArguments extends void ? [] : FuncArguments;
+
+        function useFilter<Args extends HookArgs>(
+            ...args: Args
+        ): ResultAsArray extends true ? UseQueryResult<Type, Error>[] : URecord<IdType, UseQueryResult<Type, Error>> {
+            const result = queryHook({variables: args} as QueryHookArgument);
+
+            useQueriesSubscribeToReload(
+                [hashKey(queryHook.getKey(args as Parameters<(typeof queryHook)['getKey']>[0]))],
+                result.isFetching,
+                result.error
+            );
+
+            // When staleTime is same as filterStaleTime, then the queries will run at the same time as the filter
+            // Because of this, use staleTime: Inifinity to prevent the queries from running again. The result of the
+            // filter will be saved inside the queryClient, so the queries will be updated with the new data.
+            // Same goes for reloading with context.
+            // Other usages of useManyHook are not affected by this.
+            const indexedResult = useManyHook(result.data, {staleTime: Infinity, reloadWithContext: false});
+            const arrayResult: UseQueryResult<Type, Error>[] = useMemo(
+                () => ArrayHelper.noUndefined(result.data.map(id => indexedResult[id])),
+                [indexedResult, result.data]
+            );
+
+            if (additionalOptions?.resultAsArray) {
+                return arrayResult as ResultAsArray extends true
+                    ? UseQueryResult<Type, Error>[]
+                    : URecord<IdType, UseQueryResult<Type, Error>>;
+            }
+            return indexedResult as ResultAsArray extends true
+                ? UseQueryResult<Type, Error>[]
+                : URecord<IdType, UseQueryResult<Type, Error>>;
+
+        }
+
+        return hoistReactQueryKitAttributes(queryHook, useFilter);
+    }
+
+    function generateInfiniteQuery<PageParams, FuncArguments extends any[]>(
+        queryClient: QueryClient,
+        {
+            queryFn,
+            ...options
+        }: Omit<
+            CreateInfiniteQueryOptions<IdType[], FuncArguments, Error, PageParams>,
+            'getNextPageParam' | 'getPreviousPageParam' | 'queryKey' | 'fetcher'
+        > & {
+            queryFn: (
+                pageParams: PageParams,
+                args: FuncArguments,
+                context: QueryFunctionContext<[string, FuncArguments], PageParams>
+            ) => Promise<Type[]> | Type[];
+            getNextPageParam: (options: {
+                getLastPage: () => Type[];
+                getAllPages: () => Type[][];
+                lastPageParam: PageParams;
+                allPageParams: PageParams[];
+                lastPageLength: number;
+            }) => PageParams | undefined;
+            getPreviousPageParam?: (options: {
+                getFirstPage: () => Type[];
+                getAllPages: () => Type[][];
+                firstPageParam: PageParams;
+                allPageParams: PageParams[];
+                firstPageLength: number;
+            }) => PageParams | undefined;
+        }
+    ) {
+        function findEntity(id: IdType) {
+            return queryClient.getQueryData(useQueryHook.getKey([id as DeepPartial<IdType>])) as Type | undefined;
+        }
+
+        const {getPreviousPageParam} = options;
+        const infiniteQueryHook = createInfiniteQuery<IdType[], FuncArguments, Error, PageParams>({
+            ...options,
+            queryKey: [`${key}-infinite-query`],
+            fetcher: async (_, ctx) => {
+                const context = ctx as typeof ctx & { pageParam: PageParams };
+                const result = await queryFn(
+                    context.pageParam,
+                    context.queryKey[1] as FuncArguments,
+                    context as QueryFunctionContext<[string, FuncArguments], PageParams>
+                );
+                return result.map(item => {
+                    queryClient.setQueryData(useQueryHook.getKey([item.id as DeepPartial<IdType>]), item);
+                    return item.id;
+                });
+            },
+            getNextPageParam: (lastPage: IdType[], allPages: IdType[][], lastPageParam, allPageParams) => {
+                return options.getNextPageParam({
+                    getLastPage: () => ArrayHelper.noUndefined(lastPage.map(findEntity)),
+                    getAllPages: () => allPages.map(page => ArrayHelper.noUndefined(page.map(findEntity))),
+                    lastPageParam,
+                    allPageParams,
+                    lastPageLength: lastPage.length
+                });
+            },
+            getPreviousPageParam: !getPreviousPageParam
+                ? undefined
+                : (firstPage, allPages, firstPageParam, allPageParams) => {
+                    return getPreviousPageParam({
+                        getFirstPage: () => ArrayHelper.noUndefined(firstPage.map(findEntity)),
+                        getAllPages: () => allPages.map(page => ArrayHelper.noUndefined(page.map(findEntity))),
+                        firstPageParam,
+                        allPageParams,
+                        firstPageLength: firstPage.length
+                    });
+                }
+        });
+
+        function useInfiniteQuery(...args: FuncArguments) {
+            const result = infiniteQueryHook({variables: args});
+            useQueriesSubscribeToReload(
+                [hashKey(infiniteQueryHook.getKey(args as Parameters<(typeof infiniteQueryHook)['getKey']>[0]))],
+                result.isFetching,
+                result.error
+            );
+            const ids = useMemo(() => result.data?.pages.flat() ?? [], [result.data?.pages]);
+
+            // When staleTime is same as filterStaleTime, then the queries will run at the same time as the filter
+            // Because of this, use staleTime: Inifinity to prevent the queries from running again. The result of the
+            // filter will be saved inside the queryClient, so the queries will be updated with the new data.
+            // Same goes for reloading with context.
+            // Other usages of useManyHook are not affected by this.
+            const manyData = useManyHook(ids, {staleTime: Infinity, reloadWithContext: false});
+            const indexedData = useIndexedData(manyData);
+
+            const pages = useMemo(() => {
+                return result.data
+                    ? result.data.pages.map(page => ArrayHelper.noUndefined(page.map(id => indexedData[id])))
+                    : [];
+            }, [indexedData, result.data]);
+
+            return {
+                ...result,
+                data: !result.data ? undefined : {...result.data, pages}
+            };
+        }
+
+        // @ts-expect-error type is okay
+        return hoistReactQueryKitAttributes(infiniteQueryHook, useInfiniteQuery);
+    }
+
+    const useMany = hoistReactQueryKitAttributes(useQueryHook, useManyHook);
+    const useOne = hoistReactQueryKitAttributes(useQueryHook, useOneHook);
+    return {useMany, useOne, generateFilter, generateInfiniteQuery};
+}

package/src/generateNestedIdQuery.ts

@@ -0,0 +1,38 @@
+import { type QueryClient, hashKey } from '@tanstack/react-query';
+import { generateIdsQuery } from '@/generateIdsQuery';
+import { noop } from '@/noop';
+import { useMemo } from 'react';
+import type { DeepPartial } from '@/types/DeepPartial';
+
+export function generateNestedIdQuery<
+    IdType extends number | string | symbol,
+    Type extends {
+        id: IdType;
+    },
+    Args extends any[]
+>(key: string, fetcherFactory: (...args: Args) => (ids: IdType[]) => Promise<Type[]> | Type[]) {
+    const factory = (...args: Args) => {
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        return useMemo(() => {
+            const keyWithArgs = `${key}-${hashKey(args)}`;
+            return generateIdsQuery(keyWithArgs, fetcherFactory(...args));
+        }, [args]);
+    };
+
+    factory.getFilterKey = (args: Args, variables?: any[]) => {
+        const keyWithArgs = `${key}-${hashKey(args)}`;
+        return generateIdsQuery(keyWithArgs, fetcherFactory(...args))
+            .generateFilter(undefined as unknown as QueryClient, noop as (..._: any[]) => Type[])
+            .getKey([variables]);
+    };
+
+    factory.getKey = <Variables extends [(DeepPartial<IdType> | undefined)?] | undefined = undefined>(
+        args: Args,
+        variables?: Variables
+    ) => {
+        const keyWithArgs = `${key}-${hashKey(args)}`;
+        return generateIdsQuery(keyWithArgs, fetcherFactory(...args)).useOne.getKey(variables);
+    };
+
+    return factory;
+}

package/src/generateQuery.ts

@@ -0,0 +1,59 @@
+import { createQuery } from 'react-query-kit';
+import { hashKey } from '@tanstack/react-query';
+import { hoistReactQueryKitAttributes } from '@/hoistReactQueryKitAttributes';
+import { useQueriesSubscribeToReload } from '@/QueryContext/useQuerySubscribeToReload';
+import type { CreateQueryOptions, QueryHookResult } from 'react-query-kit';
+
+export function generateQuery<
+    Func extends (...args: any[]) => Promise<any> | any,
+    FuncArguments extends Parameters<Func>['length'] extends 0
+        ? void
+        : Parameters<Func> = Parameters<Func>['length'] extends 0 ? void : Parameters<Func>,
+    FuncReturnType extends Awaited<ReturnType<Func>> = Awaited<ReturnType<Func>>,
+    AdditionalOptionsType extends Omit<
+        CreateQueryOptions<FuncReturnType, FuncArguments>,
+        'queryKey' | 'fetcher'
+    > = Omit<CreateQueryOptions<FuncReturnType, FuncArguments>, 'queryKey' | 'fetcher'>
+>(primaryKey: string, queryFn: Func, additionalOptions?: AdditionalOptionsType) {
+    const queryHook = createQuery<FuncReturnType, FuncArguments>({
+        queryKey: [primaryKey],
+        fetcher: variables => {
+            if (Array.isArray(variables)) {
+                return queryFn(...variables);
+            } 
+                return queryFn();
+            
+        },
+        initialDataUpdatedAt: 0,
+        ...additionalOptions
+    });
+
+    type QueryHookArgument = Parameters<typeof queryHook>[0];
+    type HookArgs = FuncArguments extends void ? [] | [QueryHookArgument] : [QueryHookArgument];
+
+    function useHook<Arg extends HookArgs>(...options: Arg) {
+        type DataReturnType = Arg extends [
+                {
+                    initialData: FuncReturnType | (() => FuncReturnType);
+                }
+            ]
+            ? FuncReturnType
+            : AdditionalOptionsType extends { initialData: FuncReturnType | (() => FuncReturnType) }
+                ? FuncReturnType
+                : FuncReturnType | undefined;
+
+        const result = queryHook(options[0] as QueryHookArgument);
+        useQueriesSubscribeToReload(
+            [hashKey(queryHook.getKey(options[0]?.variables as Parameters<(typeof queryHook)['getKey']>[0]))],
+            result.isFetching,
+            result.error
+        );
+
+        type Return = Arg extends [{ select: (...arg: any[]) => any }] ? ReturnType<Arg[0]['select']> : DataReturnType;
+        return result as QueryHookResult<Return, Error> & {
+            data: Return;
+        };
+    }
+
+    return hoistReactQueryKitAttributes(queryHook, useHook);
+}

package/src/hoistReactQueryKitAttributes.ts

@@ -0,0 +1,14 @@
+import type { ExposeMethods } from 'react-query-kit/build/lib/types';
+
+export function hoistReactQueryKitAttributes<ReturnType, HookArgs, ToFunc extends (...args: any) => any, Error>(
+    from: ExposeMethods<ReturnType, HookArgs, Error>,
+    to: ToFunc
+) {
+    const partialHook: Partial<ExposeMethods<ReturnType, HookArgs, Error>> & ToFunc = to;
+    const hoistedOptions = ['fetcher', 'getKey', 'queryKeyHashFn', 'getOptions'] as const;
+    for (const name of hoistedOptions) {
+        partialHook[name as 'getKey'] = from[name as 'getKey'];
+    }
+
+    return partialHook as ExposeMethods<ReturnType, HookArgs, Error> & ToFunc;
+}

package/src/hooks/useArrayData.ts

@@ -0,0 +1,19 @@
+import { ArrayHelper, ObjectHelper } from '@ainias42/js-helper';
+import { useMemo } from 'react';
+import type { URecord } from '@ainias42/js-helper';
+
+export function useArrayData<DataType>(
+    result:
+        | {
+              data: DataType;
+          }[]
+        | URecord<any, { data: DataType | undefined }>
+): Exclude<DataType, undefined>[] {
+    return useMemo(
+        () =>
+            ArrayHelper.noUndefined(
+                (Array.isArray(result) ? result : ObjectHelper.values(result)).map(data => data.data)
+            ),
+        [result]
+    );
+}

package/src/hooks/useIndexedData.ts

@@ -0,0 +1,24 @@
+import { ObjectHelper } from '@ainias42/js-helper';
+import { useMemo } from 'react';
+import type { URecord } from '@ainias42/js-helper';
+
+export function useIndexedData<DataType, IndexType extends number | string | symbol>(
+    result: URecord<
+        IndexType,
+        {
+            data: DataType | undefined;
+        }
+    >
+) {
+    return useMemo(
+        () =>
+            ObjectHelper.entries(result).reduce(
+                (acc, [key, data]) => {
+                    acc[key] = data.data;
+                    return acc;
+                },
+                {} as URecord<IndexType, DataType>
+            ),
+        [result]
+    );
+}

package/src/index.ts

@@ -0,0 +1,19 @@
+export * from './generateIdsQuery';
+export * from './generateNestedIdQuery';
+export * from './generateQuery';
+export * from './hoistReactQueryKitAttributes';
+export * from './noop';
+export * from './NotFoundError';
+export * from './hooks/useArrayData';
+export * from './hooks/useIndexedData';
+export * from './QueryContext/QueriesContext';
+export * from './QueryContext/QueriesContextProvider';
+export * from './QueryContext/SubQueriesContext';
+export * from './QueryContext/useGenerateQueriesContextId';
+export * from './QueryContext/useQueriesError';
+export * from './QueryContext/useQueriesIsFetching';
+export * from './QueryContext/useQueriesReload';
+export * from './QueryContext/useQueriesStore';
+export * from './QueryContext/useQuerySubscribeToReload';
+export * from './QueryContext/useScopedQueriesIsFetching';
+export * from './types/DeepPartial';

package/src/noop.ts

@@ -0,0 +1,2 @@
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+export function noop() {}

package/src/types/DeepPartial.ts

@@ -0,0 +1,5 @@
+export type DeepPartial<T> = T extends object
+    ? {
+          [P in keyof T]?: DeepPartial<T[P]>;
+      }
+    : T;