@hyper-fetch/react 9.5.2 → 9.6.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.
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.base.spec.tsx +745 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.boundaries.spec.tsx +362 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.edge.spec.tsx +1043 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.matrix.spec.tsx +441 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.random.spec.tsx +121 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.refetch.spec.tsx +567 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.start-over.spec.tsx +353 -0
- package/__tests__/features/use-infinite-fetch/use-infinite-fetch.typescript.spec.ts +128 -0
- package/__tests__/features/use-submit/use-submit.unmount.spec.ts +310 -0
- package/__tests__/utils/use-infinite-fetch.modes.ts +131 -0
- package/__tests__/utils/use-infinite-fetch.utils.ts +90 -0
- package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
- package/dist/hooks/use-infinite-fetch/index.d.ts +4 -0
- package/dist/hooks/use-infinite-fetch/index.d.ts.map +1 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.constants.d.ts +22 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.constants.d.ts.map +1 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts +21 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.hooks.d.ts.map +1 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.requests.d.ts +19 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.requests.d.ts.map +1 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts +119 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.d.ts.map +1 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.types.d.ts +48 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.store.types.d.ts.map +1 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts +172 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.types.d.ts.map +1 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts +15 -0
- package/dist/hooks/use-infinite-fetch/use-infinite-fetch.utils.d.ts.map +1 -0
- package/dist/index.d.ts +1 -0
- package/dist/index.d.ts.map +1 -1
- package/dist/index.mjs +914 -2
- package/dist/index.mjs.map +1 -1
- package/dist/provider/provider.types.d.ts +2 -0
- package/dist/provider/provider.types.d.ts.map +1 -1
- package/package.json +1 -1
- package/src/helpers/use-request-events/use-request-events.hooks.ts +11 -1
- package/src/hooks/use-infinite-fetch/index.ts +3 -0
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.constants.ts +25 -0
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.hooks.ts +389 -0
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.requests.ts +98 -0
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.ts +780 -0
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.store.types.ts +49 -0
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.types.ts +195 -0
- package/src/hooks/use-infinite-fetch/use-infinite-fetch.utils.ts +44 -0
- package/src/index.ts +1 -0
- package/src/provider/provider.types.ts +3 -0
- package/__tests__/features/use-fetch/use-fetch.infinite.ts +0 -39
|
@@ -0,0 +1,353 @@
|
|
|
1
|
+
import { Client } from "@hyper-fetch/core";
|
|
2
|
+
import { act, renderHook, waitFor } from "@testing-library/react";
|
|
3
|
+
import { useInfiniteFetch } from "hooks/use-infinite-fetch";
|
|
4
|
+
|
|
5
|
+
import {
|
|
6
|
+
baseUrl,
|
|
7
|
+
createDeferred,
|
|
8
|
+
createListServer,
|
|
9
|
+
pageItems,
|
|
10
|
+
settleRequests,
|
|
11
|
+
} from "../../utils/use-infinite-fetch.utils";
|
|
12
|
+
|
|
13
|
+
const { startServer, stopServer, resetMocks, mockList, calls, resetCalls } = createListServer();
|
|
14
|
+
|
|
15
|
+
type Post = { id: number; search?: string };
|
|
16
|
+
type Query = { page?: number; limit?: number; search?: string; sort?: string };
|
|
17
|
+
|
|
18
|
+
const ids = (items: Post[]) => items.map((item) => item.id);
|
|
19
|
+
|
|
20
|
+
describe("useInfiniteFetch [ Start over ]", () => {
|
|
21
|
+
let client: Client;
|
|
22
|
+
|
|
23
|
+
const createPosts = () => client.createRequest<{ response: Post[]; queryParams: Query }>()({ endpoint: "/posts" });
|
|
24
|
+
|
|
25
|
+
const mockPosts = () => {
|
|
26
|
+
mockList("/posts", ({ query }) => {
|
|
27
|
+
return pageItems(Number(query.page)).map((post) => ({ ...post, search: query.search }));
|
|
28
|
+
});
|
|
29
|
+
};
|
|
30
|
+
|
|
31
|
+
const renderList = (initialQuery: Query, options: Record<string, unknown> = {}) => {
|
|
32
|
+
return renderHook(
|
|
33
|
+
({ query }: { query: Query }) =>
|
|
34
|
+
useInfiniteFetch(createPosts().setQueryParams(query), {
|
|
35
|
+
pagination: { page: "page", limit: "limit" },
|
|
36
|
+
dependencyTracking: false,
|
|
37
|
+
...options,
|
|
38
|
+
}),
|
|
39
|
+
{ initialProps: { query: initialQuery } },
|
|
40
|
+
);
|
|
41
|
+
};
|
|
42
|
+
|
|
43
|
+
beforeAll(() => startServer());
|
|
44
|
+
afterAll(() => stopServer());
|
|
45
|
+
|
|
46
|
+
beforeEach(() => {
|
|
47
|
+
client = new Client({ url: baseUrl });
|
|
48
|
+
resetCalls();
|
|
49
|
+
mockPosts();
|
|
50
|
+
});
|
|
51
|
+
|
|
52
|
+
afterEach(async () => {
|
|
53
|
+
await settleRequests(client);
|
|
54
|
+
resetMocks();
|
|
55
|
+
});
|
|
56
|
+
|
|
57
|
+
it.each<[string, Query, Query]>([
|
|
58
|
+
["a filter", { search: "a" }, { search: "b" }],
|
|
59
|
+
["the sort", { sort: "asc" }, { sort: "desc" }],
|
|
60
|
+
["the page size", { limit: 2 }, { limit: 3 }],
|
|
61
|
+
])("should start a new list when %s changes", async (_name, before, after) => {
|
|
62
|
+
const { result, rerender } = renderList(before);
|
|
63
|
+
await waitFor(() => expect(result.current.items).toHaveLength(2));
|
|
64
|
+
await act(() => result.current.fetchNextPage());
|
|
65
|
+
expect(result.current.pageParams).toEqual([1, 2]);
|
|
66
|
+
resetCalls();
|
|
67
|
+
|
|
68
|
+
rerender({ query: after });
|
|
69
|
+
|
|
70
|
+
await waitFor(() => expect(result.current.isPreviousData).toBe(false));
|
|
71
|
+
await waitFor(() => expect(result.current.pageParams).toEqual([1]));
|
|
72
|
+
expect(calls).toHaveLength(1);
|
|
73
|
+
expect(calls[0].query.page).toBe("1");
|
|
74
|
+
});
|
|
75
|
+
|
|
76
|
+
it("should start a new list when a URL param changes", async () => {
|
|
77
|
+
mockList("/users/:userId/posts", ({ path }) => [{ id: Number(path.split("/")[2]) }]);
|
|
78
|
+
const request = client.createRequest<{ response: Post[]; queryParams: { page?: number } }>()({
|
|
79
|
+
endpoint: "/users/:userId/posts",
|
|
80
|
+
});
|
|
81
|
+
|
|
82
|
+
const { result, rerender } = renderHook(
|
|
83
|
+
({ userId }) =>
|
|
84
|
+
useInfiniteFetch(request.setParams({ userId }), { pagination: { page: "page" }, dependencyTracking: false }),
|
|
85
|
+
{ initialProps: { userId: 1 } },
|
|
86
|
+
);
|
|
87
|
+
await waitFor(() => expect(ids(result.current.items)).toEqual([1]));
|
|
88
|
+
|
|
89
|
+
rerender({ userId: 2 });
|
|
90
|
+
|
|
91
|
+
// Another resource - the list of the previous user is not shown in the meantime
|
|
92
|
+
expect(result.current.items).toEqual([]);
|
|
93
|
+
expect(result.current.loading).toBe(true);
|
|
94
|
+
await waitFor(() => expect(ids(result.current.items)).toEqual([2]));
|
|
95
|
+
});
|
|
96
|
+
|
|
97
|
+
it("should start at the new page when the parent changes the paging field", async () => {
|
|
98
|
+
const { result, rerender } = renderList({ page: 5 });
|
|
99
|
+
await waitFor(() => expect(result.current.pageParams).toEqual([5]));
|
|
100
|
+
|
|
101
|
+
rerender({ query: { page: 9 } });
|
|
102
|
+
|
|
103
|
+
await waitFor(() => expect(result.current.pageParams).toEqual([9]));
|
|
104
|
+
expect(calls.map((call) => call.query.page)).toEqual(["5", "9"]);
|
|
105
|
+
});
|
|
106
|
+
|
|
107
|
+
it("should restore every page of a filter used before without requests", async () => {
|
|
108
|
+
const { result, rerender } = renderList({ search: "a" });
|
|
109
|
+
await waitFor(() => expect(result.current.items).toHaveLength(2));
|
|
110
|
+
await act(() => result.current.fetchNextPage());
|
|
111
|
+
|
|
112
|
+
rerender({ query: { search: "b" } });
|
|
113
|
+
await waitFor(() => expect(result.current.items[0]?.search).toBe("b"));
|
|
114
|
+
resetCalls();
|
|
115
|
+
|
|
116
|
+
rerender({ query: { search: "a" } });
|
|
117
|
+
|
|
118
|
+
expect(result.current.pageParams).toEqual([1, 2]);
|
|
119
|
+
expect(result.current.items.map((item) => item.search)).toEqual(["a", "a", "a", "a"]);
|
|
120
|
+
expect(result.current.isPreviousData).toBe(false);
|
|
121
|
+
await new Promise((resolve) => {
|
|
122
|
+
setTimeout(resolve, 30);
|
|
123
|
+
});
|
|
124
|
+
expect(calls).toHaveLength(0);
|
|
125
|
+
});
|
|
126
|
+
|
|
127
|
+
it("should refresh a restored filter once its pages are stale", async () => {
|
|
128
|
+
const request = createPosts().setStaleTime(0);
|
|
129
|
+
const { result, rerender } = renderHook(
|
|
130
|
+
({ search }) =>
|
|
131
|
+
useInfiniteFetch(request.setQueryParams({ search }), {
|
|
132
|
+
pagination: { page: "page" },
|
|
133
|
+
dependencyTracking: false,
|
|
134
|
+
}),
|
|
135
|
+
{ initialProps: { search: "a" } },
|
|
136
|
+
);
|
|
137
|
+
await waitFor(() => expect(result.current.items).toHaveLength(2));
|
|
138
|
+
|
|
139
|
+
rerender({ search: "b" });
|
|
140
|
+
await waitFor(() => expect(result.current.items[0]?.search).toBe("b"));
|
|
141
|
+
await new Promise((resolve) => {
|
|
142
|
+
setTimeout(resolve, 5);
|
|
143
|
+
});
|
|
144
|
+
resetCalls();
|
|
145
|
+
|
|
146
|
+
rerender({ search: "a" });
|
|
147
|
+
|
|
148
|
+
expect(result.current.items[0]?.search).toBe("a");
|
|
149
|
+
await waitFor(() => expect(calls).toHaveLength(1));
|
|
150
|
+
});
|
|
151
|
+
|
|
152
|
+
it("should drop to the starting page on reset and fetch it again", async () => {
|
|
153
|
+
const onReset = vi.fn();
|
|
154
|
+
const { result } = renderHook(() => {
|
|
155
|
+
const list = useInfiniteFetch(createPosts(), { pagination: { page: "page" }, dependencyTracking: false });
|
|
156
|
+
list.onReset(onReset);
|
|
157
|
+
return list;
|
|
158
|
+
});
|
|
159
|
+
await waitFor(() => expect(result.current.items).toHaveLength(2));
|
|
160
|
+
await act(() => result.current.fetchNextPage());
|
|
161
|
+
resetCalls();
|
|
162
|
+
|
|
163
|
+
await act(() => result.current.reset());
|
|
164
|
+
|
|
165
|
+
expect(result.current.pageParams).toEqual([1]);
|
|
166
|
+
expect(calls.map((call) => call.query.page)).toEqual(["1"]);
|
|
167
|
+
expect(onReset).toHaveBeenCalledTimes(1);
|
|
168
|
+
});
|
|
169
|
+
|
|
170
|
+
it("should report a new list through onReset", async () => {
|
|
171
|
+
const onReset = vi.fn();
|
|
172
|
+
const { result, rerender } = renderHook(
|
|
173
|
+
({ search }) => {
|
|
174
|
+
const list = useInfiniteFetch(createPosts().setQueryParams({ search }), {
|
|
175
|
+
pagination: { page: "page" },
|
|
176
|
+
dependencyTracking: false,
|
|
177
|
+
});
|
|
178
|
+
list.onReset(onReset);
|
|
179
|
+
return list;
|
|
180
|
+
},
|
|
181
|
+
{ initialProps: { search: "a" } },
|
|
182
|
+
);
|
|
183
|
+
await waitFor(() => expect(result.current.items).toHaveLength(2));
|
|
184
|
+
expect(onReset).not.toHaveBeenCalled();
|
|
185
|
+
|
|
186
|
+
rerender({ search: "b" });
|
|
187
|
+
|
|
188
|
+
expect(onReset).toHaveBeenCalledTimes(1);
|
|
189
|
+
});
|
|
190
|
+
|
|
191
|
+
describe("late responses", () => {
|
|
192
|
+
it("should not let a late page of the old filter into the new list", async () => {
|
|
193
|
+
const gate = createDeferred();
|
|
194
|
+
mockList("/posts", async ({ query }) => {
|
|
195
|
+
if (query.search === "old") {
|
|
196
|
+
await gate.promise;
|
|
197
|
+
}
|
|
198
|
+
return pageItems(Number(query.page)).map((post) => ({ ...post, search: query.search }));
|
|
199
|
+
});
|
|
200
|
+
|
|
201
|
+
const { result, rerender } = renderList({ search: "old" });
|
|
202
|
+
await waitFor(() => expect(calls).toHaveLength(1));
|
|
203
|
+
|
|
204
|
+
rerender({ query: { search: "new" } });
|
|
205
|
+
await waitFor(() => expect(result.current.items[0]?.search).toBe("new"));
|
|
206
|
+
|
|
207
|
+
gate.resolve();
|
|
208
|
+
await new Promise((resolve) => {
|
|
209
|
+
setTimeout(resolve, 30);
|
|
210
|
+
});
|
|
211
|
+
|
|
212
|
+
expect(result.current.items.map((item) => item.search)).toEqual(["new", "new"]);
|
|
213
|
+
});
|
|
214
|
+
|
|
215
|
+
it("should cancel the page of the old filter", async () => {
|
|
216
|
+
const gate = createDeferred();
|
|
217
|
+
mockList("/posts", async ({ query }) => {
|
|
218
|
+
if (query.search === "old") {
|
|
219
|
+
await gate.promise;
|
|
220
|
+
}
|
|
221
|
+
return pageItems(1);
|
|
222
|
+
});
|
|
223
|
+
|
|
224
|
+
const { result, rerender } = renderList({ search: "old" });
|
|
225
|
+
await waitFor(() => expect(calls).toHaveLength(1));
|
|
226
|
+
|
|
227
|
+
rerender({ query: { search: "new" } });
|
|
228
|
+
await waitFor(() => expect(result.current.items).toHaveLength(2));
|
|
229
|
+
gate.resolve();
|
|
230
|
+
await new Promise((resolve) => {
|
|
231
|
+
setTimeout(resolve, 30);
|
|
232
|
+
});
|
|
233
|
+
|
|
234
|
+
const oldPage = createPosts().setQueryParams({ search: "old", page: 1 });
|
|
235
|
+
expect(oldPage.read()).toBeUndefined();
|
|
236
|
+
});
|
|
237
|
+
|
|
238
|
+
it("should keep fetching a page another hook still needs", async () => {
|
|
239
|
+
const gate = createDeferred();
|
|
240
|
+
mockList("/posts", async () => {
|
|
241
|
+
await gate.promise;
|
|
242
|
+
return pageItems(1);
|
|
243
|
+
});
|
|
244
|
+
|
|
245
|
+
const stays = renderList({ search: "shared" });
|
|
246
|
+
const leaves = renderList({ search: "shared" });
|
|
247
|
+
await waitFor(() => expect(calls).toHaveLength(1));
|
|
248
|
+
|
|
249
|
+
leaves.rerender({ query: { search: "other" } });
|
|
250
|
+
gate.resolve();
|
|
251
|
+
|
|
252
|
+
await waitFor(() => expect(stays.result.current.items).toHaveLength(2));
|
|
253
|
+
});
|
|
254
|
+
});
|
|
255
|
+
|
|
256
|
+
describe("previous data", () => {
|
|
257
|
+
it("should keep the previous list on screen until the new one arrives", async () => {
|
|
258
|
+
const gate = createDeferred();
|
|
259
|
+
const { result, rerender } = renderList({ search: "a" });
|
|
260
|
+
await waitFor(() => expect(result.current.items).toHaveLength(2));
|
|
261
|
+
|
|
262
|
+
mockList("/posts", async ({ query }) => {
|
|
263
|
+
await gate.promise;
|
|
264
|
+
return pageItems(Number(query.page)).map((post) => ({ ...post, search: query.search }));
|
|
265
|
+
});
|
|
266
|
+
rerender({ query: { search: "b" } });
|
|
267
|
+
|
|
268
|
+
expect(result.current.isPreviousData).toBe(true);
|
|
269
|
+
expect(result.current.loading).toBe(false);
|
|
270
|
+
expect(result.current.isFetching).toBe(true);
|
|
271
|
+
expect(result.current.items[0].search).toBe("a");
|
|
272
|
+
expect(result.current.hasNextPage).toBe(false);
|
|
273
|
+
|
|
274
|
+
await act(async () => {
|
|
275
|
+
gate.resolve();
|
|
276
|
+
});
|
|
277
|
+
|
|
278
|
+
await waitFor(() => expect(result.current.items[0]?.search).toBe("b"));
|
|
279
|
+
expect(result.current.isPreviousData).toBe(false);
|
|
280
|
+
});
|
|
281
|
+
|
|
282
|
+
it("should clear the list right away in the clean mode", async () => {
|
|
283
|
+
const { result, rerender } = renderList({ search: "a" }, { keepPreviousData: "clean" });
|
|
284
|
+
await waitFor(() => expect(result.current.items).toHaveLength(2));
|
|
285
|
+
|
|
286
|
+
rerender({ query: { search: "b" } });
|
|
287
|
+
|
|
288
|
+
expect(result.current.items).toEqual([]);
|
|
289
|
+
expect(result.current.isPreviousData).toBe(false);
|
|
290
|
+
expect(result.current.loading).toBe(true);
|
|
291
|
+
});
|
|
292
|
+
|
|
293
|
+
it("should keep the list of another resource in the preserve mode", async () => {
|
|
294
|
+
mockList("/users/:userId/posts", () => [{ id: 1 }]);
|
|
295
|
+
const request = client.createRequest<{ response: Post[]; queryParams: { page?: number } }>()({
|
|
296
|
+
endpoint: "/users/:userId/posts",
|
|
297
|
+
});
|
|
298
|
+
|
|
299
|
+
const { result, rerender } = renderHook(
|
|
300
|
+
({ userId }) =>
|
|
301
|
+
useInfiniteFetch(request.setParams({ userId }), {
|
|
302
|
+
pagination: { page: "page" },
|
|
303
|
+
keepPreviousData: "preserve",
|
|
304
|
+
dependencyTracking: false,
|
|
305
|
+
}),
|
|
306
|
+
{ initialProps: { userId: 1 } },
|
|
307
|
+
);
|
|
308
|
+
await waitFor(() => expect(result.current.items).toHaveLength(1));
|
|
309
|
+
|
|
310
|
+
rerender({ userId: 2 });
|
|
311
|
+
|
|
312
|
+
expect(result.current.items).toHaveLength(1);
|
|
313
|
+
expect(result.current.isPreviousData).toBe(true);
|
|
314
|
+
});
|
|
315
|
+
|
|
316
|
+
it("should show the empty state when the new list fails", async () => {
|
|
317
|
+
const { result, rerender } = renderList({ search: "a" });
|
|
318
|
+
await waitFor(() => expect(result.current.items).toHaveLength(2));
|
|
319
|
+
|
|
320
|
+
resetMocks();
|
|
321
|
+
mockList("/posts", () => ({ __failure: 500 }));
|
|
322
|
+
rerender({ query: { search: "b" } });
|
|
323
|
+
|
|
324
|
+
await waitFor(() => expect(result.current.error).toBeTruthy());
|
|
325
|
+
expect(result.current.items).toEqual([]);
|
|
326
|
+
expect(result.current.isPreviousData).toBe(false);
|
|
327
|
+
});
|
|
328
|
+
});
|
|
329
|
+
|
|
330
|
+
describe("bounce", () => {
|
|
331
|
+
it("should fetch only the settled filter", async () => {
|
|
332
|
+
const { result, rerender } = renderList({ search: "a" }, { bounce: true, bounceTime: 30 });
|
|
333
|
+
await waitFor(() => expect(result.current.items).toHaveLength(2));
|
|
334
|
+
resetCalls();
|
|
335
|
+
const add = vi.spyOn(client.fetchDispatcher, "add");
|
|
336
|
+
|
|
337
|
+
rerender({ query: { search: "ab" } });
|
|
338
|
+
rerender({ query: { search: "abc" } });
|
|
339
|
+
rerender({ query: { search: "abcd" } });
|
|
340
|
+
|
|
341
|
+
expect(add).not.toHaveBeenCalled();
|
|
342
|
+
await waitFor(() => expect(result.current.items[0]?.search).toBe("abcd"));
|
|
343
|
+
expect(add).toHaveBeenCalledTimes(1);
|
|
344
|
+
expect(calls.map((call) => call.query.search)).toEqual(["abcd"]);
|
|
345
|
+
});
|
|
346
|
+
|
|
347
|
+
it("should fetch the first page right away on mount", async () => {
|
|
348
|
+
renderList({ search: "a" }, { bounce: true, bounceTime: 5000 });
|
|
349
|
+
|
|
350
|
+
await waitFor(() => expect(calls).toHaveLength(1));
|
|
351
|
+
});
|
|
352
|
+
});
|
|
353
|
+
});
|
|
@@ -0,0 +1,128 @@
|
|
|
1
|
+
import type { Pagination } from "@hyper-fetch/core";
|
|
2
|
+
import { Client, fetchInfinite } from "@hyper-fetch/core";
|
|
3
|
+
import { useInfiniteFetch } from "hooks/use-infinite-fetch";
|
|
4
|
+
|
|
5
|
+
type Post = { id: number; title: string };
|
|
6
|
+
|
|
7
|
+
const client = new Client({ url: "http://localhost:3000" });
|
|
8
|
+
|
|
9
|
+
const getPosts = client.createRequest<{
|
|
10
|
+
response: Post[];
|
|
11
|
+
queryParams: { page?: number; limit?: number; search?: string };
|
|
12
|
+
}>()({ endpoint: "/posts" });
|
|
13
|
+
|
|
14
|
+
const getFeed = client.createRequest<{
|
|
15
|
+
response: { data: Post[]; nextCursor: string | null; count: number; label: string };
|
|
16
|
+
queryParams: { cursor?: string; topic?: string };
|
|
17
|
+
}>()({ endpoint: "/feed" });
|
|
18
|
+
|
|
19
|
+
const getUsers = client.createRequest<{
|
|
20
|
+
response: { users: Post[]; total: number };
|
|
21
|
+
queryParams: { offset?: number; limit?: number };
|
|
22
|
+
}>()({ endpoint: "/users" });
|
|
23
|
+
|
|
24
|
+
// The hook is only type checked here, rendering it would send requests
|
|
25
|
+
const types = <T>(callback: () => T) => callback as unknown as T;
|
|
26
|
+
|
|
27
|
+
describe("useInfiniteFetch [ TypeScript ]", () => {
|
|
28
|
+
it("should infer the items of an array response", () => {
|
|
29
|
+
const list = types(() => useInfiniteFetch(getPosts, { pagination: { page: "page" } }));
|
|
30
|
+
|
|
31
|
+
expectTypeOf(list.items).toEqualTypeOf<Post[]>();
|
|
32
|
+
expectTypeOf(list.pages).toEqualTypeOf<Post[][]>();
|
|
33
|
+
});
|
|
34
|
+
|
|
35
|
+
it("should infer the items from a response field", () => {
|
|
36
|
+
const list = types(() =>
|
|
37
|
+
useInfiniteFetch(getFeed, { pagination: { cursor: "cursor", next: "nextCursor", items: "data" } }),
|
|
38
|
+
);
|
|
39
|
+
|
|
40
|
+
expectTypeOf(list.items).toEqualTypeOf<Post[]>();
|
|
41
|
+
});
|
|
42
|
+
|
|
43
|
+
it("should infer the items from a function", () => {
|
|
44
|
+
const list = types(() =>
|
|
45
|
+
useInfiniteFetch(getFeed, {
|
|
46
|
+
pagination: { cursor: "cursor", next: "nextCursor", items: ({ data }) => data.data.map((post) => post.title) },
|
|
47
|
+
}),
|
|
48
|
+
);
|
|
49
|
+
|
|
50
|
+
expectTypeOf(list.items).toEqualTypeOf<string[]>();
|
|
51
|
+
});
|
|
52
|
+
|
|
53
|
+
it("should type the context of the callbacks", () => {
|
|
54
|
+
types(() =>
|
|
55
|
+
useInfiniteFetch(getFeed, {
|
|
56
|
+
pagination: {
|
|
57
|
+
cursor: "cursor",
|
|
58
|
+
items: "data",
|
|
59
|
+
next: ({ data, pages }) => {
|
|
60
|
+
expectTypeOf(data.nextCursor).toEqualTypeOf<string | null>();
|
|
61
|
+
expectTypeOf(pages).toBeArray();
|
|
62
|
+
return data.nextCursor;
|
|
63
|
+
},
|
|
64
|
+
},
|
|
65
|
+
}),
|
|
66
|
+
);
|
|
67
|
+
});
|
|
68
|
+
|
|
69
|
+
it("should use the type returned from select", () => {
|
|
70
|
+
const list = types(() =>
|
|
71
|
+
useInfiniteFetch(getPosts, {
|
|
72
|
+
pagination: { page: "page" },
|
|
73
|
+
select: ({ items }) => items.length,
|
|
74
|
+
}),
|
|
75
|
+
);
|
|
76
|
+
|
|
77
|
+
expectTypeOf(list.items).toEqualTypeOf<number>();
|
|
78
|
+
});
|
|
79
|
+
|
|
80
|
+
it("should accept a reusable pagination", () => {
|
|
81
|
+
const pagination = { offset: "offset", limit: "limit", items: "users", total: "total" } satisfies Pagination<
|
|
82
|
+
typeof getUsers
|
|
83
|
+
>;
|
|
84
|
+
const list = types(() => useInfiniteFetch(getUsers, { pagination }));
|
|
85
|
+
|
|
86
|
+
expectTypeOf(list.items).toEqualTypeOf<Post[]>();
|
|
87
|
+
expectTypeOf(list.total).toEqualTypeOf<number | null>();
|
|
88
|
+
});
|
|
89
|
+
|
|
90
|
+
it("should type the prefetched items", () => {
|
|
91
|
+
const result = types(() => fetchInfinite(getPosts, { pagination: { page: "page" } }));
|
|
92
|
+
|
|
93
|
+
expectTypeOf(result).resolves.toHaveProperty("items").toEqualTypeOf<Post[]>();
|
|
94
|
+
});
|
|
95
|
+
|
|
96
|
+
it("should reject a wrong pagination", () => {
|
|
97
|
+
types(() => {
|
|
98
|
+
// @ts-expect-error pagination is required
|
|
99
|
+
useInfiniteFetch(getPosts, {});
|
|
100
|
+
// @ts-expect-error not a query param of the request
|
|
101
|
+
useInfiniteFetch(getPosts, { pagination: { page: "pageNumber" } });
|
|
102
|
+
// @ts-expect-error the page has to be a number
|
|
103
|
+
useInfiniteFetch(getPosts, { pagination: { page: "search" } });
|
|
104
|
+
// @ts-expect-error the limit has to be a number
|
|
105
|
+
useInfiniteFetch(getPosts, { pagination: { page: "page", limit: "search" } });
|
|
106
|
+
// @ts-expect-error offset pagination needs the limit
|
|
107
|
+
useInfiniteFetch(getUsers, { pagination: { offset: "offset", items: "users" } });
|
|
108
|
+
// @ts-expect-error cursor pagination needs the next cursor
|
|
109
|
+
useInfiniteFetch(getFeed, { pagination: { cursor: "cursor", items: "data" } });
|
|
110
|
+
// @ts-expect-error not a response field
|
|
111
|
+
useInfiniteFetch(getFeed, { pagination: { cursor: "cursor", next: "nope", items: "data" } });
|
|
112
|
+
// @ts-expect-error the next cursor cannot be a list
|
|
113
|
+
useInfiniteFetch(getFeed, { pagination: { cursor: "cursor", next: "data", items: "data" } });
|
|
114
|
+
// @ts-expect-error items are required when the response is not an array
|
|
115
|
+
useInfiniteFetch(getFeed, { pagination: { cursor: "cursor", next: "nextCursor" } });
|
|
116
|
+
// @ts-expect-error items have to be an array field
|
|
117
|
+
useInfiniteFetch(getFeed, { pagination: { cursor: "cursor", next: "nextCursor", items: "label" } });
|
|
118
|
+
useInfiniteFetch(getFeed, {
|
|
119
|
+
// @ts-expect-error total has to be a number field
|
|
120
|
+
pagination: { cursor: "cursor", next: "nextCursor", items: "data", total: "label" },
|
|
121
|
+
});
|
|
122
|
+
// @ts-expect-error modes cannot be mixed
|
|
123
|
+
useInfiniteFetch(getPosts, { pagination: { page: "page", offset: "limit" } });
|
|
124
|
+
// @ts-expect-error not a field of the item
|
|
125
|
+
useInfiniteFetch(getPosts, { pagination: { page: "page" }, uniqueBy: "nope" });
|
|
126
|
+
});
|
|
127
|
+
});
|
|
128
|
+
});
|