@hyper-fetch/react 9.4.1 → 9.5.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 (38) 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.offline.spec.ts +4 -2
  5. package/__tests__/features/use-fetch/use-fetch.scope.spec.tsx +211 -0
  6. package/__tests__/features/use-fetch/use-fetch.suspense.spec.tsx +223 -0
  7. package/__tests__/tsconfig.json +2 -0
  8. package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
  9. package/dist/helpers/use-tracked-state/use-tracked-state.hooks.d.ts.map +1 -1
  10. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts +4 -1
  11. package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts.map +1 -1
  12. package/dist/hooks/use-fetch/use-fetch.hooks.d.ts.map +1 -1
  13. package/dist/hydrate/hydrate.d.ts +16 -0
  14. package/dist/hydrate/hydrate.d.ts.map +1 -0
  15. package/dist/hydrate/hydrate.types.d.ts +52 -0
  16. package/dist/hydrate/hydrate.types.d.ts.map +1 -0
  17. package/dist/hydrate/hydrate.utils.d.ts +19 -0
  18. package/dist/hydrate/hydrate.utils.d.ts.map +1 -0
  19. package/dist/hydrate/index.d.ts +3 -0
  20. package/dist/hydrate/index.d.ts.map +1 -0
  21. package/dist/index.d.ts +1 -0
  22. package/dist/index.d.ts.map +1 -1
  23. package/dist/index.mjs +225 -28
  24. package/dist/index.mjs.map +1 -1
  25. package/dist/utils/scope.utils.d.ts +7 -0
  26. package/dist/utils/scope.utils.d.ts.map +1 -0
  27. package/package.json +1 -1
  28. package/src/helpers/use-request-events/use-request-events.hooks.ts +15 -6
  29. package/src/helpers/use-tracked-state/use-tracked-state.hooks.ts +8 -3
  30. package/src/helpers/use-tracked-state/use-tracked-state.utils.ts +9 -1
  31. package/src/hooks/use-fetch/use-fetch.hooks.ts +78 -16
  32. package/src/hydrate/hydrate.tsx +74 -0
  33. package/src/hydrate/hydrate.types.ts +55 -0
  34. package/src/hydrate/hydrate.utils.ts +124 -0
  35. package/src/hydrate/index.ts +2 -0
  36. package/src/index.ts +1 -0
  37. package/src/utils/scope.utils.ts +8 -0
  38. package/tsconfig.json +2 -0
