@ventlio/tanstack-query 0.2.30 → 0.2.32

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 (22) hide show
  1. package/dist/config/useQueryHeaders.js +14 -11
  2. package/dist/config/useQueryHeaders.js.map +1 -1
  3. package/dist/index.mjs +22 -23
  4. package/dist/index.mjs.map +1 -1
  5. package/dist/queries/useDeleteRequest.js +2 -3
  6. package/dist/queries/useDeleteRequest.js.map +1 -1
  7. package/dist/queries/useGetRequest.js +2 -2
  8. package/dist/queries/usePatchRequest.js +2 -3
  9. package/dist/queries/usePatchRequest.js.map +1 -1
  10. package/dist/queries/usePostRequest.js +2 -3
  11. package/dist/queries/usePostRequest.js.map +1 -1
  12. package/dist/request/make-request.js +0 -1
  13. package/dist/request/make-request.js.map +1 -1
  14. package/dist/types/index.d.ts +1 -1
  15. package/package.json +1 -1
  16. package/src/config/useQueryHeaders.ts +21 -13
  17. package/src/queries/useDeleteRequest.ts +2 -3
  18. package/src/queries/useGetRequest.ts +2 -2
  19. package/src/queries/usePatchRequest.ts +2 -3
  20. package/src/queries/usePostRequest.ts +2 -3
  21. package/src/request/make-request.ts +0 -1
  22. package/src/types/index.ts +1 -1
package/dist/config/useQueryHeaders.js CHANGED
@@ -4,23 +4,26 @@ 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
- },
13
- staleTime: Infinity,
14
- cacheTime: Infinity,
15
- });
7
+ const getHeaders = () => {
8
+ const config = queryClient.getQueryData(['config']);
9
+ return config.headers;
16
10
  };
17
11
  const setQueryHeaders = (newHeaders) => {
12
+ // make sure the config does not expire
13
+ queryClient.setDefaultOptions({
14
+ queries: {
15
+ queryKey: ['config'],
16
+ staleTime: Infinity,
17
+ cacheTime: Infinity,
18
+ },
19
+ });
20
+ // set the config
18
21
  queryClient.setQueryData(['config'], (config) => {
19
22
  const newConfig = { ...config, headers: newHeaders };
20
23
  return newConfig;
21
- });
24
+ }, {});
22
25
  };
23
- return { setQueryHeaders, getHeadersAsync };
26
+ return { setQueryHeaders, getHeaders };
24
27
  };
25
28
 
26
29
  exports.useQueryHeaders = useQueryHeaders;
package/dist/config/useQueryHeaders.js.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"useQueryHeaders.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;"}
1
+ {"version":3,"file":"useQueryHeaders.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
package/dist/index.mjs CHANGED
@@ -19,23 +19,26 @@ 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
- },
28
- staleTime: Infinity,
29
- cacheTime: Infinity,
30
- });
22
+ const getHeaders = () => {
23
+ const config = queryClient.getQueryData(['config']);
24
+ return config.headers;
31
25
  };
32
26
  const setQueryHeaders = (newHeaders) => {
27
+ // make sure the config does not expire
28
+ queryClient.setDefaultOptions({
29
+ queries: {
30
+ queryKey: ['config'],
31
+ staleTime: Infinity,
32
+ cacheTime: Infinity,
33
+ },
34
+ });
35
+ // set the config
33
36
  queryClient.setQueryData(['config'], (config) => {
34
37
  const newConfig = { ...config, headers: newHeaders };
35
38
  return newConfig;
36
- });
39
+ }, {});
37
40
  };
38
- return { setQueryHeaders, getHeadersAsync };
41
+ return { setQueryHeaders, getHeaders };
39
42
  };
40
43
 
