@ventlio/tanstack-query 0.2.65 → 0.2.69

package/dist/config/useQueryConfig.js

@@ -2,8 +2,8 @@ import { useQueryClient } from '@tanstack/react-query';
 
 const useQueryConfig = () => {
     const queryClient = useQueryClient();
-    const { headers = {} } = queryClient.getQueryData(['config']) ?? {};
-    return { headers };
+    const { headers = {}, options = {} } = queryClient.getQueryData(['config']) ?? {};
+    return { headers, options };
 };
 
 export { useQueryConfig };

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { useQueryClient, useQuery, useMutation } from '@tanstack/react-query';
 import result from 'lodash.result';
-import set from 'lodash.set';
+import lodashSet from 'lodash.set';
 import { useState, useMemo, useEffect, startTransition } from 'react';
 import axios from 'axios';
 
@@ -40,8 +40,8 @@ const useEnvironmentVariables = () => {
 
 const useQueryConfig = () => {
     const queryClient = useQueryClient();
-    const { headers = {} } = queryClient.getQueryData(['config']) ?? {};
-    return { headers };
+    const { headers = {}, options = {} } = queryClient.getQueryData(['config']) ?? {};
+    return { headers, options };
 };
 
 const scrollToTop = () => {
@@ -117,7 +117,7 @@ const useQueryModel = (keyTracker, exact = true) => {
         }
         else {
             const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
-            queryClient.setQueryData(queryKey, set(queryData, path, records));
+            queryClient.setQueryData(queryKey, lodashSet(queryData, path, records));
         }
         return data;
     };
@@ -143,6 +143,21 @@ const useQueryModel = (keyTracker, exact = true) => {
         const data = findAll(path) ?? [];
         return data.find((record) => record[modelConfig.idColumn] === id);
     };
+    const get = (path) => {
+        let data = queryClient.getQueryData(queryKey, { exact });
+        if (path) {
+            data = result(data, path);
+        }
+        return data;
+    };
+    const set = (newData, path) => {
+        if (path) {
+            const data = get();
+            newData = lodashSet(data, path, newData);
+            return queryClient.setQueryData(queryKey, newData);
+        }
+        return queryClient.setQueryData(queryKey, newData);
+    };
     const getModelConfig = () => {
         const { options } = queryClient.getQueryData(['config']) ?? {};
         const { modelConfig } = options ?? {};
@@ -169,7 +184,7 @@ const useQueryModel = (keyTracker, exact = true) => {
         }
         else {
             const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
-            queryClient.setQueryData(queryKey, set(queryData, path, newData));
+            queryClient.setQueryData(queryKey, lodashSet(queryData, path, newData));
         }
         return updatedRecord;
     };
@@ -194,18 +209,18 @@ const useQueryModel = (keyTracker, exact = true) => {
         }
         else {
             const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
-            queryClient.setQueryData(queryKey, set(queryData, path, newData));
+            queryClient.setQueryData(queryKey, lodashSet(queryData, path, newData));
         }
         return updated;
     };
