@hyper-fetch/react 9.6.1 → 9.7.0

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 (98) 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-helpers.spec.tsx +455 -0
  47. package/__tests__/features/use-submit/use-submit.optimistic-settlement.spec.ts +6 -0
  48. package/__tests__/features/use-submit/use-submit.optimistic.spec.ts +5 -1
  49. package/__tests__/features/use-submit/use-submit.state.spec.tsx +1025 -0
  50. package/__tests__/features/use-submit/use-submit.submit-types.spec.ts +194 -0
  51. package/__tests__/features/use-submit/use-submit.submitting.spec.tsx +180 -0
  52. package/__tests__/utils/gate.utils.ts +103 -0
  53. package/__tests__/utils/gated-client.utils.ts +158 -0
  54. package/__tests__/utils/helpers.utils.ts +19 -0
  55. package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
  56. package/dist/helpers/use-request-events/use-request-events.types.d.ts +1 -1
  57. package/dist/helpers/use-request-events/use-request-events.types.d.ts.map +1 -1
  58. package/dist/helpers/use-tracked-state/use-tracked-state.hooks.d.ts.map +1 -1
  59. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts +8 -0
  60. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts.map +1 -1
  61. package/dist/hooks/use-cache/use-cache.hooks.d.ts.map +1 -1
  62. package/dist/hooks/use-fetch/use-fetch.hooks.d.ts.map +1 -1
  63. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts.map +1 -1
  64. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts +3 -0
  65. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts.map +1 -1
  66. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts +5 -3
  67. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts.map +1 -1
  68. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts +11 -1
  69. package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts.map +1 -1
  70. package/dist/hooks/use-listener/use-listener.hooks.d.ts.map +1 -1
  71. package/dist/hooks/use-queue/use-queue.hooks.d.ts.map +1 -1
  72. package/dist/hooks/use-submit/use-submit.constants.d.ts +1 -1
  73. package/dist/hooks/use-submit/use-submit.constants.d.ts.map +1 -1
  74. package/dist/hooks/use-submit/use-submit.hooks.d.ts.map +1 -1
  75. package/dist/hooks/use-submit/use-submit.types.d.ts +6 -1
  76. package/dist/hooks/use-submit/use-submit.types.d.ts.map +1 -1
  77. package/dist/index.mjs +633 -346
  78. package/dist/index.mjs.map +1 -1
  79. package/dist/provider/provider.d.ts.map +1 -1
  80. package/package.json +1 -1
  81. package/src/helpers/use-request-events/use-request-events.hooks.ts +141 -28
  82. package/src/helpers/use-request-events/use-request-events.types.ts +1 -1
  83. package/src/helpers/use-tracked-state/use-tracked-state.hooks.ts +148 -101
  84. package/src/helpers/use-tracked-state/use-tracked-state.utils.ts +26 -5
  85. package/src/hooks/use-cache/use-cache.hooks.ts +20 -5
  86. package/src/hooks/use-fetch/use-fetch.hooks.ts +194 -113
  87. package/src/hooks/use-infinite-fetch/use-infinite-fetch.hooks.ts +55 -26
  88. package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.ts +35 -29
  89. package/src/hooks/use-infinite-fetch/use-infinite-fetch.types.ts +5 -3
  90. package/src/hooks/use-infinite-fetch/use-infinite-fetch.utils.ts +25 -1
  91. package/src/hooks/use-listener/use-listener.hooks.ts +2 -1
  92. package/src/hooks/use-queue/use-queue.hooks.ts +85 -60
  93. package/src/hooks/use-submit/use-submit.constants.ts +3 -1
  94. package/src/hooks/use-submit/use-submit.hooks.ts +167 -53
  95. package/src/hooks/use-submit/use-submit.types.ts +6 -0
  96. package/src/provider/provider.tsx +9 -1
  97. package/__tests__/features/use-fetch/use-fetch.pagination.ts +0 -36
  98. package/__tests__/features/use-fetch/use-fetch.retry.ts +0 -38