41
44
  const scrollToTop = () => {
@@ -143,7 +146,6 @@ async function makeRequest({ body, method = HttpMethod.GET, path, isFormData, he
143
146
  headers['Content-Type'] = ContentType.APPLICATION_JSON;
144
147
  }
145
148
  else {
146
- console.log({ headers });
147
149
  delete headers['Content-Type'];
148
150
  }
149
151
  try {
@@ -183,12 +185,11 @@ const useDeleteRequest = () => {
183
185
  const [requestPath, updateDeletePath] = useState('');
184
186
  const [options, setOptions] = useState();
185
187
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
186
- const { getHeadersAsync } = useQueryHeaders();
188
+ const { getHeaders } = useQueryHeaders();
187
189
  const query = useQuery([requestPath, {}], () => new Promise((res, rej) => {
188
190
  setTimeout(async () => {
189
191
  // get request headers
190
- const headers = (await getHeadersAsync())
191
- .headers;
192
+ const headers = getHeaders();
192
193
  const postResponse = await makeRequest({
193
194
  path: requestPath,
194
195
  headers,
@@ -229,13 +230,13 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, }) => {
229
230
  const [options, setOptions] = useState(queryOptions);
230
231
  const [page, setPage] = useState(1);
231
232
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
232
- const { getHeadersAsync } = useQueryHeaders();
233
+ const { getHeaders } = useQueryHeaders();
233
234
  let queryClient = useQueryClient();
234
235
  // eslint-disable-next-line react-hooks/exhaustive-deps
235
236
  queryClient = useMemo(() => queryClient, []);
236
237
  const sendRequest = async (res, rej) => {
237
238
  // get request headers
238
- const headers = (await getHeadersAsync()).headers;
239
+ const headers = getHeaders();
239
240
  const postResponse = await makeRequest({
240
241
  path: requestPath,
241
242
  headers,
@@ -328,13 +329,12 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, }) => {
328
329
 
329
330
  const usePatchRequest = ({ path }) => {
330
331
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
331
- const { getHeadersAsync } = useQueryHeaders();
332
+ const { getHeaders } = useQueryHeaders();
332
333
  // register post mutation
333
334
  const mutation = useMutation((postData) => new Promise((res, rej) => {
334
335
  return (async () => {
335
336
  // get request headers
336
- const headers = (await getHeadersAsync())
337
- .headers;
337
+ const headers = getHeaders();
338
338
  makeRequest({
339
339
  path: path,
340
340
  body: postData,
@@ -367,13 +367,12 @@ const usePatchRequest = ({ path }) => {
367
367
 
368
368
  const usePostRequest = ({ path, isFormData = false, }) => {
369
369
  const { API_URL, TIMEOUT } = useEnvironmentVariables();
370
- const { getHeadersAsync } = useQueryHeaders();
370
+ const { getHeaders } = useQueryHeaders();
371
371
  // register post mutation
372
372
  const mutation = useMutation(async (postData) => new Promise((res, rej) => {
373
373
  return (async () => {
374
374
  // get request headers
375
- const headers = (await getHeadersAsync())
376
- .headers;
375
+ const headers = getHeaders();
377
376
  makeRequest({
378
377
  path: path,
379
378
  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/request/make-request.js CHANGED
@@ -13,7 +13,6 @@ async function makeRequest({ body, method = request_enum.HttpMethod.GET, path, i
13
13
  headers['Content-Type'] = request_enum.ContentType.APPLICATION_JSON;
14
14
  }
15
15
  else {
16
- console.log({ headers });
17
16
  delete headers['Content-Type'];
18
17
  }
19
18
  try {
package/dist/request/make-request.js.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"make-request.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
1
+ {"version":3,"file":"make-request.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.30",
3
+ "version": "0.2.32",
4
4
  "license": "MIT",
5
5
  "main": "dist/index.js",
6
6
  "contributors": [
package/src/config/useQueryHeaders.ts CHANGED
@@ -4,23 +4,31 @@ 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.setDefaultOptions({
15
+ queries: {
16
+ queryKey: ['config'],
17
+ staleTime: Infinity,
18
+ cacheTime: Infinity,
19
+ },
22
20
  });
21
+
22
+ // set the config
23
+ queryClient.setQueryData<TanstackQueryConfig>(
24
+ ['config'],
25
+ (config): any => {
26
+ const newConfig = { ...config, headers: newHeaders };
27
+ return newConfig;
28
+ },
29
+ {}
30
+ );
23
31
  };
24
32
 
25
- return { setQueryHeaders, getHeadersAsync };
33
+ return { setQueryHeaders, getHeaders };
26
34
  };
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/request/make-request.ts CHANGED
@@ -21,7 +21,6 @@ export async function makeRequest<TResponse>({
21
21
  if (!isFormData) {
22
22
  headers['Content-Type'] = ContentType.APPLICATION_JSON;
23
23
  } else {
24
- console.log({ headers });
25
24
  delete headers['Content-Type'];
26
25
  }
27
26
 
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
  }