@hyper-fetch/react 9.4.2 → 9.5.1

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 (42) hide show
  1. package/__tests__/features/hydrate/hydrate.spec.tsx +511 -0
  2. package/__tests__/features/hydrate/hydrate.ssr.spec.tsx +189 -0
  3. package/__tests__/features/use-fetch/use-fetch.concurrency.spec.ts +2 -1
  4. package/__tests__/features/use-fetch/use-fetch.methods.spec.ts +9 -3
  5. package/__tests__/features/use-fetch/use-fetch.offline.spec.ts +4 -2
  6. package/__tests__/features/use-fetch/use-fetch.scope.spec.tsx +211 -0
  7. package/__tests__/features/use-fetch/use-fetch.suspense.spec.tsx +223 -0
  8. package/__tests__/features/use-submit/use-submit.methods.spec.ts +9 -3
  9. package/__tests__/features/use-submit/use-submit.optimistic-settlement.spec.ts +625 -0
  10. package/__tests__/features/use-submit/use-submit.optimistic.spec.ts +12 -4
  11. package/__tests__/tsconfig.json +2 -0
  12. package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
  13. package/dist/helpers/use-tracked-state/use-tracked-state.hooks.d.ts.map +1 -1
  14. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts +4 -1
  15. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts.map +1 -1
  16. package/dist/hooks/use-fetch/use-fetch.hooks.d.ts.map +1 -1
  17. package/dist/hydrate/hydrate.d.ts +16 -0
  18. package/dist/hydrate/hydrate.d.ts.map +1 -0
  19. package/dist/hydrate/hydrate.types.d.ts +52 -0
  20. package/dist/hydrate/hydrate.types.d.ts.map +1 -0
  21. package/dist/hydrate/hydrate.utils.d.ts +19 -0
  22. package/dist/hydrate/hydrate.utils.d.ts.map +1 -0
  23. package/dist/hydrate/index.d.ts +3 -0
  24. package/dist/hydrate/index.d.ts.map +1 -0
  25. package/dist/index.d.ts +1 -0
  26. package/dist/index.d.ts.map +1 -1
  27. package/dist/index.mjs +229 -44
  28. package/dist/index.mjs.map +1 -1
  29. package/dist/utils/scope.utils.d.ts +7 -0
  30. package/dist/utils/scope.utils.d.ts.map +1 -0
  31. package/package.json +1 -1
  32. package/src/helpers/use-request-events/use-request-events.hooks.ts +24 -33
  33. package/src/helpers/use-tracked-state/use-tracked-state.hooks.ts +8 -3
  34. package/src/helpers/use-tracked-state/use-tracked-state.utils.ts +9 -1
  35. package/src/hooks/use-fetch/use-fetch.hooks.ts +78 -16
  36. package/src/hydrate/hydrate.tsx +74 -0
  37. package/src/hydrate/hydrate.types.ts +55 -0
  38. package/src/hydrate/hydrate.utils.ts +124 -0
  39. package/src/hydrate/index.ts +2 -0
  40. package/src/index.ts +1 -0
  41. package/src/utils/scope.utils.ts +8 -0
  42. package/tsconfig.json +2 -0
