@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
@@ -49,7 +49,8 @@ describe("useFetch [ Concurrency ]", () => {
49
49
  expect(spyTwo).toHaveBeenCalledTimes(1);
50
50
  });
51
51
  it("should start in loading mode when request is already handled by the queue", async () => {
52
- mockRequest(request);
52
+ // The request must still be running after waitForRender - the default 20ms delay can elapse under load
53
+ mockRequest(request, { delay: 500 });
53
54
  act(() => {
54
55
  client.fetchDispatcher.add(request);
55
56
  });
@@ -159,7 +159,12 @@ describe("useFetch [ Methods ]", () => {
159
159
  const spy7 = vi.fn();
160
160
  const spy8 = vi.fn();
161
161
 
162
- const errorMock = mockRequest(request, { status: 400 });
162
+ let successMock = mockRequest(request, { status: 400 });
163
+ // Swapped on the response event, polling for the error state can lose the race with the retry timer
164
+ const unmountListener = client.requestManager.events.onResponse(() => {
165
+ unmountListener();
166
+ successMock = mockRequest(request);
167
+ });
163
168
  const response = renderUseFetch(request.setRetry(1).setRetryTime(100));
164
169
 
165
170
  act(() => {
@@ -173,8 +178,9 @@ describe("useFetch [ Methods ]", () => {
173
178
  response.result.current.onOfflineError(spy8);
174
179
  });
175
180
 
176
- await testErrorState(errorMock, response);
177
- const successMock = mockRequest(request);
181
+ await waitFor(() => {
182
+ expect(spy5).toHaveBeenCalledTimes(1);
183
+ });
178
184
  await testSuccessState(successMock, response);
179
185
 
180
186
  expect(spy1).toHaveBeenCalledTimes(2);
@@ -72,7 +72,8 @@ describe("useFetch [ Offline ]", () => {
72
72
  });
73
73
  describe("when request offline attribute is set to true", () => {
74
74
  it("should not emit offline error until request is finished", async () => {
75
- const mock = mockRequest(request);
75
+ // The connection drops while the request is in flight - the default 20ms delay can elapse under load
76
+ const mock = mockRequest(request, { delay: 500 });
76
77
  const response = renderUseFetch(request);
77
78
  await waitForRender();
78
79
  act(() => {
@@ -87,7 +88,8 @@ describe("useFetch [ Offline ]", () => {
87
88
  });
88
89
  describe("when request offline attribute is set to false", () => {
89
90
  it("should emit offline error until request is finished", async () => {
90
- const mock = mockRequest(request, { status: 400 });
91
+ // The connection drops while the request is in flight - the default 20ms delay can elapse under load
92
+ const mock = mockRequest(request, { status: 400, delay: 500 });
91
93
  const response = renderUseFetch(request.setOffline(false));
92
94
  await waitForRender();
93
95
  act(() => {
@@ -0,0 +1,211 @@
1
+ import type { RequestInstance } from "@hyper-fetch/core";
2
+ import { Client, Time, xhrExtra } from "@hyper-fetch/core";
3
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
4
+ import { act, renderHook, waitFor } from "@testing-library/react";
5
+ import { useFetch } from "hooks/use-fetch";
6
+
7
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
8
+
9
+ type User = { name: string };
10
+
11
+ // Typed loosely - the tests write raw cache values for requests of different shapes
12
+ const createResponse = (data: User): any => ({
13
+ data,
14
+ error: null,
15
+ status: 200,
16
+ success: true,
17
+ extra: xhrExtra,
18
+ requestTimestamp: Date.now(),
19
+ responseTimestamp: Date.now(),
20
+ retries: 0,
21
+ isCanceled: false,
22
+ isOffline: false,
23
+ willRetry: false,
24
+ addedTimestamp: Date.now(),
25
+ triggerTimestamp: Date.now(),
26
+ });
27
+
28
+ describe("useFetch [ Scope ]", () => {
29
+ let client: Client;
30
+ let request: ReturnType<typeof createUserRequest>;
31
+
32
+ const createUserRequest = (c: Client) =>
33
+ c.createRequest<{ response: User }>()({ endpoint: "/users/:userId" }).setStaleTime(Time.MIN);
34
+
35
+ beforeAll(() => startServer());
36
+ afterEach(() => resetMocks());
37
+ afterAll(() => stopServer());
38
+
39
+ beforeEach(() => {
40
+ client = new Client({ url: "http://localhost:3000" });
41
+ request = createUserRequest(client);
42
+ });
43
+
44
+ const renderScoped = (initial: RequestInstance) =>
45
+ renderHook(({ req }: { req: RequestInstance }) => useFetch(req, { revalidate: false, dependencyTracking: false }), {
46
+ initialProps: { req: initial },
47
+ });
48
+
49
+ it("should read the scoped cache on mount", () => {
50
+ const scoped = request.setParams({ userId: 1 }).setScope("a");
51
+ client.cache.set(scoped, createResponse({ name: "Scoped" }));
52
+
53
+ const view = renderScoped(scoped);
54
+
55
+ expect(view.result.current.data).toEqual({ name: "Scoped" });
56
+ });
57
+
58
+ it("should read the scoped cache when the request changes to another key", () => {
59
+ const first = request.setParams({ userId: 1 }).setScope("a");
60
+ const second = request.setParams({ userId: 2 }).setScope("a");
61
+ client.cache.set(first, createResponse({ name: "First" }));
62
+ client.cache.set(second, createResponse({ name: "Second" }));
63
+ const spy = vi.spyOn(client.fetchDispatcher, "add");
64
+
65
+ const view = renderScoped(first);
66
+ view.rerender({ req: second });
67
+
68
+ expect(view.result.current.data).toEqual({ name: "Second" });
69
+ expect(spy).not.toHaveBeenCalled();
70
+ });
71
+
72
+ it("should not receive cache updates of another scope with the same cache key", async () => {
73
+ const scopeA = request.setParams({ userId: 1 }).setScope("a");
74
+ const scopeB = request.setParams({ userId: 1 }).setScope("b");
75
+ client.cache.set(scopeA, createResponse({ name: "A" }));
76
+ client.cache.set(scopeB, createResponse({ name: "B" }));
77
+
78
+ const viewA = renderScoped(scopeA);
79
+ const viewB = renderScoped(scopeB);
80
+
81
+ act(() => {
82
+ client.cache.set(scopeA, createResponse({ name: "A updated" }));
83
+ });
84
+
85
+ await waitFor(() => expect(viewA.result.current.data).toEqual({ name: "A updated" }));
86
+ expect(viewB.result.current.data).toEqual({ name: "B" });
87
+ });
88
+
89
+ it("should not receive cache updates of the unscoped request with the same cache key", async () => {
90
+ const scoped = request.setParams({ userId: 1 }).setScope("a");
91
+ const unscoped = request.setParams({ userId: 1 });
92
+ client.cache.set(scoped, createResponse({ name: "Scoped" }));
93
+
94
+ const view = renderScoped(scoped);
95
+
96
+ act(() => {
97
+ client.cache.set(unscoped, createResponse({ name: "Unscoped" }));
98
+ });
99
+
100
+ expect(view.result.current.data).toEqual({ name: "Scoped" });
101
+ });
102
+
103
+ it("should store the fetched response under its scope only", async () => {
104
+ const scoped = request.setParams({ userId: 1 }).setScope("a");
105
+ const mock = mockRequest(scoped, { data: { name: "Fetched" } });
106
+
107
+ const view = renderHook(() => useFetch(scoped, { dependencyTracking: false }));
108
+
109
+ await waitFor(() => expect(view.result.current.data).toEqual(mock));
110
+ expect(client.cache.get(`a__${scoped.cacheKey}`)?.data).toEqual(mock);
111
+ expect(client.cache.get(scoped.cacheKey)).toBeUndefined();
112
+ });
113
+ });
114
+
115
+ describe("useFetch [ Scope - loading ]", () => {
116
+ const { startServer: start, stopServer: stop, resetMocks: reset, mockRequest: mock } = createHttpMockingServer();
117
+
118
+ beforeAll(() => start());
119
+ afterEach(() => reset());
120
+ afterAll(() => stop());
121
+
122
+ it("should show loading while a scoped request is refetched", async () => {
123
+ const client = new Client({ url: "http://loading.test" });
124
+ const scoped = client.createRequest<{ response: User }>()({ endpoint: "/users/1" }).setScope("a");
125
+ mock(scoped, { data: { name: "Fetched" }, delay: 50 });
126
+ client.cache.set(scoped, createResponse({ name: "Cached" }));
127
+
128
+ const view = renderHook(() => useFetch(scoped, { revalidate: false, dependencyTracking: false }));
129
+ expect(view.result.current.loading).toBe(false);
130
+
131
+ act(() => {
132
+ view.result.current.refetch();
133
+ });
134
+
135
+ await waitFor(() => expect(view.result.current.loading).toBe(true));
136
+ await waitFor(() => expect(view.result.current.data).toEqual({ name: "Fetched" }));
137
+ expect(view.result.current.loading).toBe(false);
138
+ });
139
+
140
+ it("should not show loading when another scope with the same key is fetching", async () => {
141
+ const client = new Client({ url: "http://loading.test" });
142
+ const scopeA = client.createRequest<{ response: User }>()({ endpoint: "/users/1" }).setScope("a");
143
+ const scopeB = scopeA.setScope("b");
144
+ mock(scopeA, { data: { name: "Fetched" }, delay: 50 });
145
+ client.cache.set(scopeA, createResponse({ name: "A" }));
146
+ client.cache.set(scopeB, createResponse({ name: "B" }));
147
+
148
+ const viewA = renderHook(() => useFetch(scopeA, { revalidate: false, dependencyTracking: false }));
149
+ const viewB = renderHook(() => useFetch(scopeB, { revalidate: false, dependencyTracking: false }));
150
+
151
+ act(() => {
152
+ viewA.result.current.refetch();
153
+ });
154
+
155
+ await waitFor(() => expect(viewA.result.current.loading).toBe(true));
156
+ expect(viewB.result.current.loading).toBe(false);
157
+ await waitFor(() => expect(viewA.result.current.loading).toBe(false));
158
+ expect(viewB.result.current.data).toEqual({ name: "B" });
159
+ });
160
+ });
161
+
162
+ describe("useFetch [ Scope - key changes and running requests ]", () => {
163
+ const { startServer: start, stopServer: stop, resetMocks: reset, mockRequest: mock } = createHttpMockingServer();
164
+
165
+ beforeAll(() => start());
166
+ afterEach(() => reset());
167
+ afterAll(() => stop());
168
+
169
+ it("should show the scoped cache of the new page when only query params change", () => {
170
+ const client = new Client({ url: "http://pages.test" });
171
+ const base = client
172
+ .createRequest<{ response: User; queryParams: { page: number } }>()({ endpoint: "/users" })
173
+ .setScope("a")
174
+ .setStaleTime(Time.MIN);
175
+ const page1 = base.setQueryParams({ page: 1 });
176
+ const page2 = base.setQueryParams({ page: 2 });
177
+ client.cache.set(page1, createResponse({ name: "Page 1" }));
178
+ client.cache.set(page2, createResponse({ name: "Page 2" }));
179
+
180
+ // "auto" keeps the previous data on query param changes, so only the cache read can switch the page
181
+ const view = renderHook(
182
+ ({ req }) => useFetch(req, { revalidate: false, dependencyTracking: false, keepPreviousData: "auto" }),
183
+ { initialProps: { req: page1 } },
184
+ );
185
+ view.rerender({ req: page2 });
186
+
187
+ expect(view.result.current.data).toEqual({ name: "Page 2" });
188
+ });
189
+
190
+ it("should keep loading while a scoped request is still running and the cache changes", async () => {
191
+ const client = new Client({ url: "http://running.test" });
192
+ const scoped = client.createRequest<{ response: User }>()({ endpoint: "/users/1" }).setScope("a");
193
+ mock(scoped, { data: { name: "Fetched" }, delay: 100 });
194
+ client.cache.set(scoped, createResponse({ name: "Cached" }));
195
+
196
+ const view = renderHook(() => useFetch(scoped, { revalidate: false, dependencyTracking: false }));
197
+ act(() => {
198
+ view.result.current.refetch();
199
+ });
200
+ await waitFor(() => expect(view.result.current.loading).toBe(true));
201
+
202
+ // e.g. an optimistic update while the request is in flight
203
+ act(() => {
204
+ client.cache.set(scoped, createResponse({ name: "Optimistic" }));
205
+ });
206
+
207
+ expect(view.result.current.data).toEqual({ name: "Optimistic" });
208
+ expect(view.result.current.loading).toBe(true);
209
+ await waitFor(() => expect(view.result.current.data).toEqual({ name: "Fetched" }));
210
+ });
211
+ });
@@ -1,6 +1,8 @@
1
+ import { Client } from "@hyper-fetch/core";
1
2
  import { createHttpMockingServer } from "@hyper-fetch/testing";
2
3
  import { act, fireEvent, render, screen, waitFor } from "@testing-library/react";
3
4
  import { useFetch } from "hooks/use-fetch";
5
+ import { HttpResponse, delay, http } from "msw";
4
6
  /// <reference types="vitest/globals" />
5
7
  import type { ReactNode } from "react";
6
8
  import { Suspense, StrictMode, Component, useState } from "react";
@@ -503,3 +505,224 @@ describe("useFetch [ Suspense ]", () => {
503
505
  });
504
506
  });
505
507
  });
508
+
509
+ describe("useFetch [ Suspense - isolation ]", () => {
510
+ const { server, startServer: start, stopServer: stop, resetMocks: reset } = createHttpMockingServer();
511
+
512
+ beforeAll(() => start());
513
+ afterEach(() => reset());
514
+ afterAll(() => stop());
515
+
516
+ type Echo = { from: string };
517
+
518
+ // Echoes who asked: the host for clients, the x-scope header for scopes. The second one answers later.
519
+ const mockEcho = () => {
520
+ server.use(
521
+ http.get(/\/users\/1$/, async ({ request: req }) => {
522
+ const from = req.headers.get("x-scope") ?? new URL(req.url).host;
523
+ await delay(from === "b" || from.startsWith("b.") ? 300 : 10);
524
+ return HttpResponse.json({ from });
525
+ }),
526
+ );
527
+ };
528
+
529
+ const createUserRequest = (c: Client) => c.createRequest<{ response: Echo }>()({ endpoint: "/users/1" });
530
+
531
+ // Every value a view rendered - a view must never show data of another client or scope, even briefly
532
+ let rendered: Record<string, (string | undefined)[]> = {};
533
+ beforeEach(() => {
534
+ rendered = {};
535
+ });
536
+
537
+ const View = ({ request, testId }: { request: any; testId: string }) => {
538
+ const { data } = useFetch(request, { suspense: true, dependencyTracking: false });
539
+ const from = (data as Echo | null)?.from;
540
+ rendered[testId] = [...(rendered[testId] ?? []), from];
541
+ return <div data-testid={testId}>{from}</div>;
542
+ };
543
+
544
+ it("should not share suspense results between clients with the same cache key", async () => {
545
+ mockEcho();
546
+ const clientA = new Client({ url: "http://a.test" });
547
+ const clientB = new Client({ url: "http://b.test" });
548
+ const requestA = createUserRequest(clientA);
549
+ const requestB = createUserRequest(clientB);
550
+ expect(requestA.cacheKey).toBe(requestB.cacheKey);
551
+
552
+ render(
553
+ <>
554
+ <Suspense fallback={<div data-testid="fallback-b" />}>
555
+ <View request={requestB} testId="b" />
556
+ </Suspense>
557
+ <Suspense fallback={<div data-testid="fallback-a" />}>
558
+ <View request={requestA} testId="a" />
559
+ </Suspense>
560
+ </>,
561
+ );
562
+
563
+ // The fast client must not wait for the slow one
564
+ await waitFor(() => expect(screen.getByTestId("a")).toHaveTextContent("a.test"), { interval: 5 });
565
+ expect(screen.getByTestId("fallback-b")).toBeInTheDocument();
566
+
567
+ await waitFor(() => expect(screen.getByTestId("b")).toHaveTextContent("b.test"));
568
+ expect(rendered.a.every((value) => value === "a.test")).toBe(true);
569
+ expect(rendered.b.every((value) => value === "b.test")).toBe(true);
570
+ });
571
+
572
+ it("should not share suspense results between scopes with the same cache key", async () => {
573
+ mockEcho();
574
+ const testClient = new Client({ url: "http://scopes.test" });
575
+ const scopeA = createUserRequest(testClient).setScope("a").setHeaders({ "x-scope": "a" });
576
+ const scopeB = createUserRequest(testClient).setScope("b").setHeaders({ "x-scope": "b" });
577
+
578
+ render(
579
+ <Suspense fallback={<div data-testid="fallback" />}>
580
+ <View request={scopeB} testId="b" />
581
+ <View request={scopeA} testId="a" />
582
+ </Suspense>,
583
+ );
584
+
585
+ await waitFor(() => {
586
+ expect(screen.getByTestId("a")).toHaveTextContent(/^a$/);
587
+ expect(screen.getByTestId("b")).toHaveTextContent(/^b$/);
588
+ });
589
+ expect(rendered.a.every((value) => value === "a")).toBe(true);
590
+ expect(rendered.b.every((value) => value === "b")).toBe(true);
591
+ });
592
+
593
+ it("should send one request per scope", async () => {
594
+ mockEcho();
595
+ const testClient = new Client({ url: "http://scopes.test" });
596
+ const spy = vi.spyOn(testClient.fetchDispatcher, "add");
597
+ const scopeA = createUserRequest(testClient).setScope("a").setHeaders({ "x-scope": "a" });
598
+ const scopeB = createUserRequest(testClient).setScope("b").setHeaders({ "x-scope": "b" });
599
+
600
+ render(
601
+ <Suspense fallback={<div data-testid="fallback" />}>
602
+ <View request={scopeA} testId="a" />
603
+ <View request={scopeB} testId="b" />
604
+ </Suspense>,
605
+ );
606
+
607
+ await waitFor(() => expect(screen.getByTestId("b")).toHaveTextContent(/^b$/));
608
+ const scopes = spy.mock.calls.map(([added]) => added.scope);
609
+ expect(scopes.filter((scope) => scope === "a")).toHaveLength(1);
610
+ expect(scopes.filter((scope) => scope === "b")).toHaveLength(1);
611
+ });
612
+ });
613
+
614
+ describe("useFetch [ Suspense - requests ]", () => {
615
+ const { startServer: start, stopServer: stop, resetMocks: reset, mockRequest: mock } = createHttpMockingServer();
616
+
617
+ beforeAll(() => start());
618
+ afterEach(() => reset());
619
+ afterAll(() => stop());
620
+
621
+ const View = ({ request, options = {} }: { request: any; options?: Record<string, unknown> }) => {
622
+ const { data, error, loading } = useFetch(request, { suspense: true, dependencyTracking: false, ...options });
623
+ return (
624
+ <div data-testid="view" data-loading={String(loading)}>
625
+ {error ? "error" : JSON.stringify(data)}
626
+ </div>
627
+ );
628
+ };
629
+
630
+ it("should send a single request for a suspended component", async () => {
631
+ const testClient = new Client({ url: "http://single.test" });
632
+ const request = testClient.createRequest<{ response: any }>()({ endpoint: "/single" });
633
+ const data = mock(request, { data: { value: 1 } });
634
+ const spy = vi.spyOn(testClient.fetchDispatcher, "add");
635
+
636
+ render(
637
+ <Suspense fallback={<div data-testid="fallback" />}>
638
+ <View request={request} />
639
+ </Suspense>,
640
+ );
641
+
642
+ await waitFor(() => expect(screen.getByTestId("view")).toHaveTextContent(JSON.stringify(data)));
643
+ await act(async () => {
644
+ await new Promise((resolve) => {
645
+ setTimeout(resolve, 50);
646
+ });
647
+ });
648
+ expect(spy).toHaveBeenCalledTimes(1);
649
+ expect(screen.getByTestId("view")).toHaveAttribute("data-loading", "false");
650
+ });
651
+
652
+ it("should settle loading after an error response without refetching", async () => {
653
+ const testClient = new Client({ url: "http://error.test" });
654
+ const request = testClient.createRequest<{ response: any }>()({ endpoint: "/error" });
655
+ mock(request, { status: 400 });
656
+ const spy = vi.spyOn(testClient.fetchDispatcher, "add");
657
+
658
+ render(
659
+ <Suspense fallback={<div data-testid="fallback" />}>
660
+ <View request={request} />
661
+ </Suspense>,
662
+ );
663
+
664
+ await waitFor(() => expect(screen.getByTestId("view")).toHaveTextContent("error"));
665
+ expect(screen.getByTestId("view")).toHaveAttribute("data-loading", "false");
666
+ expect(spy).toHaveBeenCalledTimes(1);
667
+ });
668
+
669
+ it("should still revalidate on mount when the cached data is older than the suspense guard", async () => {
670
+ const testClient = new Client({ url: "http://stale.test" });
671
+ const request = testClient.createRequest<{ response: any }>()({ endpoint: "/stale" });
672
+ const fresh = mock(request, { data: { value: "fresh" } });
673
+ const old = Date.now() - 5000;
674
+ testClient.cache.set(request, {
675
+ data: { value: "cached" },
676
+ error: null,
677
+ status: 200,
678
+ success: true,
679
+ extra: null,
680
+ requestTimestamp: old,
681
+ responseTimestamp: old,
682
+ retries: 0,
683
+ isCanceled: false,
684
+ isOffline: false,
685
+ willRetry: false,
686
+ addedTimestamp: old,
687
+ triggerTimestamp: old,
688
+ } as any);
689
+
690
+ render(
691
+ <Suspense fallback={<div data-testid="fallback" />}>
692
+ <View request={request} />
693
+ </Suspense>,
694
+ );
695
+
696
+ expect(screen.getByTestId("view")).toHaveTextContent("cached");
697
+ await waitFor(() => expect(screen.getByTestId("view")).toHaveTextContent(JSON.stringify(fresh)));
698
+ });
699
+ });
700
+
701
+ describe("useFetch [ Suspense - offline ]", () => {
702
+ it("should not queue duplicates when a suspended component re-renders while offline", async () => {
703
+ const testClient = new Client({ url: "http://offline.test" });
704
+ testClient.appManager.setOnline(false);
705
+ const request = testClient.createRequest<{ response: any }>()({ endpoint: "/offline" });
706
+ const spy = vi.spyOn(testClient.fetchDispatcher, "add");
707
+
708
+ const View = () => {
709
+ const { data } = useFetch(request, { suspense: true, dependencyTracking: false });
710
+ return <div>{JSON.stringify(data)}</div>;
711
+ };
712
+ const App = ({ tick }: { tick: number }) => (
713
+ <div data-tick={tick}>
714
+ <Suspense fallback={<div data-testid="fallback" />}>
715
+ <View />
716
+ </Suspense>
717
+ </div>
718
+ );
719
+
720
+ const view = render(<App tick={0} />);
721
+ view.rerender(<App tick={1} />);
722
+ view.rerender(<App tick={2} />);
723
+
724
+ expect(screen.getByTestId("fallback")).toBeInTheDocument();
725
+ expect(spy).toHaveBeenCalledTimes(1);
726
+ expect(testClient.fetchDispatcher.getQueue(request.queryKey).requests).toHaveLength(1);
727
+ });
728
+ });
@@ -199,7 +199,12 @@ describe("useSubmit [ Methods ]", () => {
199
199
  const spy7 = vi.fn();
200
200
  const spy8 = vi.fn();
201
201
 
202
- const errorMock = mockRequest(request, { status: 400 });
202
+ let successMock = mockRequest(request, { status: 400 });
203
+ // Swapped on the response event, polling for the error state can lose the race with the retry timer
204
+ const unmountListener = client.requestManager.events.onResponse(() => {
205
+ unmountListener();
206
+ successMock = mockRequest(request);
207
+ });
203
208
  const response = renderUseSubmit(request.setRetry(1).setRetryTime(100));
204
209
 
205
210
  act(() => {
@@ -214,8 +219,9 @@ describe("useSubmit [ Methods ]", () => {
214
219
  response.result.current.submit();
215
220
  });
216
221
 
217
- await testErrorState(errorMock, response);
218
- const successMock = mockRequest(request);
222
+ await waitFor(() => {
223
+ expect(spy5).toHaveBeenCalledTimes(1);
224
+ });
219
225
  await testSuccessState(successMock, response);
220
226
 
221
227
  expect(spy1).toHaveBeenCalledTimes(2);