@ventlio/tanstack-query 0.3.3 → 0.3.5

package/dist/config/useQueryHeaders.js

@@ -1,23 +1,13 @@
-import { useQueryClient } from '@tanstack/react-query';
-import { useQueryConfig } from './useQueryConfig.js';
+import { useHeaderStore } from '../stores/useHeaderStore.js';
+import '../stores/usePauseFutureRequests.js';
 
 const useQueryHeaders = () => {
-    const queryClient = useQueryClient();
-    const { headers, options } = useQueryConfig();
+    const { headers, setHeader } = useHeaderStore();
     const getHeaders = () => {
         return headers;
     };
     const setQueryHeaders = (newHeaders) => {
-        const defaultMeta = {
-            headers: { ...headers, ...newHeaders },
-            options,
-        };
-        queryClient.setDefaultOptions({
-            queries: {
-                meta: defaultMeta,
-            },
-            mutations: { meta: defaultMeta },
-        });
+        setHeader(newHeaders);
     };
     return { setQueryHeaders, getHeaders };
 };

package/dist/config/useQueryHeaders.js.map

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

package/dist/index.js

@@ -19,5 +19,6 @@ export { buildFormData } from './request/buildFormData.js';
 export { makeRequest } from './request/make-request.js';
 export { ContentType, HttpMethod } from './request/request.enum.js';
 export { errorTransformer, successTransformer } from './request/transformer.js';
+export { useHeaderStore } from './stores/useHeaderStore.js';
 export { usePauseFutureRequests } from './stores/usePauseFutureRequests.js';
 //# sourceMappingURL=index.js.map

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,10 +1,10 @@
 import 'url-search-params-polyfill';
 import { useQueryClient, useQuery, useInfiniteQuery, useMutation } from '@tanstack/react-query';
+import { create } from 'zustand';
 import { useState, useEffect, useMemo, startTransition } from 'react';
 import result from 'lodash.result';
 import lodashSet from 'lodash.set';
 import axios from 'axios';
-import { create } from 'zustand';
 
 const bootstrapQueryRequest = (queryClient, options) => {
     // make query config doesn't expire
@@ -48,23 +48,35 @@ const useEnvironmentVariables = () => {
     };
 };
 
+const useHeaderStore = create((set) => ({
+    headers: undefined,
+    setHeader(headers) {
+        set({ headers });
+    },
+}));
+
+const usePauseFutureRequests = create((set) => {
+    const pauseFutureQueries = (status) => {
+        return set({ isFutureQueriesPaused: status });
+    };
+    const pauseFutureMutation = (status) => {
+        return set({ isFutureQueriesPaused: status });
+    };
+    return {
+        isFutureMutationsPaused: false,
+        isFutureQueriesPaused: false,
+        pauseFutureQueries,
+        pauseFutureMutation,
+    };
+});
+
 const useQueryHeaders = () => {
-    const queryClient = useQueryClient();
-    const { headers, options } = useQueryConfig();
+    const { headers, setHeader } = useHeaderStore();
     const getHeaders = () => {
         return headers;
     };
     const setQueryHeaders = (newHeaders) => {
-        const defaultMeta = {
-            headers: { ...headers, ...newHeaders },
-            options,
-        };
-        queryClient.setDefaultOptions({
-            queries: {
-                meta: defaultMeta,
-            },
-            mutations: { meta: defaultMeta },
-        });
+        setHeader(newHeaders);
     };
     return { setQueryHeaders, getHeaders };
 };
@@ -402,21 +414,6 @@ function getAppFiles(body, fileSelectors = []) {
     return files;
 }
 