@@ -0,0 +1,625 @@
1
+ import type { OptimisticRollbackArgs, RequestInstance, RequestResponseEventType } from "@hyper-fetch/core";
2
+ import { Client, getErrorMessage, scopeKey } from "@hyper-fetch/core";
3
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
4
+ import { act, renderHook, waitFor } from "@testing-library/react";
5
+ import { useSubmit } from "hooks/use-submit";
6
+ import { StrictMode } from "react";
7
+
8
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
9
+
10
+ const SERVER_ITEM = "server";
11
+ const OPTIMISTIC_ITEM = "optimistic";
12
+ const INITIAL_LIST = [SERVER_ITEM];
13
+ const OPTIMISTIC_LIST = [SERVER_ITEM, OPTIMISTIC_ITEM];
14
+
15
+ /**
16
+ * Builds isolated client with a seeded list and a mutation which adds one item to it optimistically
17
+ */
18
+ const createSetup = () => {
19
+ const client = new Client({ url: "shared-base-url" });
20
+ const list = client.createRequest<{ response: string[] }>()({ endpoint: "/list" });
21
+
22
+ client.cache.set(list, {
23
+ data: INITIAL_LIST,
24
+ error: null,
25
+ status: 200,
26
+ success: true,
27
+ extra: client.adapter.defaultExtra,
28
+ retries: 0,
29
+ isCanceled: false,
30
+ isOffline: false,
31
+ willRetry: false,
32
+ addedTimestamp: Date.now(),
33
+ triggerTimestamp: Date.now(),
34
+ requestTimestamp: Date.now(),
35
+ // Garbage collector drops the entries with outdated timestamps
36
+ responseTimestamp: Date.now(),
37
+ });
38
+
39
+ const readList = () => client.cache.get<string[], unknown>(list.cacheKey)?.data;
40
+ const addItem = (item: string) => {
41
+ client.cache.update(list, (prev) => ({ data: [...(prev?.data ?? []), item] }));
42
+ };
43
+ const removeItem = (item: string) => {
44
+ client.cache.update(list, (prev) => ({ data: (prev?.data ?? []).filter((value) => value !== item) }));
45
+ };
46
+
47
+ const rollback = vi.fn((_args: OptimisticRollbackArgs<any>) => {
48
+ removeItem(OPTIMISTIC_ITEM);
49
+ });
50
+ const invalidate = vi.spyOn(client.cache, "invalidate");
51
+
52
+ const mutation = client
53
+ .createRequest<{ response: { ok: boolean } }>()({ endpoint: "/mutation", method: "POST" })
54
+ .setOptimistic(() => {
55
+ addItem(OPTIMISTIC_ITEM);
56
+ return { context: { item: OPTIMISTIC_ITEM }, rollback, invalidate: [list] };
57
+ });
58
+
59
+ const responses: RequestResponseEventType<RequestInstance>[] = [];
60
+ client.requestManager.events.onResponse((values) => {
61
+ responses.push(values);
62
+ });
63
+
64
+ const dispatcher = client.submitDispatcher;
65
+ const queryKey = scopeKey(mutation.queryKey, mutation.scope);
66
+ const abortKey = scopeKey(mutation.abortKey, mutation.scope);
67
+
68
+ return {
69
+ client,
70
+ list,
71
+ mutation,
72
+ rollback,
73
+ invalidate,
74
+ responses,
75
+ dispatcher,
76
+ queryKey,
77
+ abortKey,
78
+ readList,
79
+ addItem,
80
+ removeItem,
81
+ };
82
+ };
83
+
84
+ type Setup = ReturnType<typeof createSetup>;
85
+ type Mutation = Setup["mutation"];
86
+
87
+ const waitForResponses = async (setup: Setup, count: number) => {
88
+ await waitFor(() => {
89
+ expect(setup.responses).toHaveLength(count);
90
+ });
91
+ };
92
+
93
+ /**
94
+ * Starts the submit inside of act and exposes its promise
95
+ */
96
+ const startSubmit = (submit: (options?: any) => Promise<any>, options?: Record<string, unknown>) => {
97
+ let pending: Promise<any> = Promise.resolve();
98
+ act(() => {
99
+ pending = submit(options);
100
+ });
101
+ return pending;
102
+ };
103
+
104
+ const finishSubmit = async (pending: Promise<any>) => {
105
+ let result: any;
106
+ await act(async () => {
107
+ result = await pending;
108
+ });
109
+ return result;
110
+ };
111
+
112
+ const goOfflineOnFirstAttempt = (setup: Setup) => {
113
+ let isFirstAttempt = true;
114
+ return {
115
+ onRequestStart: () => {
116
+ if (isFirstAttempt) {
117
+ isFirstAttempt = false;
118
+ setup.client.appManager.setOnline(false);
119
+ }
120
+ },
121
+ };
122
+ };
123
+
124
+ type Scenario = {
125
+ name: string;
126
+ build?: (setup: Setup) => Mutation;
127
+ arrange: (setup: Setup, request: Mutation) => Record<string, unknown> | void;
128
+ drive?: (setup: Setup, request: Mutation) => Promise<void>;
129
+ settled?: (setup: Setup) => Promise<void>;
130
+ expected: {
131
+ list: string[];
132
+ invalidated: boolean;
133
+ callback: "onSubmitSuccess" | "onSubmitError" | "onSubmitAbort" | null;
134
+ rollback?: { reason: "error" | "abort" | "removed"; status?: number; errorMessage?: string };
135
+ };
136
+ };
137
+
138
+ const scenarios: Scenario[] = [
139
+ {
140
+ name: "success",
141
+ arrange: (_, request) => {
142
+ mockRequest(request, { data: { ok: true } });
143
+ },
144
+ expected: { list: OPTIMISTIC_LIST, invalidated: true, callback: "onSubmitSuccess" },
145
+ },
146
+ {
147
+ name: "final error",
148
+ arrange: (_, request) => {
149
+ mockRequest(request, { status: 400 });
150
+ },
151
+ expected: {
152
+ list: INITIAL_LIST,
153
+ invalidated: false,
154
+ callback: "onSubmitError",
155
+ rollback: { reason: "error", status: 400 },
156
+ },
157
+ },
158
+ {
159
+ name: "abort",
160
+ arrange: (_, request) => {
161
+ mockRequest(request, { delay: 100 });
162
+ return {
163
+ onRequestStart: () => {
164
+ request.abort();
165
+ },
166
+ };
167
+ },
168
+ expected: {
169
+ list: INITIAL_LIST,
170
+ invalidated: false,
171
+ callback: "onSubmitAbort",
172
+ rollback: { reason: "abort", errorMessage: getErrorMessage("abort").message },
173
+ },
174
+ },
175
+ {
176
+ name: "queue removal",
177
+ arrange: (setup, request) => {
178
+ mockRequest(request);
179
+ setup.dispatcher.stop(setup.queryKey);
180
+ return {
181
+ onBeforeSent: ({ requestId }: { requestId: string }) => {
182
+ // Listeners of the send call are attached right after this callback
183
+ queueMicrotask(() => {
184
+ setup.dispatcher.delete(setup.queryKey, requestId, setup.abortKey);
185
+ });
186
+ },
187
+ };
188
+ },
189
+ expected: { list: INITIAL_LIST, invalidated: false, callback: null, rollback: { reason: "removed" } },
190
+ },
191
+ {
192
+ name: "retry then success",
193
+ build: ({ mutation }) => mutation.setRetry(1).setRetryTime(10),
194
+ arrange: (setup, request) => {
195
+ mockRequest(request, { status: 400 });
196
+ const unmount = setup.client.requestManager.events.onResponse(() => {
197
+ unmount();
198
+ mockRequest(request, { data: { ok: true } });
199
+ });
200
+ },
201
+ expected: { list: OPTIMISTIC_LIST, invalidated: true, callback: "onSubmitSuccess" },
202
+ },
203
+ {
204
+ name: "retry then error",
205
+ build: ({ mutation }) => mutation.setRetry(1).setRetryTime(10),
206
+ arrange: (setup, request) => {
207
+ mockRequest(request, { status: 400 });
208
+ const unmount = setup.client.requestManager.events.onResponse(() => {
209
+ unmount();
210
+ mockRequest(request, { status: 500 });
211
+ });
212
+ },
213
+ expected: {
214
+ list: INITIAL_LIST,
215
+ invalidated: false,
216
+ callback: "onSubmitError",
217
+ rollback: { reason: "error", status: 500 },
218
+ },
219
+ },
220
+ {
221
+ name: "offline then success",
222
+ arrange: (setup, request) => {
223
+ mockRequest(request, { status: 400, delay: 30 });
224
+ return goOfflineOnFirstAttempt(setup);
225
+ },
226
+ drive: async (setup, request) => {
227
+ await waitForResponses(setup, 1);
228
+ expect(setup.rollback).not.toHaveBeenCalled();
229
+ expect(setup.readList()).toStrictEqual(OPTIMISTIC_LIST);
230
+ mockRequest(request, { data: { ok: true } });
231
+ act(() => {
232
+ setup.client.appManager.setOnline(true);
233
+ });
234
+ },
235
+ expected: { list: OPTIMISTIC_LIST, invalidated: true, callback: "onSubmitSuccess" },
236
+ },
237
+ {
238
+ name: "offline then error",
239
+ arrange: (setup, request) => {
240
+ mockRequest(request, { status: 400, delay: 30 });
241
+ return goOfflineOnFirstAttempt(setup);
242
+ },
243
+ drive: async (setup, request) => {
244
+ await waitForResponses(setup, 1);
245
+ expect(setup.rollback).not.toHaveBeenCalled();
246
+ expect(setup.readList()).toStrictEqual(OPTIMISTIC_LIST);
247
+ mockRequest(request, { status: 500 });
248
+ act(() => {
249
+ setup.client.appManager.setOnline(true);
250
+ });
251
+ },
252
+ expected: {
253
+ list: INITIAL_LIST,
254
+ invalidated: false,
255
+ callback: "onSubmitError",
256
+ rollback: { reason: "error", status: 500 },
257
+ },
258
+ },
259
+ ];
260
+
261
+ describe("useSubmit [ Optimistic settlement ]", () => {
262
+ beforeAll(() => {
263
+ startServer();
264
+ });
265
+
266
+ afterEach(() => {
267
+ resetMocks();
268
+ });
269
+
270
+ afterAll(() => {
271
+ stopServer();
272
+ });
273
+
274
+ describe("when settling the submitted request", () => {
275
+ it.each(scenarios)("should settle $name", async ({ build, arrange, drive, settled, expected }) => {
276
+ const setup = createSetup();
277
+ const request = build?.(setup) ?? setup.mutation;
278
+ const callback = vi.fn();
279
+ let sentRequest: RequestInstance | undefined;
280
+
281
+ const options = arrange(setup, request) ?? {};
282
+ const { result } = renderHook(() => useSubmit(request));
283
+ act(() => {
284
+ if (expected.callback) {
285
+ result.current[expected.callback](callback);
286
+ }
287
+ });
288
+
289
+ const pending = startSubmit(result.current.submit, {
290
+ ...options,
291
+ onBeforeSent: (data: { request: RequestInstance; requestId: string }) => {
292
+ sentRequest = data.request;
293
+ (options as { onBeforeSent?: (value: typeof data) => void }).onBeforeSent?.(data);
294
+ },
295
+ });
296
+
297
+ await drive?.(setup, request);
298
+ await finishSubmit(pending);
299
+ await settled?.(setup);
300
+
301
+ expect(setup.readList()).toStrictEqual(expected.list);
302
+
303
+ if (expected.invalidated) {
304
+ expect(setup.invalidate).toHaveBeenCalledTimes(1);
305
+ expect(setup.invalidate).toHaveBeenCalledWith(setup.list);
306
+ } else {
307
+ expect(setup.invalidate).not.toHaveBeenCalled();
308
+ }
309
+
310
+ if (expected.rollback) {
311
+ expect(setup.rollback).toHaveBeenCalledTimes(1);
312
+ const [args] = setup.rollback.mock.calls[0];
313
+ expect(args.reason).toBe(expected.rollback.reason);
314
+ expect(args.request).toBe(sentRequest);
315
+ if (expected.rollback.reason === "removed") {
316
+ expect(args).not.toHaveProperty("response");
317
+ }
318
+ if (expected.rollback.status) {
319
+ expect(args.response?.status).toBe(expected.rollback.status);
320
+ }
321
+ if (expected.rollback.errorMessage) {
322
+ expect(args.response?.error).toHaveProperty("message", expected.rollback.errorMessage);
323
+ }
324
+ } else {
325
+ expect(setup.rollback).not.toHaveBeenCalled();
326
+ }
327
+
328
+ if (expected.callback) {
329
+ await waitFor(() => {
330
+ expect(callback).toHaveBeenCalled();
331
+ });
332
+ const lastCall = callback.mock.calls.at(-1)?.[0];
333
+ expect(lastCall.mutationContext).toStrictEqual({ item: OPTIMISTIC_ITEM });
334
+ }
335
+ });
336
+
337
+ it("should report removal when aborting with the hook method", async () => {
338
+ const setup = createSetup();
339
+ mockRequest(setup.mutation, { delay: 100 });
340
+ const { result } = renderHook(() => useSubmit(setup.mutation));
341
+
342
+ const pending = startSubmit(result.current.submit, {
343
+ onRequestStart: () => {
344
+ result.current.abort();
345
+ },
346
+ });
347
+ await finishSubmit(pending);
348
+ await waitForResponses(setup, 1);
349
+
350
+ expect(setup.rollback).toHaveBeenCalledTimes(1);
351
+ expect(setup.rollback.mock.calls[0][0].reason).toBe("removed");
352
+ expect(setup.readList()).toStrictEqual(INITIAL_LIST);
353
+ });
354
+
355
+ it("should have the cache rolled back when onSubmitError fires", async () => {
356
+ const setup = createSetup();
357
+ mockRequest(setup.mutation, { status: 400 });
358
+ const { result } = renderHook(() => useSubmit(setup.mutation));
359
+ let listInCallback: string[] | null | undefined;
360
+
361
+ act(() => {
362
+ result.current.onSubmitError(() => {
363
+ listInCallback = setup.readList();
364
+ });
365
+ });
366
+ await finishSubmit(startSubmit(result.current.submit));
367
+
368
+ await waitFor(() => {
369
+ expect(listInCallback).toStrictEqual(INITIAL_LIST);
370
+ });
371
+ });
372
+
373
+ it("should fire callbacks when rollback throws", async () => {
374
+ const setup = createSetup();
375
+ setup.rollback.mockImplementation(() => {
376
+ throw new Error("Rollback failed");
377
+ });
378
+ mockRequest(setup.mutation, { status: 400 });
379
+ const { result } = renderHook(() => useSubmit(setup.mutation));
380
+ const onError = vi.fn();
381
+ const onFinished = vi.fn();
382
+
383
+ act(() => {
384
+ result.current.onSubmitError(onError);
385
+ result.current.onSubmitFinished(onFinished);
386
+ });
387
+ const response = await finishSubmit(startSubmit(result.current.submit));
388
+
389
+ expect(response.status).toBe(400);
390
+ expect(setup.rollback).toHaveBeenCalledTimes(1);
391
+ await waitFor(() => {
392
+ expect(onError).toHaveBeenCalledTimes(1);
393
+ expect(onFinished).toHaveBeenCalledTimes(1);
394
+ });
395
+ });
396
+ });
397
+
398
+ describe("when component unmounts while the request is pending", () => {
399
+ it("should roll back failed request", async () => {
400
+ const setup = createSetup();
401
+ mockRequest(setup.mutation, { status: 400, delay: 30 });
402
+ const { result, unmount } = renderHook(() => useSubmit(setup.mutation));
403
+
404
+ const pending = startSubmit(result.current.submit);
405
+ await waitFor(() => {
406
+ expect(setup.readList()).toStrictEqual(OPTIMISTIC_LIST);
407
+ });
408
+ unmount();
409
+ const response = await pending;
410
+
411
+ expect(response.status).toBe(400);
412
+ expect(setup.rollback).toHaveBeenCalledTimes(1);
413
+ expect(setup.rollback.mock.calls[0][0].reason).toBe("error");
414
+ expect(setup.readList()).toStrictEqual(INITIAL_LIST);
415
+ });
416
+
417
+ it("should invalidate after successful request", async () => {
418
+ const setup = createSetup();
419
+ mockRequest(setup.mutation, { data: { ok: true }, delay: 30 });
420
+ const { result, unmount } = renderHook(() => useSubmit(setup.mutation));
421
+
422
+ const pending = startSubmit(result.current.submit);
423
+ await waitFor(() => {
424
+ expect(setup.readList()).toStrictEqual(OPTIMISTIC_LIST);
425
+ });
426
+ unmount();
427
+ await pending;
428
+
429
+ expect(setup.rollback).not.toHaveBeenCalled();
430
+ expect(setup.invalidate).toHaveBeenCalledTimes(1);
431
+ expect(setup.invalidate).toHaveBeenCalledWith(setup.list);
432
+ });
433
+
434
+ it("should roll back aborted request", async () => {
435
+ const setup = createSetup();
436
+ mockRequest(setup.mutation, { delay: 100 });
437
+ const { result, unmount } = renderHook(() => useSubmit(setup.mutation));
438
+
439
+ const pending = startSubmit(result.current.submit);
440
+ await waitFor(() => {
441
+ expect(setup.dispatcher.getAllRunningRequests()).toHaveLength(1);
442
+ });
443
+ unmount();
444
+ setup.mutation.abort();
445
+ await pending;
446
+
447
+ expect(setup.rollback).toHaveBeenCalledTimes(1);
448
+ expect(setup.rollback.mock.calls[0][0].reason).toBe("abort");
449
+ expect(setup.readList()).toStrictEqual(INITIAL_LIST);
450
+ });
451
+
452
+ it("should roll back request removed from the queue", async () => {
453
+ const setup = createSetup();
454
+ setup.dispatcher.stop(setup.queryKey);
455
+ const { result, unmount } = renderHook(() => useSubmit(setup.mutation));
456
+ let requestId = "";
457
+
458
+ const pending = startSubmit(result.current.submit, {
459
+ onBeforeSent: (data: { requestId: string }) => {
460
+ requestId = data.requestId;
461
+ },
462
+ });
463
+ await waitFor(() => {
464
+ expect(requestId).not.toBe("");
465
+ });
466
+ unmount();
467
+ setup.dispatcher.delete(setup.queryKey, requestId, setup.abortKey);
468
+ await pending;
469
+
470
+ expect(setup.rollback).toHaveBeenCalledTimes(1);
471
+ expect(setup.rollback.mock.calls[0][0].reason).toBe("removed");
472
+ expect(setup.readList()).toStrictEqual(INITIAL_LIST);
473
+ });
474
+
475
+ it("should roll back once retries are exhausted", async () => {
476
+ const setup = createSetup();
477
+ const request = setup.mutation.setRetry(1).setRetryTime(10);
478
+ mockRequest(request, { status: 400 });
479
+ const { result, unmount } = renderHook(() => useSubmit(request));
480
+ const unmountListener = setup.client.requestManager.events.onResponse(() => {
481
+ unmountListener();
482
+ unmount();
483
+ mockRequest(request, { status: 500 });
484
+ });
485
+
486
+ await startSubmit(result.current.submit);
487
+
488
+ expect(setup.responses).toHaveLength(2);
489
+ expect(setup.rollback).toHaveBeenCalledTimes(1);
490
+ // Status of the last attempt proves the first failure did not trigger the rollback
491
+ expect(setup.rollback.mock.calls[0][0].response?.status).toBe(500);
492
+ expect(setup.readList()).toStrictEqual(INITIAL_LIST);
493
+ });
494
+ });
495
+
496
+ describe("when rendered in StrictMode", () => {
497
+ it("should roll back failed request once", async () => {
498
+ const setup = createSetup();
499
+ mockRequest(setup.mutation, { status: 400 });
500
+ const { result } = renderHook(() => useSubmit(setup.mutation), { wrapper: StrictMode });
501
+
502
+ await finishSubmit(startSubmit(result.current.submit));
503
+
504
+ expect(setup.rollback).toHaveBeenCalledTimes(1);
505
+ expect(setup.readList()).toStrictEqual(INITIAL_LIST);
506
+ });
507
+
508
+ it("should invalidate successful request once", async () => {
509
+ const setup = createSetup();
510
+ mockRequest(setup.mutation, { data: { ok: true } });
511
+ const { result } = renderHook(() => useSubmit(setup.mutation), { wrapper: StrictMode });
512
+
513
+ await finishSubmit(startSubmit(result.current.submit));
514
+
515
+ expect(setup.rollback).not.toHaveBeenCalled();
516
+ expect(setup.invalidate).toHaveBeenCalledTimes(1);
517
+ });
518
+
519
+ it("should roll back once when unmounted while pending", async () => {
520
+ const setup = createSetup();
521
+ mockRequest(setup.mutation, { status: 400, delay: 30 });
522
+ const { result, unmount } = renderHook(() => useSubmit(setup.mutation), { wrapper: StrictMode });
523
+
524
+ const pending = startSubmit(result.current.submit);
525
+ await waitFor(() => {
526
+ expect(setup.readList()).toStrictEqual(OPTIMISTIC_LIST);
527
+ });
528
+ unmount();
529
+ await pending;
530
+
531
+ expect(setup.rollback).toHaveBeenCalledTimes(1);
532
+ expect(setup.readList()).toStrictEqual(INITIAL_LIST);
533
+ });
534
+ });
535
+
536
+ describe("when multiple mutations are running", () => {
537
+ const createItemMutation = (setup: Setup, item: string) => {
538
+ const rollback = vi.fn(() => {
539
+ setup.removeItem(item);
540
+ });
541
+ const request = setup.client
542
+ .createRequest<{ response: null }>()({ endpoint: `/mutation/${item}`, method: "POST" })
543
+ .setOptimistic(() => {
544
+ setup.addItem(item);
545
+ return { rollback };
546
+ });
547
+ return { request, rollback };
548
+ };
549
+
550
+ it("should roll back only the failed mutation of two hooks", async () => {
551
+ const setup = createSetup();
552
+ const failed = createItemMutation(setup, "failed");
553
+ const passed = createItemMutation(setup, "passed");
554
+ mockRequest(failed.request, { status: 400, delay: 10 });
555
+ mockRequest(passed.request, { delay: 30 });
556
+ const failedHook = renderHook(() => useSubmit(failed.request));
557
+ const passedHook = renderHook(() => useSubmit(passed.request));
558
+
559
+ await finishSubmit(
560
+ Promise.all([startSubmit(failedHook.result.current.submit), startSubmit(passedHook.result.current.submit)]),
561
+ );
562
+
563
+ expect(failed.rollback).toHaveBeenCalledTimes(1);
564
+ expect(passed.rollback).not.toHaveBeenCalled();
565
+ expect(setup.readList()).toStrictEqual([SERVER_ITEM, "passed"]);
566
+ });
567
+
568
+ it("should roll back each of two failed mutations once", async () => {
569
+ const setup = createSetup();
570
+ const first = createItemMutation(setup, "first");
571
+ const second = createItemMutation(setup, "second");
572
+ mockRequest(first.request, { status: 400, delay: 30 });
573
+ mockRequest(second.request, { status: 500, delay: 10 });
574
+ const firstHook = renderHook(() => useSubmit(first.request));
575
+ const secondHook = renderHook(() => useSubmit(second.request));
576
+
577
+ await finishSubmit(
578
+ Promise.all([startSubmit(firstHook.result.current.submit), startSubmit(secondHook.result.current.submit)]),
579
+ );
580
+
581
+ expect(first.rollback).toHaveBeenCalledTimes(1);
582
+ expect(second.rollback).toHaveBeenCalledTimes(1);
583
+ expect(setup.readList()).toStrictEqual(INITIAL_LIST);
584
+ });
585
+
586
+ it("should roll back two submits of one hook separately", async () => {
587
+ const setup = createSetup();
588
+ const rollbacks: Record<string, ReturnType<typeof vi.fn>> = {};
589
+ const request = setup.client
590
+ .createRequest<{ response: null; payload: { item: string } }>()({ endpoint: "/mutation", method: "POST" })
591
+ .setOptimistic(({ payload }) => {
592
+ setup.addItem(payload.item);
593
+ const rollback = vi.fn(() => {
594
+ setup.removeItem(payload.item);
595
+ });
596
+ rollbacks[payload.item] = rollback;
597
+ return { rollback };
598
+ });
599
+ mockRequest(request, { status: 400, delay: 20 });
600
+ const { result } = renderHook(() => useSubmit(request));
601
+
602
+ await finishSubmit(
603
+ Promise.all([
604
+ startSubmit(result.current.submit, { payload: { item: "first" } }),
605
+ startSubmit(result.current.submit, { payload: { item: "second" } }),
606
+ ]),
607
+ );
608
+
609
+ expect(rollbacks.first).toHaveBeenCalledTimes(1);
610
+ expect(rollbacks.second).toHaveBeenCalledTimes(1);
611
+ expect(setup.readList()).toStrictEqual(INITIAL_LIST);
612
+ });
613
+
614
+ it("should roll back once when two hooks observe the same request", async () => {
615
+ const setup = createSetup();
616
+ mockRequest(setup.mutation, { status: 400 });
617
+ const submitting = renderHook(() => useSubmit(setup.mutation));
618
+ renderHook(() => useSubmit(setup.mutation));
619
+
620
+ await finishSubmit(startSubmit(submitting.result.current.submit));
621
+
622
+ expect(setup.rollback).toHaveBeenCalledTimes(1);
623
+ });
624
+ });
625
+ });
@@ -312,6 +312,7 @@ describe("useSubmit [ Optimistic ]", () => {
312
312
  it("should not call rollback when retry succeeds after initial failure", async () => {
313
313
  const rollbackSpy = vi.fn();
314
314
  const successSpy = vi.fn();
315
+ const errorSpy = vi.fn();
315
316
 
316
317
  const optimisticRequest = request
317
318
  .setOptimistic(() => ({
@@ -321,18 +322,25 @@ describe("useSubmit [ Optimistic ]", () => {
321
322
  .setRetry(1)
322
323
  .setRetryTime(50);
323
324
 
324
- const errorMock = mockRequest(optimisticRequest, { status: 400 });
325
+ let successMock = mockRequest(optimisticRequest, { status: 400 });
326
+ // Swapped on the response event, polling for the error state can lose the race with the retry timer
327
+ const unmountListener = client.requestManager.events.onResponse(() => {
328
+ unmountListener();
329
+ successMock = mockRequest(optimisticRequest);
330
+ });
325
331
  const response = renderUseSubmit(optimisticRequest);
326
332
 
327
333
  act(() => {
328
334
  response.result.current.onSubmitSuccess(successSpy);
335
+ response.result.current.onSubmitError(errorSpy);
329
336
  response.result.current.submit();
330
337
  });
331
338
 
332
- await testErrorState(errorMock, response);
333
- const successMock = mockRequest(optimisticRequest);
334
-
339
+ await waitFor(() => {
340
+ expect(successSpy).toHaveBeenCalledTimes(1);
341
+ });
335
342
  await testSuccessState(successMock, response);
343
+ expect(errorSpy).toHaveBeenCalledTimes(1);
336
344
  expect(rollbackSpy).not.toHaveBeenCalled();
337
345
  expect(successSpy).toHaveBeenCalledTimes(1);
338
346
  expect(successSpy.mock.calls[0][0].mutationContext).toStrictEqual({ snapshot: "v1" });
@@ -8,6 +8,8 @@
8
8
  "paths": {
9
9
  "helpers": ["../src/helpers"],
10
10
  "helpers/*": ["../src/helpers/*"],
11
+ "hydrate": ["../src/hydrate"],
12
+ "hydrate/*": ["../src/hydrate/*"],
11
13
  "hooks": ["../src/hooks"],
12
14
  "hooks/*": ["../src/hooks/*"],
13
15
  "provider": ["../src/provider"],
@@ -1 +1 @@
1
- {"version":3,"file":"use-request-events.hooks.d.ts","sourceRoot":"","sources":["../../../src/helpers/use-request-events/use-request-events.hooks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGV,eAAe,EAQhB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAOV,0BAA0B,EAC1B,yBAAyB,EAE1B,MAAM,SAAS,CAAC;AAGjB;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,eAAe,EAAE,8EAOzD,yBAAyB,CAAC,CAAC,CAAC,KAAG,0BAA0B,CAAC,CAAC,CA+T7D,CAAC"}
1
+ {"version":3,"file":"use-request-events.hooks.d.ts","sourceRoot":"","sources":["../../../src/helpers/use-request-events/use-request-events.hooks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGV,eAAe,EAQhB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAOV,0BAA0B,EAC1B,yBAAyB,EAE1B,MAAM,SAAS,CAAC;AAIjB;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,eAAe,EAAE,8EAOzD,yBAAyB,CAAC,CAAC,CAAC,KAAG,0BAA0B,CAAC,CAAC,CAqT7D,CAAC"}
@@ -1 +1 @@
1
- {"version":3,"file":"use-tracked-state.hooks.d.ts","sourceRoot":"","sources":["../../../src/helpers/use-tracked-state/use-tracked-state.hooks.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGV,mBAAmB,EACnB,eAAe,EAIhB,MAAM,mBAAmB,CAAC;AAK3B,OAAO,KAAK,EAGV,oBAAoB,EACpB,qBAAqB,EAEtB,MAAM,2BAA2B,CAAC;AASnC;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,eAAe,EAAE,KAAK,GAAG,mBAAmB,CAAC,CAAC,CAAC,EAAE,+IAWxF,oBAAoB,CAAC,CAAC,EAAE,KAAK,CAAC,KAAG,qBAAqB,CAAC,CAAC,EAAE,KAAK,CAgXjE,CAAC"}
1
+ {"version":3,"file":"use-tracked-state.hooks.d.ts","sourceRoot":"","sources":["../../../src/helpers/use-tracked-state/use-tracked-state.hooks.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGV,mBAAmB,EACnB,eAAe,EAIhB,MAAM,mBAAmB,CAAC;AAM3B,OAAO,KAAK,EAGV,oBAAoB,EACpB,qBAAqB,EAEtB,MAAM,2BAA2B,CAAC;AASnC;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,eAAe,EAAE,KAAK,GAAG,mBAAmB,CAAC,CAAC,CAAC,EAAE,+IAWxF,oBAAoB,CAAC,CAAC,EAAE,KAAK,CAAC,KAAG,qBAAqB,CAAC,CAAC,EAAE,KAAK,CAoXjE,CAAC"}