@ventlio/tanstack-query 0.5.5 → 0.5.7

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 (21) hide show
  1. package/dist/index.mjs +92 -172
  2. package/dist/index.mjs.map +1 -1
  3. package/dist/queries/useDeleteRequest.js +13 -27
  4. package/dist/queries/useDeleteRequest.js.map +1 -1
  5. package/dist/queries/useGetInfiniteRequest.js +16 -30
  6. package/dist/queries/useGetInfiniteRequest.js.map +1 -1
  7. package/dist/queries/useGetRequest.js +22 -41
  8. package/dist/queries/useGetRequest.js.map +1 -1
  9. package/dist/queries/usePatchRequest.js +21 -37
  10. package/dist/queries/usePatchRequest.js.map +1 -1
  11. package/dist/queries/usePostRequest.js +20 -37
  12. package/dist/queries/usePostRequest.js.map +1 -1
  13. package/dist/types/index.d.ts +15 -11
  14. package/package.json +1 -1
  15. package/src/queries/useDeleteRequest.ts +18 -32
  16. package/src/queries/useGetInfiniteRequest.ts +22 -37
  17. package/src/queries/useGetRequest.ts +28 -46
  18. package/src/queries/usePatchRequest.ts +24 -42
  19. package/src/queries/usePostRequest.ts +23 -43
  20. package/src/queries/usePutRequest.ts +23 -43
  21. package/src/types/index.ts +16 -7
package/dist/index.mjs CHANGED
@@ -437,36 +437,22 @@ const useDeleteRequest = (deleteOptions) => {
437
437
  method: HttpMethod.DELETE,
438
438
  timeout: TIMEOUT,
439
439
  };