-const usePauseFutureRequests = create((set) => {
-    const pauseFutureQueries = (status) => {
-        return set({ isFutureQueriesPaused: status });
-    };
-    const pauseFutureMutation = (status) => {
-        return set({ isFutureQueriesPaused: status });
-    };
-    return {
-        isFutureMutationsPaused: false,
-        isFutureQueriesPaused: false,
-        pauseFutureQueries,
-        pauseFutureMutation,
-    };
-});
-
 const useDeleteRequest = (deleteOptions) => {
     const { baseUrl, headers } = deleteOptions ?? {};
     const [requestPath, setRequestPath] = useState('');
@@ -425,10 +422,8 @@ const useDeleteRequest = (deleteOptions) => {
     const [requestPayload, setRequestPayload] = useState();
     const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
-    const { getHeaders } = useQueryHeaders();
+    const globalHeaders = useHeaderStore((state) => state.headers);
     const sendRequest = async (res, rej, queryKey) => {
-        // get request headers
-        const globalHeaders = getHeaders();
         const [url] = queryKey;
         const requestUrl = (url ?? requestPath);
         const requestOptions = {
@@ -488,7 +483,7 @@ const useDeleteRequest = (deleteOptions) => {
 
 const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
-    const { getHeaders } = useQueryHeaders();
+    const globalHeaders = useHeaderStore((state) => state.headers);
     const [requestPath, setRequestPath] = useState(path);
     const [options, setOptions] = useState(queryOptions);
     const { options: queryConfigOptions } = useQueryConfig();
@@ -500,7 +495,6 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
     const sendRequest = async (res, rej, queryKey, pageParam) => {
         if (load) {
             // get request headers
-            const globalHeaders = getHeaders();
             const requestOptions = {
                 path: pageParam ?? requestPath,
                 headers: { ...globalHeaders, ...headers },
@@ -595,7 +589,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     const [options, setOptions] = useState(queryOptions);
     const [page, setPage] = useState(1);
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
-    const { getHeaders } = useQueryHeaders();
+    const globalHeaders = useHeaderStore((state) => state.headers);
     const { options: queryConfigOptions } = useQueryConfig();
     const [requestPayload, setRequestPayload] = useState();
     const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
@@ -604,8 +598,6 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     queryClient = useMemo(() => queryClient, []);
     const sendRequest = async (res, rej, queryKey) => {
         if (load) {
-            // get request headers
-            const globalHeaders = getHeaders();
             const [url] = queryKey;
             const requestUrl = (url ?? requestPath);
             const requestOptions = {
@@ -729,13 +721,12 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
 const usePatchRequest = ({ path, baseUrl, headers }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
+    const globalHeaders = useHeaderStore((state) => state.headers);
     const [requestPayload, setRequestPayload] = useState();
     const isFutureMutationsPaused = usePauseFutureRequests((state) => state.isFutureMutationsPaused);
-    const { getHeaders } = useQueryHeaders();
     const config = useQueryConfig();
     const sendRequest = async (res, rej, data) => {
         // get request headers
-        const globalHeaders = getHeaders();
         const requestOptions = {
             path: path,
             body: data,
@@ -799,14 +790,13 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
 const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelectors, }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const config = useQueryConfig();
-    const { getHeaders } = useQueryHeaders();
+    const globalHeaders = useHeaderStore((state) => state.headers);
     const { isApp } = useReactNativeEnv();
     const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
     const [requestPayload, setRequestPayload] = useState();
     const isFutureMutationsPaused = usePauseFutureRequests((state) => state.isFutureMutationsPaused);
     const sendRequest = async (res, rej, postData) => {
         // get request headers
-        const globalHeaders = getHeaders();
         const { data, requestConfig } = postData;
         delete requestConfig?.body;
         const requestOptions = {
@@ -876,5 +866,5 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
     return { post, uploadProgressPercent, ...mutation, isLoading: mutation.isLoading || isFutureMutationsPaused };
 };
 
-export { ContentType, HttpMethod, axiosInstance, bootstrapQueryRequest, buildFormData, errorTransformer, getDateInFuture, makeRequest, scrollToTop, successTransformer, useDeleteRequest, useEnvironmentVariables, useGetInfiniteRequest, useGetRequest, useKeyTrackerModel, usePatchRequest, usePauseFutureRequests, usePostRequest, useQueryConfig, useQueryHeaders, useQueryModel, useReactNativeEnv, useRefetchQuery, useUploadProgress };
+export { ContentType, HttpMethod, axiosInstance, bootstrapQueryRequest, buildFormData, errorTransformer, getDateInFuture, makeRequest, scrollToTop, successTransformer, useDeleteRequest, useEnvironmentVariables, useGetInfiniteRequest, useGetRequest, useHeaderStore, useKeyTrackerModel, usePatchRequest, usePauseFutureRequests, usePostRequest, useQueryConfig, useQueryHeaders, useQueryModel, useReactNativeEnv, useRefetchQuery, useUploadProgress };
 //# 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/useQueryModel.js

@@ -3,6 +3,8 @@ import result from 'lodash.result';
 import lodashSet from 'lodash.set';
 import 'url-search-params-polyfill';
 import { useQueryConfig } from '../config/useQueryConfig.js';
+import '../stores/useHeaderStore.js';
+import '../stores/usePauseFutureRequests.js';
 import { useKeyTrackerModel } from './useKeyTrackerModel.js';
 
 const useQueryModel = (keyTracker, exact = true) => {

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/queries/useDeleteRequest.js

@@ -3,11 +3,11 @@ import { useState, useEffect } from 'react';
 import 'url-search-params-polyfill';
 import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
 import { useQueryConfig } from '../config/useQueryConfig.js';
-import { useQueryHeaders } from '../config/useQueryHeaders.js';
+import { useHeaderStore } from '../stores/useHeaderStore.js';
+import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
 import 'axios';
 import { makeRequest } from '../request/make-request.js';
 import { HttpMethod } from '../request/request.enum.js';
-import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
 
 const useDeleteRequest = (deleteOptions) => {
     const { baseUrl, headers } = deleteOptions ?? {};
@@ -17,10 +17,8 @@ const useDeleteRequest = (deleteOptions) => {
     const [requestPayload, setRequestPayload] = useState();
     const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
-    const { getHeaders } = useQueryHeaders();
+    const globalHeaders = useHeaderStore((state) => state.headers);
     const sendRequest = async (res, rej, queryKey) => {
-        // get request headers
-        const globalHeaders = getHeaders();
         const [url] = queryKey;
         const requestUrl = (url ?? requestPath);
         const requestOptions = {

package/dist/queries/useDeleteRequest.js.map

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

package/dist/queries/useGetInfiniteRequest.js

@@ -3,15 +3,15 @@ import { useState, useMemo, useEffect, startTransition } from 'react';
 import 'url-search-params-polyfill';
 import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
 import { useQueryConfig } from '../config/useQueryConfig.js';
-import { useQueryHeaders } from '../config/useQueryHeaders.js';
+import { useHeaderStore } from '../stores/useHeaderStore.js';
+import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
 import 'axios';
 import { makeRequest } from '../request/make-request.js';
 import '../request/request.enum.js';
-import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
 
 const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
-    const { getHeaders } = useQueryHeaders();
+    const globalHeaders = useHeaderStore((state) => state.headers);
     const [requestPath, setRequestPath] = useState(path);
     const [options, setOptions] = useState(queryOptions);
     const { options: queryConfigOptions } = useQueryConfig();
@@ -23,7 +23,6 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
     const sendRequest = async (res, rej, queryKey, pageParam) => {
         if (load) {
             // get request headers
-            const globalHeaders = getHeaders();
             const requestOptions = {
                 path: pageParam ?? requestPath,
                 headers: { ...globalHeaders, ...headers },

package/dist/queries/useGetInfiniteRequest.js.map

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

package/dist/queries/useGetRequest.js

@@ -3,18 +3,18 @@ import { useState, useMemo, useEffect, startTransition } from 'react';
 import 'url-search-params-polyfill';
 import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
 import { useQueryConfig } from '../config/useQueryConfig.js';
-import { useQueryHeaders } from '../config/useQueryHeaders.js';
+import { useHeaderStore } from '../stores/useHeaderStore.js';
+import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
 import 'axios';
 import { makeRequest } from '../request/make-request.js';
 import '../request/request.enum.js';
-import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
 
 const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
     const [requestPath, setRequestPath] = useState(path);
     const [options, setOptions] = useState(queryOptions);
     const [page, setPage] = useState(1);
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
-    const { getHeaders } = useQueryHeaders();
+    const globalHeaders = useHeaderStore((state) => state.headers);
     const { options: queryConfigOptions } = useQueryConfig();
     const [requestPayload, setRequestPayload] = useState();
     const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
@@ -23,8 +23,6 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     queryClient = useMemo(() => queryClient, []);
     const sendRequest = async (res, rej, queryKey) => {
         if (load) {
-            // get request headers
-            const globalHeaders = getHeaders();
             const [url] = queryKey;
             const requestUrl = (url ?? requestPath);
             const requestOptions = {

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

@@ -3,24 +3,23 @@ import { useState, useEffect } from 'react';
 import 'url-search-params-polyfill';
 import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
 import { useQueryConfig } from '../config/useQueryConfig.js';
-import { useQueryHeaders } from '../config/useQueryHeaders.js';
+import { useHeaderStore } from '../stores/useHeaderStore.js';
+import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
 import { scrollToTop } from '../helpers/scrollToTop.js';
 import { useUploadProgress } from '../hooks/useUploadProgress.js';
 import 'axios';
 import { makeRequest } from '../request/make-request.js';
 import { HttpMethod } from '../request/request.enum.js';
-import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
 
 const usePatchRequest = ({ path, baseUrl, headers }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
+    const globalHeaders = useHeaderStore((state) => state.headers);
     const [requestPayload, setRequestPayload] = useState();
     const isFutureMutationsPaused = usePauseFutureRequests((state) => state.isFutureMutationsPaused);
-    const { getHeaders } = useQueryHeaders();
     const config = useQueryConfig();
     const sendRequest = async (res, rej, data) => {
         // get request headers
-        const globalHeaders = getHeaders();
         const requestOptions = {
             path: path,
             body: data,

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/dist/queries/usePostRequest.js

@@ -2,7 +2,8 @@ import { useMutation } from '@tanstack/react-query';
 import 'url-search-params-polyfill';
 import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
 import { useQueryConfig } from '../config/useQueryConfig.js';
-import { useQueryHeaders } from '../config/useQueryHeaders.js';
+import { useHeaderStore } from '../stores/useHeaderStore.js';
+import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
 import { useReactNativeEnv } from '../config/useReactNativeEnv.js';
 import { useState, useEffect } from 'react';
 import { scrollToTop } from '../helpers/scrollToTop.js';
@@ -10,19 +11,17 @@ import { useUploadProgress } from '../hooks/useUploadProgress.js';
 import 'axios';
 import { makeRequest } from '../request/make-request.js';
 import { HttpMethod } from '../request/request.enum.js';
-import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
 
 const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelectors, }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const config = useQueryConfig();
-    const { getHeaders } = useQueryHeaders();
+    const globalHeaders = useHeaderStore((state) => state.headers);
     const { isApp } = useReactNativeEnv();
     const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
     const [requestPayload, setRequestPayload] = useState();
     const isFutureMutationsPaused = usePauseFutureRequests((state) => state.isFutureMutationsPaused);
     const sendRequest = async (res, rej, postData) => {
         // get request headers
-        const globalHeaders = getHeaders();
         const { data, requestConfig } = postData;
         delete requestConfig?.body;
         const requestOptions = {

package/dist/queries/usePostRequest.js.map

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

package/dist/stores/index.d.ts

@@ -1 +1,2 @@
+export * from './useHeaderStore';
 export * from './usePauseFutureRequests';

package/dist/stores/useHeaderStore.d.ts

@@ -0,0 +1,7 @@
+import type { QueryHeaders } from '../types';
+interface IUserHeaders {
+    headers: QueryHeaders | undefined;
+    setHeader: (headers: QueryHeaders) => void;
+}
+export declare const useHeaderStore: import("zustand").UseBoundStore<import("zustand").StoreApi<IUserHeaders>>;
+export {};

package/dist/stores/useHeaderStore.js

@@ -0,0 +1,11 @@
+import { create } from 'zustand';
+
+const useHeaderStore = create((set) => ({
+    headers: undefined,
+    setHeader(headers) {
+        set({ headers });
+    },
+}));
+
+export { useHeaderStore };
+//# sourceMappingURL=useHeaderStore.js.map

package/dist/stores/useHeaderStore.js.map

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

package/dist/types/index.d.ts

@@ -20,10 +20,10 @@ export interface BootstrapModelConfig {
 }
 export type ContextType = 'app' | 'web' | 'electronjs';
 export interface TanstackQueryConfig {
-    headers: RawAxiosRequestHeaders;
     options?: BootstrapConfig;
 }
 export interface IUseQueryHeaders {
-    getHeaders: () => TanstackQueryConfig['headers'];
-    setQueryHeaders: (header: TanstackQueryConfig['headers']) => void;
+    getHeaders: () => QueryHeaders;
+    setQueryHeaders: (header: QueryHeaders) => void;
 }
+export type QueryHeaders = RawAxiosRequestHeaders | undefined;

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@ventlio/tanstack-query",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "license": "MIT",
   "main": "dist/index.js",
   "contributors": [
     {
-      "email": "soromgawide@gmail.com",
+      "email": "stancoproof@gmail.com",
       "name": "stancobridge",
       "url": "https://github.com/stancobridge"
     }

package/src/config/useQueryHeaders.ts

@@ -1,27 +1,15 @@
-import { useQueryClient } from '@tanstack/react-query';
-import type { IUseQueryHeaders, TanstackQueryConfig } from '../types';
-import { useQueryConfig } from './useQueryConfig';
+import { useHeaderStore } from '../stores';
+import type { IUseQueryHeaders, QueryHeaders } from '../types';
 
 export const useQueryHeaders = (): IUseQueryHeaders => {
-  const queryClient = useQueryClient();
-  const { headers, options } = useQueryConfig();
+  const { headers, setHeader } = useHeaderStore();
 
-  const getHeaders = (): TanstackQueryConfig['headers'] => {
+  const getHeaders = (): QueryHeaders => {
     return headers;
   };
 
-  const setQueryHeaders = (newHeaders: TanstackQueryConfig['headers']) => {
-    const defaultMeta = {
-      headers: { ...headers, ...newHeaders },
-      options,
-    };
-
-    queryClient.setDefaultOptions({
-      queries: {
-        meta: defaultMeta,
-      },
-      mutations: { meta: defaultMeta },
-    });
+  const setQueryHeaders = (newHeaders: QueryHeaders) => {
+    setHeader(newHeaders);
   };
 
   return { setQueryHeaders, getHeaders };

package/src/queries/useDeleteRequest.ts

@@ -1,11 +1,10 @@
 import type { QueryKey, UseQueryOptions } from '@tanstack/react-query';
 import { useQuery } from '@tanstack/react-query';
-import type { RawAxiosRequestHeaders } from 'axios';
 import { useEffect, useState } from 'react';
-import { useEnvironmentVariables, useQueryConfig, useQueryHeaders } from '../config';
+import { useEnvironmentVariables, useQueryConfig } from '../config';
 import type { IRequestError, IRequestSuccess } from '../request';
 import { HttpMethod, makeRequest } from '../request';
-import { usePauseFutureRequests } from '../stores';
+import { useHeaderStore, usePauseFutureRequests } from '../stores';
 import type { DefaultRequestOptions } from './queries.interface';
 
 export const useDeleteRequest = <TResponse>(deleteOptions?: DefaultRequestOptions) => {
@@ -20,12 +19,9 @@ export const useDeleteRequest = <TResponse>(deleteOptions?: DefaultRequestOption
 
   const { API_URL, TIMEOUT } = useEnvironmentVariables();
 
-  const { getHeaders } = useQueryHeaders();
+  const globalHeaders = useHeaderStore((state) => state.headers);
 
   const sendRequest = async (res: (value: any) => void, rej: (reason?: any) => void, queryKey: QueryKey) => {
-    // get request headers
-    const globalHeaders: RawAxiosRequestHeaders = getHeaders();
-
     const [url] = queryKey;
     const requestUrl = (url ?? requestPath) as string;
 

package/src/queries/useGetInfiniteRequest.ts

@@ -1,12 +1,11 @@
 import type { InfiniteData, QueryKey, UseQueryOptions } from '@tanstack/react-query';
 import { useInfiniteQuery, useQueryClient } from '@tanstack/react-query';
-import type { RawAxiosRequestHeaders } from 'axios';
 import { startTransition, useEffect, useMemo, useState } from 'react';
-import { useEnvironmentVariables, useQueryConfig, useQueryHeaders } from '../config';
+import { useEnvironmentVariables, useQueryConfig } from '../config';
 
 import type { IRequestError, IRequestSuccess } from '../request';
 import { makeRequest } from '../request';
-import { usePauseFutureRequests } from '../stores';
+import { useHeaderStore, usePauseFutureRequests } from '../stores';
 import type { DefaultRequestOptions, TanstackInfiniteQueryOption } from './queries.interface';
 
 interface Pagination {
@@ -32,7 +31,7 @@ export const useGetInfiniteRequest = <TResponse extends Record<string, any>>({
   keyTracker?: string;
 } & DefaultRequestOptions) => {
   const { API_URL, TIMEOUT } = useEnvironmentVariables();
-  const { getHeaders } = useQueryHeaders();
+  const globalHeaders = useHeaderStore((state) => state.headers);
   const [requestPath, setRequestPath] = useState<string>(path);
 
   const [options, setOptions] = useState<any>(queryOptions);
@@ -59,7 +58,6 @@ export const useGetInfiniteRequest = <TResponse extends Record<string, any>>({
   ) => {
     if (load) {
       // get request headers
-      const globalHeaders: RawAxiosRequestHeaders = getHeaders();
 
       const requestOptions = {
         path: pageParam ?? requestPath,

package/src/queries/useGetRequest.ts

@@ -1,12 +1,11 @@
 import type { QueryKey, UseQueryOptions } from '@tanstack/react-query';
 import { useQuery, useQueryClient } from '@tanstack/react-query';
 import { startTransition, useEffect, useMemo, useState } from 'react';
-import type { RawAxiosRequestHeaders } from '../../node_modules/axios/index';
-import { useEnvironmentVariables, useQueryConfig, useQueryHeaders } from '../config';
+import { useEnvironmentVariables, useQueryConfig } from '../config';
 
 import type { IRequestError, IRequestSuccess } from '../request';
 import { makeRequest } from '../request';
-import { usePauseFutureRequests } from '../stores';
+import { useHeaderStore, usePauseFutureRequests } from '../stores';
 import type { DefaultRequestOptions, IPagination, TanstackQueryOption } from './queries.interface';
 
 export const useGetRequest = <TResponse extends Record<string, any>>({
@@ -27,7 +26,8 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
   const [page, setPage] = useState<number>(1);
 
   const { API_URL, TIMEOUT } = useEnvironmentVariables();
-  const { getHeaders } = useQueryHeaders();
+  const globalHeaders = useHeaderStore((state) => state.headers);
+
   const { options: queryConfigOptions } = useQueryConfig();
   const [requestPayload, setRequestPayload] = useState<Record<any, any>>();
 
@@ -46,9 +46,6 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
     queryKey: QueryKey
   ) => {
     if (load) {
-      // get request headers
-      const globalHeaders: RawAxiosRequestHeaders = getHeaders();
-
       const [url] = queryKey;
       const requestUrl = (url ?? requestPath) as string;
 

package/src/queries/usePatchRequest.ts

@@ -1,30 +1,27 @@
 import type { MutateOptions } from '@tanstack/react-query';
 import { useMutation } from '@tanstack/react-query';
-import type { RawAxiosRequestHeaders } from 'axios';
 import { useEffect, useState } from 'react';
-import { useEnvironmentVariables, useQueryConfig, useQueryHeaders } from '../config';
+import { useEnvironmentVariables, useQueryConfig } from '../config';
 import { scrollToTop } from '../helpers';
 import { useUploadProgress } from '../hooks';
 import { HttpMethod, makeRequest } from '../request';
 import type { IRequestError, IRequestSuccess } from '../request/request.interface';
-import { usePauseFutureRequests } from '../stores';
+import { useHeaderStore, usePauseFutureRequests } from '../stores';
 import type { DefaultRequestOptions } from './queries.interface';
 
 export const usePatchRequest = <TResponse>({ path, baseUrl, headers }: { path: string } & DefaultRequestOptions) => {
   const { API_URL, TIMEOUT } = useEnvironmentVariables();
   const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
+  const globalHeaders = useHeaderStore((state) => state.headers);
 
   const [requestPayload, setRequestPayload] = useState<Record<any, any>>();
 
   const isFutureMutationsPaused = usePauseFutureRequests((state) => state.isFutureMutationsPaused);
 
-  const { getHeaders } = useQueryHeaders();
-
   const config = useQueryConfig();
 
   const sendRequest = async (res: (value: any) => void, rej: (reason?: any) => void, data: any) => {
     // get request headers
-    const globalHeaders: RawAxiosRequestHeaders = getHeaders();
 
     const requestOptions = {
       path: path,

package/src/queries/usePostRequest.ts

@@ -1,14 +1,13 @@
 import type { MutateOptions } from '@tanstack/react-query';
 import { useMutation } from '@tanstack/react-query';
-import { useEnvironmentVariables, useQueryConfig, useQueryHeaders, useReactNativeEnv } from '../config';
+import { useEnvironmentVariables, useQueryConfig, useReactNativeEnv } from '../config';
 
-import type { RawAxiosRequestHeaders } from 'axios';
 import { useEffect, useState } from 'react';
 import { scrollToTop } from '../helpers';
 import { useUploadProgress } from '../hooks';
 import type { IMakeRequest, IRequestError, IRequestSuccess } from '../request';
 import { HttpMethod, makeRequest } from '../request';
-import { usePauseFutureRequests } from '../stores';
+import { useHeaderStore, usePauseFutureRequests } from '../stores';
 import type { DefaultRequestOptions } from './queries.interface';
 
 export const usePostRequest = <TResponse>({
@@ -26,7 +25,7 @@ export const usePostRequest = <TResponse>({
 
   const config = useQueryConfig();
 
-  const { getHeaders } = useQueryHeaders();
+  const globalHeaders = useHeaderStore((state) => state.headers);
   const { isApp } = useReactNativeEnv();
   const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
   const [requestPayload, setRequestPayload] = useState<Record<any, any>>();
@@ -39,7 +38,6 @@ export const usePostRequest = <TResponse>({
     postData: { data: any; requestConfig?: Partial<IMakeRequest> }
   ) => {
     // get request headers
-    const globalHeaders: RawAxiosRequestHeaders = getHeaders();
 
     const { data, requestConfig } = postData;
 

package/src/stores/index.ts

@@ -1 +1,2 @@
+export * from './useHeaderStore';
 export * from './usePauseFutureRequests';

package/src/stores/useHeaderStore.ts

@@ -0,0 +1,13 @@
+import { create } from 'zustand';
+import type { QueryHeaders } from '../types';
+
+interface IUserHeaders {
+  headers: QueryHeaders | undefined;
+  setHeader: (headers: QueryHeaders) => void;
+}
+export const useHeaderStore = create<IUserHeaders>((set) => ({
+  headers: undefined,
+  setHeader(headers) {
+    set({ headers });
+  },
+}));

package/src/types/index.ts

@@ -19,11 +19,12 @@ export interface BootstrapModelConfig {
 
 export type ContextType = 'app' | 'web' | 'electronjs';
 export interface TanstackQueryConfig {
-  headers: RawAxiosRequestHeaders;
   options?: BootstrapConfig;
 }
 
 export interface IUseQueryHeaders {
-  getHeaders: () => TanstackQueryConfig['headers'];
-  setQueryHeaders: (header: TanstackQueryConfig['headers']) => void;
+  getHeaders: () => QueryHeaders;
+  setQueryHeaders: (header: QueryHeaders) => void;
 }
+
+export type QueryHeaders = RawAxiosRequestHeaders | undefined;