@hyper-fetch/react 9.6.1 → 9.6.2

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 (91) hide show
  1. package/__tests__/features/helpers/use-tracked-state/use-tacked-state.actions.spec.ts +1 -1
  2. package/__tests__/features/helpers/use-tracked-state/use-tracked-state.keys.spec.ts +294 -0
  3. package/__tests__/features/helpers/utils.spec.ts +127 -0
  4. package/__tests__/features/provider/provider.config.spec.tsx +172 -0
  5. package/__tests__/features/use-app-manager/use-app-manager.events.spec.tsx +497 -0
  6. package/__tests__/features/use-cache/use-cache.state.spec.tsx +326 -0
  7. package/__tests__/features/use-emitter/use-emitter.lifecycle.spec.tsx +417 -0
  8. package/__tests__/features/use-fetch/use-fetch.bounce-timers.spec.ts +199 -0
  9. package/__tests__/features/use-fetch/use-fetch.cache-events.spec.ts +212 -0
  10. package/__tests__/features/use-fetch/use-fetch.callbacks.spec.tsx +359 -0
  11. package/__tests__/features/use-fetch/use-fetch.hydration.spec.tsx +126 -0
  12. package/__tests__/features/use-fetch/use-fetch.infinite.spec.ts +146 -0
  13. package/__tests__/features/use-fetch/use-fetch.initial-state.spec.ts +340 -0
  14. package/__tests__/features/use-fetch/use-fetch.keys.spec.tsx +559 -0
  15. package/__tests__/features/use-fetch/use-fetch.lifecycle.spec.ts +348 -0
  16. package/__tests__/features/use-fetch/use-fetch.mounting.spec.tsx +411 -0
  17. package/__tests__/features/use-fetch/use-fetch.pagination.spec.ts +177 -0
  18. package/__tests__/features/use-fetch/use-fetch.refresh-interval.spec.ts +355 -0
  19. package/__tests__/features/use-fetch/use-fetch.response-order.spec.ts +105 -0
  20. package/__tests__/features/use-fetch/use-fetch.retry.spec.ts +235 -0
  21. package/__tests__/features/use-fetch/use-fetch.return-types.spec.ts +186 -0
  22. package/__tests__/features/use-fetch/use-fetch.scope.spec.ts +333 -0
  23. package/__tests__/features/use-fetch/use-fetch.ssr.spec.tsx +195 -0
  24. package/__tests__/features/use-fetch/use-fetch.suspense-edge.spec.tsx +391 -0
  25. package/__tests__/features/use-fetch/use-fetch.throwing-callbacks.spec.tsx +112 -0
  26. package/__tests__/features/use-fetch/use-fetch.tracking.spec.tsx +364 -0
  27. package/__tests__/features/use-fetch/use-fetch.window-events.spec.ts +300 -0
  28. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.parity.spec.tsx +1027 -0
  29. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.resubscribe.spec.tsx +267 -0
  30. package/__tests__/features/use-infinite-fetch/use-infinite-fetch.typescript.spec.ts +64 -1
  31. package/__tests__/features/use-is-fetching/use-is-fetching.lifecycle.spec.tsx +301 -0
  32. package/__tests__/features/use-listener/use-listener.lifecycle.spec.tsx +507 -0
  33. package/__tests__/features/use-listener/use-listener.ssr.spec.tsx +89 -0
  34. package/__tests__/features/use-queue/use-queue.controls.spec.tsx +593 -0
  35. package/__tests__/features/use-queue/use-queue.list.spec.tsx +560 -0
  36. package/__tests__/features/use-queue/use-queue.progress.spec.tsx +650 -0
  37. package/__tests__/features/use-submit/use-submit.abort.spec.tsx +270 -0
  38. package/__tests__/features/use-submit/use-submit.actions.spec.tsx +446 -0
  39. package/__tests__/features/use-submit/use-submit.arguments.spec.tsx +732 -0
  40. package/__tests__/features/use-submit/use-submit.bounce.spec.tsx +644 -0
  41. package/__tests__/features/use-submit/use-submit.callbacks.spec.tsx +860 -0
  42. package/__tests__/features/use-submit/use-submit.chaining.spec.tsx +167 -0
  43. package/__tests__/features/use-submit/use-submit.double-submit.spec.tsx +552 -0
  44. package/__tests__/features/use-submit/use-submit.offline.spec.tsx +285 -0
  45. package/__tests__/features/use-submit/use-submit.optimistic-cache.spec.tsx +619 -0
  46. package/__tests__/features/use-submit/use-submit.optimistic-settlement.spec.ts +6 -0
  47. package/__tests__/features/use-submit/use-submit.optimistic.spec.ts +5 -1
  48. package/__tests__/features/use-submit/use-submit.state.spec.tsx +1025 -0
  49. package/__tests__/features/use-submit/use-submit.submit-types.spec.ts +194 -0
  50. package/__tests__/features/use-submit/use-submit.submitting.spec.tsx +180 -0
  51. package/__tests__/utils/gate.utils.ts +103 -0
  52. package/__tests__/utils/gated-client.utils.ts +158 -0
  53. package/__tests__/utils/helpers.utils.ts +19 -0
  54. package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
  55. package/dist/helpers/use-request-events/use-request-events.types.d.ts +1 -1
  56. package/dist/helpers/use-request-events/use-request-events.types.d.ts.map +1 -1
  57. package/dist/helpers/use-tracked-state/use-tracked-state.hooks.d.ts.map +1 -1
  58. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts +8 -0
  59. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts.map +1 -1
  60. package/dist/hooks/use-cache/use-cache.hooks.d.ts.map +1 -1
  61. package/dist/hooks/use-fetch/use-fetch.hooks.d.ts.map +1 -1
  62. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts.map +1 -1
  63. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts +3 -0
  64. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts.map +1 -1
  65. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts +5 -3
  66. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts.map +1 -1
  67. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts +11 -1
  68. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts.map +1 -1
  69. package/dist/hooks/use-listener/use-listener.hooks.d.ts.map +1 -1
  70. package/dist/hooks/use-queue/use-queue.hooks.d.ts.map +1 -1
  71. package/dist/hooks/use-submit/use-submit.hooks.d.ts.map +1 -1
  72. package/dist/index.mjs +630 -346
  73. package/dist/index.mjs.map +1 -1
  74. package/dist/provider/provider.d.ts.map +1 -1
  75. package/package.json +1 -1
  76. package/src/helpers/use-request-events/use-request-events.hooks.ts +141 -28
  77. package/src/helpers/use-request-events/use-request-events.types.ts +1 -1
  78. package/src/helpers/use-tracked-state/use-tracked-state.hooks.ts +148 -101
  79. package/src/helpers/use-tracked-state/use-tracked-state.utils.ts +26 -5
  80. package/src/hooks/use-cache/use-cache.hooks.ts +20 -5
  81. package/src/hooks/use-fetch/use-fetch.hooks.ts +194 -113
  82. package/src/hooks/use-infinite-fetch/use-infinite-fetch.hooks.ts +55 -26
  83. package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.ts +35 -29
  84. package/src/hooks/use-infinite-fetch/use-infinite-fetch.types.ts +5 -3
  85. package/src/hooks/use-infinite-fetch/use-infinite-fetch.utils.ts +25 -1
  86. package/src/hooks/use-listener/use-listener.hooks.ts +2 -1
  87. package/src/hooks/use-queue/use-queue.hooks.ts +85 -60
  88. package/src/hooks/use-submit/use-submit.hooks.ts +163 -53
  89. package/src/provider/provider.tsx +9 -1
  90. package/__tests__/features/use-fetch/use-fetch.pagination.ts +0 -36
  91. package/__tests__/features/use-fetch/use-fetch.retry.ts +0 -38
