@hyper-fetch/sockets 9.6.1 → 9.6.2

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 (39) hide show
  1. package/__tests__/e2e/e2e.lifecycle.spec.ts +258 -0
  2. package/__tests__/features/adapter/adapter.connection.spec.ts +27 -6
  3. package/__tests__/features/adapter/adapter.sse.lifecycle.spec.ts +514 -0
  4. package/__tests__/features/adapter/adapter.sse.spec.ts +20 -6
  5. package/__tests__/features/adapter/adapter.websocket.heartbeat.timers.spec.ts +337 -0
  6. package/__tests__/features/adapter/adapter.websocket.lifecycle.spec.ts +528 -0
  7. package/__tests__/features/adapter/adapter.websocket.reconnection.spec.ts +669 -0
  8. package/__tests__/features/delivery/delivery.backpressure.spec.ts +382 -0
  9. package/__tests__/features/emitter/emitter.sending.spec.ts +493 -0
  10. package/__tests__/features/emitter/emitter.typescript.spec.ts +153 -0
  11. package/__tests__/features/listener/listener.dispatch.spec.ts +427 -0
  12. package/__tests__/features/listener/listener.params.spec.ts +192 -0
  13. package/__tests__/features/socket/socket.app-manager.spec.ts +24 -2
  14. package/__tests__/features/socket/socket.interceptors.spec.ts +430 -0
  15. package/__tests__/utils/controlled-event-source.ts +149 -0
  16. package/__tests__/utils/controlled-websocket.ts +213 -0
  17. package/dist/adapter/adapter.bindings.d.ts.map +1 -1
  18. package/dist/adapter/adapter.d.ts.map +1 -1
  19. package/dist/adapter-sse/sse-adapter.d.ts.map +1 -1
  20. package/dist/adapter-websockets/websocket-adapter.d.ts.map +1 -1
  21. package/dist/emitter/emitter.d.ts.map +1 -1
  22. package/dist/index.mjs +284 -105
  23. package/dist/index.mjs.map +1 -1
  24. package/dist/listener/listener.d.ts +2 -0
  25. package/dist/listener/listener.d.ts.map +1 -1
  26. package/dist/socket/socket.d.ts +1 -1
  27. package/dist/socket/socket.utils.d.ts +11 -3
  28. package/dist/socket/socket.utils.d.ts.map +1 -1
  29. package/dist/utils/topic.utils.d.ts +10 -0
  30. package/dist/utils/topic.utils.d.ts.map +1 -0
  31. package/package.json +1 -1
  32. package/src/adapter/adapter.bindings.ts +44 -20
  33. package/src/adapter/adapter.ts +29 -10
  34. package/src/adapter-sse/sse-adapter.ts +95 -15
  35. package/src/adapter-websockets/websocket-adapter.ts +124 -41
  36. package/src/emitter/emitter.ts +16 -9
  37. package/src/listener/listener.ts +7 -8
  38. package/src/socket/socket.utils.ts +20 -6
  39. package/src/utils/topic.utils.ts +26 -0
