@ventlio/tanstack-query 0.3.4 → 0.3.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (18) hide show
  1. package/dist/index.mjs +5 -12
  2. package/dist/index.mjs.map +1 -1
  3. package/dist/queries/useDeleteRequest.js +3 -6
  4. package/dist/queries/useDeleteRequest.js.map +1 -1
  5. package/dist/queries/useGetInfiniteRequest.js +3 -5
  6. package/dist/queries/useGetInfiniteRequest.js.map +1 -1
  7. package/dist/queries/useGetRequest.js +3 -6
  8. package/dist/queries/useGetRequest.js.map +1 -1
  9. package/dist/queries/usePatchRequest.js +3 -5
  10. package/dist/queries/usePatchRequest.js.map +1 -1
  11. package/dist/queries/usePostRequest.js +3 -5
  12. package/dist/queries/usePostRequest.js.map +1 -1
  13. package/package.json +1 -1
  14. package/src/queries/useDeleteRequest.ts +3 -7
  15. package/src/queries/useGetInfiniteRequest.ts +3 -5
  16. package/src/queries/useGetRequest.ts +13 -11
  17. package/src/queries/usePatchRequest.ts +3 -6
  18. package/src/queries/usePostRequest.ts +3 -5
package/dist/index.mjs CHANGED
@@ -422,10 +422,8 @@ const useDeleteRequest = (deleteOptions) => {
422
422
  const [requestPayload, setRequestPayload] = useState();
423
423
  const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
424
424
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
425
- const { getHeaders } = useQueryHeaders();
425
+ const globalHeaders = useHeaderStore((state) => state.headers);
426
426
  const sendRequest = async (res, rej, queryKey) => {
427
- // get request headers
428
- const globalHeaders = getHeaders();
429
427
  const [url] = queryKey;
430
428
  const requestUrl = (url ?? requestPath);
431
429
  const requestOptions = {
@@ -485,7 +483,7 @@ const useDeleteRequest = (deleteOptions) => {
485
483
 
486
484
  const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
487
485
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
488
- const { getHeaders } = useQueryHeaders();
486
+ const globalHeaders = useHeaderStore((state) => state.headers);
489
487
  const [requestPath, setRequestPath] = useState(path);
490
488
  const [options, setOptions] = useState(queryOptions);
491
489
  const { options: queryConfigOptions } = useQueryConfig();
@@ -497,7 +495,6 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
497
495
  const sendRequest = async (res, rej, queryKey, pageParam) => {
498
496
  if (load) {
499
497
  // get request headers
500
- const globalHeaders = getHeaders();
501
498
  const requestOptions = {
502
499
  path: pageParam ?? requestPath,
503
500
  headers: { ...globalHeaders, ...headers },
@@ -592,7 +589,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
592
589
  const [options, setOptions] = useState(queryOptions);
593
590
  const [page, setPage] = useState(1);
594
591
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
595
- const { getHeaders } = useQueryHeaders();
592
+ const globalHeaders = useHeaderStore((state) => state.headers);
596
593
  const { options: queryConfigOptions } = useQueryConfig();
597
594
  const [requestPayload, setRequestPayload] = useState();
598
595
  const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
@@ -601,8 +598,6 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
601
598
  queryClient = useMemo(() => queryClient, []);
602
599
  const sendRequest = async (res, rej, queryKey) => {
603
600
  if (load) {
604
- // get request headers
605
- const globalHeaders = getHeaders();
606
601
  const [url] = queryKey;
607
602
  const requestUrl = (url ?? requestPath);
608
603
  const requestOptions = {
@@ -726,13 +721,12 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
726
721
  const usePatchRequest = ({ path, baseUrl, headers }) => {
727
722
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
728
723
  const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
724
+ const globalHeaders = useHeaderStore((state) => state.headers);
729
725
  const [requestPayload, setRequestPayload] = useState();
730
726
  const isFutureMutationsPaused = usePauseFutureRequests((state) => state.isFutureMutationsPaused);
731
- const { getHeaders } = useQueryHeaders();
732
727
  const config = useQueryConfig();
733
728
  const sendRequest = async (res, rej, data) => {
734
729
  // get request headers
735
- const globalHeaders = getHeaders();
736
730
  const requestOptions = {
737
731
  path: path,
738
732
  body: data,
@@ -796,14 +790,13 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
796
790
  const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelectors, }) => {
797
791
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
798
792
  const config = useQueryConfig();
799
- const { getHeaders } = useQueryHeaders();
793
+ const globalHeaders = useHeaderStore((state) => state.headers);
800
794
  const { isApp } = useReactNativeEnv();
801
795
  const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
802
796
  const [requestPayload, setRequestPayload] = useState();
803
797
  const isFutureMutationsPaused = usePauseFutureRequests((state) => state.isFutureMutationsPaused);
804
798
  const sendRequest = async (res, rej, postData) => {
805
799
  // get request headers
806
- const globalHeaders = getHeaders();
807
800
  const { data, requestConfig } = postData;
808
801
  delete requestConfig?.body;
809
802
  const requestOptions = {
package/dist/index.mjs.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
1
+ {"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
package/dist/queries/useDeleteRequest.js CHANGED
@@ -3,12 +3,11 @@ import { useState, useEffect } from 'react';
3
3
  import 'url-search-params-polyfill';
4
4
  import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
5
5
  import { useQueryConfig } from '../config/useQueryConfig.js';
6
- import { useQueryHeaders } from '../config/useQueryHeaders.js';
6
+ import { useHeaderStore } from '../stores/useHeaderStore.js';
7
+ import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
7
8
  import 'axios';
8
9
  import { makeRequest } from '../request/make-request.js';
9
10
  import { HttpMethod } from '../request/request.enum.js';
10
- import '../stores/useHeaderStore.js';
11
- import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
12
11
 
13
12
  const useDeleteRequest = (deleteOptions) => {
14
13
  const { baseUrl, headers } = deleteOptions ?? {};
@@ -18,10 +17,8 @@ const useDeleteRequest = (deleteOptions) => {
18
17
  const [requestPayload, setRequestPayload] = useState();
19
18
  const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
20
19
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
21
- const { getHeaders } = useQueryHeaders();
20
+ const globalHeaders = useHeaderStore((state) => state.headers);
22
21
  const sendRequest = async (res, rej, queryKey) => {
23
- // get request headers
24
- const globalHeaders = getHeaders();
25
22
  const [url] = queryKey;
26
23
  const requestUrl = (url ?? requestPath);
27
24
  const requestOptions = {
package/dist/queries/useDeleteRequest.js.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"useDeleteRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
1
+ {"version":3,"file":"useDeleteRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
package/dist/queries/useGetInfiniteRequest.js CHANGED
@@ -3,16 +3,15 @@ import { useState, useMemo, useEffect, startTransition } from 'react';
3
3
  import 'url-search-params-polyfill';
4
4
  import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
5
5
  import { useQueryConfig } from '../config/useQueryConfig.js';
6
- import { useQueryHeaders } from '../config/useQueryHeaders.js';
6
+ import { useHeaderStore } from '../stores/useHeaderStore.js';
7
+ import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
7
8
  import 'axios';
8
9
  import { makeRequest } from '../request/make-request.js';
9
10
  import '../request/request.enum.js';
10
- import '../stores/useHeaderStore.js';
11
- import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
12
11
 
13
12
  const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
14
13
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
15
- const { getHeaders } = useQueryHeaders();
14
+ const globalHeaders = useHeaderStore((state) => state.headers);
16
15
  const [requestPath, setRequestPath] = useState(path);
17
16
  const [options, setOptions] = useState(queryOptions);
18
17
  const { options: queryConfigOptions } = useQueryConfig();
@@ -24,7 +23,6 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
24
23
  const sendRequest = async (res, rej, queryKey, pageParam) => {
25
24
  if (load) {
26
25
  // get request headers
27
- const globalHeaders = getHeaders();
28
26
  const requestOptions = {
29
27
  path: pageParam ?? requestPath,
30
28
  headers: { ...globalHeaders, ...headers },
package/dist/queries/useGetInfiniteRequest.js.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"useGetInfiniteRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
1
+ {"version":3,"file":"useGetInfiniteRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
package/dist/queries/useGetRequest.js CHANGED
@@ -3,19 +3,18 @@ import { useState, useMemo, useEffect, startTransition } from 'react';
3
3
  import 'url-search-params-polyfill';
4
4
  import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
5
5
  import { useQueryConfig } from '../config/useQueryConfig.js';
6
- import { useQueryHeaders } from '../config/useQueryHeaders.js';
6
+ import { useHeaderStore } from '../stores/useHeaderStore.js';
7
+ import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
7
8
  import 'axios';
8
9
  import { makeRequest } from '../request/make-request.js';
9
10
  import '../request/request.enum.js';
10
- import '../stores/useHeaderStore.js';
11
- import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
12
11
 
13
12
  const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
14
13
  const [requestPath, setRequestPath] = useState(path);
15
14
  const [options, setOptions] = useState(queryOptions);
16
15
  const [page, setPage] = useState(1);
17
16
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
18
- const { getHeaders } = useQueryHeaders();
17
+ const globalHeaders = useHeaderStore((state) => state.headers);
19
18
  const { options: queryConfigOptions } = useQueryConfig();
20
19
  const [requestPayload, setRequestPayload] = useState();
21
20
  const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
@@ -24,8 +23,6 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
24
23
  queryClient = useMemo(() => queryClient, []);
25
24
  const sendRequest = async (res, rej, queryKey) => {
26
25
  if (load) {
27
- // get request headers
28
- const globalHeaders = getHeaders();
29
26
  const [url] = queryKey;
30
27
  const requestUrl = (url ?? requestPath);
31
28
  const requestOptions = {
package/dist/queries/useGetRequest.js.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"useGetRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
1
+ {"version":3,"file":"useGetRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
package/dist/queries/usePatchRequest.js CHANGED
@@ -3,25 +3,23 @@ import { useState, useEffect } from 'react';
3
3
  import 'url-search-params-polyfill';
4
4
  import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
5
5
  import { useQueryConfig } from '../config/useQueryConfig.js';
6
- import { useQueryHeaders } from '../config/useQueryHeaders.js';
6
+ import { useHeaderStore } from '../stores/useHeaderStore.js';
7
+ import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
7
8
  import { scrollToTop } from '../helpers/scrollToTop.js';
8
9
  import { useUploadProgress } from '../hooks/useUploadProgress.js';
9
10
  import 'axios';
10
11
  import { makeRequest } from '../request/make-request.js';
11
12
  import { HttpMethod } from '../request/request.enum.js';
12
- import '../stores/useHeaderStore.js';
13
- import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
14
13
 
15
14
  const usePatchRequest = ({ path, baseUrl, headers }) => {
16
15
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
17
16
  const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
17
+ const globalHeaders = useHeaderStore((state) => state.headers);
18
18
  const [requestPayload, setRequestPayload] = useState();
19
19
  const isFutureMutationsPaused = usePauseFutureRequests((state) => state.isFutureMutationsPaused);
20
- const { getHeaders } = useQueryHeaders();
21
20
  const config = useQueryConfig();
22
21
  const sendRequest = async (res, rej, data) => {
23
22
  // get request headers
24
- const globalHeaders = getHeaders();
25
23
  const requestOptions = {
26
24
  path: path,
27
25
  body: data,
package/dist/queries/usePatchRequest.js.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"usePatchRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
1
+ {"version":3,"file":"usePatchRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
package/dist/queries/usePostRequest.js CHANGED
@@ -2,7 +2,8 @@ import { useMutation } from '@tanstack/react-query';
2
2
  import 'url-search-params-polyfill';
3
3
  import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
4
4
  import { useQueryConfig } from '../config/useQueryConfig.js';
5
- import { useQueryHeaders } from '../config/useQueryHeaders.js';
5
+ import { useHeaderStore } from '../stores/useHeaderStore.js';
6
+ import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
6
7
  import { useReactNativeEnv } from '../config/useReactNativeEnv.js';
7
8
  import { useState, useEffect } from 'react';
8
9
  import { scrollToTop } from '../helpers/scrollToTop.js';
@@ -10,20 +11,17 @@ import { useUploadProgress } from '../hooks/useUploadProgress.js';
10
11
  import 'axios';
11
12
  import { makeRequest } from '../request/make-request.js';
12
13
  import { HttpMethod } from '../request/request.enum.js';
13
- import '../stores/useHeaderStore.js';
14
- import { usePauseFutureRequests } from '../stores/usePauseFutureRequests.js';
15
14
 
16
15
  const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelectors, }) => {
17
16
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
18
17
  const config = useQueryConfig();
19
- const { getHeaders } = useQueryHeaders();
18
+ const globalHeaders = useHeaderStore((state) => state.headers);
20
19
  const { isApp } = useReactNativeEnv();
21
20
  const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
22
21
  const [requestPayload, setRequestPayload] = useState();
23
22
  const isFutureMutationsPaused = usePauseFutureRequests((state) => state.isFutureMutationsPaused);
24
23
  const sendRequest = async (res, rej, postData) => {
25
24
  // get request headers
26
- const globalHeaders = getHeaders();
27
25
  const { data, requestConfig } = postData;
28
26
  delete requestConfig?.body;
29
27
  const requestOptions = {
package/dist/queries/usePostRequest.js.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"usePostRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
1
+ {"version":3,"file":"usePostRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@ventlio/tanstack-query",
3
- "version": "0.3.4",
3
+ "version": "0.3.6",
4
4
  "license": "MIT",
5
5
  "main": "dist/index.js",
6
6
  "contributors": [
package/src/queries/useDeleteRequest.ts CHANGED
@@ -1,11 +1,10 @@
1
1
  import type { QueryKey, UseQueryOptions } from '@tanstack/react-query';
2
2
  import { useQuery } from '@tanstack/react-query';
3
- import type { RawAxiosRequestHeaders } from 'axios';
4
3
  import { useEffect, useState } from 'react';
5
- import { useEnvironmentVariables, useQueryConfig, useQueryHeaders } from '../config';
4
+ import { useEnvironmentVariables, useQueryConfig } from '../config';
6
5
  import type { IRequestError, IRequestSuccess } from '../request';
7
6
  import { HttpMethod, makeRequest } from '../request';
8
- import { usePauseFutureRequests } from '../stores';
7
+ import { useHeaderStore, usePauseFutureRequests } from '../stores';
9
8
  import type { DefaultRequestOptions } from './queries.interface';
10
9
 
11
10
  export const useDeleteRequest = <TResponse>(deleteOptions?: DefaultRequestOptions) => {
@@ -20,12 +19,9 @@ export const useDeleteRequest = <TResponse>(deleteOptions?: DefaultRequestOption
20
19
 
21
20
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
22
21
 
23
- const { getHeaders } = useQueryHeaders();
22
+ const globalHeaders = useHeaderStore((state) => state.headers);
24
23
 
25
24
  const sendRequest = async (res: (value: any) => void, rej: (reason?: any) => void, queryKey: QueryKey) => {
26
- // get request headers
27
- const globalHeaders: RawAxiosRequestHeaders | undefined = getHeaders();
28
-
29
25
  const [url] = queryKey;
30
26
  const requestUrl = (url ?? requestPath) as string;
31
27
 
package/src/queries/useGetInfiniteRequest.ts CHANGED
@@ -1,12 +1,11 @@
1
1
  import type { InfiniteData, QueryKey, UseQueryOptions } from '@tanstack/react-query';
2
2
  import { useInfiniteQuery, useQueryClient } from '@tanstack/react-query';
3
- import type { RawAxiosRequestHeaders } from 'axios';
4
3
  import { startTransition, useEffect, useMemo, useState } from 'react';
5
- import { useEnvironmentVariables, useQueryConfig, useQueryHeaders } from '../config';
4
+ import { useEnvironmentVariables, useQueryConfig } from '../config';
6
5
 
7
6
  import type { IRequestError, IRequestSuccess } from '../request';
8
7
  import { makeRequest } from '../request';
9
- import { usePauseFutureRequests } from '../stores';
8
+ import { useHeaderStore, usePauseFutureRequests } from '../stores';
10
9
  import type { DefaultRequestOptions, TanstackInfiniteQueryOption } from './queries.interface';
11
10
 
12
11
  interface Pagination {
@@ -32,7 +31,7 @@ export const useGetInfiniteRequest = <TResponse extends Record<string, any>>({
32
31
  keyTracker?: string;
33
32
  } & DefaultRequestOptions) => {
34
33
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
35
- const { getHeaders } = useQueryHeaders();
34
+ const globalHeaders = useHeaderStore((state) => state.headers);
36
35
  const [requestPath, setRequestPath] = useState<string>(path);
37
36
 
38
37
  const [options, setOptions] = useState<any>(queryOptions);
@@ -59,7 +58,6 @@ export const useGetInfiniteRequest = <TResponse extends Record<string, any>>({
59
58
  ) => {
60
59
  if (load) {
61
60
  // get request headers
62
- const globalHeaders: RawAxiosRequestHeaders | undefined = getHeaders();
63
61
 
64
62
  const requestOptions = {
65
63
  path: pageParam ?? requestPath,
package/src/queries/useGetRequest.ts CHANGED
@@ -1,12 +1,11 @@
1
1
  import type { QueryKey, UseQueryOptions } from '@tanstack/react-query';
2
2
  import { useQuery, useQueryClient } from '@tanstack/react-query';
3
3
  import { startTransition, useEffect, useMemo, useState } from 'react';
4
- import type { RawAxiosRequestHeaders } from '../../node_modules/axios/index';
5
- import { useEnvironmentVariables, useQueryConfig, useQueryHeaders } from '../config';
4
+ import { useEnvironmentVariables, useQueryConfig } from '../config';
6
5
 
7
6
  import type { IRequestError, IRequestSuccess } from '../request';
8
7
  import { makeRequest } from '../request';
9
- import { usePauseFutureRequests } from '../stores';
8
+ import { useHeaderStore, usePauseFutureRequests } from '../stores';
10
9
  import type { DefaultRequestOptions, IPagination, TanstackQueryOption } from './queries.interface';
11
10
 
12
11
  export const useGetRequest = <TResponse extends Record<string, any>>({
@@ -27,7 +26,8 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
27
26
  const [page, setPage] = useState<number>(1);
28
27
 
29
28
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
30
- const { getHeaders } = useQueryHeaders();
29
+ const globalHeaders = useHeaderStore((state) => state.headers);
30
+
31
31
  const { options: queryConfigOptions } = useQueryConfig();
32
32
  const [requestPayload, setRequestPayload] = useState<Record<any, any>>();
33
33
 
@@ -46,9 +46,6 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
46
46
  queryKey: QueryKey
47
47
  ) => {
48
48
  if (load) {
49
- // get request headers
50
- const globalHeaders: RawAxiosRequestHeaders | undefined = getHeaders();
51
-
52
49
  const [url] = queryKey;
53
50
  const requestUrl = (url ?? requestPath) as string;
54
51
 
@@ -110,8 +107,11 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
110
107
  }, [keyTracker, requestPath, queryClient, queryOptions?.staleTime]);
111
108
 
112
109
  const nextPage = () => {
113
- if (query.data?.data.pagination) {
114
- const pagination: IPagination = query.data.data.pagination;
110
+ const queryData = query.data;
111
+ const data = queryData ?? queryClient.getQueryData([requestPath, {}]);
112
+
113
+ if (data?.data.pagination) {
114
+ const pagination: IPagination = data.data.pagination;
115
115
  if (pagination.next_page !== pagination.current_page && pagination.next_page > pagination.current_page) {
116
116
  setRequestPath(constructPaginationLink(requestPath, pagination.next_page));
117
117
  }
@@ -119,8 +119,10 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
119
119
  };
120
120
 
121
121
  const prevPage = () => {
122
- if (query.data?.data.pagination) {
123
- const pagination: IPagination = query.data.data.pagination;
122
+ const queryData = query.data;
123
+ const data = queryData ?? queryClient.getQueryData([requestPath, {}]);
124
+ if (data?.data.pagination) {
125
+ const pagination: IPagination = data.data.pagination;
124
126
  if (pagination.previous_page !== pagination.current_page && pagination.previous_page < pagination.current_page) {
125
127
  setRequestPath(constructPaginationLink(requestPath, pagination.previous_page));
126
128
  }
package/src/queries/usePatchRequest.ts CHANGED
@@ -1,30 +1,27 @@
1
1
  import type { MutateOptions } from '@tanstack/react-query';
2
2
  import { useMutation } from '@tanstack/react-query';
3
- import type { RawAxiosRequestHeaders } from 'axios';
4
3
  import { useEffect, useState } from 'react';
5
- import { useEnvironmentVariables, useQueryConfig, useQueryHeaders } from '../config';
4
+ import { useEnvironmentVariables, useQueryConfig } from '../config';
6
5
  import { scrollToTop } from '../helpers';
7
6
  import { useUploadProgress } from '../hooks';
8
7
  import { HttpMethod, makeRequest } from '../request';
9
8
  import type { IRequestError, IRequestSuccess } from '../request/request.interface';
10
- import { usePauseFutureRequests } from '../stores';
9
+ import { useHeaderStore, usePauseFutureRequests } from '../stores';
11
10
  import type { DefaultRequestOptions } from './queries.interface';
12
11
 
13
12
  export const usePatchRequest = <TResponse>({ path, baseUrl, headers }: { path: string } & DefaultRequestOptions) => {
14
13
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
15
14
  const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
15
+ const globalHeaders = useHeaderStore((state) => state.headers);
16
16
 
17
17
  const [requestPayload, setRequestPayload] = useState<Record<any, any>>();
18
18
 
19
19
  const isFutureMutationsPaused = usePauseFutureRequests((state) => state.isFutureMutationsPaused);
20
20
 
21
- const { getHeaders } = useQueryHeaders();
22
-
23
21
  const config = useQueryConfig();
24
22
 
25
23
  const sendRequest = async (res: (value: any) => void, rej: (reason?: any) => void, data: any) => {
26
24
  // get request headers
27
- const globalHeaders: RawAxiosRequestHeaders | undefined = getHeaders();
28
25
 
29
26
  const requestOptions = {
30
27
  path: path,
package/src/queries/usePostRequest.ts CHANGED
@@ -1,14 +1,13 @@
1
1
  import type { MutateOptions } from '@tanstack/react-query';
2
2
  import { useMutation } from '@tanstack/react-query';
3
- import { useEnvironmentVariables, useQueryConfig, useQueryHeaders, useReactNativeEnv } from '../config';
3
+ import { useEnvironmentVariables, useQueryConfig, useReactNativeEnv } from '../config';
4
4
 
5
- import type { RawAxiosRequestHeaders } from 'axios';
6
5
  import { useEffect, useState } from 'react';
7
6
  import { scrollToTop } from '../helpers';
8
7
  import { useUploadProgress } from '../hooks';
9
8
  import type { IMakeRequest, IRequestError, IRequestSuccess } from '../request';
10
9
  import { HttpMethod, makeRequest } from '../request';
11
- import { usePauseFutureRequests } from '../stores';
10
+ import { useHeaderStore, usePauseFutureRequests } from '../stores';
12
11
  import type { DefaultRequestOptions } from './queries.interface';
13
12
 
14
13
  export const usePostRequest = <TResponse>({
@@ -26,7 +25,7 @@ export const usePostRequest = <TResponse>({
26
25
 
27
26
  const config = useQueryConfig();
28
27
 
29
- const { getHeaders } = useQueryHeaders();
28
+ const globalHeaders = useHeaderStore((state) => state.headers);
30
29
  const { isApp } = useReactNativeEnv();
31
30
  const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
32
31
  const [requestPayload, setRequestPayload] = useState<Record<any, any>>();
@@ -39,7 +38,6 @@ export const usePostRequest = <TResponse>({
39
38
  postData: { data: any; requestConfig?: Partial<IMakeRequest> }
40
39
  ) => {
41
40
  // get request headers
42
- const globalHeaders: RawAxiosRequestHeaders | undefined = getHeaders();
43
41
 
44
42
  const { data, requestConfig } = postData;
45
43