@@ -0,0 +1,511 @@
1
+ import type { HydrateDataType, ResponseType } from "@hyper-fetch/core";
2
+ import { Client, Time, xhrExtra } from "@hyper-fetch/core";
3
+ import { createHttpMockingServer } from "@hyper-fetch/testing";
4
+ import { act, render, screen, waitFor } from "@testing-library/react";
5
+ import { useCache } from "hooks/use-cache";
6
+ import { useFetch } from "hooks/use-fetch";
7
+ import { useSubmit } from "hooks/use-submit";
8
+ import { Hydrate } from "hydrate";
9
+ import type { HydrateProps } from "hydrate";
10
+ import { StrictMode, Suspense, memo, useEffect } from "react";
11
+
12
+ const { resetMocks, startServer, stopServer, mockRequest } = createHttpMockingServer();
13
+
14
+ type User = { id: number; name: string };
15
+
16
+ const createClient = () => new Client({ url: "http://localhost:3000" });
17
+
18
+ const createUserRequest = (client: Client) =>
19
+ client.createRequest<{ response: User }>()({ endpoint: "/users/:userId" }).setParams({ userId: 1 });
20
+
21
+ const createResponse = (data: User, responseTimestamp = Date.now()): ResponseType<User, any, any> => ({
22
+ data,
23
+ error: null,
24
+ status: 200,
25
+ success: true,
26
+ extra: xhrExtra,
27
+ requestTimestamp: responseTimestamp,
28
+ responseTimestamp,
29
+ });
30
+
31
+ const dehydrate = (request: ReturnType<typeof createUserRequest>, data: User, responseTimestamp?: number) =>
32
+ request.setStaleTime(Time.MIN).dehydrate({ response: createResponse(data, responseTimestamp) })!;
33
+
34
+ const server = { id: 1, name: "From server" };
35
+ const newer = { id: 1, name: "Newer" };
36
+ const older = { id: 1, name: "Older" };
37
+
38
+ describe("Hydrate", () => {
39
+ let client: Client;
40
+ let request: ReturnType<typeof createUserRequest>;
41
+
42
+ beforeAll(() => startServer());
43
+ afterEach(() => resetMocks());
44
+ afterAll(() => stopServer());
45
+
46
+ beforeEach(() => {
47
+ client = createClient();
48
+ request = createUserRequest(client);
49
+ });
50
+
51
+ // Records the data of every render, so the first render can be asserted
52
+ const createFetchView = (options: Parameters<typeof useFetch>[1] = {}, testId = "view") => {
53
+ const renders: { data: unknown; loading: boolean }[] = [];
54
+ const View = ({ req = request }: { req?: any }) => {
55
+ const { data, loading } = useFetch(req, { revalidate: false, dependencyTracking: false, ...options });
56
+ renders.push({ data, loading });
57
+ return <div data-testid={testId}>{(data as User | null)?.name ?? "empty"}</div>;
58
+ };
59
+ return { View, renders };
60
+ };
61
+
62
+ describe("given the client renders hydrated data", () => {
63
+ it("should render the hydrated data on the first render without a loading state", () => {
64
+ const { View, renders } = createFetchView();
65
+
66
+ render(
67
+ <Hydrate client={client} data={[dehydrate(request, server)]}>
68
+ <View />
69
+ </Hydrate>,
70
+ );
71
+
72
+ expect(renders[0]).toEqual({ data: server, loading: false });
73
+ expect(screen.getByTestId("view")).toHaveTextContent(server.name);
74
+ });
75
+
76
+ it("should write the data to the cache before child hooks mount", () => {
77
+ let cacheOnMount: unknown;
78
+ // A passive effect of a child - runs at the same time as the mount logic of the hooks
79
+ const Probe = () => {
80
+ useEffect(() => {
81
+ cacheOnMount = client.cache.get(request.cacheKey)?.data;
82
+ }, []);
83
+ return null;
84
+ };
85
+
86
+ render(
87
+ <Hydrate client={client} data={[dehydrate(request, server)]}>
88
+ <Probe />
89
+ </Hydrate>,
90
+ );
91
+
92
+ expect(cacheOnMount).toEqual(server);
93
+ expect(client.cache.get(request.cacheKey)?.data).toEqual(server);
94
+ });
95
+
96
+ it("should not send a request while the hydrated data is fresh", async () => {
97
+ const spy = vi.spyOn(client.fetchDispatcher, "add");
98
+ const { View } = createFetchView();
99
+
100
+ render(
101
+ <Hydrate client={client} data={[dehydrate(request, server)]}>
102
+ <View />
103
+ </Hydrate>,
104
+ );
105
+
106
+ await act(async () => {
107
+ await new Promise((resolve) => {
108
+ setTimeout(resolve, 50);
109
+ });
110
+ });
111
+ expect(spy).not.toHaveBeenCalled();
112
+ });
113
+
114
+ it("should refetch in the background when revalidation is on, without losing the hydrated data", async () => {
115
+ const fresh = mockRequest(request, { data: { id: 1, name: "Fetched" } }) as User;
116
+ const { View, renders } = createFetchView({ revalidate: true });
117
+
118
+ render(
119
+ <Hydrate client={client} data={[dehydrate(request, server)]}>
120
+ <View />
121
+ </Hydrate>,
122
+ );
123
+
124
+ expect(renders[0].data).toEqual(server);
125
+ await waitFor(() => expect(screen.getByTestId("view")).toHaveTextContent(fresh.name));
126
+ expect(renders.every((entry) => entry.data !== null)).toBe(true);
127
+ });
128
+
129
+ it("should hydrate useSubmit and useCache", () => {
130
+ const results: Record<string, unknown> = {};
131
+ const View = () => {
132
+ results.submit = useSubmit(request).data;
133
+ results.cache = useCache(request).data;
134
+ return null;
135
+ };
136
+
137
+ render(
138
+ <Hydrate client={client} data={[dehydrate(request, server)]}>
139
+ <View />
140
+ </Hydrate>,
141
+ );
142
+
143
+ expect(results.submit).toEqual(server);
144
+ expect(results.cache).toEqual(server);
145
+ });
146
+
147
+ it("should not suspend when the data is hydrated", () => {
148
+ const spy = vi.spyOn(client.fetchDispatcher, "add");
149
+ const { View } = createFetchView({ suspense: true });
150
+
151
+ render(
152
+ <Suspense fallback={<div data-testid="fallback" />}>
153
+ <Hydrate client={client} data={[dehydrate(request, server)]}>
154
+ <View />
155
+ </Hydrate>
156
+ </Suspense>,
157
+ );
158
+
159
+ expect(screen.queryByTestId("fallback")).toBeNull();
160
+ expect(screen.getByTestId("view")).toHaveTextContent(server.name);
161
+ expect(spy).not.toHaveBeenCalled();
162
+ });
163
+
164
+ it("should keep the cache when Hydrate unmounts", () => {
165
+ const view = render(
166
+ <Hydrate client={client} data={[dehydrate(request, server)]}>
167
+ <div />
168
+ </Hydrate>,
169
+ );
170
+
171
+ view.unmount();
172
+
173
+ expect(client.cache.get(request.cacheKey)?.data).toEqual(server);
174
+ });
175
+
176
+ it("should work in StrictMode and write every item only once", () => {
177
+ const spy = vi.spyOn(client.cache, "set");
178
+ const { View, renders } = createFetchView();
179
+
180
+ render(
181
+ <StrictMode>
182
+ <Hydrate client={client} data={[dehydrate(request, server)]}>
183
+ <View />
184
+ </Hydrate>
185
+ </StrictMode>,
186
+ );
187
+
188
+ expect(renders[0].data).toEqual(server);
189
+ expect(spy).toHaveBeenCalledTimes(1);
190
+ });
191
+ });
192
+
193
+ describe("given several items, clients and boundaries", () => {
194
+ it("should keep the data of two clients with the same cache key apart", () => {
195
+ const otherClient = createClient();
196
+ const otherRequest = createUserRequest(otherClient);
197
+ const otherData = { id: 1, name: "Other client" };
198
+ expect(otherRequest.cacheKey).toBe(request.cacheKey);
199
+
200
+ const { View } = createFetchView({}, "first");
201
+ const { View: OtherView } = createFetchView({}, "second");
202
+
203
+ render(
204
+ <Hydrate client={client} data={[dehydrate(request, server)]}>
205
+ <Hydrate client={otherClient} data={[dehydrate(otherRequest, otherData)]}>
206
+ <View />
207
+ <OtherView req={otherRequest} />
208
+ </Hydrate>
209
+ </Hydrate>,
210
+ );
211
+
212
+ expect(screen.getByTestId("first")).toHaveTextContent(server.name);
213
+ expect(screen.getByTestId("second")).toHaveTextContent(otherData.name);
214
+ expect(client.cache.get(request.cacheKey)?.data).toEqual(server);
215
+ expect(otherClient.cache.get(otherRequest.cacheKey)?.data).toEqual(otherData);
216
+ });
217
+
218
+ it("should serve keys from both the outer and the inner boundary", () => {
219
+ const second = request.setParams({ userId: 2 });
220
+ const secondData = { id: 2, name: "Second" };
221
+ const { View } = createFetchView({}, "outer");
222
+ const { View: InnerView } = createFetchView({}, "inner");
223
+
224
+ render(
225
+ <Hydrate client={client} data={[dehydrate(request, server)]}>
226
+ <Hydrate client={client} data={[dehydrate(second, secondData)]}>
227
+ <View />
228
+ <InnerView req={second} />
229
+ </Hydrate>
230
+ </Hydrate>,
231
+ );
232
+
233
+ expect(screen.getByTestId("outer")).toHaveTextContent(server.name);
234
+ expect(screen.getByTestId("inner")).toHaveTextContent(secondData.name);
235
+ });
236
+
237
+ it("should keep the newer data when nested boundaries hold the same key", () => {
238
+ const now = Date.now();
239
+ const { View } = createFetchView();
240
+
241
+ render(
242
+ <Hydrate client={client} data={[dehydrate(request, newer, now)]}>
243
+ <Hydrate client={client} data={[dehydrate(request, older, now - 1000)]}>
244
+ <View />
245
+ </Hydrate>
246
+ </Hydrate>,
247
+ );
248
+
249
+ expect(screen.getByTestId("view")).toHaveTextContent(newer.name);
250
+ expect(client.cache.get(request.cacheKey)?.data).toEqual(newer);
251
+ });
252
+
253
+ it("should ignore empty data and empty items", () => {
254
+ const { View, renders } = createFetchView();
255
+
256
+ render(
257
+ <>
258
+ <Hydrate client={client} data={undefined}>
259
+ <span />
260
+ </Hydrate>
261
+ <Hydrate client={client} data={null}>
262
+ <span />
263
+ </Hydrate>
264
+ <Hydrate client={client} data={[]}>
265
+ <span />
266
+ </Hydrate>
267
+ <Hydrate client={client} data={[null, undefined, dehydrate(request, server)]}>
268
+ <View />
269
+ </Hydrate>
270
+ </>,
271
+ );
272
+
273
+ expect(renders[0].data).toEqual(server);
274
+ });
275
+
276
+ it("should hydrate when rendered conditionally later", () => {
277
+ const { View, renders } = createFetchView();
278
+ const items = [dehydrate(request, server)];
279
+ const App = ({ show }: { show: boolean }) =>
280
+ show ? (
281
+ <Hydrate client={client} data={items}>
282
+ <View />
283
+ </Hydrate>
284
+ ) : null;
285
+
286
+ const view = render(<App show={false} />);
287
+ expect(client.cache.get(request.cacheKey)).toBeUndefined();
288
+
289
+ view.rerender(<App show />);
290
+ expect(renders[0].data).toEqual(server);
291
+ expect(client.cache.get(request.cacheKey)?.data).toEqual(server);
292
+ });
293
+ });
294
+
295
+ describe("given the cache already has data", () => {
296
+ const setCache = (data: User, responseTimestamp: number) => {
297
+ client.cache.set(request, {
298
+ ...createResponse(data, responseTimestamp),
299
+ ...createDetails(responseTimestamp),
300
+ } as any);
301
+ };
302
+
303
+ it("should not replace newer cache data with an older snapshot", () => {
304
+ const now = Date.now();
305
+ setCache(newer, now);
306
+ const { View, renders } = createFetchView();
307
+
308
+ render(
309
+ <Hydrate client={client} data={[dehydrate(request, older, now - 1000)]}>
310
+ <View />
311
+ </Hydrate>,
312
+ );
313
+
314
+ expect(renders[0].data).toEqual(newer);
315
+ expect(client.cache.get(request.cacheKey)?.data).toEqual(newer);
316
+ });
317
+
318
+ it("should replace older cache data and update hooks that already show it", () => {
319
+ const now = Date.now();
320
+ setCache(older, now - 1000);
321
+ const { View: Outside } = createFetchView({}, "outside");
322
+ const { View, renders } = createFetchView({}, "inside");
323
+
324
+ render(
325
+ <>
326
+ <Outside />
327
+ <Hydrate client={client} data={[dehydrate(request, newer, now)]}>
328
+ <View />
329
+ </Hydrate>
330
+ </>,
331
+ );
332
+
333
+ expect(renders[0].data).toEqual(newer);
334
+ expect(screen.getByTestId("outside")).toHaveTextContent(newer.name);
335
+ expect(client.cache.get(request.cacheKey)?.data).toEqual(newer);
336
+ });
337
+
338
+ it("should keep existing cache data when override is false", () => {
339
+ const now = Date.now();
340
+ setCache(older, now - 1000);
341
+ const { View, renders } = createFetchView();
342
+
343
+ render(
344
+ <Hydrate client={client} data={[dehydrate(request, newer, now)]} options={{ override: false }}>
345
+ <View />
346
+ </Hydrate>,
347
+ );
348
+
349
+ expect(renders[0].data).toEqual(older);
350
+ expect(client.cache.get(request.cacheKey)?.data).toEqual(older);
351
+ });
352
+
353
+ it("should still hydrate empty keys when override is false", () => {
354
+ const { View, renders } = createFetchView();
355
+
356
+ render(
357
+ <Hydrate client={client} data={[dehydrate(request, server)]} options={{ override: false }}>
358
+ <View />
359
+ </Hydrate>,
360
+ );
361
+
362
+ expect(renders[0].data).toEqual(server);
363
+ expect(client.cache.get(request.cacheKey)?.data).toEqual(server);
364
+ });
365
+
366
+ it("should not resurrect the snapshot for hooks mounted after the cache was cleared", async () => {
367
+ const items = [dehydrate(request, server)];
368
+ mockRequest(request, { data: { id: 1, name: "Fetched" }, delay: 50 });
369
+ const { View: First } = createFetchView({}, "first");
370
+ const { View: Second, renders } = createFetchView({}, "second");
371
+ const App = ({ showSecond }: { showSecond: boolean }) => (
372
+ <Hydrate client={client} data={items}>
373
+ <First />
374
+ {showSecond && <Second />}
375
+ </Hydrate>
376
+ );
377
+
378
+ const view = render(<App showSecond={false} />);
379
+ await act(async () => {
380
+ await client.cache.clear();
381
+ });
382
+ view.rerender(<App showSecond />);
383
+
384
+ expect(renders[0].data).toBeNull();
385
+ });
386
+ });
387
+
388
+ describe("given options and re-renders", () => {
389
+ it("should not write the snapshot again when re-rendered after the cache was cleared", async () => {
390
+ const items = [dehydrate(request, server)];
391
+ // Inline options create new entries on every render, so the effect runs again
392
+ const view = render(<Hydrate client={client} data={items} options={{ cache: true }} />);
393
+ expect(client.cache.get(request.cacheKey)?.data).toEqual(server);
394
+
395
+ await act(async () => {
396
+ await client.cache.clear();
397
+ });
398
+ view.rerender(<Hydrate client={client} data={items} options={{ cache: true }} />);
399
+
400
+ expect(client.cache.get(request.cacheKey)).toBeUndefined();
401
+ });
402
+
403
+ it("should not re-render memoized children when Hydrate re-renders", () => {
404
+ const renders = vi.fn();
405
+ const Child = memo(() => {
406
+ renders();
407
+ useFetch(request, { revalidate: false });
408
+ return null;
409
+ });
410
+ const items = [dehydrate(request, server)];
411
+ const child = <Child />;
412
+ const view = render(
413
+ <Hydrate client={client} data={items} options={{ cache: true }}>
414
+ {child}
415
+ </Hydrate>,
416
+ );
417
+
418
+ view.rerender(
419
+ <Hydrate client={client} data={items} options={{ cache: true }}>
420
+ {child}
421
+ </Hydrate>,
422
+ );
423
+
424
+ expect(renders).toHaveBeenCalledTimes(1);
425
+ });
426
+
427
+ it("should apply options given as an object", () => {
428
+ render(<Hydrate client={client} data={[dehydrate(request, server)]} options={{ staleTime: Time.HOUR }} />);
429
+
430
+ expect(client.cache.get(request.cacheKey)?.staleTime).toBe(Time.HOUR);
431
+ });
432
+
433
+ it("should apply options given as a function of the item", () => {
434
+ const options = vi.fn((item: HydrateDataType) => ({ cacheTime: item.cacheKey ? Time.DAY : 0 }));
435
+
436
+ render(<Hydrate client={client} data={[dehydrate(request, server)]} options={options} />);
437
+
438
+ expect(options).toHaveBeenCalled();
439
+ expect(client.cache.get(request.cacheKey)?.cacheTime).toBe(Time.DAY);
440
+ });
441
+
442
+ it("should not write again when re-rendered with the same items", () => {
443
+ const spy = vi.spyOn(client.cache, "set");
444
+ const items = [dehydrate(request, server)];
445
+ const view = render(<Hydrate client={client} data={items} />);
446
+
447
+ view.rerender(<Hydrate client={client} data={items} />);
448
+ view.rerender(<Hydrate client={client} data={[...items]} />);
449
+
450
+ expect(spy).toHaveBeenCalledTimes(1);
451
+ });
452
+
453
+ it("should write a new snapshot with newer data", () => {
454
+ const now = Date.now();
455
+ const { View } = createFetchView();
456
+ const view = render(
457
+ <Hydrate client={client} data={[dehydrate(request, older, now - 1000)]}>
458
+ <View />
459
+ </Hydrate>,
460
+ );
461
+
462
+ view.rerender(
463
+ <Hydrate client={client} data={[dehydrate(request, newer, now)]}>
464
+ <View />
465
+ </Hydrate>,
466
+ );
467
+
468
+ expect(client.cache.get(request.cacheKey)?.data).toEqual(newer);
469
+ expect(screen.getByTestId("view")).toHaveTextContent(newer.name);
470
+ });
471
+ });
472
+
473
+ describe("given scoped requests", () => {
474
+ it("should hydrate only the matching scope", () => {
475
+ const scoped = request.setScope("session-1");
476
+ const { View: ScopedView } = createFetchView({}, "scoped");
477
+ const { View: PlainView } = createFetchView({}, "plain");
478
+
479
+ render(
480
+ <Hydrate client={client} data={[dehydrate(scoped, server)]}>
481
+ <ScopedView req={scoped} />
482
+ <PlainView req={request} />
483
+ </Hydrate>,
484
+ );
485
+
486
+ expect(screen.getByTestId("scoped")).toHaveTextContent(server.name);
487
+ expect(screen.getByTestId("plain")).toHaveTextContent("empty");
488
+ });
489
+ });
490
+
491
+ describe("types", () => {
492
+ it("should accept the output of dehydrate and empty values", () => {
493
+ expectTypeOf(request.dehydrate()).toMatchTypeOf<NonNullable<HydrateProps["data"]>[number]>();
494
+ expectTypeOf<null>().toMatchTypeOf<HydrateProps["data"]>();
495
+ expectTypeOf<undefined>().toMatchTypeOf<HydrateProps["data"]>();
496
+ expectTypeOf<{ staleTime: number }>().toMatchTypeOf<HydrateProps["options"]>();
497
+ expectTypeOf<(item: HydrateDataType) => { override: boolean }>().toMatchTypeOf<HydrateProps["options"]>();
498
+ // @ts-expect-error client is required
499
+ expectTypeOf<{ data: [] }>().toMatchTypeOf<HydrateProps>();
500
+ });
501
+ });
502
+ });
503
+
504
+ const createDetails = (timestamp: number) => ({
505
+ retries: 0,
506
+ isCanceled: false,
507
+ isOffline: false,
508
+ willRetry: false,
509
+ addedTimestamp: timestamp,
510
+ triggerTimestamp: timestamp,
511
+ });
@@ -0,0 +1,189 @@
1
+ import type { ResponseType } from "@hyper-fetch/core";
2
+ import { Client, Time, xhrExtra } from "@hyper-fetch/core";
3
+ import { act } from "@testing-library/react";
4
+ import { useFetch } from "hooks/use-fetch";
5
+ import { useSubmit } from "hooks/use-submit";
6
+ import { Hydrate } from "hydrate";
7
+ import { hydrateRoot } from "react-dom/client";
8
+ import { renderToString } from "react-dom/server";
9
+
10
+ type User = { id: number; name: string };
11
+
12
+ const createRequest = (client: Client, userId = 1) =>
13
+ client
14
+ .createRequest<{ response: User }>()({ endpoint: "/users/:userId" })
15
+ .setParams({ userId })
16
+ .setStaleTime(Time.MIN);
17
+
18
+ const createResponse = (data: User, responseTimestamp = Date.now()): ResponseType<User, any, any> => ({
19
+ data,
20
+ error: null,
21
+ status: 200,
22
+ success: true,
23
+ extra: xhrExtra,
24
+ requestTimestamp: responseTimestamp,
25
+ responseTimestamp,
26
+ });
27
+
28
+ // Dehydrated payloads cross the network as JSON (structuredClone would keep values JSON drops)
29
+ // oxlint-disable-next-line unicorn/prefer-structured-clone
30
+ const toWire = <T,>(value: T): T => JSON.parse(JSON.stringify(value));
31
+
32
+ const UserName = ({ request }: { request: ReturnType<typeof createRequest> }) => {
33
+ const { data, loading } = useFetch(request, { revalidate: false });
34
+ return <span data-loading={String(loading)}>{data?.name ?? "empty"}</span>;
35
+ };
36
+
37
+ const App = ({ client, data, userIds = [1] }: { client: Client; data: any[]; userIds?: number[] }) => (
38
+ <Hydrate client={client} data={data}>
39
+ {userIds.map((userId) => (
40
+ <UserName key={userId} request={createRequest(client, userId)} />
41
+ ))}
42
+ </Hydrate>
43
+ );
44
+
45
+ describe("Hydrate [ Server rendering ]", () => {
46
+ describe("given a server mode client", () => {
47
+ it("should render the hydrated data into the markup", () => {
48
+ const client = new Client({ url: "http://localhost:3000", mode: "server" });
49
+ const request = createRequest(client);
50
+ const data = [request.dehydrate({ response: createResponse({ id: 1, name: "Server user" }) })];
51
+
52
+ const html = renderToString(<App client={client} data={data} />);
53
+
54
+ expect(html).toContain("Server user");
55
+ expect(html).toContain('data-loading="false"');
56
+ });
57
+
58
+ it("should not store anything in the server cache", () => {
59
+ const client = new Client({ url: "http://localhost:3000", mode: "server" });
60
+ const request = createRequest(client);
61
+ const data = [request.dehydrate({ response: createResponse({ id: 1, name: "Server user" }) })];
62
+
63
+ renderToString(<App client={client} data={data} />);
64
+
65
+ expect(client.cache.get(request.cacheKey)).toBeUndefined();
66
+ expect([...client.cache.storage.keys()]).toHaveLength(0);
67
+ });
68
+
69
+ it("should not leak data between two server renders sharing one client", () => {
70
+ const client = new Client({ url: "http://localhost:3000", mode: "server" });
71
+ const request = createRequest(client);
72
+
73
+ const first = renderToString(
74
+ <App client={client} data={[request.dehydrate({ response: createResponse({ id: 1, name: "Alice" }) })]} />,
75
+ );
76
+ const second = renderToString(
77
+ <App client={client} data={[request.dehydrate({ response: createResponse({ id: 1, name: "Bob" }) })]} />,
78
+ );
79
+ const third = renderToString(<App client={client} data={[]} />);
80
+
81
+ expect(first).toContain("Alice");
82
+ expect(second).toContain("Bob");
83
+ expect(second).not.toContain("Alice");
84
+ expect(third).toContain("empty");
85
+ });
86
+
87
+ it("should render several keys and useSubmit from the same payload", () => {
88
+ const client = new Client({ url: "http://localhost:3000", mode: "server" });
89
+ const data = [1, 2, 3].map((userId) =>
90
+ createRequest(client, userId).dehydrate({ response: createResponse({ id: userId, name: `User ${userId}` }) }),
91
+ );
92
+ const SubmitName = () => {
93
+ const { data: submitData } = useSubmit(createRequest(client, 2));
94
+ return <b>{submitData?.name}</b>;
95
+ };
96
+
97
+ const html = renderToString(
98
+ <Hydrate client={client} data={data}>
99
+ {[1, 2, 3].map((userId) => (
100
+ <UserName key={userId} request={createRequest(client, userId)} />
101
+ ))}
102
+ <SubmitName />
103
+ </Hydrate>,
104
+ );
105
+
106
+ expect(html).toContain("User 1");
107
+ expect(html).toContain("User 2");
108
+ expect(html).toContain("User 3");
109
+ expect(html).toContain("<b>User 2</b>");
110
+ });
111
+ });
112
+
113
+ describe("given server markup hydrated on the client", () => {
114
+ let container: HTMLDivElement;
115
+
116
+ beforeEach(() => {
117
+ container = document.createElement("div");
118
+ document.body.append(container);
119
+ });
120
+
121
+ afterEach(() => {
122
+ container.remove();
123
+ });
124
+
125
+ const hydrate = async (element: React.ReactElement) => {
126
+ const onRecoverableError = vi.fn();
127
+ const consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
128
+ let root: ReturnType<typeof hydrateRoot> | undefined;
129
+ await act(async () => {
130
+ root = hydrateRoot(container, element, { onRecoverableError });
131
+ });
132
+ const errors = consoleError.mock.calls;
133
+ consoleError.mockRestore();
134
+ return { onRecoverableError, errors, unmount: () => act(() => root?.unmount()) };
135
+ };
136
+
137
+ it("should hydrate without a mismatch and without a request", async () => {
138
+ const serverClient = new Client({ url: "http://localhost:3000", mode: "server" });
139
+ const payload = toWire([
140
+ createRequest(serverClient).dehydrate({ response: createResponse({ id: 1, name: "Round trip" }) }),
141
+ ]);
142
+ container.innerHTML = renderToString(<App client={serverClient} data={payload} />);
143
+
144
+ const browserClient = new Client({ url: "http://localhost:3000" });
145
+ const spy = vi.spyOn(browserClient.fetchDispatcher, "add");
146
+ const { onRecoverableError, errors, unmount } = await hydrate(<App client={browserClient} data={payload} />);
147
+
148
+ expect(onRecoverableError).not.toHaveBeenCalled();
149
+ expect(errors).toHaveLength(0);
150
+ expect(container.textContent).toBe("Round trip");
151
+ expect(browserClient.cache.get(createRequest(browserClient).cacheKey)?.data).toEqual({
152
+ id: 1,
153
+ name: "Round trip",
154
+ });
155
+ expect(spy).not.toHaveBeenCalled();
156
+ await unmount();
157
+ });
158
+
159
+ it("should hydrate without a mismatch when the browser cache holds older data", async () => {
160
+ const serverClient = new Client({ url: "http://localhost:3000", mode: "server" });
161
+ const now = Date.now();
162
+ const payload = toWire([
163
+ createRequest(serverClient).dehydrate({ response: createResponse({ id: 1, name: "Fresh" }, now) }),
164
+ ]);
165
+ container.innerHTML = renderToString(<App client={serverClient} data={payload} />);
166
+
167
+ // e.g. restored from persistent storage
168
+ const browserClient = new Client({ url: "http://localhost:3000" });
169
+ const browserRequest = createRequest(browserClient);
170
+ browserClient.cache.set(browserRequest, {
171
+ ...createResponse({ id: 1, name: "Persisted" }, now - Time.MIN),
172
+ retries: 0,
173
+ isCanceled: false,
174
+ isOffline: false,
175
+ willRetry: false,
176
+ addedTimestamp: now,
177
+ triggerTimestamp: now,
178
+ } as any);
179
+
180
+ const { onRecoverableError, errors, unmount } = await hydrate(<App client={browserClient} data={payload} />);
181
+
182
+ expect(onRecoverableError).not.toHaveBeenCalled();
183
+ expect(errors).toHaveLength(0);
184
+ expect(container.textContent).toBe("Fresh");
185
+ expect(browserClient.cache.get(browserRequest.cacheKey)?.data).toEqual({ id: 1, name: "Fresh" });
186
+ await unmount();
187
+ });
188
+ });
189
+ });