@ventlio/tanstack-query 0.2.31 → 0.2.33

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/config/useQueryHeaders.js +10 -10
  2. package/dist/index.mjs +18 -21
  3. package/dist/index.mjs.map +1 -1
  4. package/dist/queries/useDeleteRequest.js +2 -3
  5. package/dist/queries/useDeleteRequest.js.map +1 -1
  6. package/dist/queries/useGetRequest.js +2 -2
  7. package/dist/queries/usePatchRequest.js +2 -3
  8. package/dist/queries/usePatchRequest.js.map +1 -1
  9. package/dist/queries/usePostRequest.js +2 -3
  10. package/dist/queries/usePostRequest.js.map +1 -1
  11. package/dist/types/index.d.ts +1 -1
  12. package/package.json +1 -1
  13. package/src/config/useQueryHeaders.ts +18 -13
  14. package/src/queries/useDeleteRequest.ts +2 -3
  15. package/src/queries/useGetRequest.ts +2 -2
  16. package/src/queries/usePatchRequest.ts +2 -3
  17. package/src/queries/usePostRequest.ts +2 -3
  18. package/src/types/index.ts +1 -1
package/dist/config/useQueryHeaders.js CHANGED
@@ -4,23 +4,23 @@ var reactQuery = require('@tanstack/react-query');
4
4
 