440
- let shouldContinue = true;
441
- if (queryConfigOptions?.queryMiddleware) {
442
- shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
440
+ let deleteResponse;
441
+ if (queryConfigOptions?.middleware) {
442
+ // perform global middleware
443
+ deleteResponse = await queryConfigOptions.middleware(async (middlewareOptions) => await makeRequest(middlewareOptions ? { ...requestOptions, ...middlewareOptions } : requestOptions), {
444
+ path: requestUrl,
445
+ baseUrl: baseUrl ?? API_URL,
446
+ });
443
447
  }
444
- if (shouldContinue) {
445
- let deleteResponse;
446
- if (queryConfigOptions?.middleware) {
447
- // perform global middleware
448
- const middlewareResponse = await queryConfigOptions.middleware(async () => await makeRequest(requestOptions), {
449
- path: requestUrl,
450
- baseUrl: baseUrl ?? API_URL,
451
- });
452
- if (!middlewareResponse) {
453
- rej();
454
- return;
455
- }
456
- deleteResponse = middlewareResponse;
457
- }
458
- else {
459
- deleteResponse = await makeRequest(requestOptions);
460
- }
461
- if (deleteResponse.status) {
462
- res(deleteResponse);
463
- }
464
- else {
465
- rej(deleteResponse);
466
- }
448
+ else {
449
+ deleteResponse = await makeRequest(requestOptions);
450
+ }
451
+ if (deleteResponse.status) {
452
+ res(deleteResponse);
467
453
  }
468
454
  else {
469
- rej(null);
455
+ rej(deleteResponse);
470
456
  }
471
457
  };
472
458
  const query = useQuery({
@@ -517,7 +503,7 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
517
503
  let queryClient = useQueryClient();
518
504
  // eslint-disable-next-line react-hooks/exhaustive-deps
519
505
  queryClient = useMemo(() => queryClient, []);
520
- const sendRequest = async (res, rej, queryKey, pageParam) => {
506
+ const sendRequest = async (res, rej, pageParam) => {
521
507
  if (load) {
522
508
  // get request headers
523
509
  const requestOptions = {
@@ -526,40 +512,26 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
526
512
  baseURL: baseUrl ?? API_URL,
527
513
  timeout: TIMEOUT,
528
514
  };
529
- let shouldContinue = true;
530
- if (queryConfigOptions?.queryMiddleware) {
531
- shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
515
+ let getResponse;
516
+ if (queryConfigOptions?.middleware) {
517
+ // perform global middleware
518
+ getResponse = await queryConfigOptions.middleware(async (middlewareOptions) => await makeRequest(middlewareOptions ? { ...requestOptions, ...middlewareOptions } : requestOptions), {
519
+ path,
520
+ baseUrl: baseUrl ?? API_URL,
521
+ });
532
522
  }
533
- if (shouldContinue) {
534
- let getResponse;
535
- if (queryConfigOptions?.middleware) {
536
- // perform global middleware
537
- const middlewareResponse = await queryConfigOptions.middleware(async () => await makeRequest(requestOptions), {
538
- path,
539
- baseUrl: baseUrl ?? API_URL,
540
- });
541
- if (!middlewareResponse) {
542
- rej();
543
- return;
544
- }
545
- getResponse = middlewareResponse;
546
- }
547
- else {
548
- getResponse = await makeRequest(requestOptions);
549
- }
550
- if (getResponse.status) {
551
- res(getResponse);
552
- }
553
- else {
554
- rej(getResponse);
555
- }
523
+ else {
524
+ getResponse = await makeRequest(requestOptions);
525
+ }
526
+ if (getResponse.status) {
527
+ res(getResponse);
556
528
  }
557
529
  else {
558
- rej(null);
530
+ rej(getResponse);
559
531
  }
560
532
  }
561
533
  else {
562
- res(null);
534
+ rej(null);
563
535
  }
564
536
  };
565
537
  /**
@@ -575,7 +547,7 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
575
547
  };
576
548
  const query = useInfiniteQuery({
577
549
  queryKey: [requestPath, {}],
578
- queryFn: ({ pageParam = requestPath, queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey, pageParam)),
550
+ queryFn: ({ pageParam = requestPath }) => new Promise((res, rej) => sendRequest(res, rej, pageParam)),
579
551
  enabled: load && !isFutureQueriesPaused,
580
552
  getNextPageParam: (lastPage) => constructPaginationLink('next_page', lastPage),
581
553
  getPreviousPageParam: (lastPage) => constructPaginationLink('previous_page', lastPage),
@@ -638,49 +610,30 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
638
610
  // eslint-disable-next-line react-hooks/exhaustive-deps
639
611
  queryClient = useMemo(() => queryClient, []);
640
612
  const sendRequest = async (res, rej, queryKey) => {
641
- if (load) {
642
- const [url] = queryKey;
643
- const requestUrl = (url ?? requestPath);
644
- const requestOptions = {
645
- path: requestUrl,
646
- headers: { ...globalHeaders, ...headers },
647
- baseURL: baseUrl ?? API_URL,
648
- timeout: TIMEOUT,
649
- };
650
- let shouldContinue = true;
651
- if (queryConfigOptions?.queryMiddleware) {
652
- shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
653
- }
654
- if (shouldContinue) {
655
- let getResponse;
656
- if (queryConfigOptions?.middleware) {
657
- // perform global middleware
658
- const middlewareResponse = await queryConfigOptions.middleware(async () => await makeRequest(requestOptions), {
659
- path,
660
- baseUrl: baseUrl ?? API_URL,
661
- });
662
- if (!middlewareResponse) {
663
- rej();
664
- return;
665
- }
666
- getResponse = middlewareResponse;
667
- }
668
- else {
669
- getResponse = await makeRequest(requestOptions);
670
- }
671
- if (getResponse.status) {
672
- res(getResponse);
673
- }
674
- else {
675
- rej(getResponse);
676
- }
677
- }
678
- else {
679
- rej(null);
680
- }
613
+ const [url] = queryKey;
614
+ const requestUrl = (url ?? requestPath);
615
+ const requestOptions = {
616
+ path: requestUrl,
617
+ headers: { ...globalHeaders, ...headers },
618
+ baseURL: baseUrl ?? API_URL,
619
+ timeout: TIMEOUT,
620
+ };
621
+ let getResponse;
622
+ if (queryConfigOptions?.middleware) {
623
+ // perform global middleware
624
+ getResponse = await queryConfigOptions.middleware(async (middlewareOptions) => await makeRequest(middlewareOptions ? { ...requestOptions, ...middlewareOptions } : requestOptions), {
625
+ path,
626
+ baseUrl: baseUrl ?? API_URL,
627
+ });
628
+ }
629
+ else {
630
+ getResponse = await makeRequest(requestOptions);
631
+ }
632
+ if (getResponse.status) {
633
+ res(getResponse);
681
634
  }
682
635
  else {
683
- res(null);
636
+ rej(getResponse);
684
637
  }
685
638
  };
686
639
  const query = useQuery({
@@ -793,48 +746,32 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
793
746
  timeout: TIMEOUT,
794
747
  onUploadProgress,
795
748
  };
796
- let shouldContinue = true;
797
- if (config.options?.mutationMiddleware) {
798
- shouldContinue = await config.options.mutationMiddleware({
799
- mutationKey: [path, { type: 'mutation' }],
800
- ...requestOptions,
749
+ let patchResponse;
750
+ if (config.options?.middleware) {
751
+ // perform global middleware
752
+ const middlewareResponse = await config.options.middleware(async (options) => await makeRequest(options ? { ...requestOptions, ...options } : requestOptions), {
753
+ path,
754
+ baseUrl: baseUrl ?? API_URL,
755
+ body: data,
801
756
  });
757
+ patchResponse = middlewareResponse;
802
758
  }
803
- if (shouldContinue) {
804
- let patchResponse;
805
- if (config.options?.middleware) {
806
- // perform global middleware
807
- const middlewareResponse = await config.options.middleware(async () => await makeRequest(requestOptions), {
808
- path,
809
- baseUrl: baseUrl ?? API_URL,
810
- body: data,
811
- });
812
- if (!middlewareResponse) {
813
- rej();
814
- return;
815
- }
816
- patchResponse = middlewareResponse;
817
- }
818
- else {
819
- patchResponse = await makeRequest(requestOptions);
820
- }
821
- if (patchResponse.status) {
822
- // scroll to top after success
823
- if (config.options?.context !== 'app') {
824
- scrollToTop();
825
- }
826
- res(patchResponse);
827
- }
828
- else {
829
- // scroll to top after error
830
- if (config.options?.context !== 'app') {
831
- scrollToTop();
832
- }
833
- rej(patchResponse);
759
+ else {
760
+ patchResponse = await makeRequest(requestOptions);
761
+ }
762
+ if (patchResponse.status) {
763
+ // scroll to top after success
764
+ if (config.options?.context !== 'app') {
765
+ scrollToTop();
834
766
  }
767
+ res(patchResponse);
835
768
  }
836
769
  else {
837
- rej(null);
770
+ // scroll to top after error
771
+ if (config.options?.context !== 'app') {
772
+ scrollToTop();
773
+ }
774
+ rej(patchResponse);
838
775
  }
839
776
  };
840
777
  // register post mutation
@@ -890,48 +827,31 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
890
827
  onUploadProgress,
891
828
  ...requestConfig,
892
829
  };
893
- let shouldContinue = true;
894
- if (config.options?.mutationMiddleware) {
895
- shouldContinue = await config.options.mutationMiddleware({
896
- mutationKey: [path, { type: 'mutation' }],
897
- ...requestOptions,
830
+ let postResponse;
831
+ if (config.options?.middleware) {
832
+ // perform global middleware
833
+ postResponse = await config.options.middleware(async (options) => await makeRequest(options ? { ...requestOptions, ...options } : requestOptions), {
834
+ path,
835
+ baseUrl: baseUrl ?? API_URL,
836
+ body: data,
898
837
  });
899
838
  }
900
- if (shouldContinue) {
901
- let postResponse;
902
- if (config.options?.middleware) {
903
- // perform global middleware
904
- const middlewareResponse = await config.options.middleware(async () => await makeRequest(requestOptions), {
905
- path,
906
- baseUrl: baseUrl ?? API_URL,
907
- body: data,
908
- });
909
- if (!middlewareResponse) {
910
- rej();
911
- return;
912
- }
913
- postResponse = middlewareResponse;
914
- }
915
- else {
916
- postResponse = await makeRequest(requestOptions);
917
- }
918
- if (postResponse.status) {
919
- // scroll to top after success
920
- if (config.options?.context !== 'app') {
921
- scrollToTop();
922
- }
923
- res(postResponse);
924
- }
925
- else {
926
- // scroll to top after error
927
- if (config.options?.context !== 'app') {
928
- scrollToTop();
929
- }
930
- rej(postResponse);
839
+ else {
840
+ postResponse = await makeRequest(requestOptions);
841
+ }
842
+ if (postResponse.status) {
843
+ // scroll to top after success
844
+ if (config.options?.context !== 'app') {
845
+ scrollToTop();
931
846
  }
847
+ res(postResponse);
932
848
  }
933
849
  else {
934
- rej(null);
850
+ // scroll to top after error
851
+ if (config.options?.context !== 'app') {
852
+ scrollToTop();
853
+ }
854
+ rej(postResponse);
935
855
  }
936
856
  };
937
857
  // register post mutation
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
@@ -28,36 +28,22 @@ const useDeleteRequest = (deleteOptions) => {
28
28
  method: HttpMethod.DELETE,
29
29
  timeout: TIMEOUT,
30
30
  };
31
- let shouldContinue = true;
32
- if (queryConfigOptions?.queryMiddleware) {
33
- shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
31
+ let deleteResponse;
32
+ if (queryConfigOptions?.middleware) {
33
+ // perform global middleware
34
+ deleteResponse = await queryConfigOptions.middleware(async (middlewareOptions) => await makeRequest(middlewareOptions ? { ...requestOptions, ...middlewareOptions } : requestOptions), {
35
+ path: requestUrl,
36
+ baseUrl: baseUrl ?? API_URL,
37
+ });
34
38
  }
35
- if (shouldContinue) {
36
- let deleteResponse;
37
- if (queryConfigOptions?.middleware) {
38
- // perform global middleware
39
- const middlewareResponse = await queryConfigOptions.middleware(async () => await makeRequest(requestOptions), {
40
- path: requestUrl,
41
- baseUrl: baseUrl ?? API_URL,
42
- });
43
- if (!middlewareResponse) {
44
- rej();
45
- return;
46
- }
47
- deleteResponse = middlewareResponse;
48
- }
49
- else {
50
- deleteResponse = await makeRequest(requestOptions);
51
- }
52
- if (deleteResponse.status) {
53
- res(deleteResponse);
54
- }
55
- else {
56
- rej(deleteResponse);
57
- }
39
+ else {
40
+ deleteResponse = await makeRequest(requestOptions);
41
+ }
42
+ if (deleteResponse.status) {
43
+ res(deleteResponse);
58
44
  }
59
45
  else {
60
- rej(null);
46
+ rej(deleteResponse);
61
47
  }
62
48
  };
63
49
  const query = useQuery({
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
@@ -20,7 +20,7 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
20
20
  let queryClient = useQueryClient();
21
21
  // eslint-disable-next-line react-hooks/exhaustive-deps
22
22
  queryClient = useMemo(() => queryClient, []);
23
- const sendRequest = async (res, rej, queryKey, pageParam) => {
23
+ const sendRequest = async (res, rej, pageParam) => {
24
24
  if (load) {
25
25
  // get request headers
26
26
  const requestOptions = {
@@ -29,40 +29,26 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
29
29
  baseURL: baseUrl ?? API_URL,
30
30
  timeout: TIMEOUT,
31
31
  };
32
- let shouldContinue = true;
33
- if (queryConfigOptions?.queryMiddleware) {
34
- shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
32
+ let getResponse;
33
+ if (queryConfigOptions?.middleware) {
34
+ // perform global middleware
35
+ getResponse = await queryConfigOptions.middleware(async (middlewareOptions) => await makeRequest(middlewareOptions ? { ...requestOptions, ...middlewareOptions } : requestOptions), {
36
+ path,
37
+ baseUrl: baseUrl ?? API_URL,
38
+ });
35
39
  }
36
- if (shouldContinue) {
37
- let getResponse;
38
- if (queryConfigOptions?.middleware) {
39
- // perform global middleware
40
- const middlewareResponse = await queryConfigOptions.middleware(async () => await makeRequest(requestOptions), {
41
- path,
42
- baseUrl: baseUrl ?? API_URL,
43
- });
44
- if (!middlewareResponse) {
45
- rej();
46
- return;
47
- }
48
- getResponse = middlewareResponse;
49
- }
50
- else {
51
- getResponse = await makeRequest(requestOptions);
52
- }
53
- if (getResponse.status) {
54
- res(getResponse);
55
- }
56
- else {
57
- rej(getResponse);
58
- }
40
+ else {
41
+ getResponse = await makeRequest(requestOptions);
42
+ }
43
+ if (getResponse.status) {
44
+ res(getResponse);
59
45
  }
60
46
  else {
61
- rej(null);
47
+ rej(getResponse);
62
48
  }
63
49
  }
64
50
  else {
65
- res(null);
51
+ rej(null);
66
52
  }
67
53
  };
68
54
  /**
@@ -78,7 +64,7 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
78
64
  };
79
65
  const query = useInfiniteQuery({
80
66
  queryKey: [requestPath, {}],
81
- queryFn: ({ pageParam = requestPath, queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey, pageParam)),
67
+ queryFn: ({ pageParam = requestPath }) => new Promise((res, rej) => sendRequest(res, rej, pageParam)),
82
68
  enabled: load && !isFutureQueriesPaused,
83
69
  getNextPageParam: (lastPage) => constructPaginationLink('next_page', lastPage),
84
70
  getPreviousPageParam: (lastPage) => constructPaginationLink('previous_page', lastPage),
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
@@ -22,49 +22,30 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
22
22
  // eslint-disable-next-line react-hooks/exhaustive-deps
23
23
  queryClient = useMemo(() => queryClient, []);
24
24
  const sendRequest = async (res, rej, queryKey) => {
25
- if (load) {
26
- const [url] = queryKey;
27
- const requestUrl = (url ?? requestPath);
28
- const requestOptions = {
29
- path: requestUrl,
30
- headers: { ...globalHeaders, ...headers },
31
- baseURL: baseUrl ?? API_URL,
32
- timeout: TIMEOUT,
33
- };
34
- let shouldContinue = true;
35
- if (queryConfigOptions?.queryMiddleware) {
36
- shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
37
- }
38
- if (shouldContinue) {
39
- let getResponse;
40
- if (queryConfigOptions?.middleware) {
41
- // perform global middleware
42
- const middlewareResponse = await queryConfigOptions.middleware(async () => await makeRequest(requestOptions), {
43
- path,
44
- baseUrl: baseUrl ?? API_URL,
45
- });
46
- if (!middlewareResponse) {
47
- rej();
48
- return;
49
- }
50
- getResponse = middlewareResponse;
51
- }
52
- else {
53
- getResponse = await makeRequest(requestOptions);
54
- }
55
- if (getResponse.status) {
56
- res(getResponse);
57
- }
58
- else {
59
- rej(getResponse);
60
- }
61
- }
62
- else {
63
- rej(null);
64
- }
25
+ const [url] = queryKey;
26
+ const requestUrl = (url ?? requestPath);
27
+ const requestOptions = {
28
+ path: requestUrl,
29
+ headers: { ...globalHeaders, ...headers },
30
+ baseURL: baseUrl ?? API_URL,
31
+ timeout: TIMEOUT,
32
+ };
33
+ let getResponse;
34
+ if (queryConfigOptions?.middleware) {
35
+ // perform global middleware
36
+ getResponse = await queryConfigOptions.middleware(async (middlewareOptions) => await makeRequest(middlewareOptions ? { ...requestOptions, ...middlewareOptions } : requestOptions), {
37
+ path,
38
+ baseUrl: baseUrl ?? API_URL,
39
+ });
40
+ }
41
+ else {
42
+ getResponse = await makeRequest(requestOptions);
43
+ }
44
+ if (getResponse.status) {
45
+ res(getResponse);
65
46
  }
66
47
  else {
67
- res(null);
48
+ rej(getResponse);
68
49
  }
69
50
  };
70
51
  const query = useQuery({
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
@@ -29,48 +29,32 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
29
29
  timeout: TIMEOUT,
30
30
  onUploadProgress,
31
31
  };
32
- let shouldContinue = true;
33
- if (config.options?.mutationMiddleware) {
34
- shouldContinue = await config.options.mutationMiddleware({
35
- mutationKey: [path, { type: 'mutation' }],
36
- ...requestOptions,
32
+ let patchResponse;
33
+ if (config.options?.middleware) {
34
+ // perform global middleware
35
+ const middlewareResponse = await config.options.middleware(async (options) => await makeRequest(options ? { ...requestOptions, ...options } : requestOptions), {
36
+ path,
37
+ baseUrl: baseUrl ?? API_URL,
38
+ body: data,
37
39
  });
40
+ patchResponse = middlewareResponse;
38
41
  }
39
- if (shouldContinue) {
40
- let patchResponse;
41
- if (config.options?.middleware) {
42
- // perform global middleware
43
- const middlewareResponse = await config.options.middleware(async () => await makeRequest(requestOptions), {
44
- path,
45
- baseUrl: baseUrl ?? API_URL,
46
- body: data,
47
- });
48
- if (!middlewareResponse) {
49
- rej();
50
- return;
51
- }
52
- patchResponse = middlewareResponse;
53
- }
54
- else {
55
- patchResponse = await makeRequest(requestOptions);
56
- }
57
- if (patchResponse.status) {
58
- // scroll to top after success
59
- if (config.options?.context !== 'app') {
60
- scrollToTop();
61
- }
62
- res(patchResponse);
63
- }
64
- else {
65
- // scroll to top after error
66
- if (config.options?.context !== 'app') {
67
- scrollToTop();
68
- }
69
- rej(patchResponse);
42
+ else {
43
+ patchResponse = await makeRequest(requestOptions);
44
+ }
45
+ if (patchResponse.status) {
46
+ // scroll to top after success
47
+ if (config.options?.context !== 'app') {
48
+ scrollToTop();
70
49
  }
50
+ res(patchResponse);
71
51
  }
72
52
  else {
73
- rej(null);
53
+ // scroll to top after error
54
+ if (config.options?.context !== 'app') {
55
+ scrollToTop();
56
+ }
57
+ rej(patchResponse);
74
58
  }
75
59
  };
76
60
  // register post mutation
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
@@ -39,48 +39,31 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
39
39
  onUploadProgress,
40
40
  ...requestConfig,
41
41
  };
42
- let shouldContinue = true;
43
- if (config.options?.mutationMiddleware) {
44
- shouldContinue = await config.options.mutationMiddleware({
45
- mutationKey: [path, { type: 'mutation' }],
46
- ...requestOptions,
42
+ let postResponse;
43
+ if (config.options?.middleware) {
44
+ // perform global middleware
45
+ postResponse = await config.options.middleware(async (options) => await makeRequest(options ? { ...requestOptions, ...options } : requestOptions), {
46
+ path,
47
+ baseUrl: baseUrl ?? API_URL,
48
+ body: data,
47
49
  });
48
50
  }
49
- if (shouldContinue) {
50
- let postResponse;
51
- if (config.options?.middleware) {
52
- // perform global middleware
53
- const middlewareResponse = await config.options.middleware(async () => await makeRequest(requestOptions), {
54
- path,
55
- baseUrl: baseUrl ?? API_URL,
56
- body: data,
57
- });
58
- if (!middlewareResponse) {
59
- rej();
60
- return;
61
- }
62
- postResponse = middlewareResponse;
63
- }
64
- else {
65
- postResponse = await makeRequest(requestOptions);
66
- }
67
- if (postResponse.status) {
68
- // scroll to top after success
69
- if (config.options?.context !== 'app') {
70
- scrollToTop();
71
- }
72
- res(postResponse);
73
- }
74
- else {
75
- // scroll to top after error
76
- if (config.options?.context !== 'app') {
77
- scrollToTop();
78
- }
79
- rej(postResponse);
51
+ else {
52
+ postResponse = await makeRequest(requestOptions);
53
+ }
54
+ if (postResponse.status) {
55
+ // scroll to top after success
56
+ if (config.options?.context !== 'app') {
57
+ scrollToTop();
80
58
  }
59
+ res(postResponse);
81
60
  }
82
61
  else {
83
- rej(null);
62
+ // scroll to top after error
63
+ if (config.options?.context !== 'app') {
64
+ scrollToTop();
65
+ }
66
+ rej(postResponse);
84
67
  }
85
68
  };
86
69
  // register post mutation
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
@@ -1,6 +1,5 @@
1
- import type { QueryKey } from '@tanstack/react-query';
2
- import type { RawAxiosRequestHeaders } from 'axios';
3
- import type { IMakeRequest, IRequestError, IRequestSuccess } from '../request';
1
+ import type { AxiosProgressEvent, RawAxiosRequestHeaders } from 'axios';
2
+ import type { AppFileConfig, HttpMethod, IMakeRequest, IRequestError, IRequestSuccess } from '../request';
4
3
  export interface BootstrapConfig {
5
4
  environments?: {
6
5
  appBaseUrl: string;
@@ -8,17 +7,22 @@ export interface BootstrapConfig {
8
7
  };
9
8
  context?: ContextType;
10
9
  modelConfig?: BootstrapModelConfig;
11
- mutationMiddleware?: (mutateRequestConfig?: IMakeRequest & {
12
- mutationKey: QueryKey;
13
- }) => Promise<boolean>;
14
- queryMiddleware?: (queryRequestConfig?: IMakeRequest & {
15
- queryKey: QueryKey;
16
- }) => Promise<boolean>;
17
- middleware?: <T = any>(next: () => Promise<IRequestSuccess<T> | IRequestError>, configs?: {
10
+ middleware?: <T = any>(next: (options?: Partial<NextOptions>) => Promise<IRequestSuccess<T> | IRequestError>, configs?: {
18
11
  baseUrl: string;
19
12
  path: string;
20
13
  body?: Record<string, any>;
21
- }) => Promise<false | IRequestSuccess<T>>;
14
+ }) => Promise<IRequestError | IRequestSuccess<T>>;
15
+ }
16
+ export interface NextOptions extends Partial<IMakeRequest> {
17
+ baseURL: string;
18
+ timeout: number;
19
+ path: string;
20
+ body: any;
21
+ method: HttpMethod;
22
+ isFormData: boolean;
23
+ headers: RawAxiosRequestHeaders;
24
+ appFileConfig: AppFileConfig;
25
+ onUploadProgress: (progressEvent: AxiosProgressEvent) => void;
22
26
  }
23
27
  export interface BootstrapModelConfig {
24
28
  idColumn: string;
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@ventlio/tanstack-query",
3
- "version": "0.5.5",
3
+ "version": "0.5.7",
4
4
  "license": "MIT",
5
5
  "main": "dist/index.js",
6
6
  "contributors": [
package/src/queries/useDeleteRequest.ts CHANGED
@@ -33,41 +33,27 @@ export const useDeleteRequest = <TResponse>(deleteOptions?: DefaultRequestOption
33
33
  timeout: TIMEOUT,
34
34
  };
35
35
 
36
- let shouldContinue = true;
37
-
38
- if (queryConfigOptions?.queryMiddleware) {
39
- shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
40
- }
41
-
42
- if (shouldContinue) {
43
- let deleteResponse: IRequestError | IRequestSuccess<TResponse>;
44
- if (queryConfigOptions?.middleware) {
45
- // perform global middleware
46
- const middlewareResponse = await queryConfigOptions.middleware(
47
- async () => await makeRequest<TResponse>(requestOptions),
48
- {
49
- path: requestUrl,
50
- baseUrl: baseUrl ?? API_URL,
51
- }
52
- );
53
-
54
- if (!middlewareResponse) {
55
- rej();
56
- return;
36
+ let deleteResponse: IRequestError | IRequestSuccess<TResponse>;
37
+ if (queryConfigOptions?.middleware) {
38
+ // perform global middleware
39
+ deleteResponse = await queryConfigOptions.middleware(
40
+ async (middlewareOptions) =>
41
+ await makeRequest<TResponse>(
42
+ middlewareOptions ? { ...requestOptions, ...middlewareOptions } : requestOptions
43
+ ),
44
+ {
45
+ path: requestUrl,
46
+ baseUrl: baseUrl ?? API_URL,
57
47
  }
48
+ );
49
+ } else {
50
+ deleteResponse = await makeRequest<TResponse>(requestOptions);
51
+ }
58
52
 
59
- deleteResponse = middlewareResponse;
60
- } else {
61
- deleteResponse = await makeRequest<TResponse>(requestOptions);
62
- }
63
-
64
- if (deleteResponse.status) {
65
- res(deleteResponse as IRequestSuccess<TResponse>);
66
- } else {
67
- rej(deleteResponse);
68
- }
53
+ if (deleteResponse.status) {
54
+ res(deleteResponse as IRequestSuccess<TResponse>);
69
55
  } else {
70
- rej(null);
56
+ rej(deleteResponse);
71
57
  }
72
58
  };
73
59
 
package/src/queries/useGetInfiniteRequest.ts CHANGED
@@ -1,4 +1,4 @@
1
- import type { InfiniteData, QueryKey, UseQueryOptions } from '@tanstack/react-query';
1
+ import type { InfiniteData, UseQueryOptions } from '@tanstack/react-query';
2
2
  import { useInfiniteQuery, useQueryClient } from '@tanstack/react-query';
3
3
  import { startTransition, useEffect, useMemo, useState } from 'react';
4
4
  import { useEnvironmentVariables, useQueryConfig } from '../config';
@@ -53,7 +53,6 @@ export const useGetInfiniteRequest = <TResponse extends Record<string, any>>({
53
53
  | PromiseLike<IRequestError | IRequestSuccess<TResponse & { pagination: Pagination }>>
54
54
  ) => void,
55
55
  rej: (reason?: any) => void,
56
- queryKey: QueryKey,
57
56
  pageParam?: string
58
57
  ) => {
59
58
  if (load) {
@@ -66,44 +65,30 @@ export const useGetInfiniteRequest = <TResponse extends Record<string, any>>({
66
65
  timeout: TIMEOUT,
67
66
  };
68
67
 
69
- let shouldContinue = true;
70
-
71
- if (queryConfigOptions?.queryMiddleware) {
72
- shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
73
- }
74
-
75
- if (shouldContinue) {
76
- let getResponse: IRequestError | IRequestSuccess<TResponse>;
77
- if (queryConfigOptions?.middleware) {
78
- // perform global middleware
79
- const middlewareResponse = await queryConfigOptions.middleware(
80
- async () => await makeRequest<TResponse>(requestOptions),
81
- {
82
- path,
83
- baseUrl: baseUrl ?? API_URL,
84
- }
85
- );
86
-
87
- if (!middlewareResponse) {
88
- rej();
89
- return;
68
+ let getResponse: IRequestError | IRequestSuccess<TResponse>;
69
+ if (queryConfigOptions?.middleware) {
70
+ // perform global middleware
71
+ getResponse = await queryConfigOptions.middleware(
72
+ async (middlewareOptions) =>
73
+ await makeRequest<TResponse>(
74
+ middlewareOptions ? { ...requestOptions, ...middlewareOptions } : requestOptions
75
+ ),
76
+ {
77
+ path,
78
+ baseUrl: baseUrl ?? API_URL,
90
79
  }
80
+ );
81
+ } else {
82
+ getResponse = await makeRequest<TResponse>(requestOptions);
83
+ }
91
84
 
92
- getResponse = middlewareResponse;
93
- } else {
94
- getResponse = await makeRequest<TResponse>(requestOptions);
95
- }
96
-
97
- if (getResponse.status) {
98
- res(getResponse as IRequestSuccess<TResponse & { pagination: Pagination }>);
99
- } else {
100
- rej(getResponse);
101
- }
85
+ if (getResponse.status) {
86
+ res(getResponse as IRequestSuccess<TResponse & { pagination: Pagination }>);
102
87
  } else {
103
- rej(null);
88
+ rej(getResponse);
104
89
  }
105
90
  } else {
106
- res(null as any);
91
+ rej(null);
107
92
  }
108
93
  };
109
94
 
@@ -131,9 +116,9 @@ export const useGetInfiniteRequest = <TResponse extends Record<string, any>>({
131
116
 
132
117
  const query = useInfiniteQuery<any, any, InfiniteData<IRequestSuccess<TResponse & { pagination: Pagination }>>>({
133
118
  queryKey: [requestPath, {}],
134
- queryFn: ({ pageParam = requestPath, queryKey }) =>
119
+ queryFn: ({ pageParam = requestPath }) =>
135
120
  new Promise<IRequestSuccess<TResponse & { pagination: Pagination }> | IRequestError>((res, rej) =>
136
- sendRequest(res, rej, queryKey, pageParam as string)
121
+ sendRequest(res, rej, pageParam as string)
137
122
  ),
138
123
  enabled: load && !isFutureQueriesPaused,
139
124
  getNextPageParam: (lastPage) => constructPaginationLink('next_page', lastPage),
package/src/queries/useGetRequest.ts CHANGED
@@ -43,55 +43,37 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
43
43
  rej: (reason?: any) => void,
44
44
  queryKey: QueryKey
45
45
  ) => {
46
- if (load) {
47
- const [url] = queryKey;
48
- const requestUrl = (url ?? requestPath) as string;
49
-
50
- const requestOptions = {
51
- path: requestUrl,
52
- headers: { ...globalHeaders, ...headers },
53
- baseURL: baseUrl ?? API_URL,
54
- timeout: TIMEOUT,
55
- };
56
-
57
- let shouldContinue = true;
58
-
59
- if (queryConfigOptions?.queryMiddleware) {
60
- shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
61
- }
62
-
63
- if (shouldContinue) {
64
- let getResponse: IRequestError | IRequestSuccess<TResponse>;
65
- if (queryConfigOptions?.middleware) {
66
- // perform global middleware
67
- const middlewareResponse = await queryConfigOptions.middleware(
68
- async () => await makeRequest<TResponse>(requestOptions),
69
- {
70
- path,
71
- baseUrl: baseUrl ?? API_URL,
72
- }
73
- );
74
-
75
- if (!middlewareResponse) {
76
- rej();
77
- return;
78
- }
79
-
80
- getResponse = middlewareResponse;
81
- } else {
82
- getResponse = await makeRequest<TResponse>(requestOptions);
46
+ const [url] = queryKey;
47
+ const requestUrl = (url ?? requestPath) as string;
48
+
49
+ const requestOptions = {
50
+ path: requestUrl,
51
+ headers: { ...globalHeaders, ...headers },
52
+ baseURL: baseUrl ?? API_URL,
53
+ timeout: TIMEOUT,
54
+ };
55
+
56
+ let getResponse: IRequestError | IRequestSuccess<TResponse>;
57
+ if (queryConfigOptions?.middleware) {
58
+ // perform global middleware
59
+ getResponse = await queryConfigOptions.middleware(
60
+ async (middlewareOptions) =>
61
+ await makeRequest<TResponse>(
62
+ middlewareOptions ? { ...requestOptions, ...middlewareOptions } : requestOptions
63
+ ),
64
+ {
65
+ path,
66
+ baseUrl: baseUrl ?? API_URL,
83
67
  }
68
+ );
69
+ } else {
70
+ getResponse = await makeRequest<TResponse>(requestOptions);
71
+ }
84
72
 
85
- if (getResponse.status) {
86
- res(getResponse as IRequestSuccess<TResponse>);
87
- } else {
88
- rej(getResponse);
89
- }
90
- } else {
91
- rej(null);
92
- }
73
+ if (getResponse.status) {
74
+ res(getResponse as IRequestSuccess<TResponse>);
93
75
  } else {
94
- res(null as any);
76
+ rej(getResponse);
95
77
  }
96
78
  };
97
79
 
package/src/queries/usePatchRequest.ts CHANGED
@@ -33,52 +33,34 @@ export const usePatchRequest = <TResponse>({ path, baseUrl, headers }: { path: s
33
33
  onUploadProgress,
34
34
  };
35
35
 
36
- let shouldContinue = true;
37
-
38
- if (config.options?.mutationMiddleware) {
39
- shouldContinue = await config.options.mutationMiddleware({
40
- mutationKey: [path, { type: 'mutation' }],
41
- ...requestOptions,
42
- });
43
- }
44
-
45
- if (shouldContinue) {
46
- let patchResponse: IRequestError | IRequestSuccess<TResponse>;
47
- if (config.options?.middleware) {
48
- // perform global middleware
49
- const middlewareResponse = await config.options.middleware(
50
- async () => await makeRequest<TResponse>(requestOptions),
51
- {
52
- path,
53
- baseUrl: baseUrl ?? API_URL,
54
- body: data,
55
- }
56
- );
57
-
58
- if (!middlewareResponse) {
59
- rej();
60
- return;
36
+ let patchResponse: IRequestError | IRequestSuccess<TResponse>;
37
+ if (config.options?.middleware) {
38
+ // perform global middleware
39
+ const middlewareResponse = await config.options.middleware(
40
+ async (options) => await makeRequest<TResponse>(options ? { ...requestOptions, ...options } : requestOptions),
41
+ {
42
+ path,
43
+ baseUrl: baseUrl ?? API_URL,
44
+ body: data,
61
45
  }
46
+ );
62
47
 
63
- patchResponse = middlewareResponse;
64
- } else {
65
- patchResponse = await makeRequest<TResponse>(requestOptions);
66
- }
67
- if (patchResponse.status) {
68
- // scroll to top after success
69
- if (config.options?.context !== 'app') {
70
- scrollToTop();
71
- }
72
- res(patchResponse as IRequestSuccess<TResponse>);
73
- } else {
74
- // scroll to top after error
75
- if (config.options?.context !== 'app') {
76
- scrollToTop();
77
- }
78
- rej(patchResponse);
48
+ patchResponse = middlewareResponse;
49
+ } else {
50
+ patchResponse = await makeRequest<TResponse>(requestOptions);
51
+ }
52
+ if (patchResponse.status) {
53
+ // scroll to top after success
54
+ if (config.options?.context !== 'app') {
55
+ scrollToTop();
79
56
  }
57
+ res(patchResponse as IRequestSuccess<TResponse>);
80
58
  } else {
81
- rej(null);
59
+ // scroll to top after error
60
+ if (config.options?.context !== 'app') {
61
+ scrollToTop();
62
+ }
63
+ rej(patchResponse);
82
64
  }
83
65
  };
84
66
 
package/src/queries/usePostRequest.ts CHANGED
@@ -59,54 +59,34 @@ export const usePostRequest = <TResponse>({
59
59
  ...requestConfig,
60
60
  };
61
61
 
62
- let shouldContinue = true;
63
-
64
- if (config.options?.mutationMiddleware) {
65
- shouldContinue = await config.options.mutationMiddleware({
66
- mutationKey: [path, { type: 'mutation' }],
67
- ...requestOptions,
68
- });
69
- }
70
-
71
- if (shouldContinue) {
72
- let postResponse: IRequestError | IRequestSuccess<TResponse>;
73
- if (config.options?.middleware) {
74
- // perform global middleware
75
- const middlewareResponse = await config.options.middleware(
76
- async () => await makeRequest<TResponse>(requestOptions),
77
- {
78
- path,
79
- baseUrl: baseUrl ?? API_URL,
80
- body: data,
81
- }
82
- );
83
-
84
- if (!middlewareResponse) {
85
- rej();
86
- return;
62
+ let postResponse: IRequestError | IRequestSuccess<TResponse>;
63
+ if (config.options?.middleware) {
64
+ // perform global middleware
65
+ postResponse = await config.options.middleware(
66
+ async (options) => await makeRequest<TResponse>(options ? { ...requestOptions, ...options } : requestOptions),
67
+ {
68
+ path,
69
+ baseUrl: baseUrl ?? API_URL,
70
+ body: data,
87
71
  }
72
+ );
73
+ } else {
74
+ postResponse = await makeRequest<TResponse>(requestOptions);
75
+ }
88
76
 
89
- postResponse = middlewareResponse;
90
- } else {
91
- postResponse = await makeRequest<TResponse>(requestOptions);
92
- }
93
-
94
- if (postResponse.status) {
95
- // scroll to top after success
77
+ if (postResponse.status) {
78
+ // scroll to top after success
96
79
 
97
- if (config.options?.context !== 'app') {
98
- scrollToTop();
99
- }
100
- res(postResponse as IRequestSuccess<TResponse>);
101
- } else {
102
- // scroll to top after error
103
- if (config.options?.context !== 'app') {
104
- scrollToTop();
105
- }
106
- rej(postResponse);
80
+ if (config.options?.context !== 'app') {
81
+ scrollToTop();
107
82
  }
83
+ res(postResponse as IRequestSuccess<TResponse>);
108
84
  } else {
109
- rej(null);
85
+ // scroll to top after error
86
+ if (config.options?.context !== 'app') {
87
+ scrollToTop();
88
+ }
89
+ rej(postResponse);
110
90
  }
111
91
  };
112
92
 
package/src/queries/usePutRequest.ts CHANGED
@@ -33,52 +33,32 @@ export const usePutRequest = <TResponse>({ path, baseUrl, headers }: { path: str
33
33
  onUploadProgress,
34
34
  };
35
35
 
36
- let shouldContinue = true;
37
-
38
- if (config.options?.mutationMiddleware) {
39
- shouldContinue = await config.options.mutationMiddleware({
40
- mutationKey: [path, { type: 'mutation' }],
41
- ...requestOptions,
42
- });
43
- }
44
-
45
- if (shouldContinue) {
46
- let putResponse: IRequestError | IRequestSuccess<TResponse>;
47
- if (config.options?.middleware) {
48
- // perform global middleware
49
- const middlewareResponse = await config.options.middleware(
50
- async () => await makeRequest<TResponse>(requestOptions),
51
- {
52
- path,
53
- baseUrl: baseUrl ?? API_URL,
54
- body: data,
55
- }
56
- );
57
-
58
- if (!middlewareResponse) {
59
- rej();
60
- return;
36
+ let putResponse: IRequestError | IRequestSuccess<TResponse>;
37
+ if (config.options?.middleware) {
38
+ // perform global middleware
39
+ putResponse = await config.options.middleware(
40
+ async (options) => await makeRequest<TResponse>(options ? { ...requestOptions, ...options } : requestOptions),
41
+ {
42
+ path,
43
+ baseUrl: baseUrl ?? API_URL,
44
+ body: data,
61
45
  }
62
-
63
- putResponse = middlewareResponse;
64
- } else {
65
- putResponse = await makeRequest<TResponse>(requestOptions);
66
- }
67
- if (putResponse.status) {
68
- // scroll to top after success
69
- if (config.options?.context !== 'app') {
70
- scrollToTop();
71
- }
72
- res(putResponse as IRequestSuccess<TResponse>);
73
- } else {
74
- // scroll to top after error
75
- if (config.options?.context !== 'app') {
76
- scrollToTop();
77
- }
78
- rej(putResponse);
46
+ );
47
+ } else {
48
+ putResponse = await makeRequest<TResponse>(requestOptions);
49
+ }
50
+ if (putResponse.status) {
51
+ // scroll to top after success
52
+ if (config.options?.context !== 'app') {
53
+ scrollToTop();
79
54
  }
55
+ res(putResponse as IRequestSuccess<TResponse>);
80
56
  } else {
81
- rej(null);
57
+ // scroll to top after error
58
+ if (config.options?.context !== 'app') {
59
+ scrollToTop();
60
+ }
61
+ rej(putResponse);
82
62
  }
83
63
  };
84
64
 
package/src/types/index.ts CHANGED
@@ -1,6 +1,5 @@
1
- import type { QueryKey } from '@tanstack/react-query';
2
- import type { RawAxiosRequestHeaders } from 'axios';
3
- import type { IMakeRequest, IRequestError, IRequestSuccess } from '../request';
1
+ import type { AxiosProgressEvent, RawAxiosRequestHeaders } from 'axios';
2
+ import type { AppFileConfig, HttpMethod, IMakeRequest, IRequestError, IRequestSuccess } from '../request';
4
3
 
5
4
  export interface BootstrapConfig {
6
5
  environments?: {
@@ -9,12 +8,22 @@ export interface BootstrapConfig {
9
8
  };
10
9
  context?: ContextType;
11
10
  modelConfig?: BootstrapModelConfig;
12
- mutationMiddleware?: (mutateRequestConfig?: IMakeRequest & { mutationKey: QueryKey }) => Promise<boolean>;
13
- queryMiddleware?: (queryRequestConfig?: IMakeRequest & { queryKey: QueryKey }) => Promise<boolean>;
14
11
  middleware?: <T = any>(
15
- next: () => Promise<IRequestSuccess<T> | IRequestError>,
12
+ next: (options?: Partial<NextOptions>) => Promise<IRequestSuccess<T> | IRequestError>,
16
13
  configs?: { baseUrl: string; path: string; body?: Record<string, any> }
17
- ) => Promise<false | IRequestSuccess<T>>;
14
+ ) => Promise<IRequestError | IRequestSuccess<T>>;
15
+ }
16
+
17
+ export interface NextOptions extends Partial<IMakeRequest> {
18
+ baseURL: string;
19
+ timeout: number;
20
+ path: string;
21
+ body: any;
22
+ method: HttpMethod;
23
+ isFormData: boolean;
24
+ headers: RawAxiosRequestHeaders;
25
+ appFileConfig: AppFileConfig;
26
+ onUploadProgress: (progressEvent: AxiosProgressEvent) => void;
18
27
  }
19
28
 
20
29
  export interface BootstrapModelConfig {