@@ -0,0 +1,528 @@
1
+ import { Socket } from "socket";
2
+
3
+ import {
4
+ ControlledWebSocket,
5
+ flushPromises,
6
+ installControlledWebSocket,
7
+ openWebSocket,
8
+ uninstallControlledWebSocket,
9
+ waitForWebSocket,
10
+ } from "../../utils/controlled-websocket";
11
+
12
+ const url = "ws://lifecycle";
13
+
14
+ /** Records every connection event of a socket in the order it was emitted */
15
+ const trackEvents = (socket: Socket) => {
16
+ const events: string[] = [];
17
+ socket.events.onConnecting(({ connecting }) => events.push(`connecting:${connecting}`));
18
+ socket.events.onConnected(() => events.push("connected"));
19
+ socket.events.onDisconnected(() => events.push("disconnected"));
20
+ socket.events.onReconnecting(({ attempts }) => events.push(`reconnecting:${attempts}`));
21
+ socket.events.onReconnectingFailed(({ attempts }) => events.push(`reconnecting-failed:${attempts}`));
22
+ socket.events.onError(({ error }: any) => events.push(`error:${error.message}`));
23
+ return events;
24
+ };
25
+
26
+ describe("Websocket Adapter [ Lifecycle ]", () => {
27
+ const sockets: Socket[] = [];
28
+
29
+ const createSocket = (options?: Partial<ConstructorParameters<typeof Socket>[0]>) => {
30
+ const socket = new Socket({ url, ...options });
31
+ sockets.push(socket);
32
+ return socket;
33
+ };
34
+
35
+ const createManualSocket = (options?: Partial<ConstructorParameters<typeof Socket>[0]>) => {
36
+ return createSocket({ ...options, adapterOptions: { autoConnect: false, ...options?.adapterOptions } });
37
+ };
38
+
39
+ /** Waits for the transport of the attempt in progress and lets the server refuse it */
40
+ const refuseWebSocket = async () => {
41
+ const websocket = await waitForWebSocket();
42
+ websocket.serverRefuse();
43
+ return websocket;
44
+ };
45
+
46
+ beforeEach(() => {
47
+ installControlledWebSocket();
48
+ vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
49
+ });
50
+
51
+ afterEach(async () => {
52
+ await Promise.all(sockets.map((socket) => socket.disconnect()));
53
+ sockets.forEach((socket) => socket.appManager.unmount());
54
+ sockets.length = 0;
55
+ vi.useRealTimers();
56
+ uninstallControlledWebSocket();
57
+ });
58
+
59
+ describe("When connecting", () => {
60
+ it("should start in the disconnected state without autoConnect", async () => {
61
+ const socket = createManualSocket();
62
+ await flushPromises();
63
+
64
+ expect(socket.adapter.connected).toBeFalse();
65
+ expect(socket.adapter.connecting).toBeFalse();
66
+ expect(ControlledWebSocket.instances).toHaveLength(0);
67
+ });
68
+
69
+ it("should mark the socket as connecting synchronously with autoConnect", () => {
70
+ const socket = createSocket();
71
+
72
+ expect(socket.adapter.connecting).toBeTrue();
73
+ expect(socket.adapter.connected).toBeFalse();
74
+ });
75
+
76
+ it("should emit connecting, then connected in order", async () => {
77
+ const socket = createManualSocket();
78
+ const events = trackEvents(socket);
79
+
80
+ const connecting = socket.connect();
81
+ await openWebSocket();
82
+ await connecting;
83
+
84
+ expect(events).toStrictEqual(["connecting:true", "connecting:false", "connected"]);
85
+ expect(socket.adapter.connected).toBeTrue();
86
+ expect(socket.adapter.connecting).toBeFalse();
87
+ });
88
+
89
+ it("should resolve connect only after the connection is open", async () => {
90
+ const socket = createManualSocket();
91
+ const resolved = vi.fn();
92
+
93
+ const connecting = socket.connect().then(resolved);
94
+ const websocket = await waitForWebSocket();
95
+ await flushPromises();
96
+ expect(resolved).not.toHaveBeenCalled();
97
+
98
+ websocket.serverOpen();
99
+ await connecting;
100
+
101
+ expect(resolved).toHaveBeenCalledTimes(1);
102
+ expect(socket.adapter.connected).toBeTrue();
103
+ });
104
+
105
+ it("should wait for the automatic connection when connect is called right after creating the socket", async () => {
106
+ const socket = createSocket();
107
+ const resolved = vi.fn();
108
+
109
+ const connecting = socket.connect().then(resolved);
110
+ const websocket = await waitForWebSocket();
111
+ await flushPromises();
112
+ expect(resolved).not.toHaveBeenCalled();
113
+
114
+ websocket.serverOpen();
115
+ await connecting;
116
+
117
+ expect(socket.adapter.connected).toBeTrue();
118
+ expect(ControlledWebSocket.instances).toHaveLength(1);
119
+ });
120
+
121
+ it("should resolve every concurrent connect call with the same result", async () => {
122
+ const socket = createManualSocket();
123
+
124
+ const first = socket.adapter.connect();
125
+ const second = socket.adapter.connect();
126
+ const third = socket.adapter.connect();
127
+ await openWebSocket();
128
+
129
+ await expect(Promise.all([first, second, third])).resolves.toStrictEqual([true, true, true]);
130
+ expect(ControlledWebSocket.instances).toHaveLength(1);
131
+ });
132
+
133
+ it("should open a single transport and emit a single connecting event for concurrent connect calls", async () => {
134
+ const socket = createManualSocket();
135
+ const events = trackEvents(socket);
136
+
137
+ socket.connect();
138
+ socket.connect();
139
+ socket.connect();
140
+ await openWebSocket();
141
+
142
+ expect(ControlledWebSocket.instances).toHaveLength(1);
143
+ expect(events).toStrictEqual(["connecting:true", "connecting:false", "connected"]);
144
+ });
145
+
146
+ it("should resolve joined connect calls with false when the attempt fails", async () => {
147
+ const socket = createManualSocket({ reconnect: 0 });
148
+ socket.onError(() => null);
149
+
150
+ const first = socket.adapter.connect();
151
+ const second = socket.adapter.connect();
152
+ const websocket = await waitForWebSocket();
153
+ websocket.serverRefuse();
154
+
155
+ await expect(Promise.all([first, second])).resolves.toStrictEqual([false, false]);
156
+ });
157
+
158
+ it("should start a fresh attempt after the previous one failed", async () => {
159
+ const socket = createManualSocket({ reconnect: 0 });
160
+ socket.onError(() => null);
161
+
162
+ const first = socket.adapter.connect();
163
+ await refuseWebSocket();
164
+ await expect(first).resolves.toBe(false);
165
+
166
+ const second = socket.adapter.connect();
167
+ await openWebSocket(2);
168
+
169
+ await expect(second).resolves.toBe(true);
170
+ expect(ControlledWebSocket.instances).toHaveLength(2);
171
+ });
172
+
173
+ it("should keep the open connection when connect is called again", async () => {
174
+ const socket = createSocket();
175
+ await openWebSocket();
176
+ const events = trackEvents(socket);
177
+
178
+ await expect(socket.adapter.connect()).resolves.toBe(true);
179
+ await expect(socket.adapter.connect()).resolves.toBe(true);
180
+
181
+ expect(ControlledWebSocket.instances).toHaveLength(1);
182
+ expect(events).toStrictEqual([]);
183
+ });
184
+
185
+ it("should connect to the url with stringified query params", async () => {
186
+ createSocket({ url: "ws://lifecycle/path", queryParams: { token: "abc", rooms: [1, 2] } });
187
+
188
+ const websocket = await waitForWebSocket();
189
+
190
+ expect(websocket.url).toBe("ws://lifecycle/path?token=abc&rooms[]=1&rooms[]=2");
191
+ });
192
+
193
+ it("should pass the protocols to the transport", async () => {
194
+ createSocket({ adapterOptions: { protocols: ["v1", "v2"] } });
195
+
196
+ const websocket = await waitForWebSocket();
197
+
198
+ expect(websocket.protocols).toStrictEqual(["v1", "v2"]);
199
+ });
200
+
201
+ it("should report an error when the transport cannot be created", async () => {
202
+ const socket = createManualSocket();
203
+ const events = trackEvents(socket);
204
+ ControlledWebSocket.constructorError = new SyntaxError("The URL is invalid");
205
+
206
+ await expect(socket.adapter.connect()).resolves.toBe(false);
207
+
208
+ expect(events).toStrictEqual(["connecting:true", "connecting:false", "error:The URL is invalid"]);
209
+ expect(socket.adapter.connecting).toBeFalse();
210
+ expect(socket.adapter.connected).toBeFalse();
211
+ });
212
+
213
+ it("should report an error and a disconnection when the server refuses the connection", async () => {
214
+ const socket = createManualSocket({ reconnect: 0 });
215
+ const events = trackEvents(socket);
216
+
217
+ const connecting = socket.adapter.connect();
218
+ await refuseWebSocket();
219
+
220
+ await expect(connecting).resolves.toBe(false);
221
+ expect(events).toStrictEqual([
222
+ "connecting:true",
223
+ "connecting:false",
224
+ "disconnected",
225
+ "error:The connection was closed abnormally, e.g., without sending or receiving a Close control frame",
226
+ ]);
227
+ expect(socket.adapter.connected).toBeFalse();
228
+ expect(socket.adapter.connecting).toBeFalse();
229
+ });
230
+ });
231
+
232
+ describe("When disconnecting", () => {
233
+ it("should close the transport with the normal closure code", async () => {
234
+ const socket = createSocket();
235
+ const websocket = await openWebSocket();
236
+
237
+ await socket.disconnect();
238
+
239
+ expect(websocket.closeCalls).toStrictEqual([{ code: 1000, reason: undefined }]);
240
+ expect(websocket.readyState).toBe(ControlledWebSocket.CLOSED);
241
+ });
242
+
243
+ it("should emit a single disconnected event and no error", async () => {
244
+ const socket = createSocket();
245
+ await openWebSocket();
246
+ const events = trackEvents(socket);
247
+
248
+ await socket.disconnect();
249
+
250
+ expect(events).toStrictEqual(["connecting:false", "disconnected"]);
251
+ });
252
+
253
+ it("should update the state before the transport finished closing", async () => {
254
+ ControlledWebSocket.autoFinishClose = false;
255
+ const socket = createSocket();
256
+ const websocket = await openWebSocket();
257
+ const resolved = vi.fn();
258
+
259
+ const disconnecting = socket.disconnect().then(resolved);
260
+ await flushPromises();
261
+
262
+ expect(socket.adapter.connected).toBeFalse();
263
+ expect(resolved).not.toHaveBeenCalled();
264
+
265
+ websocket.finishClose();
266
+ await disconnecting;
267
+
268
+ expect(resolved).toHaveBeenCalledTimes(1);
269
+ });
270
+
271
+ it("should be a no-op when the socket was never connected", async () => {
272
+ const socket = createManualSocket();
273
+ const events = trackEvents(socket);
274
+
275
+ await expect(socket.adapter.disconnect()).resolves.toBe(true);
276
+ await expect(socket.adapter.disconnect()).resolves.toBe(true);
277
+
278
+ expect(events).toStrictEqual([]);
279
+ });
280
+
281
+ it("should emit disconnected once when disconnect is called twice", async () => {
282
+ const socket = createSocket();
283
+ await openWebSocket();
284
+ const events = trackEvents(socket);
285
+
286
+ await Promise.all([socket.disconnect(), socket.disconnect()]);
287
+ await socket.disconnect();
288
+
289
+ expect(events).toStrictEqual(["connecting:false", "disconnected"]);
290
+ });
291
+
292
+ it("should cancel a connection that is still opening", async () => {
293
+ const socket = createManualSocket();
294
+ const events = trackEvents(socket);
295
+
296
+ const connecting = socket.adapter.connect();
297
+ const websocket = await waitForWebSocket();
298
+ await socket.disconnect();
299
+
300
+ await expect(connecting).resolves.toBe(false);
301
+ expect(websocket.readyState).toBe(ControlledWebSocket.CLOSED);
302
+ expect(events).toStrictEqual(["connecting:true", "connecting:false", "disconnected"]);
303
+ expect(socket.adapter.connecting).toBeFalse();
304
+ expect(socket.adapter.connected).toBeFalse();
305
+ });
306
+
307
+ it("should not reconnect after disconnecting a connection that is still opening", async () => {
308
+ const socket = createManualSocket({ reconnectTime: 100 });
309
+ const events = trackEvents(socket);
310
+
311
+ socket.connect();
312
+ await waitForWebSocket();
313
+ await socket.disconnect();
314
+ events.length = 0;
315
+
316
+ await vi.advanceTimersByTimeAsync(1000);
317
+
318
+ expect(events).toStrictEqual([]);
319
+ expect(ControlledWebSocket.instances).toHaveLength(1);
320
+ expect(vi.getTimerCount()).toBe(0);
321
+ });
322
+
323
+ it("should ignore a server that opens the connection after it was cancelled", async () => {
324
+ ControlledWebSocket.autoFinishClose = false;
325
+ const socket = createManualSocket();
326
+
327
+ socket.connect();
328
+ const websocket = await waitForWebSocket();
329
+ socket.disconnect();
330
+ const events = trackEvents(socket);
331
+ // The handshake finished at the very moment the client gave up
332
+ websocket.readyState = ControlledWebSocket.OPEN;
333
+ websocket.dispatchEvent(new Event("open"));
334
+
335
+ expect(events).toStrictEqual([]);
336
+ expect(socket.adapter.connected).toBeFalse();
337
+ websocket.finishClose();
338
+ });
339
+
340
+ it("should ignore frames arriving after disconnect", async () => {
341
+ ControlledWebSocket.autoFinishClose = false;
342
+ const socket = createSocket();
343
+ const websocket = await openWebSocket();
344
+ const spy = vi.fn();
345
+ socket.createListener<number>()({ topic: "late" }).listen(spy);
346
+
347
+ socket.disconnect();
348
+ websocket.serverEmit("late", 1);
349
+
350
+ expect(spy).not.toHaveBeenCalled();
351
+ websocket.finishClose();
352
+ });
353
+
354
+ it("should allow connecting again after a disconnect", async () => {
355
+ const socket = createSocket();
356
+ await openWebSocket();
357
+ await socket.disconnect();
358
+ const events = trackEvents(socket);
359
+
360
+ const connecting = socket.connect();
361
+ await openWebSocket(2);
362
+ await connecting;
363
+
364
+ expect(events).toStrictEqual(["connecting:true", "connecting:false", "connected"]);
365
+ expect(ControlledWebSocket.active).toHaveLength(1);
366
+ });
367
+
368
+ it("should connect again when connect is called while the previous transport is still closing", async () => {
369
+ ControlledWebSocket.autoFinishClose = false;
370
+ const socket = createSocket();
371
+ const first = await openWebSocket();
372
+
373
+ socket.disconnect();
374
+ const connecting = socket.connect();
375
+ const second = await openWebSocket(2);
376
+ await connecting;
377
+ // The old transport finishes closing only now - it must not affect the new connection
378
+ first.finishClose();
379
+ ControlledWebSocket.autoFinishClose = true;
380
+
381
+ expect(socket.adapter.connected).toBeTrue();
382
+ expect(second.readyState).toBe(ControlledWebSocket.OPEN);
383
+ });
384
+
385
+ it("should leave no timers behind", async () => {
386
+ const socket = createSocket({ adapterOptions: { heartbeat: true, pingTimeout: 50, pongTimeout: 50 } });
387
+ await openWebSocket();
388
+
389
+ await socket.disconnect();
390
+
391
+ expect(vi.getTimerCount()).toBe(0);
392
+ });
393
+ });
394
+
395
+ describe("When the server closes the connection", () => {
396
+ it.each([
397
+ {
398
+ code: 1001,
399
+ message:
400
+ 'An endpoint is "going away", such as a server going down or a browser having navigated away from a page.',
401
+ },
402
+ {
403
+ code: 1006,
404
+ message: "The connection was closed abnormally, e.g., without sending or receiving a Close control frame",
405
+ },
406
+ {
407
+ code: 1011,
408
+ message:
409
+ "A server is terminating the connection because it encountered an unexpected condition that prevented it from fulfilling the request.",
410
+ },
411
+ { code: 4000, message: "Unknown reason" },
412
+ ])("should report close code $code and schedule a reconnect", async ({ code, message }) => {
413
+ const socket = createSocket({ reconnectTime: 100 });
414
+ const websocket = await openWebSocket();
415
+ const events = trackEvents(socket);
416
+
417
+ websocket.serverClose({ code });
418
+
419
+ expect(events).toStrictEqual(["connecting:false", "disconnected", `error:${message}`]);
420
+ expect(socket.adapter.connected).toBeFalse();
421
+ expect(vi.getTimerCount()).toBe(1);
422
+ });
423
+
424
+ it("should not reconnect after a normal closure from the server", async () => {
425
+ const socket = createSocket({ reconnectTime: 100 });
426
+ const websocket = await openWebSocket();
427
+ const events = trackEvents(socket);
428
+
429
+ websocket.serverClose({ code: 1000, wasClean: true });
430
+ await vi.advanceTimersByTimeAsync(1000);
431
+
432
+ expect(events).toStrictEqual([
433
+ "connecting:false",
434
+ "disconnected",
435
+ "error:Normal closure, meaning that the purpose for which the connection was established has been fulfilled.",
436
+ ]);
437
+ expect(ControlledWebSocket.instances).toHaveLength(1);
438
+ });
439
+
440
+ it("should deliver the message that arrived right before the close", async () => {
441
+ const socket = createSocket();
442
+ const websocket = await openWebSocket();
443
+ const order: string[] = [];
444
+ socket
445
+ .createListener<number>()({ topic: "last" })
446
+ .listen(({ data }) => order.push(`message:${data}`));
447
+ socket.events.onDisconnected(() => order.push("disconnected"));
448
+
449
+ websocket.serverEmit("last", 1);
450
+ websocket.serverClose({ code: 1006 });
451
+
452
+ expect(order).toStrictEqual(["message:1", "disconnected"]);
453
+ });
454
+
455
+ it("should stop emitting through a connection closed by the server", async () => {
456
+ const socket = createSocket();
457
+ const websocket = await openWebSocket();
458
+ const emitterError = vi.fn();
459
+ socket.onError(() => null);
460
+ socket.events.onEmitterError(({ error }) => emitterError(error.message));
461
+
462
+ websocket.serverClose({ code: 1006 });
463
+ socket.createEmitter<number>()({ topic: "after-close" }).emit({ payload: 1 });
464
+ await flushPromises();
465
+
466
+ expect(websocket.sent).toStrictEqual([]);
467
+ expect(emitterError).toHaveBeenCalledWith("Cannot emit event when connection is not open");
468
+ });
469
+ });
470
+
471
+ describe("When using many sockets", () => {
472
+ it("should keep the connection state of every socket separate", async () => {
473
+ const first = createSocket({ url: "ws://first" });
474
+ const second = createSocket({ url: "ws://second" });
475
+ const firstWebsocket = await openWebSocket(1);
476
+ await openWebSocket(2);
477
+
478
+ firstWebsocket.serverClose({ code: 1006 });
479
+
480
+ expect(first.adapter.connected).toBeFalse();
481
+ expect(second.adapter.connected).toBeTrue();
482
+ });
483
+
484
+ it("should route messages only to the listeners of the receiving socket", async () => {
485
+ const first = createSocket({ url: "ws://first" });
486
+ const second = createSocket({ url: "ws://second" });
487
+ const firstWebsocket = await openWebSocket(1);
488
+ await openWebSocket(2);
489
+ const firstSpy = vi.fn();
490
+ const secondSpy = vi.fn();
491
+ first.createListener<number>()({ topic: "shared-topic" }).listen(firstSpy);
492
+ second.createListener<number>()({ topic: "shared-topic" }).listen(secondSpy);
493
+
494
+ firstWebsocket.serverEmit("shared-topic", 1);
495
+
496
+ expect(firstSpy).toHaveBeenCalledTimes(1);
497
+ expect(secondSpy).not.toHaveBeenCalled();
498
+ });
499
+
500
+ it("should keep listeners, callbacks and adapters of every socket separate", () => {
501
+ const first = createManualSocket();
502
+ const second = createManualSocket();
503
+ first.onConnected(() => null).onError(() => null);
504
+ first
505
+ .createListener<number>()({ topic: "topic" })
506
+ .listen(() => null);
507
+
508
+ expect(first.adapter).not.toBe(second.adapter);
509
+ expect(first.emitter).not.toBe(second.emitter);
510
+ expect(first.appManager).not.toBe(second.appManager);
511
+ expect(second.unstable_onConnectedCallbacks).toHaveLength(0);
512
+ expect(second.unstable_onErrorCallbacks).toHaveLength(0);
513
+ expect(second.adapter.listeners.size).toBe(0);
514
+ });
515
+
516
+ it("should disconnect one socket without touching the other", async () => {
517
+ const first = createSocket({ url: "ws://first" });
518
+ const second = createSocket({ url: "ws://second" });
519
+ await openWebSocket(1);
520
+ const secondWebsocket = await openWebSocket(2);
521
+
522
+ await first.disconnect();
523
+
524
+ expect(second.adapter.connected).toBeTrue();
525
+ expect(secondWebsocket.closeCalls).toStrictEqual([]);
526
+ });
527
+ });
528
+ });