5
5
  const useQueryHeaders = () => {
6
6
  const queryClient = reactQuery.useQueryClient();
7
- const getHeadersAsync = async () => {
8
- return queryClient.ensureQueryData({
9
- queryKey: ['config'],
10
- queryFn: () => {
11
- return queryClient.getQueryData(['config']);
12
- },
7
+ const getHeaders = () => {
8
+ const config = queryClient.getQueryData(['config']);
9
+ return config.headers;
10
+ };
11
+ const setQueryHeaders = (newHeaders) => {
12
+ // make sure the config does not expire
13
+ queryClient.setQueryDefaults(['config'], {
13
14
  staleTime: Infinity,
14
15
  cacheTime: Infinity,
15
16
  });
16
- };
17
- const setQueryHeaders = (newHeaders) => {
17
+ // set the config
18
18
  queryClient.setQueryData(['config'], (config) => {
19
19
  const newConfig = { ...config, headers: newHeaders };
20
20
  return newConfig;
21
- });
21
+ }, {});
22
22
  };
23
- return { setQueryHeaders, getHeadersAsync };
23
+ return { setQueryHeaders, getHeaders };
24
24
  };
25
25
 
26
26
  exports.useQueryHeaders = useQueryHeaders;
package/dist/index.mjs CHANGED
@@ -19,23 +19,23 @@ const useQueryConfig = () => {
19
19
 
20
20
  const useQueryHeaders = () => {
21
21
  const queryClient = useQueryClient();
22
- const getHeadersAsync = async () => {
23
- return queryClient.ensureQueryData({
24
- queryKey: ['config'],
25
- queryFn: () => {
26
- return queryClient.getQueryData(['config']);
27
- },
22
+ const getHeaders = () => {
23
+ const config = queryClient.getQueryData(['config']);
24
+ return config.headers;
25
+ };
26
+ const setQueryHeaders = (newHeaders) => {
27
+ // make sure the config does not expire
28
+ queryClient.setQueryDefaults(['config'], {
28
29
  staleTime: Infinity,
29
30
  cacheTime: Infinity,
30
31
  });
31
- };
32
- const setQueryHeaders = (newHeaders) => {
32
+ // set the config
33
33
  queryClient.setQueryData(['config'], (config) => {
34
34
  const newConfig = { ...config, headers: newHeaders };
35
35
  return newConfig;
36
- });
36
+ }, {});
37
37
  };
38
- return { setQueryHeaders, getHeadersAsync };
38
+ return { setQueryHeaders, getHeaders };
39
39
  };
40
40
 
41
41
  const scrollToTop = () => {
@@ -182,12 +182,11 @@ const useDeleteRequest = () => {
182
182
  const [requestPath, updateDeletePath] = useState('');
183
183
  const [options, setOptions] = useState();
184
184
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
185
- const { getHeadersAsync } = useQueryHeaders();
185
+ const { getHeaders } = useQueryHeaders();
186
186
  const query = useQuery([requestPath, {}], () => new Promise((res, rej) => {
187
187
  setTimeout(async () => {
188
188
  // get request headers
189
- const headers = (await getHeadersAsync())
190
- .headers;
189
+ const headers = getHeaders();
191
190
  const postResponse = await makeRequest({
192
191
  path: requestPath,
193
192
  headers,
@@ -228,13 +227,13 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, }) => {
228
227
  const [options, setOptions] = useState(queryOptions);
229
228
  const [page, setPage] = useState(1);
230
229
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
231
- const { getHeadersAsync } = useQueryHeaders();
230
+ const { getHeaders } = useQueryHeaders();
232
231
  let queryClient = useQueryClient();
233
232
  // eslint-disable-next-line react-hooks/exhaustive-deps
234
233
  queryClient = useMemo(() => queryClient, []);
235
234
  const sendRequest = async (res, rej) => {
236
235
  // get request headers
237
- const headers = (await getHeadersAsync()).headers;
236
+ const headers = getHeaders();
238
237
  const postResponse = await makeRequest({
239
238
  path: requestPath,
240
239
  headers,
@@ -327,13 +326,12 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, }) => {
327
326
 
328
327
  const usePatchRequest = ({ path }) => {
329
328
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
330
- const { getHeadersAsync } = useQueryHeaders();
329
+ const { getHeaders } = useQueryHeaders();
331
330
  // register post mutation
332
331
  const mutation = useMutation((postData) => new Promise((res, rej) => {
333
332
  return (async () => {
334
333
  // get request headers
335
- const headers = (await getHeadersAsync())
336
- .headers;
334
+ const headers = getHeaders();
337
335
  makeRequest({
338
336
  path: path,
339
337
  body: postData,
@@ -366,13 +364,12 @@ const usePatchRequest = ({ path }) => {
366
364
 
367
365
  const usePostRequest = ({ path, isFormData = false, }) => {
368
366
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
369
- const { getHeadersAsync } = useQueryHeaders();
367
+ const { getHeaders } = useQueryHeaders();
370
368
  // register post mutation
371
369
  const mutation = useMutation(async (postData) => new Promise((res, rej) => {
372
370
  return (async () => {
373
371
  // get request headers
374
- const headers = (await getHeadersAsync())
375
- .headers;
372
+ const headers = getHeaders();
376
373
  makeRequest({
377
374
  path: path,
378
375
  body: postData,
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
@@ -12,12 +12,11 @@ const useDeleteRequest = () => {
12
12
  const [requestPath, updateDeletePath] = react.useState('');
13
13
  const [options, setOptions] = react.useState();
14
14
  const { API_URL, TIMEOUT } = useEnvironmentVariables.useEnvironmentVariables();
15
- const { getHeadersAsync } = useQueryHeaders.useQueryHeaders();
15
+ const { getHeaders } = useQueryHeaders.useQueryHeaders();
16
16
  const query = reactQuery.useQuery([requestPath, {}], () => new Promise((res, rej) => {
17
17
  setTimeout(async () => {
18
18
  // get request headers
19
- const headers = (await getHeadersAsync())
20
- .headers;
19
+ const headers = getHeaders();
21
20
  const postResponse = await makeRequest.makeRequest({
22
21
  path: requestPath,
23
22
  headers,
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/useGetRequest.js CHANGED
@@ -13,13 +13,13 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, }) => {
13
13
  const [options, setOptions] = react.useState(queryOptions);
14
14
  const [page, setPage] = react.useState(1);
15
15
  const { API_URL, TIMEOUT } = useEnvironmentVariables.useEnvironmentVariables();
16
- const { getHeadersAsync } = useQueryHeaders.useQueryHeaders();
16
+ const { getHeaders } = useQueryHeaders.useQueryHeaders();
17
17
  let queryClient = reactQuery.useQueryClient();
18
18
  // eslint-disable-next-line react-hooks/exhaustive-deps
19
19
  queryClient = react.useMemo(() => queryClient, []);
20
20
  const sendRequest = async (res, rej) => {
21
21
  // get request headers
22
- const headers = (await getHeadersAsync()).headers;
22
+ const headers = getHeaders();
23
23
  const postResponse = await makeRequest.makeRequest({
24
24
  path: requestPath,
25
25
  headers,
package/dist/queries/usePatchRequest.js CHANGED
@@ -10,13 +10,12 @@ var request_enum = require('../request/request.enum.js');
10
10
 
11
11
  const usePatchRequest = ({ path }) => {
12
12
  const { API_URL, TIMEOUT } = useEnvironmentVariables.useEnvironmentVariables();
13
- const { getHeadersAsync } = useQueryHeaders.useQueryHeaders();
13
+ const { getHeaders } = useQueryHeaders.useQueryHeaders();
14
14
  // register post mutation
15
15
  const mutation = reactQuery.useMutation((postData) => new Promise((res, rej) => {
16
16
  return (async () => {
17
17
  // get request headers
18
- const headers = (await getHeadersAsync())
19
- .headers;
18
+ const headers = getHeaders();
20
19
  makeRequest.makeRequest({
21
20
  path: path,
22
21
  body: postData,
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
@@ -9,13 +9,12 @@ var request_enum = require('../request/request.enum.js');
9
9
 
10
10
  const usePostRequest = ({ path, isFormData = false, }) => {
11
11
  const { API_URL, TIMEOUT } = useEnvironmentVariables.useEnvironmentVariables();
12
- const { getHeadersAsync } = useQueryHeaders.useQueryHeaders();
12
+ const { getHeaders } = useQueryHeaders.useQueryHeaders();
13
13
  // register post mutation
14
14
  const mutation = reactQuery.useMutation(async (postData) => new Promise((res, rej) => {
15
15
  return (async () => {
16
16
  // get request headers
17
- const headers = (await getHeadersAsync())
18
- .headers;
17
+ const headers = getHeaders();
19
18
  makeRequest.makeRequest({
20
19
  path: path,
21
20
  body: postData,
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/dist/types/index.d.ts CHANGED
@@ -3,6 +3,6 @@ export interface TanstackQueryConfig {
3
3
  headers: RawAxiosRequestHeaders;
4
4
  }
5
5
  export interface IUseQueryHeaders {
6
- getHeadersAsync: () => Promise<TanstackQueryConfig>;
6
+ getHeaders: () => TanstackQueryConfig['headers'];
7
7
  setQueryHeaders: (header: TanstackQueryConfig['headers']) => void;
8
8
  }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@ventlio/tanstack-query",
3
- "version": "0.2.31",
3
+ "version": "0.2.33",
4
4
  "license": "MIT",
5
5
  "main": "dist/index.js",
6
6
  "contributors": [
package/src/config/useQueryHeaders.ts CHANGED
@@ -4,23 +4,28 @@ import type { IUseQueryHeaders, TanstackQueryConfig } from '../types';
4
4
  export const useQueryHeaders = (): IUseQueryHeaders => {
5
5
  const queryClient = useQueryClient();
6
6
 
7
- const getHeadersAsync = async (): Promise<TanstackQueryConfig> => {
8
- return queryClient.ensureQueryData({
9
- queryKey: ['config'],
10
- queryFn: () => {
11
- return queryClient.getQueryData(['config']);
12
- },
13
- staleTime: Infinity,
14
- cacheTime: Infinity,
15
- });
7
+ const getHeaders = (): TanstackQueryConfig['headers'] => {
8
+ const config = queryClient.getQueryData(['config']) as TanstackQueryConfig;
9
+ return config.headers;
16
10
  };
17
11
 
18
12
  const setQueryHeaders = (newHeaders: TanstackQueryConfig['headers']) => {
19
- queryClient.setQueryData<TanstackQueryConfig>(['config'], (config): any => {
20
- const newConfig = { ...config, headers: newHeaders };
21
- return newConfig;
13
+ // make sure the config does not expire
14
+ queryClient.setQueryDefaults(['config'], {
15
+ staleTime: Infinity,
16
+ cacheTime: Infinity,
22
17
  });
18
+
19
+ // set the config
20
+ queryClient.setQueryData<TanstackQueryConfig>(
21
+ ['config'],
22
+ (config): TanstackQueryConfig => {
23
+ const newConfig = { ...config, headers: newHeaders };
24
+ return newConfig;
25
+ },
26
+ {}
27
+ );
23
28
  };
24
29
 
25
- return { setQueryHeaders, getHeadersAsync };
30
+ return { setQueryHeaders, getHeaders };
26
31
  };
package/src/queries/useDeleteRequest.ts CHANGED
@@ -12,7 +12,7 @@ export const useDeleteRequest = <TResponse>() => {
12
12
 
13
13
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
14
14
 
15
- const { getHeadersAsync } = useQueryHeaders();
15
+ const { getHeaders } = useQueryHeaders();
16
16
 
17
17
  const query = useQuery<any, any, IRequestSuccess<TResponse>>(
18
18
  [requestPath, {}],
@@ -20,8 +20,7 @@ export const useDeleteRequest = <TResponse>() => {
20
20
  new Promise<IRequestSuccess<TResponse> | IRequestError>((res, rej) => {
21
21
  setTimeout(async () => {
22
22
  // get request headers
23
- const headers: RawAxiosRequestHeaders = (await getHeadersAsync())
24
- .headers;
23
+ const headers: RawAxiosRequestHeaders = getHeaders();
25
24
 
26
25
  const postResponse = await makeRequest<TResponse>({
27
26
  path: requestPath,
package/src/queries/useGetRequest.ts CHANGED
@@ -24,7 +24,7 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
24
24
  const [page, setPage] = useState<number>(1);
25
25
 
26
26
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
27
- const { getHeadersAsync } = useQueryHeaders();
27
+ const { getHeaders } = useQueryHeaders();
28
28
 
29
29
  let queryClient = useQueryClient();
30
30
  // eslint-disable-next-line react-hooks/exhaustive-deps
@@ -40,7 +40,7 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
40
40
  rej: (reason?: any) => void
41
41
  ) => {
42
42
  // get request headers
43
- const headers: RawAxiosRequestHeaders = (await getHeadersAsync()).headers;
43
+ const headers: RawAxiosRequestHeaders = getHeaders();
44
44
 
45
45
  const postResponse = await makeRequest<TResponse>({
46
46
  path: requestPath,
package/src/queries/usePatchRequest.ts CHANGED
@@ -13,7 +13,7 @@ import type {
13
13
  export const usePatchRequest = <TResponse>({ path }: { path: string }) => {
14
14
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
15
15
 
16
- const { getHeadersAsync } = useQueryHeaders();
16
+ const { getHeaders } = useQueryHeaders();
17
17
 
18
18
  // register post mutation
19
19
  const mutation = useMutation<IRequestSuccess<TResponse>, IRequestError>(
@@ -21,8 +21,7 @@ export const usePatchRequest = <TResponse>({ path }: { path: string }) => {
21
21
  new Promise<IRequestSuccess<TResponse>>((res, rej) => {
22
22
  return (async () => {
23
23
  // get request headers
24
- const headers: RawAxiosRequestHeaders = (await getHeadersAsync())
25
- .headers;
24
+ const headers: RawAxiosRequestHeaders = getHeaders();
26
25
 
27
26
  makeRequest<TResponse>({
28
27
  path: path,
package/src/queries/usePostRequest.ts CHANGED
@@ -15,7 +15,7 @@ export const usePostRequest = <TResponse>({
15
15
  }) => {
16
16
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
17
17
 
18
- const { getHeadersAsync } = useQueryHeaders();
18
+ const { getHeaders } = useQueryHeaders();
19
19
 
20
20
  // register post mutation
21
21
  const mutation = useMutation<IRequestSuccess<TResponse>, IRequestError>(
@@ -23,8 +23,7 @@ export const usePostRequest = <TResponse>({
23
23
  new Promise<IRequestSuccess<TResponse>>((res, rej) => {
24
24
  return (async () => {
25
25
  // get request headers
26
- const headers: RawAxiosRequestHeaders = (await getHeadersAsync())
27
- .headers;
26
+ const headers: RawAxiosRequestHeaders = getHeaders();
28
27
 
29
28
  makeRequest<TResponse>({
30
29
  path: path,
package/src/types/index.ts CHANGED
@@ -5,6 +5,6 @@ export interface TanstackQueryConfig {
5
5
  }
6
6
 
7
7
  export interface IUseQueryHeaders {
8
- getHeadersAsync: () => Promise<TanstackQueryConfig>;
8
+ getHeaders: () => TanstackQueryConfig['headers'];
9
9
  setQueryHeaders: (header: TanstackQueryConfig['headers']) => void;
10
10
  }