@ventlio/tanstack-query 0.2.64 → 0.2.66

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.js

@@ -5,7 +5,6 @@ export { useQueryHeaders } from './config/useQueryHeaders.js';
 export { useReactNativeEnv } from './config/useReactNativeEnv.js';
 export { scrollToTop } from './helpers/scrollToTop.js';
 export { getDateInFuture } from './helpers/timeFuncs.js';
-export { QueryModel } from './model/Model.js';
 export { useKeyTrackerModel } from './model/useKeyTrackerModel.js';
 export { useQueryModel } from './model/useQueryModel.js';
 export { useRefetchQuery } from './model/useRefetchQuery.js';

package/dist/index.js.map

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

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 = () => {
@@ -83,94 +83,6 @@ const useQueryHeaders = () => {
     return { setQueryHeaders, getHeaders };
 };
 
-class QueryModel {
-    queryKey;
-    queryClient;
-    exact;
-    constructor(queryKey, queryClient, exact = true) {
-        this.queryKey = queryKey;
-        this.queryClient = queryClient;
-        this.exact = exact;
-    }
-    findAll(path) {
-        const data = this.queryClient.getQueryData(this.queryKey, { exact: this.exact });
-        if (!data) {
-            return [];
-        }
-        if (!path) {
-            return Array.isArray(data) ? data : [data];
-        }
-        return result(data, path, []);
-    }
-    findMany(selector, path) {
-        const data = this.findAll(path) ?? [];
-        return data.filter(selector);
-    }
-    find(id, path) {
-        const modelConfig = this.getModelConfig();
-        if (!modelConfig?.idColumn) {
-            return undefined;
-        }
-        const data = this.findAll(path) ?? [];
-        return data.find((record) => record[modelConfig.idColumn] === id);
-    }
-    update(id, data, path) {
-        const oldData = this.findAll(path) ?? [];
-        const modelConfig = this.getModelConfig();
-        if (!modelConfig?.idColumn) {
-            return undefined;
-        }
-        const idColumn = modelConfig.idColumn;
-        let updatedRecord = undefined;
-        const newData = oldData.map((record) => {
-            let dataRecord = record;
-            if (dataRecord[idColumn] === id) {
-                dataRecord = { ...dataRecord, ...data };
-                updatedRecord = dataRecord;
-            }
-            return dataRecord;
-        });
-        if (!path) {
-            this.queryClient.setQueryData(this.queryKey, newData);
-        }
-        else {
-            const queryData = this.queryClient.getQueryData(this.queryKey, { exact: this.exact }) ?? {};
-            this.queryClient.setQueryData(this.queryKey, set(queryData, path, newData));
-        }
-        return updatedRecord;
-    }
-    remove(id, path) {
-        const oldData = this.findAll(path) ?? [];
-        const modelConfig = this.getModelConfig();
-        if (!modelConfig?.idColumn) {
-            return false;
-        }
-        const idColumn = modelConfig.idColumn;
-        let updated = false;
-        const newData = oldData.filter((record) => {
-            const dataRecord = record;
-            if (dataRecord[idColumn] === id) {
-                updated = true;
-                return false;
-            }
-            return true;
-        });
-        if (!path) {
-            this.queryClient.setQueryData(this.queryKey, newData);
-        }
-        else {
-            const queryData = this.queryClient.getQueryData(this.queryKey, { exact: this.exact }) ?? {};
-            this.queryClient.setQueryData(this.queryKey, set(queryData, path, newData));
-        }
-        return updated;
-    }
-    getModelConfig() {
-        const { options } = this.queryClient.getQueryData(['config']) ?? {};
-        const { modelConfig } = options ?? {};
-        return modelConfig;
-    }
-}
-
 const useKeyTrackerModel = (keyTracker) => {
     const queryClient = useQueryClient();
     const getQueryKey = (innerKeyTracker) => {
@@ -191,6 +103,24 @@ const useQueryModel = (keyTracker, exact = true) => {
     const queryClient = useQueryClient();
     const { getQueryKey } = useKeyTrackerModel(keyTracker);
     const queryKey = getQueryKey();
+    const add = (data, position, path) => {
+        let records = findAll(path) ?? [];
+        if (!position || position === 'end') {
+            records = [...records, data];
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        }
+        else if (position === 'start') {
+            records = [data, ...records];
+        }
+        if (!path) {
+            queryClient.setQueryData(queryKey, records);
+        }
+        else {
+            const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
+            queryClient.setQueryData(queryKey, lodashSet(queryData, path, records));
+        }
+        return data;
+    };
     const findAll = (path) => {
         const data = queryClient.getQueryData(queryKey, { exact });
         if (!data) {
@@ -213,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 ?? {};
@@ -239,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;
     };
@@ -264,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 };
+    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);
@@ -496,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)), {
@@ -668,5 +618,5 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
     return { post, ...mutation };
 };
 
-export { ContentType, HttpMethod, QueryModel, axiosInstance, bootstrapQueryRequest, buildFormData, errorTransformer, getDateInFuture, makeRequest, scrollToTop, successTransformer, useDeleteRequest, useEnvironmentVariables, useGetRequest, useKeyTrackerModel, usePatchRequest, usePostRequest, useQueryConfig, useQueryHeaders, useQueryModel, useReactNativeEnv, useRefetchQuery };
+export { ContentType, HttpMethod, axiosInstance, bootstrapQueryRequest, buildFormData, errorTransformer, getDateInFuture, makeRequest, scrollToTop, successTransformer, useDeleteRequest, useEnvironmentVariables, useGetRequest, useKeyTrackerModel, usePatchRequest, usePostRequest, useQueryConfig, useQueryHeaders, useQueryModel, useReactNativeEnv, useRefetchQuery };
 //# sourceMappingURL=index.mjs.map

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/index.d.ts

@@ -1,4 +1,3 @@
-export * from './Model';
 export * from './model.interface';
 export * from './useKeyTrackerModel';
 export * from './useQueryModel';

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

@@ -1,7 +1,11 @@
 export interface QueryModelBuilder<T> {
+    add: (data: T, position?: QueryModelAddPosition, path?: string) => T | undefined;
     findAll: (path?: string) => T[] | undefined;
     findMany: (selector: (record: T) => boolean, path?: string) => 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,12 +1,30 @@
 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) => {
     const queryClient = useQueryClient();
     const { getQueryKey } = useKeyTrackerModel(keyTracker);
     const queryKey = getQueryKey();
+    const add = (data, position, path) => {
+        let records = findAll(path) ?? [];
+        if (!position || position === 'end') {
+            records = [...records, data];
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        }
+        else if (position === 'start') {
+            records = [data, ...records];
+        }
+        if (!path) {
+            queryClient.setQueryData(queryKey, records);
+        }
+        else {
+            const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
+            queryClient.setQueryData(queryKey, lodashSet(queryData, path, records));
+        }
+        return data;
+    };
     const findAll = (path) => {
         const data = queryClient.getQueryData(queryKey, { exact });
         if (!data) {
@@ -29,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 ?? {};
@@ -55,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;
     };
@@ -80,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 };
+    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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ventlio/tanstack-query",
-  "version": "0.2.64",
+  "version": "0.2.66",
   "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/index.ts

@@ -1,4 +1,3 @@
-export * from './Model';
 export * from './model.interface';
 export * from './useKeyTrackerModel';
 export * from './useQueryModel';

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/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/dist/model/Model.d.ts

@@ -1,14 +0,0 @@
-import type { QueryClient } from '@tanstack/react-query';
-import type { QueryModelBuilder } from './model.interface';
-export declare class QueryModel<T> implements QueryModelBuilder<T> {
-    private readonly queryKey;
-    private readonly queryClient;
-    private readonly exact;
-    constructor(queryKey: any[], queryClient: QueryClient, exact?: boolean);
-    findAll(path?: string): T[] | undefined;
-    findMany(selector: (record: T) => boolean, path?: string): T[];
-    find(id: string | number, path?: string): T | undefined;
-    update(id: string | number, data: Partial<T>, path?: string): T | undefined;
-    remove(id: number | string, path?: string): boolean;
-    private getModelConfig;
-}

package/dist/model/Model.js

@@ -1,93 +0,0 @@
-import result from 'lodash.result';
-import set from 'lodash.set';
-
-class QueryModel {
-    queryKey;
-    queryClient;
-    exact;
-    constructor(queryKey, queryClient, exact = true) {
-        this.queryKey = queryKey;
-        this.queryClient = queryClient;
-        this.exact = exact;
-    }
-    findAll(path) {
-        const data = this.queryClient.getQueryData(this.queryKey, { exact: this.exact });
-        if (!data) {
-            return [];
-        }
-        if (!path) {
-            return Array.isArray(data) ? data : [data];
-        }
-        return result(data, path, []);
-    }
-    findMany(selector, path) {
-        const data = this.findAll(path) ?? [];
-        return data.filter(selector);
-    }
-    find(id, path) {
-        const modelConfig = this.getModelConfig();
-        if (!modelConfig?.idColumn) {
-            return undefined;
-        }
-        const data = this.findAll(path) ?? [];
-        return data.find((record) => record[modelConfig.idColumn] === id);
-    }
-    update(id, data, path) {
-        const oldData = this.findAll(path) ?? [];
-        const modelConfig = this.getModelConfig();
-        if (!modelConfig?.idColumn) {
-            return undefined;
-        }
-        const idColumn = modelConfig.idColumn;
-        let updatedRecord = undefined;
-        const newData = oldData.map((record) => {
-            let dataRecord = record;
-            if (dataRecord[idColumn] === id) {
-                dataRecord = { ...dataRecord, ...data };
-                updatedRecord = dataRecord;
-            }
-            return dataRecord;
-        });
-        if (!path) {
-            this.queryClient.setQueryData(this.queryKey, newData);
-        }
-        else {
-            const queryData = this.queryClient.getQueryData(this.queryKey, { exact: this.exact }) ?? {};
-            this.queryClient.setQueryData(this.queryKey, set(queryData, path, newData));
-        }
-        return updatedRecord;
-    }
-    remove(id, path) {
-        const oldData = this.findAll(path) ?? [];
-        const modelConfig = this.getModelConfig();
-        if (!modelConfig?.idColumn) {
-            return false;
-        }
-        const idColumn = modelConfig.idColumn;
-        let updated = false;
-        const newData = oldData.filter((record) => {
-            const dataRecord = record;
-            if (dataRecord[idColumn] === id) {
-                updated = true;
-                return false;
-            }
-            return true;
-        });
-        if (!path) {
-            this.queryClient.setQueryData(this.queryKey, newData);
-        }
-        else {
-            const queryData = this.queryClient.getQueryData(this.queryKey, { exact: this.exact }) ?? {};
-            this.queryClient.setQueryData(this.queryKey, set(queryData, path, newData));
-        }
-        return updated;
-    }
-    getModelConfig() {
-        const { options } = this.queryClient.getQueryData(['config']) ?? {};
-        const { modelConfig } = options ?? {};
-        return modelConfig;
-    }
-}
-
-export { QueryModel };
-//# sourceMappingURL=Model.js.map

package/dist/model/Model.js.map

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

package/src/model/Model.ts

@@ -1,107 +0,0 @@
-import type { QueryClient } from '@tanstack/react-query';
-import result from 'lodash.result';
-import set from 'lodash.set';
-import type { TanstackQueryConfig } from '../types';
-import type { QueryModelBuilder } from './model.interface';
-
-export class QueryModel<T> implements QueryModelBuilder<T> {
-  constructor(
-    private readonly queryKey: any[],
-    private readonly queryClient: QueryClient,
-    private readonly exact: boolean = true
-  ) {}
-
-  public findAll(path?: string): T[] | undefined {
-    const data = this.queryClient.getQueryData(this.queryKey, { exact: this.exact });
-
-    if (!data) {
-      return [];
-    }
-
-    if (!path) {
-      return Array.isArray(data) ? data : [data];
-    }
-
-    return result<T[]>(data, path, []);
-  }
-
-  public findMany(selector: (record: T) => boolean, path?: string): T[] {
-    const data = this.findAll(path) ?? [];
-    return data.filter(selector);
-  }
-
-  find(id: string | number, path?: string): T | undefined {
-    const modelConfig = this.getModelConfig();
-
-    if (!modelConfig?.idColumn) {
-      return undefined;
-    }
-    const data = this.findAll(path) ?? [];
-
-    return data.find((record) => (record as Record<string, any>)[modelConfig.idColumn] === id);
-  }
-
-  update(id: string | number, data: Partial<T>, path?: string): T | undefined {
-    const oldData = this.findAll(path) ?? [];
-    const modelConfig = this.getModelConfig();
-
-    if (!modelConfig?.idColumn) {
-      return undefined;
-    }
-    const idColumn = modelConfig.idColumn;
-
-    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;
-      }
-
-      return dataRecord;
-    });
-
-    if (!path) {
-      this.queryClient.setQueryData(this.queryKey, newData);
-    } else {
-      const queryData = this.queryClient.getQueryData(this.queryKey, { exact: this.exact }) ?? {};
-      this.queryClient.setQueryData(this.queryKey, set(queryData, path, newData));
-    }
-    return updatedRecord;
-  }
-
-  remove(id: number | string, path?: string): boolean {
-    const oldData = this.findAll(path) ?? [];
-    const modelConfig = this.getModelConfig();
-
-    if (!modelConfig?.idColumn) {
-      return false;
-    }
-    const idColumn = modelConfig.idColumn;
-    let updated = false;
-    const newData = oldData.filter((record) => {
-      const dataRecord = record as Record<string, any>;
-      if (dataRecord[idColumn] === id) {
-        updated = true;
-        return false;
-      }
-      return true;
-    });
-
-    if (!path) {
-      this.queryClient.setQueryData(this.queryKey, newData);
-    } else {
-      const queryData = this.queryClient.getQueryData(this.queryKey, { exact: this.exact }) ?? {};
-      this.queryClient.setQueryData(this.queryKey, set(queryData, path, newData));
-    }
-    return updated;
-  }
-
-  private getModelConfig() {
-    const { options } = this.queryClient.getQueryData<TanstackQueryConfig>(['config']) ?? {};
-    const { modelConfig } = options ?? {};
-
-    return modelConfig;
-  }
-}