@@ -0,0 +1,860 @@
1
+ import type { RequestInstance } from "@hyper-fetch/core";
2
+ import { act, renderHook, waitFor } from "@testing-library/react";
3
+ import type { UseSubmitReturnType } from "hooks/use-submit";
4
+ import { useSubmit } from "hooks/use-submit";
5
+ import type { Mock } from "vitest";
6
+
7
+ import { createGatedClient } from "../../utils/gated-client.utils";
8
+ import { collectThrownErrors } from "../../utils/helpers.utils";
9
+
10
+ type User = { id: number; name: string };
11
+
12
+ const setup = (options?: { retry?: number; retryTime?: number; cancelable?: boolean; queued?: boolean }) => {
13
+ const gated = createGatedClient();
14
+ const request = gated.client.createRequest<{ response: User; payload: { name: string } }>()({
15
+ endpoint: "/users",
16
+ method: "POST",
17
+ retry: options?.retry ?? 0,
18
+ retryTime: options?.retryTime ?? 0,
19
+ cancelable: options?.cancelable ?? false,
20
+ queued: options?.queued ?? false,
21
+ });
22
+ return { ...gated, request };
23
+ };
24
+
25
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
26
+ type EventSpy = Mock<(params: any) => void>;
27
+
28
+ type Events = {
29
+ order: string[];
30
+ success: EventSpy;
31
+ error: EventSpy;
32
+ finished: EventSpy;
33
+ requestStart: EventSpy;
34
+ responseStart: EventSpy;
35
+ upload: EventSpy;
36
+ download: EventSpy;
37
+ abort: EventSpy;
38
+ offline: EventSpy;
39
+ };
40
+
41
+ const createEvents = (): Events => {
42
+ const order: string[] = [];
43
+ const track = (name: string): EventSpy =>
44
+ vi.fn(() => {
45
+ order.push(name);
46
+ });
47
+ return {
48
+ order,
49
+ success: track("success"),
50
+ error: track("error"),
51
+ finished: track("finished"),
52
+ requestStart: track("requestStart"),
53
+ responseStart: track("responseStart"),
54
+ upload: vi.fn<(params: any) => void>(),
55
+ download: vi.fn<(params: any) => void>(),
56
+ abort: track("abort"),
57
+ offline: track("offline"),
58
+ };
59
+ };
60
+
61
+ /** Registers every callback the way components do - during the render */
62
+ const useSubmitWithEvents = <T extends RequestInstance>(request: T, events: Events) => {
63
+ const view = useSubmit(request, { dependencyTracking: false });
64
+ view.onSubmitSuccess(events.success);
65
+ view.onSubmitError(events.error);
66
+ view.onSubmitFinished(events.finished);
67
+ view.onSubmitRequestStart(events.requestStart);
68
+ view.onSubmitResponseStart(events.responseStart);
69
+ view.onSubmitUploadProgress(events.upload);
70
+ view.onSubmitDownloadProgress(events.download);
71
+ view.onSubmitAbort(events.abort);
72
+ view.onSubmitOfflineError(events.offline);
73
+ return view;
74
+ };
75
+
76
+ /** Errors thrown by the user callbacks are thrown outside of the request lifecycle */
77
+ const collectReportedErrors = collectThrownErrors;
78
+
79
+ /** Run the pending timers and promise callbacks - for the tests using fake timers */
80
+ const advance = async (time = 0) => {
81
+ await act(async () => {
82
+ await vi.advanceTimersByTimeAsync(time);
83
+ });
84
+ };
85
+
86
+ describe("useSubmit [ Callbacks ]", () => {
87
+ afterEach(() => {
88
+ vi.useRealTimers();
89
+ });
90
+
91
+ describe("when the submit succeeds", () => {
92
+ it("should call the callbacks in the lifecycle order", async () => {
93
+ const { request, waitForCall } = setup();
94
+ const events = createEvents();
95
+ const { result } = renderHook(() => useSubmitWithEvents(request, events));
96
+ let promise: Promise<unknown> = Promise.resolve();
97
+
98
+ act(() => {
99
+ promise = result.current.submit({ payload: { name: "Maciej" } }).then(() => events.order.push("resolved"));
100
+ });
101
+ const call = await waitForCall(0);
102
+ await act(async () => {
103
+ call.succeed({ id: 1, name: "Maciej" });
104
+ await promise;
105
+ });
106
+
107
+ expect(events.order).toStrictEqual(["requestStart", "responseStart", "success", "finished", "resolved"]);
108
+ });
109
+ it("should call every callback once", async () => {
110
+ const { request, waitForCall } = setup();
111
+ const events = createEvents();
112
+ const { result } = renderHook(() => useSubmitWithEvents(request, events));
113
+ let promise: Promise<unknown> = Promise.resolve();
114
+
115
+ act(() => {
116
+ promise = result.current.submit({ payload: { name: "Maciej" } });
117
+ });
118
+ const call = await waitForCall(0);
119
+ await act(async () => {
120
+ call.succeed({ id: 1, name: "Maciej" });
121
+ await promise;
122
+ });
123
+
124
+ expect(events.requestStart).toHaveBeenCalledTimes(1);
125
+ expect(events.responseStart).toHaveBeenCalledTimes(1);
126
+ expect(events.success).toHaveBeenCalledTimes(1);
127
+ expect(events.finished).toHaveBeenCalledTimes(1);
128
+ });
129
+ it("should not call the error, abort and offline callbacks", async () => {
130
+ const { request, waitForCall } = setup();
131
+ const events = createEvents();
132
+ const { result } = renderHook(() => useSubmitWithEvents(request, events));
133
+ let promise: Promise<unknown> = Promise.resolve();
134
+
135
+ act(() => {
136
+ promise = result.current.submit({ payload: { name: "Maciej" } });
137
+ });
138
+ const call = await waitForCall(0);
139
+ await act(async () => {
140
+ call.succeed({ id: 1, name: "Maciej" });
141
+ await promise;
142
+ });
143
+
144
+ expect(events.error).not.toHaveBeenCalled();
145
+ expect(events.abort).not.toHaveBeenCalled();
146
+ expect(events.offline).not.toHaveBeenCalled();
147
+ });
148
+ it("should pass the response, the request and its details as a single object", async () => {
149
+ const { request, waitForCall } = setup();
150
+ const events = createEvents();
151
+ const { result } = renderHook(() => useSubmitWithEvents(request, events));
152
+ let promise: Promise<unknown> = Promise.resolve();
153
+
154
+ act(() => {
155
+ promise = result.current.submit({ payload: { name: "Maciej" } });
156
+ });
157
+ const call = await waitForCall(0);
158
+ await act(async () => {
159
+ call.succeed({ id: 1, name: "Maciej" }, 201);
160
+ await promise;
161
+ });
162
+
163
+ const [params] = events.success.mock.calls[0];
164
+ expect(events.success.mock.calls[0]).toHaveLength(1);
165
+ expect(params.response.data).toStrictEqual({ id: 1, name: "Maciej" });
166
+ expect(params.response.status).toBe(201);
167
+ expect(params.response.success).toBeTrue();
168
+ expect(params.response.error).toBeNull();
169
+ expect(params.requestId).toBe(call.requestId);
170
+ expect(params.request.payload).toStrictEqual({ name: "Maciej" });
171
+ expect(params.details.retries).toBe(0);
172
+ expect(params.details.isCanceled).toBeFalse();
173
+ expect(params.details.isOffline).toBeFalse();
174
+ expect(params.details.willRetry).toBeFalse();
175
+ expect(params.mutationContext).toBeUndefined();
176
+ });
177
+ it("should pass the same response to onSubmitSuccess and onSubmitFinished", async () => {
178
+ const { request, waitForCall } = setup();
179
+ const events = createEvents();
180
+ const { result } = renderHook(() => useSubmitWithEvents(request, events));
181
+ let promise: Promise<unknown> = Promise.resolve();
182
+
183
+ act(() => {
184
+ promise = result.current.submit({ payload: { name: "Maciej" } });
185
+ });
186
+ const call = await waitForCall(0);
187
+ await act(async () => {
188
+ call.succeed({ id: 1, name: "Maciej" });
189
+ await promise;
190
+ });
191
+
192
+ expect(events.finished.mock.calls[0][0].response).toStrictEqual(events.success.mock.calls[0][0].response);
193
+ expect(events.finished.mock.calls[0][0].requestId).toBe(call.requestId);
194
+ });
195
+ it("should pass the request to the start callbacks", async () => {
196
+ const { request, waitForCall } = setup();
197
+ const events = createEvents();
198
+ const { result } = renderHook(() => useSubmitWithEvents(request, events));
199
+
200
+ act(() => {
201
+ result.current.submit({ payload: { name: "Maciej" } });
202
+ });
203
+ const call = await waitForCall(0);
204
+
205
+ expect(events.requestStart).toHaveBeenCalledTimes(1);
206
+ expect(events.requestStart.mock.calls[0][0].requestId).toBe(call.requestId);
207
+ expect(events.requestStart.mock.calls[0][0].request.payload).toStrictEqual({ name: "Maciej" });
208
+ expect(events.responseStart).not.toHaveBeenCalled();
209
+ });
210
+ it("should call the callbacks once for every submit", async () => {
211
+ const { request, waitForCalls } = setup();
212
+ const events = createEvents();
213
+ const { result } = renderHook(() => useSubmitWithEvents(request, events));
214
+ let promises: Promise<unknown>[] = [];
215
+
216
+ act(() => {
217
+ promises = ["First", "Second", "Third"].map((name) => result.current.submit({ payload: { name } }));
218
+ });
219
+ const calls = await waitForCalls(3);
220
+ await act(async () => {
221
+ calls.forEach((call, index) => call.succeed({ id: index, name: `User ${index}` }));
222
+ await Promise.all(promises);
223
+ });
224
+
225
+ expect(events.requestStart).toHaveBeenCalledTimes(3);
226
+ expect(events.success).toHaveBeenCalledTimes(3);
227
+ expect(events.finished).toHaveBeenCalledTimes(3);
228
+ expect(events.success.mock.calls.map(([params]) => params.requestId).toSorted()).toStrictEqual(
229
+ calls.map((call) => call.requestId).toSorted(),
230
+ );
231
+ });
232
+ });
233
+
234
+ describe("when the submit fails", () => {
235
+ it("should call the callbacks in the lifecycle order", async () => {
236
+ const { request, waitForCall } = setup();
237
+ const events = createEvents();
238
+ const { result } = renderHook(() => useSubmitWithEvents(request, events));
239
+ let promise: Promise<unknown> = Promise.resolve();
240
+
241
+ act(() => {
242
+ promise = result.current.submit({ payload: { name: "Maciej" } }).then(() => events.order.push("resolved"));
243
+ });
244
+ const call = await waitForCall(0);
245
+ await act(async () => {
246
+ call.fail({ message: "Nope" }, 400);
247
+ await promise;
248
+ });
249
+
250
+ expect(events.order).toStrictEqual(["requestStart", "responseStart", "error", "finished", "resolved"]);
251
+ });
252
+ it("should not call the success callback", async () => {
253
+ const { request, waitForCall } = setup();
254
+ const events = createEvents();
255
+ const { result } = renderHook(() => useSubmitWithEvents(request, events));
256
+ let promise: Promise<unknown> = Promise.resolve();
257
+
258
+ act(() => {
259
+ promise = result.current.submit({ payload: { name: "Maciej" } });
260
+ });
261
+ const call = await waitForCall(0);
262
+ await act(async () => {
263
+ call.fail({ message: "Nope" }, 400);
264
+ await promise;
265
+ });
266
+
267
+ expect(events.success).not.toHaveBeenCalled();
268
+ expect(events.error).toHaveBeenCalledTimes(1);
269
+ expect(events.finished).toHaveBeenCalledTimes(1);
270
+ });
271
+ it("should pass the error response as a single object", async () => {
272
+ const { request, waitForCall } = setup();
273
+ const events = createEvents();
274
+ const { result } = renderHook(() => useSubmitWithEvents(request, events));
275
+ let promise: Promise<unknown> = Promise.resolve();
276
+
277
+ act(() => {
278
+ promise = result.current.submit({ payload: { name: "Maciej" } });
279
+ });
280
+ const call = await waitForCall(0);
281
+ await act(async () => {
282
+ call.fail({ message: "Name is taken" }, 409);
283
+ await promise;
284
+ });
285
+
286
+ const [params] = events.error.mock.calls[0];
287
+ expect(events.error.mock.calls[0]).toHaveLength(1);
288
+ expect(params.response.error).toStrictEqual({ message: "Name is taken" });
289
+ expect(params.response.status).toBe(409);
290
+ expect(params.response.success).toBeFalse();
291
+ expect(params.response.data).toBeNull();
292
+ expect(params.requestId).toBe(call.requestId);
293
+ expect(params.details.willRetry).toBeFalse();
294
+ });
295
+ it("should report every failed attempt of a retried request", async () => {
296
+ vi.useFakeTimers();
297
+ const { request, calls } = setup({ retry: 2, retryTime: 5000 });
298
+ const events = createEvents();
299
+ const { result } = renderHook(() => useSubmitWithEvents(request, events));
300
+
301
+ act(() => {
302
+ result.current.submit({ payload: { name: "Maciej" } });
303
+ });
304
+ await advance();
305
+ for (let attempt = 0; attempt < 3; attempt += 1) {
306
+ calls[attempt].fail({ message: `Attempt ${attempt}` }, 500);
307
+ // eslint-disable-next-line no-await-in-loop
308
+ await advance(5000);
309
+ }
310
+
311
+ expect(events.error).toHaveBeenCalledTimes(3);
312
+ expect(events.error.mock.calls.map(([params]) => params.details.willRetry)).toStrictEqual([true, true, false]);
313
+ expect(events.error.mock.calls.map(([params]) => params.details.retries)).toStrictEqual([0, 1, 2]);
314
+ expect(events.requestStart).toHaveBeenCalledTimes(3);
315
+ expect(events.success).not.toHaveBeenCalled();
316
+ });
317
+ it("should call the success callback when the retry succeeds", async () => {
318
+ vi.useFakeTimers();
319
+ const { request, calls } = setup({ retry: 1, retryTime: 5000 });
320
+ const events = createEvents();
321
+ const { result } = renderHook(() => useSubmitWithEvents(request, events));
322
+
323
+ act(() => {
324
+ result.current.submit({ payload: { name: "Maciej" } });
325
+ });
326
+ await advance();
327
+ calls[0].fail();
328
+ await advance(5000);
329
+ calls[1].succeed({ id: 1, name: "Maciej" });
330
+ await advance();
331
+
332
+ expect(events.order).toStrictEqual([
333
+ "requestStart",
334
+ "responseStart",
335
+ "error",
336
+ "finished",
337
+ "requestStart",
338
+ "responseStart",
339
+ "success",
340
+ "finished",
341
+ ]);
342
+ expect(events.success.mock.calls[0][0].details.retries).toBe(1);
343
+ });
344
+ });
345
+
346
+ describe("when the request reports its progress", () => {
347
+ it("should call the upload progress callback", async () => {
348
+ const { request, waitForCall } = setup();
349
+ const events = createEvents();
350
+ const { result } = renderHook(() => useSubmitWithEvents(request, events));
351
+
352
+ act(() => {
353
+ result.current.submit({ payload: { name: "Maciej" } });
354
+ });
355
+ const call = await waitForCall(0);
356
+ events.upload.mockClear();
357
+ act(() => {
358
+ call.upload(30, 100);
359
+ call.upload(100, 100);
360
+ });
361
+
362
+ expect(events.upload).toHaveBeenCalledTimes(2);
363
+ expect(events.upload.mock.calls[0][0]).toMatchObject({ loaded: 30, total: 100, progress: 30, sizeLeft: 70 });
364
+ expect(events.upload.mock.calls[1][0]).toMatchObject({ loaded: 100, total: 100, progress: 100, sizeLeft: 0 });
365
+ expect(events.upload.mock.calls[0][0].requestId).toBe(call.requestId);
366
+ });
367
+ it("should call the download progress callback", async () => {
368
+ const { request, waitForCall } = setup();
369
+ const events = createEvents();
370
+ const { result } = renderHook(() => useSubmitWithEvents(request, events));
371
+
372
+ act(() => {
373
+ result.current.submit({ payload: { name: "Maciej" } });
374
+ });
375
+ const call = await waitForCall(0);
376
+ act(() => {
377
+ call.download(25, 50);
378
+ });
379
+
380
+ expect(events.download).toHaveBeenCalledTimes(1);
381
+ expect(events.download.mock.calls[0][0]).toMatchObject({ loaded: 25, total: 50, progress: 50 });
382
+ });
383
+ it("should report the progress of every request in flight", async () => {
384
+ const { request, waitForCalls } = setup();
385
+ const events = createEvents();
386
+ const { result } = renderHook(() => useSubmitWithEvents(request, events));
387
+
388
+ act(() => {
389
+ result.current.submit({ payload: { name: "First" } });
390
+ result.current.submit({ payload: { name: "Second" } });
391
+ });
392
+ const calls = await waitForCalls(2);
393
+ events.upload.mockClear();
394
+ act(() => {
395
+ calls[0].upload(10, 100);
396
+ calls[1].upload(90, 100);
397
+ });
398
+
399
+ expect(events.upload.mock.calls.map(([params]) => [params.requestId, params.loaded])).toStrictEqual([
400
+ [calls[0].requestId, 10],
401
+ [calls[1].requestId, 90],
402
+ ]);
403
+ });
404
+ });
405
+
406
+ describe("when the callbacks change between renders", () => {
407
+ it("should call the callback from the latest render", async () => {
408
+ const { request, waitForCall } = setup();
409
+ const seen: string[] = [];
410
+ const { result, rerender } = renderHook(
411
+ ({ label }: { label: string }) => {
412
+ const view = useSubmit(request, { dependencyTracking: false });
413
+ view.onSubmitSuccess(() => {
414
+ seen.push(label);
415
+ });
416
+ return view;
417
+ },
418
+ { initialProps: { label: "first render" } },
419
+ );
420
+ let promise: Promise<unknown> = Promise.resolve();
421
+ act(() => {
422
+ promise = result.current.submit({ payload: { name: "Maciej" } });
423
+ });
424
+ const call = await waitForCall(0);
425
+
426
+ rerender({ label: "latest render" });
427
+ await act(async () => {
428
+ call.succeed({ id: 1, name: "Maciej" });
429
+ await promise;
430
+ });
431
+
432
+ expect(seen).toStrictEqual(["latest render"]);
433
+ });
434
+ it("should call the error callback from the latest render", async () => {
435
+ const { request, waitForCall } = setup();
436
+ const seen: string[] = [];
437
+ const { result, rerender } = renderHook(
438
+ ({ label }: { label: string }) => {
439
+ const view = useSubmit(request, { dependencyTracking: false });
440
+ view.onSubmitError(() => {
441
+ seen.push(label);
442
+ });
443
+ return view;
444
+ },
445
+ { initialProps: { label: "first render" } },
446
+ );
447
+ let promise: Promise<unknown> = Promise.resolve();
448
+ act(() => {
449
+ promise = result.current.submit({ payload: { name: "Maciej" } });
450
+ });
451
+ const call = await waitForCall(0);
452
+
453
+ rerender({ label: "latest render" });
454
+ await act(async () => {
455
+ call.fail();
456
+ await promise;
457
+ });
458
+
459
+ expect(seen).toStrictEqual(["latest render"]);
460
+ });
461
+ it("should work without any callback registered", async () => {
462
+ const { request, waitForCall } = setup();
463
+ const { result } = renderHook(() => useSubmit(request, { dependencyTracking: false }));
464
+ let promise: ReturnType<UseSubmitReturnType<typeof request>["submit"]> | null = null;
465
+
466
+ act(() => {
467
+ promise = result.current.submit({ payload: { name: "Maciej" } });
468
+ });
469
+ const call = await waitForCall(0);
470
+ act(() => {
471
+ call.succeed({ id: 1, name: "Maciej" });
472
+ });
473
+
474
+ const response = await promise!;
475
+ expect(response.success).toBeTrue();
476
+ });
477
+ });
478
+
479
+ describe("when the hook unmounts before the response", () => {
480
+ it("should not call the callbacks", async () => {
481
+ const { request, waitForCall } = setup();
482
+ const events = createEvents();
483
+ const { result, unmount } = renderHook(() => useSubmitWithEvents(request, events));
484
+ let promise: Promise<unknown> = Promise.resolve();
485
+ act(() => {
486
+ promise = result.current.submit({ payload: { name: "Maciej" } });
487
+ });
488
+ const call = await waitForCall(0);
489
+ events.upload.mockClear();
490
+
491
+ unmount();
492
+ call.upload(1, 2);
493
+ call.succeed({ id: 1, name: "Maciej" });
494
+ await promise;
495
+
496
+ expect(events.success).not.toHaveBeenCalled();
497
+ expect(events.finished).not.toHaveBeenCalled();
498
+ expect(events.responseStart).not.toHaveBeenCalled();
499
+ expect(events.upload).not.toHaveBeenCalled();
500
+ });
501
+ it("should not call the error callbacks", async () => {
502
+ const { request, waitForCall } = setup();
503
+ const events = createEvents();
504
+ const { result, unmount } = renderHook(() => useSubmitWithEvents(request, events));
505
+ let promise: Promise<unknown> = Promise.resolve();
506
+ act(() => {
507
+ promise = result.current.submit({ payload: { name: "Maciej" } });
508
+ });
509
+ const call = await waitForCall(0);
510
+
511
+ unmount();
512
+ call.fail();
513
+ await promise;
514
+
515
+ expect(events.error).not.toHaveBeenCalled();
516
+ expect(events.finished).not.toHaveBeenCalled();
517
+ });
518
+ });
519
+
520
+ describe("when two hooks use the same request", () => {
521
+ it("should call the callbacks only in the hook that submitted", async () => {
522
+ const { request, waitForCall } = setup();
523
+ const submitterEvents = createEvents();
524
+ const observerEvents = createEvents();
525
+ const submitter = renderHook(() => useSubmitWithEvents(request, submitterEvents));
526
+ renderHook(() => useSubmitWithEvents(request, observerEvents));
527
+ let promise: Promise<unknown> = Promise.resolve();
528
+
529
+ act(() => {
530
+ promise = submitter.result.current.submit({ payload: { name: "Maciej" } });
531
+ });
532
+ const call = await waitForCall(0);
533
+ await act(async () => {
534
+ call.succeed({ id: 1, name: "Maciej" });
535
+ await promise;
536
+ });
537
+
538
+ expect(submitterEvents.success).toHaveBeenCalledTimes(1);
539
+ expect(submitterEvents.finished).toHaveBeenCalledTimes(1);
540
+ expect(observerEvents.requestStart).not.toHaveBeenCalled();
541
+ expect(observerEvents.success).not.toHaveBeenCalled();
542
+ expect(observerEvents.finished).not.toHaveBeenCalled();
543
+ });
544
+ });
545
+
546
+ describe("when a newer cancelable submit replaces the request", () => {
547
+ it("should call the abort callback for the replaced request", async () => {
548
+ const { request, waitForCall } = setup({ cancelable: true });
549
+ const events = createEvents();
550
+ const { result } = renderHook(() => useSubmitWithEvents(request, events));
551
+ let promise: Promise<unknown> = Promise.resolve();
552
+ act(() => {
553
+ result.current.submit({ payload: { name: "First" } });
554
+ });
555
+ const firstCall = await waitForCall(0);
556
+
557
+ act(() => {
558
+ promise = result.current.submit({ payload: { name: "Second" } });
559
+ });
560
+ const secondCall = await waitForCall(1);
561
+ await act(async () => {
562
+ secondCall.succeed({ id: 2, name: "Second" });
563
+ await promise;
564
+ });
565
+
566
+ expect(events.abort).toHaveBeenCalledTimes(1);
567
+ expect(events.abort.mock.calls[0][0].requestId).toBe(firstCall.requestId);
568
+ expect(events.abort.mock.calls[0][0].details.isCanceled).toBeTrue();
569
+ expect(events.error).not.toHaveBeenCalled();
570
+ expect(events.success).toHaveBeenCalledTimes(1);
571
+ expect(events.success.mock.calls[0][0].requestId).toBe(secondCall.requestId);
572
+ expect(events.finished).toHaveBeenCalledTimes(2);
573
+ });
574
+ });
575
+
576
+ describe("when the application is offline", () => {
577
+ it("should call the offline callback instead of the error callback", async () => {
578
+ const { request, client, waitForCall } = setup();
579
+ const events = createEvents();
580
+ const { result } = renderHook(() => useSubmitWithEvents(request, events));
581
+ act(() => {
582
+ result.current.submit({ payload: { name: "Maciej" } });
583
+ });
584
+ const call = await waitForCall(0);
585
+
586
+ act(() => {
587
+ client.appManager.setOnline(false);
588
+ call.fail({ message: "Network error" }, 0);
589
+ });
590
+
591
+ await waitFor(() => {
592
+ expect(events.offline).toHaveBeenCalledTimes(1);
593
+ });
594
+ expect(events.offline.mock.calls[0][0].details.isOffline).toBeTrue();
595
+ expect(events.error).not.toHaveBeenCalled();
596
+ expect(events.finished).toHaveBeenCalledTimes(1);
597
+ });
598
+ it("should call the error callback for a request that does not wait for the network", async () => {
599
+ const { request, client, waitForCall } = setup();
600
+ const events = createEvents();
601
+ const { result } = renderHook(() => useSubmitWithEvents(request.setOffline(false), events));
602
+ act(() => {
603
+ result.current.submit({ payload: { name: "Maciej" } });
604
+ });
605
+ const call = await waitForCall(0);
606
+
607
+ act(() => {
608
+ client.appManager.setOnline(false);
609
+ call.fail({ message: "Network error" }, 0);
610
+ });
611
+
612
+ await waitFor(() => {
613
+ expect(events.error).toHaveBeenCalledTimes(1);
614
+ });
615
+ expect(events.offline).not.toHaveBeenCalled();
616
+ });
617
+ });
618
+
619
+ describe("when a callback submits another request", () => {
620
+ it("should send the follow-up request from the success callback", async () => {
621
+ const { request, client, waitForCall } = setup();
622
+ const followUp = client.createRequest<{ response: { sent: boolean }; payload: { userId: number } }>()({
623
+ endpoint: "/welcome-emails",
624
+ method: "POST",
625
+ });
626
+ const finished: string[] = [];
627
+ const { result } = renderHook(() => {
628
+ const user = useSubmit(request, { dependencyTracking: false });
629
+ const email = useSubmit(followUp, { dependencyTracking: false });
630
+ user.onSubmitSuccess(({ response }) => {
631
+ email.submit({ payload: { userId: response.data.id } });
632
+ });
633
+ user.onSubmitFinished(() => {
634
+ finished.push("user");
635
+ });
636
+ email.onSubmitFinished(() => {
637
+ finished.push("email");
638
+ });
639
+ return { user, email };
640
+ });
641
+
642
+ act(() => {
643
+ result.current.user.submit({ payload: { name: "Maciej" } });
644
+ });
645
+ const userCall = await waitForCall(0);
646
+ act(() => {
647
+ userCall.succeed({ id: 7, name: "Maciej" });
648
+ });
649
+ const emailCall = await waitForCall(1);
650
+ expect(emailCall.request.payload).toStrictEqual({ userId: 7 });
651
+ act(() => {
652
+ emailCall.succeed({ sent: true });
653
+ });
654
+
655
+ await waitFor(() => {
656
+ expect(result.current.email.data).toStrictEqual({ sent: true });
657
+ });
658
+ expect(finished).toStrictEqual(["user", "email"]);
659
+ expect(result.current.user.data).toStrictEqual({ id: 7, name: "Maciej" });
660
+ });
661
+ });
662
+
663
+ describe("when a callback throws", () => {
664
+ const setupThrowing = (
665
+ register: (view: UseSubmitReturnType<ReturnType<typeof setup>["request"]>) => void,
666
+ options?: Parameters<typeof setup>[0],
667
+ ) => {
668
+ const context = setup(options);
669
+ const view = renderHook(() => {
670
+ const submit = useSubmit(context.request, { dependencyTracking: false });
671
+ register(submit);
672
+ return submit;
673
+ });
674
+ return { ...context, view };
675
+ };
676
+ const fail = () => {
677
+ throw new Error("Callback failed");
678
+ };
679
+
680
+ it("should still finish the request when onSubmitSuccess throws", async () => {
681
+ const errors = collectReportedErrors();
682
+ const { view, waitForCall, client, request } = setupThrowing((submit) => submit.onSubmitSuccess(fail));
683
+ let promise: ReturnType<typeof view.result.current.submit> | null = null;
684
+ act(() => {
685
+ promise = view.result.current.submit({ payload: { name: "Maciej" } });
686
+ });
687
+ const call = await waitForCall(0);
688
+
689
+ act(() => {
690
+ call.succeed({ id: 1, name: "Maciej" });
691
+ });
692
+
693
+ const response = await promise!;
694
+ expect(response.data).toStrictEqual({ id: 1, name: "Maciej" });
695
+ await waitFor(() => {
696
+ expect(view.result.current.data).toStrictEqual({ id: 1, name: "Maciej" });
697
+ });
698
+ expect(view.result.current.submitting).toBeFalse();
699
+ expect(client.submitDispatcher.getQueue(request.queryKey).requests).toHaveLength(0);
700
+ await waitFor(() => {
701
+ expect(errors).toHaveLength(1);
702
+ });
703
+ expect((errors[0] as Error).message).toBe("Callback failed");
704
+ });
705
+ it("should still call onSubmitFinished when onSubmitSuccess throws", async () => {
706
+ collectReportedErrors();
707
+ const finished = vi.fn();
708
+ const { view, waitForCall } = setupThrowing((submit) => {
709
+ submit.onSubmitSuccess(fail);
710
+ submit.onSubmitFinished(finished);
711
+ });
712
+ let promise: Promise<unknown> = Promise.resolve();
713
+ act(() => {
714
+ promise = view.result.current.submit({ payload: { name: "Maciej" } });
715
+ });
716
+ const call = await waitForCall(0);
717
+
718
+ await act(async () => {
719
+ call.succeed({ id: 1, name: "Maciej" });
720
+ await promise;
721
+ });
722
+
723
+ expect(finished).toHaveBeenCalledTimes(1);
724
+ });
725
+ it("should still finish the request when onSubmitError throws", async () => {
726
+ const errors = collectReportedErrors();
727
+ const { view, waitForCall } = setupThrowing((submit) => submit.onSubmitError(fail));
728
+ let promise: ReturnType<typeof view.result.current.submit> | null = null;
729
+ act(() => {
730
+ promise = view.result.current.submit({ payload: { name: "Maciej" } });
731
+ });
732
+ const call = await waitForCall(0);
733
+
734
+ act(() => {
735
+ call.fail({ message: "Nope" }, 400);
736
+ });
737
+
738
+ const response = await promise!;
739
+ expect(response.error).toStrictEqual({ message: "Nope" });
740
+ await waitFor(() => {
741
+ expect(view.result.current.error).toStrictEqual({ message: "Nope" });
742
+ });
743
+ expect(view.result.current.submitting).toBeFalse();
744
+ await waitFor(() => {
745
+ expect(errors).toHaveLength(1);
746
+ });
747
+ });
748
+ it("should still finish the request when onSubmitFinished throws", async () => {
749
+ const errors = collectReportedErrors();
750
+ const { view, waitForCall } = setupThrowing((submit) => submit.onSubmitFinished(fail));
751
+ let promise: ReturnType<typeof view.result.current.submit> | null = null;
752
+ act(() => {
753
+ promise = view.result.current.submit({ payload: { name: "Maciej" } });
754
+ });
755
+ const call = await waitForCall(0);
756
+
757
+ act(() => {
758
+ call.succeed({ id: 1, name: "Maciej" });
759
+ });
760
+
761
+ const response = await promise!;
762
+ expect(response.success).toBeTrue();
763
+ await waitFor(() => {
764
+ expect(view.result.current.submitting).toBeFalse();
765
+ });
766
+ await waitFor(() => {
767
+ expect(errors).toHaveLength(1);
768
+ });
769
+ });
770
+ it("should still send the request when onSubmitRequestStart throws", async () => {
771
+ const errors = collectReportedErrors();
772
+ const { view, waitForCall } = setupThrowing((submit) => submit.onSubmitRequestStart(fail));
773
+ let promise: ReturnType<typeof view.result.current.submit> | null = null;
774
+ act(() => {
775
+ promise = view.result.current.submit({ payload: { name: "Maciej" } });
776
+ });
777
+ const call = await waitForCall(0);
778
+
779
+ act(() => {
780
+ call.succeed({ id: 1, name: "Maciej" });
781
+ });
782
+
783
+ const response = await promise!;
784
+ expect(response.success).toBeTrue();
785
+ expect(response.data).toStrictEqual({ id: 1, name: "Maciej" });
786
+ await waitFor(() => {
787
+ expect(errors).toHaveLength(1);
788
+ });
789
+ });
790
+ it("should still finish the request when a progress callback throws", async () => {
791
+ const errors = collectReportedErrors();
792
+ const { view, waitForCall } = setupThrowing((submit) => submit.onSubmitDownloadProgress(fail));
793
+ let promise: ReturnType<typeof view.result.current.submit> | null = null;
794
+ act(() => {
795
+ promise = view.result.current.submit({ payload: { name: "Maciej" } });
796
+ });
797
+ const call = await waitForCall(0);
798
+
799
+ act(() => {
800
+ call.download(1, 2);
801
+ call.succeed({ id: 1, name: "Maciej" });
802
+ });
803
+
804
+ const response = await promise!;
805
+ expect(response.success).toBeTrue();
806
+ await waitFor(() => {
807
+ expect(errors.length).toBeGreaterThanOrEqual(1);
808
+ });
809
+ });
810
+ it("should allow to submit again after a callback threw", async () => {
811
+ collectReportedErrors();
812
+ const { view, waitForCall } = setupThrowing((submit) => submit.onSubmitSuccess(fail));
813
+ let promise: Promise<unknown> = Promise.resolve();
814
+ act(() => {
815
+ promise = view.result.current.submit({ payload: { name: "First" } });
816
+ });
817
+ const firstCall = await waitForCall(0);
818
+ await act(async () => {
819
+ firstCall.succeed({ id: 1, name: "First" });
820
+ await promise;
821
+ });
822
+
823
+ act(() => {
824
+ view.result.current.submit({ payload: { name: "Second" } });
825
+ });
826
+ const secondCall = await waitForCall(1);
827
+ act(() => {
828
+ secondCall.succeed({ id: 2, name: "Second" });
829
+ });
830
+
831
+ await waitFor(() => {
832
+ expect(view.result.current.data).toStrictEqual({ id: 2, name: "Second" });
833
+ });
834
+ expect(view.result.current.submitting).toBeFalse();
835
+ });
836
+ it("should not block the queued requests when a callback throws", async () => {
837
+ collectReportedErrors();
838
+ const { view, waitForCall } = setupThrowing((submit) => submit.onSubmitSuccess(fail), { queued: true });
839
+ let promises: Promise<unknown>[] = [];
840
+ act(() => {
841
+ promises = ["First", "Second"].map((name) => view.result.current.submit({ payload: { name } }));
842
+ });
843
+ const firstCall = await waitForCall(0);
844
+
845
+ act(() => {
846
+ firstCall.succeed({ id: 1, name: "First" });
847
+ });
848
+ const secondCall = await waitForCall(1);
849
+ await act(async () => {
850
+ secondCall.succeed({ id: 2, name: "Second" });
851
+ await Promise.all(promises);
852
+ });
853
+
854
+ expect(secondCall.request.payload).toStrictEqual({ name: "Second" });
855
+ await waitFor(() => {
856
+ expect(view.result.current.submitting).toBeFalse();
857
+ });
858
+ });
859
+ });
860
+ });