@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.
- package/__tests__/features/hydrate/hydrate.spec.tsx +511 -0
- package/__tests__/features/hydrate/hydrate.ssr.spec.tsx +189 -0
- package/__tests__/features/use-fetch/use-fetch.concurrency.spec.ts +2 -1
- package/__tests__/features/use-fetch/use-fetch.methods.spec.ts +9 -3
- package/__tests__/features/use-fetch/use-fetch.offline.spec.ts +4 -2
- package/__tests__/features/use-fetch/use-fetch.scope.spec.tsx +211 -0
- package/__tests__/features/use-fetch/use-fetch.suspense.spec.tsx +223 -0
- package/__tests__/features/use-submit/use-submit.methods.spec.ts +9 -3
- package/__tests__/features/use-submit/use-submit.optimistic-settlement.spec.ts +625 -0
- package/__tests__/features/use-submit/use-submit.optimistic.spec.ts +12 -4
- package/__tests__/tsconfig.json +2 -0
- package/dist/helpers/use-request-events/use-request-events.hooks.d.ts.map +1 -1
- package/dist/helpers/use-tracked-state/use-tracked-state.hooks.d.ts.map +1 -1
- package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts +4 -1
- package/dist/helpers/use-tracked-state/use-tracked-state.utils.d.ts.map +1 -1
- package/dist/hooks/use-fetch/use-fetch.hooks.d.ts.map +1 -1
- package/dist/hydrate/hydrate.d.ts +16 -0
- package/dist/hydrate/hydrate.d.ts.map +1 -0
- package/dist/hydrate/hydrate.types.d.ts +52 -0
- package/dist/hydrate/hydrate.types.d.ts.map +1 -0
- package/dist/hydrate/hydrate.utils.d.ts +19 -0
- package/dist/hydrate/hydrate.utils.d.ts.map +1 -0
- package/dist/hydrate/index.d.ts +3 -0
- package/dist/hydrate/index.d.ts.map +1 -0
- package/dist/index.d.ts +1 -0
- package/dist/index.d.ts.map +1 -1
- package/dist/index.mjs +229 -44
- package/dist/index.mjs.map +1 -1
- package/dist/utils/scope.utils.d.ts +7 -0
- package/dist/utils/scope.utils.d.ts.map +1 -0
- package/package.json +1 -1
- package/src/helpers/use-request-events/use-request-events.hooks.ts +24 -33
- package/src/helpers/use-tracked-state/use-tracked-state.hooks.ts +8 -3
- package/src/helpers/use-tracked-state/use-tracked-state.utils.ts +9 -1
- package/src/hooks/use-fetch/use-fetch.hooks.ts +78 -16
- package/src/hydrate/hydrate.tsx +74 -0
- package/src/hydrate/hydrate.types.ts +55 -0
- package/src/hydrate/hydrate.utils.ts +124 -0
- package/src/hydrate/index.ts +2 -0
- package/src/index.ts +1 -0
- package/src/utils/scope.utils.ts +8 -0
- 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
|
-
|
|
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
|
|
333
|
-
|
|
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" });
|
package/__tests__/tsconfig.json
CHANGED
|
@@ -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;
|
|
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;
|
|
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"}
|