-    return { find, findAll, findMany, remove, update, add };
+    return { find, findAll, findMany, remove, update, add, get, set };
 };
 
 const useRefetchQuery = async (queryKey) => {
     const queryClient = useQueryClient();
     const refetchQuery = async (innerQueryKey) => {
-        await queryClient.refetchQueries({
-            queryKey,
+        await queryClient.invalidateQueries({
+            queryKey: innerQueryKey ?? queryKey,
             exact: true,
         }, { throwOnError: true, cancelRefetch: true });
         return queryClient.getQueriesData(innerQueryKey ?? queryKey);
@@ -409,8 +424,8 @@ const useDeleteRequest = (deleteOptions) => {
         // set enabled to be true for every delete
         internalDeleteOptions = internalDeleteOptions ?? {};
         internalDeleteOptions.enabled = true;
-        await updatedPathAsync(link);
         await setOptionsAsync(internalDeleteOptions);
+        await updatedPathAsync(link);
         return query.data;
     };
     return { destroy, ...query };
@@ -426,19 +441,24 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     // eslint-disable-next-line react-hooks/exhaustive-deps
     queryClient = useMemo(() => queryClient, []);
     const sendRequest = async (res, rej) => {
-        // get request headers
-        const globalHeaders = getHeaders();
-        const getResponse = await makeRequest({
-            path: requestPath,
-            headers: { ...globalHeaders, ...headers },
-            baseURL: baseUrl ?? API_URL,
-            timeout: TIMEOUT,
-        });
-        if (getResponse.status) {
-            res(getResponse);
+        if (load) {
+            // get request headers
+            const globalHeaders = getHeaders();
+            const getResponse = await makeRequest({
+                path: requestPath,
+                headers: { ...globalHeaders, ...headers },
+                baseURL: baseUrl ?? API_URL,
+                timeout: TIMEOUT,
+            });
+            if (getResponse.status) {
+                res(getResponse);
+            }
+            else {
+                rej(getResponse);
+            }
         }
         else {
-            rej(getResponse);
+            res(null);
         }
     };
     const query = useQuery([requestPath, {}], () => new Promise((res, rej) => sendRequest(res, rej)), {
@@ -521,6 +541,8 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
 const usePatchRequest = ({ path, baseUrl, headers }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const { getHeaders } = useQueryHeaders();
+    const queryClient = useQueryClient();
+    const config = queryClient.getQueryData(['config']);
     const sendRequest = async (res, rej, data) => {
         // get request headers
         const globalHeaders = getHeaders();
@@ -534,12 +556,16 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
         });
         if (patchResponse.status) {
             // scroll to top after success
-            scrollToTop();
+            if (config?.options?.context !== 'app') {
+                scrollToTop();
+            }
             res(patchResponse);
         }
         else {
             // scroll to top after error
-            scrollToTop();
+            if (config?.options?.context !== 'app') {
+                scrollToTop();
+            }
             rej(patchResponse);
         }
     };

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/model/model.interface.d.ts

@@ -5,5 +5,7 @@ export interface QueryModelBuilder<T> {
     find: (id: number | string, path?: string) => T | undefined;
     update: (id: number | string, data: Partial<T>, path?: string) => T | undefined;
     remove: (id: number, path?: string) => boolean;
+    get: (path?: string) => T | undefined;
+    set: (data: Partial<T>, path?: string) => T | undefined;
 }
 export type QueryModelAddPosition = 'start' | 'end';

package/dist/model/useQueryModel.js

@@ -1,6 +1,6 @@
 import { useQueryClient } from '@tanstack/react-query';
 import result from 'lodash.result';
-import set from 'lodash.set';
+import lodashSet from 'lodash.set';
 import { useKeyTrackerModel } from './useKeyTrackerModel.js';
 
 const useQueryModel = (keyTracker, exact = true) => {
@@ -21,7 +21,7 @@ const useQueryModel = (keyTracker, exact = true) => {
         }
         else {
             const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
-            queryClient.setQueryData(queryKey, set(queryData, path, records));
+            queryClient.setQueryData(queryKey, lodashSet(queryData, path, records));
         }
         return data;
     };
@@ -47,6 +47,21 @@ const useQueryModel = (keyTracker, exact = true) => {
         const data = findAll(path) ?? [];
         return data.find((record) => record[modelConfig.idColumn] === id);
     };
+    const get = (path) => {
+        let data = queryClient.getQueryData(queryKey, { exact });
+        if (path) {
+            data = result(data, path);
+        }
+        return data;
+    };
+    const set = (newData, path) => {
+        if (path) {
+            const data = get();
+            newData = lodashSet(data, path, newData);
+            return queryClient.setQueryData(queryKey, newData);
+        }
+        return queryClient.setQueryData(queryKey, newData);
+    };
     const getModelConfig = () => {
         const { options } = queryClient.getQueryData(['config']) ?? {};
         const { modelConfig } = options ?? {};
@@ -73,7 +88,7 @@ const useQueryModel = (keyTracker, exact = true) => {
         }
         else {
             const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
-            queryClient.setQueryData(queryKey, set(queryData, path, newData));
+            queryClient.setQueryData(queryKey, lodashSet(queryData, path, newData));
         }
         return updatedRecord;
     };
@@ -98,11 +113,11 @@ const useQueryModel = (keyTracker, exact = true) => {
         }
         else {
             const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
-            queryClient.setQueryData(queryKey, set(queryData, path, newData));
+            queryClient.setQueryData(queryKey, lodashSet(queryData, path, newData));
         }
         return updated;
     };
-    return { find, findAll, findMany, remove, update, add };
+    return { find, findAll, findMany, remove, update, add, get, set };
 };
 
 export { useQueryModel };

package/dist/model/useQueryModel.js.map

@@ -1 +1 @@
-{"version":3,"file":"useQueryModel.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"useQueryModel.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/model/useRefetchQuery.js

@@ -3,8 +3,8 @@ import { useQueryClient } from '@tanstack/react-query';
 const useRefetchQuery = async (queryKey) => {
     const queryClient = useQueryClient();
     const refetchQuery = async (innerQueryKey) => {
-        await queryClient.refetchQueries({
-            queryKey,
+        await queryClient.invalidateQueries({
+            queryKey: innerQueryKey ?? queryKey,
             exact: true,
         }, { throwOnError: true, cancelRefetch: true });
         return queryClient.getQueriesData(innerQueryKey ?? queryKey);

package/dist/queries/useDeleteRequest.d.ts

@@ -27,7 +27,9 @@ export declare const useDeleteRequest: <TResponse>(deleteOptions?: DefaultReques
     refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<IRequestSuccess<TResponse>, any>>;
     remove: () => void;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
-    destroy: (link: string, internalDeleteOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    destroy: (link: string, internalDeleteOptions?: (UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> & {
+        cached?: boolean | undefined;
+    }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
 } | {
     data: IRequestSuccess<TResponse>;
     error: null;
@@ -54,7 +56,9 @@ export declare const useDeleteRequest: <TResponse>(deleteOptions?: DefaultReques
     refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<IRequestSuccess<TResponse>, any>>;
     remove: () => void;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
-    destroy: (link: string, internalDeleteOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    destroy: (link: string, internalDeleteOptions?: (UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> & {
+        cached?: boolean | undefined;
+    }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
 } | {
     data: undefined;
     error: any;
@@ -81,7 +85,9 @@ export declare const useDeleteRequest: <TResponse>(deleteOptions?: DefaultReques
     refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<IRequestSuccess<TResponse>, any>>;
     remove: () => void;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
-    destroy: (link: string, internalDeleteOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    destroy: (link: string, internalDeleteOptions?: (UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> & {
+        cached?: boolean | undefined;
+    }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
 } | {
     data: undefined;
     error: null;
@@ -108,5 +114,7 @@ export declare const useDeleteRequest: <TResponse>(deleteOptions?: DefaultReques
     refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<IRequestSuccess<TResponse>, any>>;
     remove: () => void;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
-    destroy: (link: string, internalDeleteOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    destroy: (link: string, internalDeleteOptions?: (UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> & {
+        cached?: boolean | undefined;
+    }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
 };

package/dist/queries/useDeleteRequest.js

@@ -40,8 +40,8 @@ const useDeleteRequest = (deleteOptions) => {
         // set enabled to be true for every delete
         internalDeleteOptions = internalDeleteOptions ?? {};
         internalDeleteOptions.enabled = true;
-        await updatedPathAsync(link);
         await setOptionsAsync(internalDeleteOptions);
+        await updatedPathAsync(link);
         return query.data;
     };
     return { destroy, ...query };

package/dist/queries/useGetRequest.js

@@ -16,19 +16,24 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     // eslint-disable-next-line react-hooks/exhaustive-deps
     queryClient = useMemo(() => queryClient, []);
     const sendRequest = async (res, rej) => {
-        // get request headers
-        const globalHeaders = getHeaders();
-        const getResponse = await makeRequest({
-            path: requestPath,
-            headers: { ...globalHeaders, ...headers },
-            baseURL: baseUrl ?? API_URL,
-            timeout: TIMEOUT,
-        });
-        if (getResponse.status) {
-            res(getResponse);
+        if (load) {
+            // get request headers
+            const globalHeaders = getHeaders();
+            const getResponse = await makeRequest({
+                path: requestPath,
+                headers: { ...globalHeaders, ...headers },
+                baseURL: baseUrl ?? API_URL,
+                timeout: TIMEOUT,
+            });
+            if (getResponse.status) {
+                res(getResponse);
+            }
+            else {
+                rej(getResponse);
+            }
         }
         else {
-            rej(getResponse);
+            res(null);
         }
     };
     const query = useQuery([requestPath, {}], () => new Promise((res, rej) => sendRequest(res, rej)), {

package/dist/queries/useGetRequest.js.map

@@ -1 +1 @@
-{"version":3,"file":"useGetRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"useGetRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/queries/usePatchRequest.js

@@ -1,4 +1,4 @@
-import { useMutation } from '@tanstack/react-query';
+import { useQueryClient, useMutation } from '@tanstack/react-query';
 import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
 import { useQueryHeaders } from '../config/useQueryHeaders.js';
 import { scrollToTop } from '../helpers/scrollToTop.js';
@@ -9,6 +9,8 @@ import { HttpMethod } from '../request/request.enum.js';
 const usePatchRequest = ({ path, baseUrl, headers }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const { getHeaders } = useQueryHeaders();
+    const queryClient = useQueryClient();
+    const config = queryClient.getQueryData(['config']);
     const sendRequest = async (res, rej, data) => {
         // get request headers
         const globalHeaders = getHeaders();
@@ -22,12 +24,16 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
         });
         if (patchResponse.status) {
             // scroll to top after success
-            scrollToTop();
+            if (config?.options?.context !== 'app') {
+                scrollToTop();
+            }
             res(patchResponse);
         }
         else {
             // scroll to top after error
-            scrollToTop();
+            if (config?.options?.context !== 'app') {
+                scrollToTop();
+            }
             rej(patchResponse);
         }
     };

package/dist/queries/usePatchRequest.js.map

@@ -1 +1 @@
-{"version":3,"file":"usePatchRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"usePatchRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ventlio/tanstack-query",
-  "version": "0.2.65",
+  "version": "0.2.69",
   "license": "MIT",
   "main": "dist/index.js",
   "contributors": [

package/src/config/useQueryConfig.ts

@@ -4,7 +4,7 @@ import type { TanstackQueryConfig } from '../types';
 export const useQueryConfig = (): TanstackQueryConfig => {
   const queryClient = useQueryClient();
 
-  const { headers = {} } = queryClient.getQueryData<TanstackQueryConfig>(['config']) ?? {};
+  const { headers = {}, options = {} } = queryClient.getQueryData<TanstackQueryConfig>(['config']) ?? {};
 
-  return { headers };
+  return { headers, options };
 };

package/src/model/model.interface.ts

@@ -5,6 +5,8 @@ export interface QueryModelBuilder<T> {
   find: (id: number | string, path?: string) => T | undefined;
   update: (id: number | string, data: Partial<T>, path?: string) => T | undefined;
   remove: (id: number, path?: string) => boolean;
+  get: (path?: string) => T | undefined;
+  set: (data: Partial<T>, path?: string) => T | undefined;
 }
 
 export type QueryModelAddPosition = 'start' | 'end';

package/src/model/useQueryModel.ts

@@ -1,6 +1,6 @@
 import { useQueryClient } from '@tanstack/react-query';
 import result from 'lodash.result';
-import set from 'lodash.set';
+import { default as lodashSet } from 'lodash.set';
 import type { TanstackQueryConfig } from '../types';
 import type { QueryModelAddPosition, QueryModelBuilder } from './model.interface';
 import { useKeyTrackerModel } from './useKeyTrackerModel';
@@ -24,7 +24,7 @@ export const useQueryModel = <T>(keyTracker: string, exact: boolean = true): Que
       queryClient.setQueryData(queryKey, records);
     } else {
       const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
-      queryClient.setQueryData(queryKey, set(queryData, path, records));
+      queryClient.setQueryData(queryKey, lodashSet(queryData, path, records));
     }
 
     return data;
@@ -60,6 +60,24 @@ export const useQueryModel = <T>(keyTracker: string, exact: boolean = true): Que
     return data.find((record) => (record as Record<string, any>)[modelConfig.idColumn] === id);
   };
 
+  const get = (path?: string): T | undefined => {
+    let data = queryClient.getQueryData(queryKey, { exact });
+    if (path) {
+      data = result<T>(data, path);
+    }
+    return data as T;
+  };
+
+  const set = (newData: any, path?: string): T | undefined => {
+    if (path) {
+      const data = get() as any;
+      newData = lodashSet(data, path, newData);
+
+      return queryClient.setQueryData(queryKey, newData) as T;
+    }
+    return queryClient.setQueryData(queryKey, newData) as T;
+  };
+
   const getModelConfig = () => {
     const { options } = queryClient.getQueryData<TanstackQueryConfig>(['config']) ?? {};
     const { modelConfig } = options ?? {};
@@ -79,7 +97,6 @@ export const useQueryModel = <T>(keyTracker: string, exact: boolean = true): Que
     let updatedRecord: T | undefined = undefined;
     const newData = oldData.map((record) => {
       let dataRecord = record as Record<string, any>;
-
       if (dataRecord[idColumn] === id) {
         dataRecord = { ...dataRecord, ...data };
         updatedRecord = dataRecord as T;
@@ -92,7 +109,7 @@ export const useQueryModel = <T>(keyTracker: string, exact: boolean = true): Que
       queryClient.setQueryData(queryKey, newData);
     } else {
       const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
-      queryClient.setQueryData(queryKey, set(queryData, path, newData));
+      queryClient.setQueryData(queryKey, lodashSet(queryData, path, newData));
     }
     return updatedRecord;
   };
@@ -119,10 +136,10 @@ export const useQueryModel = <T>(keyTracker: string, exact: boolean = true): Que
       queryClient.setQueryData(queryKey, newData);
     } else {
       const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
-      queryClient.setQueryData(queryKey, set(queryData, path, newData));
+      queryClient.setQueryData(queryKey, lodashSet(queryData, path, newData));
     }
     return updated;
   };
 
-  return { find, findAll, findMany, remove, update, add };
+  return { find, findAll, findMany, remove, update, add, get, set };
 };

package/src/model/useRefetchQuery.ts

@@ -4,9 +4,9 @@ export const useRefetchQuery = async (queryKey: any[]) => {
   const queryClient = useQueryClient();
 
   const refetchQuery = async <T>(innerQueryKey?: any[]) => {
-    await queryClient.refetchQueries(
+    await queryClient.invalidateQueries(
       {
-        queryKey,
+        queryKey: innerQueryKey ?? queryKey,
         exact: true,
       },
       { throwOnError: true, cancelRefetch: true }

package/src/queries/useDeleteRequest.ts

@@ -56,14 +56,14 @@ export const useDeleteRequest = <TResponse>(deleteOptions?: DefaultRequestOption
       IRequestError,
       IRequestSuccess<TResponse | undefined>,
       Array<any>
-    >
+    > & { cached?: boolean }
   ): Promise<IRequestSuccess<TResponse> | undefined> => {
     // set enabled to be true for every delete
     internalDeleteOptions = internalDeleteOptions ?? {};
     internalDeleteOptions.enabled = true;
 
-    await updatedPathAsync(link);
     await setOptionsAsync(internalDeleteOptions);
+    await updatedPathAsync(link);
 
     return query.data;
   };

package/src/queries/useGetRequest.ts

@@ -39,20 +39,24 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
     ) => void,
     rej: (reason?: any) => void
   ) => {
-    // get request headers
-    const globalHeaders: RawAxiosRequestHeaders = getHeaders();
-
-    const getResponse = await makeRequest<TResponse>({
-      path: requestPath,
-      headers: { ...globalHeaders, ...headers },
-      baseURL: baseUrl ?? API_URL,
-      timeout: TIMEOUT,
-    });
+    if (load) {
+      // get request headers
+      const globalHeaders: RawAxiosRequestHeaders = getHeaders();
+
+      const getResponse = await makeRequest<TResponse>({
+        path: requestPath,
+        headers: { ...globalHeaders, ...headers },
+        baseURL: baseUrl ?? API_URL,
+        timeout: TIMEOUT,
+      });
 
-    if (getResponse.status) {
-      res(getResponse as IRequestSuccess<TResponse>);
+      if (getResponse.status) {
+        res(getResponse as IRequestSuccess<TResponse>);
+      } else {
+        rej(getResponse);
+      }
     } else {
-      rej(getResponse);
+      res(null as any);
     }
   };
 

package/src/queries/usePatchRequest.ts

@@ -1,16 +1,20 @@
 import type { MutateOptions } from '@tanstack/react-query';
-import { useMutation } from '@tanstack/react-query';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
 import type { RawAxiosRequestHeaders } from 'axios';
 import { useEnvironmentVariables, useQueryHeaders } from '../config';
 import { scrollToTop } from '../helpers';
 import { HttpMethod, makeRequest } from '../request';
 import type { IRequestError, IRequestSuccess } from '../request/request.interface';
+import type { TanstackQueryConfig } from '../types';
 import type { DefaultRequestOptions } from './queries.interface';
 
 export const usePatchRequest = <TResponse>({ path, baseUrl, headers }: { path: string } & DefaultRequestOptions) => {
   const { API_URL, TIMEOUT } = useEnvironmentVariables();
 
   const { getHeaders } = useQueryHeaders();
+  const queryClient = useQueryClient();
+
+  const config = queryClient.getQueryData<TanstackQueryConfig>(['config']);
 
   const sendRequest = async (res: (value: any) => void, rej: (reason?: any) => void, data: any) => {
     // get request headers
@@ -27,11 +31,15 @@ export const usePatchRequest = <TResponse>({ path, baseUrl, headers }: { path: s
 
     if (patchResponse.status) {
       // scroll to top after success
-      scrollToTop();
+      if (config?.options?.context !== 'app') {
+        scrollToTop();
+      }
       res(patchResponse as IRequestSuccess<TResponse>);
     } else {
       // scroll to top after error
-      scrollToTop();
+      if (config?.options?.context !== 'app') {
+        scrollToTop();
+      }
       rej(patchResponse);
     }
   };