@@ -0,0 +1,212 @@
1
+ import { act, renderHook } from "@testing-library/react";
2
+ import { useFetch } from "hooks/use-fetch";
3
+
4
+ import { client, createRequest } from "../../utils";
5
+ import { advance, gateRequest, setCacheResponse, settle } from "../../utils/gate.utils";
6
+
7
+ type User = { id: number; name: string };
8
+
9
+ const user: User = { id: 1, name: "Maciej" };
10
+
11
+ describe("useFetch [ Cache Events ]", () => {
12
+ let request = createRequest<User>();
13
+ let calls = gateRequest(request);
14
+
15
+ const renderLoaded = async (options?: Parameters<typeof useFetch<typeof request>>[1]) => {
16
+ const view = renderHook(() => {
17
+ const { data, loading, error, success } = useFetch(request, options);
18
+ return { data, loading, error, success };
19
+ });
20
+ await advance();
21
+ if (calls.length > 0) {
22
+ calls[0].succeed(user);
23
+ await settle();
24
+ }
25
+ return view;
26
+ };
27
+
28
+ beforeEach(() => {
29
+ vi.useFakeTimers();
30
+ client.clear();
31
+ request = createRequest<User>();
32
+ calls = gateRequest(request);
33
+ });
34
+
35
+ afterEach(() => {
36
+ vi.useRealTimers();
37
+ });
38
+
39
+ describe("when the cache is changed from outside", () => {
40
+ it("should show the data saved in the cache", async () => {
41
+ const { result } = await renderLoaded();
42
+
43
+ act(() => {
44
+ setCacheResponse(request, { id: 1, name: "External" });
45
+ });
46
+
47
+ expect(result.current.data).toStrictEqual({ id: 1, name: "External" });
48
+ expect(calls).toHaveLength(1);
49
+ });
50
+ it("should show the data updated with cache.update", async () => {
51
+ const { result } = await renderLoaded();
52
+
53
+ act(() => {
54
+ client.cache.update(request, (previous) => ({ data: { ...(previous?.data as User), name: "Patched" } }));
55
+ });
56
+
57
+ expect(result.current.data).toStrictEqual({ id: 1, name: "Patched" });
58
+ });
59
+ it("should show the data saved for the disabled hook", async () => {
60
+ const { result } = await renderLoaded({ disabled: true });
61
+
62
+ act(() => {
63
+ setCacheResponse(request, user);
64
+ });
65
+
66
+ expect(result.current.data).toStrictEqual(user);
67
+ expect(result.current.success).toBeTrue();
68
+ expect(calls).toHaveLength(0);
69
+ });
70
+ it("should show the response of the request sent outside of the hook", async () => {
71
+ const { result } = await renderLoaded();
72
+
73
+ act(() => {
74
+ client.fetchDispatcher.add(request);
75
+ });
76
+ await advance();
77
+ expect(result.current.loading).toBeTrue();
78
+
79
+ calls[1].succeed({ id: 1, name: "From outside" });
80
+ await settle();
81
+
82
+ expect(result.current.data).toStrictEqual({ id: 1, name: "From outside" });
83
+ expect(result.current.loading).toBeFalse();
84
+ });
85
+ it("should ignore the changes of other cache keys", async () => {
86
+ const { result } = await renderLoaded();
87
+
88
+ act(() => {
89
+ setCacheResponse(request.setQueryParams({ page: 2 }), { id: 2, name: "Other" });
90
+ });
91
+
92
+ expect(result.current.data).toStrictEqual(user);
93
+ });
94
+ });
95
+
96
+ describe("when the cache is invalidated", () => {
97
+ it.each([
98
+ ["request", () => client.cache.invalidate(request)],
99
+ ["cache key", () => client.cache.invalidate(request.cacheKey)],
100
+ ["RegExp", () => client.cache.invalidate(/shared-endpoint/)],
101
+ ["list of keys", () => client.cache.invalidate([request.cacheKey, "other"])],
102
+ ["no arguments", () => client.cache.invalidate()],
103
+ ])("should refetch after the invalidation by %s", async (_, invalidate) => {
104
+ const { result } = await renderLoaded();
105
+
106
+ act(() => {
107
+ invalidate();
108
+ });
109
+ await advance();
110
+
111
+ expect(calls).toHaveLength(2);
112
+ expect(result.current.loading).toBeTrue();
113
+ expect(result.current.data).toStrictEqual(user);
114
+ });
115
+ it("should not refetch after the invalidation of another key", async () => {
116
+ await renderLoaded();
117
+
118
+ act(() => {
119
+ client.cache.invalidate("another-key");
120
+ client.cache.invalidate(/nothing-matches/);
121
+ });
122
+ await advance();
123
+
124
+ expect(calls).toHaveLength(1);
125
+ });
126
+ it("should not refetch the disabled hook", async () => {
127
+ setCacheResponse(request, user);
128
+ await renderLoaded({ disabled: true });
129
+
130
+ act(() => {
131
+ client.cache.invalidate(request);
132
+ });
133
+ await advance();
134
+
135
+ expect(calls).toHaveLength(0);
136
+ });
137
+ it("should send one request for many hooks of the invalidated key", async () => {
138
+ await renderLoaded();
139
+ renderHook(() => useFetch(request, { revalidate: false }).data);
140
+ renderHook(() => useFetch(request, { revalidate: false }).data);
141
+
142
+ act(() => {
143
+ client.cache.invalidate(request);
144
+ });
145
+ await advance();
146
+
147
+ expect(calls).toHaveLength(2);
148
+ });
149
+ it("should not refetch after unmount", async () => {
150
+ const { unmount } = await renderLoaded();
151
+
152
+ unmount();
153
+ act(() => {
154
+ client.cache.invalidate(request);
155
+ });
156
+ await advance();
157
+
158
+ expect(calls).toHaveLength(1);
159
+ });
160
+ it("should refetch on the next mount after the invalidation without mounted hooks", async () => {
161
+ const { unmount } = await renderLoaded({ revalidate: false });
162
+ unmount();
163
+
164
+ act(() => {
165
+ client.cache.invalidate(request);
166
+ });
167
+ renderHook(() => useFetch(request, { revalidate: false }).data);
168
+ await advance();
169
+
170
+ expect(calls).toHaveLength(2);
171
+ });
172
+ });
173
+
174
+ describe("when the cache entry is deleted", () => {
175
+ it("should keep the data visible and refetch it", async () => {
176
+ const { result } = await renderLoaded();
177
+
178
+ act(() => {
179
+ client.cache.delete(request.cacheKey);
180
+ });
181
+ await advance();
182
+
183
+ expect(result.current.data).toStrictEqual(user);
184
+ expect(result.current.loading).toBeTrue();
185
+ expect(calls).toHaveLength(2);
186
+ });
187
+ it("should not refetch the disabled hook", async () => {
188
+ setCacheResponse(request, user);
189
+ const { result } = await renderLoaded({ disabled: true });
190
+
191
+ act(() => {
192
+ client.cache.delete(request.cacheKey);
193
+ });
194
+ await advance();
195
+
196
+ expect(calls).toHaveLength(0);
197
+ expect(result.current.data).toStrictEqual(user);
198
+ });
199
+ });
200
+
201
+ describe("when the cache is disabled for the request", () => {
202
+ it("should show the response without saving it", async () => {
203
+ request = createRequest<User>({ cache: false });
204
+ calls = gateRequest(request);
205
+
206
+ const { result } = await renderLoaded();
207
+
208
+ expect(result.current.data).toStrictEqual(user);
209
+ expect(client.cache.get(request.cacheKey)).toBeUndefined();
210
+ });
211
+ });
212
+ });
@@ -0,0 +1,359 @@
1
+ import { act, renderHook } from "@testing-library/react";
2
+ import { useFetch } from "hooks/use-fetch";
3
+ import { useState } from "react";
4
+
5
+ import { client, createRequest } from "../../utils";
6
+ import { advance, gateRequest, settle } from "../../utils/gate.utils";
7
+
8
+ type User = { id: number };
9
+
10
+ describe("useFetch [ Callbacks ]", () => {
11
+ let request = createRequest<User, any, "/users/:id">({ endpoint: "/users/:id" });
12
+ let calls = gateRequest(request);
13
+
14
+ beforeEach(() => {
15
+ vi.useFakeTimers();
16
+ client.clear();
17
+ request = createRequest<User, any, "/users/:id">({ endpoint: "/users/:id" });
18
+ calls = gateRequest(request);
19
+ });
20
+
21
+ afterEach(() => {
22
+ vi.useRealTimers();
23
+ });
24
+
25
+ const renderCallbacks = (id = 1) => {
26
+ const spies = {
27
+ onSuccess: vi.fn(),
28
+ onError: vi.fn(),
29
+ onFinished: vi.fn(),
30
+ onAbort: vi.fn(),
31
+ onRequestStart: vi.fn(),
32
+ onResponseStart: vi.fn(),
33
+ };
34
+ const view = renderHook(
35
+ (props: { id: number }) => {
36
+ const state = useFetch(request.setParams({ id: props.id }));
37
+ state.onSuccess(spies.onSuccess);
38
+ state.onError(spies.onError);
39
+ state.onFinished(spies.onFinished);
40
+ state.onAbort(spies.onAbort);
41
+ state.onRequestStart(spies.onRequestStart);
42
+ state.onResponseStart(spies.onResponseStart);
43
+ return { data: state.data, refetch: state.refetch, abort: state.abort };
44
+ },
45
+ { initialProps: { id } },
46
+ );
47
+ return { ...view, spies };
48
+ };
49
+
50
+ describe("when the request succeeds", () => {
51
+ it("should call onSuccess and onFinished once", async () => {
52
+ const { spies } = renderCallbacks();
53
+ await advance();
54
+ calls[0].succeed({ id: 1 });
55
+ await settle();
56
+
57
+ expect(spies.onSuccess).toHaveBeenCalledOnce();
58
+ expect(spies.onFinished).toHaveBeenCalledOnce();
59
+ expect(spies.onError).not.toHaveBeenCalled();
60
+ expect(spies.onAbort).not.toHaveBeenCalled();
61
+ });
62
+ it("should pass the response, details and request to onSuccess", async () => {
63
+ const { spies } = renderCallbacks();
64
+ await advance();
65
+ calls[0].succeed({ id: 1 });
66
+ await settle();
67
+
68
+ const [params] = spies.onSuccess.mock.calls[0];
69
+ expect(params.response.data).toStrictEqual({ id: 1 });
70
+ expect(params.response.success).toBeTrue();
71
+ expect(params.response.status).toBe(200);
72
+ expect(params.details.retries).toBe(0);
73
+ expect(params.details.isCanceled).toBeFalse();
74
+ expect(params.request.endpoint).toBe("/users/1");
75
+ expect(params.requestId).toBe(calls[0].requestId);
76
+ });
77
+ it("should call the start callbacks once per request", async () => {
78
+ const { spies } = renderCallbacks();
79
+ await advance();
80
+ calls[0].succeed({ id: 1 });
81
+ await settle();
82
+
83
+ expect(spies.onRequestStart).toHaveBeenCalledOnce();
84
+ expect(spies.onResponseStart).toHaveBeenCalledOnce();
85
+ });
86
+ it("should call the callbacks once per every refetch", async () => {
87
+ const { spies, result } = renderCallbacks();
88
+ await advance();
89
+ calls[0].succeed({ id: 1 });
90
+ await settle();
91
+
92
+ act(() => {
93
+ result.current.refetch();
94
+ });
95
+ await advance();
96
+ calls[1].succeed({ id: 1 });
97
+ await settle();
98
+
99
+ expect(spies.onSuccess).toHaveBeenCalledTimes(2);
100
+ expect(spies.onFinished).toHaveBeenCalledTimes(2);
101
+ });
102
+ it("should call the callback even when the data did not change", async () => {
103
+ const { spies, result } = renderCallbacks();
104
+ await advance();
105
+ calls[0].succeed({ id: 1 });
106
+ await settle();
107
+
108
+ act(() => {
109
+ result.current.refetch();
110
+ });
111
+ await advance();
112
+ calls[1].succeed({ id: 1 });
113
+ await settle();
114
+
115
+ expect(spies.onSuccess.mock.calls[1][0].response.data).toStrictEqual({ id: 1 });
116
+ });
117
+ });
118
+
119
+ describe("when the request fails", () => {
120
+ it("should call onError and onFinished once", async () => {
121
+ const { spies } = renderCallbacks();
122
+ await advance();
123
+ calls[0].fail(new Error("Failed"), 500);
124
+ await settle();
125
+
126
+ expect(spies.onError).toHaveBeenCalledOnce();
127
+ expect(spies.onFinished).toHaveBeenCalledOnce();
128
+ expect(spies.onSuccess).not.toHaveBeenCalled();
129
+ });
130
+ it("should pass the error response to onError", async () => {
131
+ const { spies } = renderCallbacks();
132
+ await advance();
133
+ calls[0].fail(new Error("Failed"), 500);
134
+ await settle();
135
+
136
+ const [params] = spies.onError.mock.calls[0];
137
+ expect(params.response.error.message).toBe("Failed");
138
+ expect(params.response.status).toBe(500);
139
+ expect(params.response.success).toBeFalse();
140
+ expect(params.response.data).toBeNull();
141
+ });
142
+ it("should call onSuccess after the failed request is refetched", async () => {
143
+ const { spies, result } = renderCallbacks();
144
+ await advance();
145
+ calls[0].fail();
146
+ await settle();
147
+
148
+ act(() => {
149
+ result.current.refetch();
150
+ });
151
+ await advance();
152
+ calls[1].succeed({ id: 1 });
153
+ await settle();
154
+
155
+ expect(spies.onError).toHaveBeenCalledOnce();
156
+ expect(spies.onSuccess).toHaveBeenCalledOnce();
157
+ expect(spies.onFinished).toHaveBeenCalledTimes(2);
158
+ });
159
+ });
160
+
161
+ describe("when the callback changes between renders", () => {
162
+ it("should call the callback from the latest render", async () => {
163
+ const seen: number[] = [];
164
+ const { result } = renderHook(() => {
165
+ const [count, setCount] = useState(0);
166
+ const state = useFetch(request.setParams({ id: 1 }));
167
+ state.onSuccess(() => {
168
+ seen.push(count);
169
+ });
170
+ return { data: state.data, setCount };
171
+ });
172
+ await advance();
173
+
174
+ act(() => {
175
+ result.current.setCount(5);
176
+ });
177
+ calls[0].succeed({ id: 1 });
178
+ await settle();
179
+
180
+ expect(seen).toStrictEqual([5]);
181
+ });
182
+ it("should allow to update the state from the callback", async () => {
183
+ const { result } = renderHook(() => {
184
+ const [message, setMessage] = useState("idle");
185
+ const state = useFetch(request.setParams({ id: 1 }));
186
+ state.onSuccess(({ response }) => setMessage(`user ${response.data.id}`));
187
+ state.onError(({ response }) => setMessage(response.error.message));
188
+ return { message, refetch: state.refetch };
189
+ });
190
+ await advance();
191
+ calls[0].succeed({ id: 1 });
192
+ await settle();
193
+ expect(result.current.message).toBe("user 1");
194
+
195
+ act(() => {
196
+ result.current.refetch();
197
+ });
198
+ await advance();
199
+ calls[1].fail(new Error("Failed"));
200
+ await settle();
201
+ expect(result.current.message).toBe("Failed");
202
+ });
203
+ it("should not fail when no callbacks are registered", async () => {
204
+ const { result } = renderHook(() => useFetch(request.setParams({ id: 1 })).data);
205
+ await advance();
206
+ calls[0].succeed({ id: 1 });
207
+ await settle();
208
+
209
+ expect(result.current).toStrictEqual({ id: 1 });
210
+ });
211
+ });
212
+
213
+ describe("when the key changes", () => {
214
+ it("should not call the callbacks for the response of the previous key", async () => {
215
+ const { spies, rerender } = renderCallbacks(1);
216
+ await advance();
217
+ rerender({ id: 2 });
218
+ await advance();
219
+
220
+ calls[0].succeed({ id: 1 });
221
+ await settle();
222
+
223
+ expect(spies.onSuccess).not.toHaveBeenCalled();
224
+ expect(spies.onFinished).not.toHaveBeenCalled();
225
+ });
226
+ it("should call the callbacks for the response of the current key", async () => {
227
+ const { spies, rerender } = renderCallbacks(1);
228
+ await advance();
229
+ rerender({ id: 2 });
230
+ await advance();
231
+
232
+ calls[1].succeed({ id: 2 });
233
+ await settle();
234
+
235
+ expect(spies.onSuccess).toHaveBeenCalledOnce();
236
+ expect(spies.onSuccess.mock.calls[0][0].response.data).toStrictEqual({ id: 2 });
237
+ });
238
+ });
239
+
240
+ describe("when the hook unmounts", () => {
241
+ it("should not call the callbacks of the request finished after the unmount", async () => {
242
+ const { spies, unmount } = renderCallbacks();
243
+ await advance();
244
+
245
+ unmount();
246
+ calls[0].succeed({ id: 1 });
247
+ await settle();
248
+
249
+ expect(spies.onSuccess).not.toHaveBeenCalled();
250
+ expect(spies.onFinished).not.toHaveBeenCalled();
251
+ expect(spies.onResponseStart).not.toHaveBeenCalled();
252
+ });
253
+ it("should not call onError after the unmount", async () => {
254
+ const { spies, unmount } = renderCallbacks();
255
+ await advance();
256
+
257
+ unmount();
258
+ calls[0].fail();
259
+ await settle();
260
+
261
+ expect(spies.onError).not.toHaveBeenCalled();
262
+ });
263
+ });
264
+
265
+ describe("when many hooks use the same request", () => {
266
+ it("should call the callbacks of every hook once", async () => {
267
+ const first = renderCallbacks();
268
+ const second = renderCallbacks();
269
+ await advance();
270
+ expect(calls).toHaveLength(1);
271
+
272
+ calls[0].succeed({ id: 1 });
273
+ await settle();
274
+
275
+ expect(first.spies.onSuccess).toHaveBeenCalledOnce();
276
+ expect(second.spies.onSuccess).toHaveBeenCalledOnce();
277
+ });
278
+ it("should call the callbacks for the request sent outside of the hook", async () => {
279
+ const { spies } = renderCallbacks();
280
+ await advance();
281
+ calls[0].succeed({ id: 1 });
282
+ await settle();
283
+
284
+ act(() => {
285
+ client.fetchDispatcher.add(request.setParams({ id: 1 }));
286
+ });
287
+ await advance();
288
+ calls[1].succeed({ id: 1 });
289
+ await settle();
290
+
291
+ expect(spies.onSuccess).toHaveBeenCalledTimes(2);
292
+ });
293
+ });
294
+
295
+ describe("when the request uses a response mapper", () => {
296
+ it("should pass the mapped response to the callbacks", async () => {
297
+ const mapped = createRequest<User>().setResponseMapper(
298
+ (response) => ({ ...response, data: { id: 100 } }) as typeof response,
299
+ );
300
+ const mappedCalls = gateRequest(mapped);
301
+ const onSuccess = vi.fn();
302
+ const { result } = renderHook(() => {
303
+ const state = useFetch(mapped);
304
+ state.onSuccess(({ response }) => onSuccess(response.data));
305
+ return { data: state.data };
306
+ });
307
+ await advance();
308
+ mappedCalls[0].succeed({ id: 1 });
309
+ await settle();
310
+
311
+ expect(result.current.data).toStrictEqual({ id: 100 });
312
+ expect(onSuccess).toHaveBeenCalledWith({ id: 100 });
313
+ });
314
+ it("should pass the asynchronously mapped response to the callbacks", async () => {
315
+ const mapped = createRequest<User>().setResponseMapper(
316
+ async (response) => ({ ...response, data: { id: 100 } }) as typeof response,
317
+ );
318
+ const mappedCalls = gateRequest(mapped);
319
+ const onSuccess = vi.fn();
320
+ renderHook(() => {
321
+ const state = useFetch(mapped);
322
+ state.onSuccess(({ response }) => onSuccess(response.data));
323
+ return { data: state.data };
324
+ });
325
+ await advance();
326
+ mappedCalls[0].succeed({ id: 1 });
327
+ await settle();
328
+
329
+ expect(onSuccess).toHaveBeenCalledWith({ id: 100 });
330
+ });
331
+ it("should call onError when the mapper turns the response into a failure", async () => {
332
+ const mapped = createRequest<User>().setResponseMapper(
333
+ (response) =>
334
+ ({
335
+ ...response,
336
+ data: null,
337
+ error: new Error("Mapped failure"),
338
+ success: false,
339
+ }) as typeof response,
340
+ );
341
+ const mappedCalls = gateRequest(mapped);
342
+ const onSuccess = vi.fn();
343
+ const onError = vi.fn();
344
+ const { result } = renderHook(() => {
345
+ const state = useFetch(mapped);
346
+ state.onSuccess(onSuccess);
347
+ state.onError(({ response }) => onError(response.error?.message));
348
+ return { error: state.error };
349
+ });
350
+ await advance();
351
+ mappedCalls[0].succeed({ id: 1 });
352
+ await settle();
353
+
354
+ expect(result.current.error?.message).toBe("Mapped failure");
355
+ expect(onError).toHaveBeenCalledWith("Mapped failure");
356
+ expect(onSuccess).not.toHaveBeenCalled();
357
+ });
358
+ });
359
+ });
@@ -0,0 +1,126 @@
1
+ import { act } from "@testing-library/react";
2
+ import { useFetch } from "hooks/use-fetch";
3
+ import { hydrateRoot } from "react-dom/client";
4
+ import { renderToString } from "react-dom/server";
5
+
6
+ import { client, createRequest } from "../../utils";
7
+ import { advance, gateRequest, setCacheResponse, settle } from "../../utils/gate.utils";
8
+
9
+ type User = { id: number; name: string };
10
+
11
+ const user: User = { id: 1, name: "Maciej" };
12
+
13
+ describe("useFetch [ Hydration ]", () => {
14
+ let request = createRequest<User>();
15
+ let calls = gateRequest(request);
16
+ let container = document.createElement("div");
17
+ let unmount: VoidFunction = () => null;
18
+
19
+ const Page = ({ revalidate }: { revalidate?: boolean }) => {
20
+ const { data, loading } = useFetch(request, { revalidate });
21
+ return (
22
+ <div>
23
+ {data?.name ?? "empty"}:{loading ? "loading" : "idle"}
24
+ </div>
25
+ );
26
+ };
27
+
28
+ /** Renders the markup like the server does and hydrates it in the browser */
29
+ const hydrate = async (element: React.ReactElement) => {
30
+ container.innerHTML = renderToString(element);
31
+ const serverMarkup = container.textContent;
32
+ await act(async () => {
33
+ const root = hydrateRoot(container, element);
34
+ unmount = () => root.unmount();
35
+ });
36
+ return serverMarkup;
37
+ };
38
+
39
+ beforeEach(() => {
40
+ vi.useFakeTimers();
41
+ client.clear();
42
+ request = createRequest<User>();
43
+ calls = gateRequest(request);
44
+ container = document.createElement("div");
45
+ document.body.append(container);
46
+ vi.spyOn(console, "error").mockImplementation(() => null);
47
+ });
48
+
49
+ afterEach(() => {
50
+ act(() => unmount());
51
+ container.remove();
52
+ vi.restoreAllMocks();
53
+ vi.useRealTimers();
54
+ });
55
+
56
+ describe("when the cache is hydrated with the server data", () => {
57
+ beforeEach(() => {
58
+ const hydrationData = request.dehydrate({
59
+ response: {
60
+ data: user,
61
+ error: null,
62
+ status: 200,
63
+ success: true,
64
+ extra: client.adapter.defaultExtra,
65
+ requestTimestamp: Date.now(),
66
+ responseTimestamp: Date.now(),
67
+ },
68
+ });
69
+ client.hydrate([hydrationData]);
70
+ });
71
+
72
+ it("should render the data without hydration mismatch", async () => {
73
+ const serverMarkup = await hydrate(<Page revalidate={false} />);
74
+
75
+ expect(serverMarkup).toBe("Maciej:idle");
76
+ expect(container.textContent).toBe("Maciej:idle");
77
+ // eslint-disable-next-line no-console
78
+ expect(console.error).not.toHaveBeenCalled();
79
+ });
80
+ it("should not refetch fresh hydrated data when revalidate is off", async () => {
81
+ await hydrate(<Page revalidate={false} />);
82
+ await advance();
83
+
84
+ expect(calls).toHaveLength(0);
85
+ });
86
+ it("should revalidate the hydrated data by default", async () => {
87
+ await hydrate(<Page />);
88
+ await advance();
89
+ expect(calls).toHaveLength(1);
90
+ expect(container.textContent).toBe("Maciej:loading");
91
+
92
+ calls[0].succeed({ id: 1, name: "Fresh" });
93
+ await settle();
94
+
95
+ expect(container.textContent).toBe("Fresh:idle");
96
+ });
97
+ it("should refetch the hydrated data once it gets stale", async () => {
98
+ client.clear();
99
+ request = createRequest<User>({ staleTime: 1000 });
100
+ calls = gateRequest(request);
101
+ setCacheResponse(request, user, Date.now() - 5000);
102
+
103
+ await hydrate(<Page revalidate={false} />);
104
+ await advance();
105
+
106
+ expect(calls).toHaveLength(1);
107
+ });
108
+ });
109
+
110
+ describe("when there is no data on the server", () => {
111
+ it("should render the loading state and fetch after the hydration", async () => {
112
+ const serverMarkup = await hydrate(<Page />);
113
+ await advance();
114
+
115
+ expect(serverMarkup).toBe("empty:loading");
116
+ expect(calls).toHaveLength(1);
117
+ // eslint-disable-next-line no-console
118
+ expect(console.error).not.toHaveBeenCalled();
119
+
120
+ calls[0].succeed(user);
121
+ await settle();
122
+
123
+ expect(container.textContent).toBe("Maciej:idle");
124
+ });
125
+ });
126
+ });