@hyper-fetch/sockets 9.6.0 → 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 (40) hide show
  1. package/__tests__/e2e/e2e.lifecycle.spec.ts +258 -0
  2. package/__tests__/features/adapter/adapter.connection.spec.ts +63 -6
  3. package/__tests__/features/adapter/adapter.sse.connection.spec.ts +45 -0
  4. package/__tests__/features/adapter/adapter.sse.lifecycle.spec.ts +514 -0
  5. package/__tests__/features/adapter/adapter.sse.spec.ts +20 -6
  6. package/__tests__/features/adapter/adapter.websocket.heartbeat.timers.spec.ts +337 -0
  7. package/__tests__/features/adapter/adapter.websocket.lifecycle.spec.ts +528 -0
  8. package/__tests__/features/adapter/adapter.websocket.reconnection.spec.ts +669 -0
  9. package/__tests__/features/delivery/delivery.backpressure.spec.ts +382 -0
  10. package/__tests__/features/emitter/emitter.sending.spec.ts +493 -0
  11. package/__tests__/features/emitter/emitter.typescript.spec.ts +153 -0
  12. package/__tests__/features/listener/listener.dispatch.spec.ts +427 -0
  13. package/__tests__/features/listener/listener.params.spec.ts +192 -0
  14. package/__tests__/features/socket/socket.app-manager.spec.ts +24 -2
  15. package/__tests__/features/socket/socket.interceptors.spec.ts +430 -0
  16. package/__tests__/utils/controlled-event-source.ts +149 -0
  17. package/__tests__/utils/controlled-websocket.ts +213 -0
  18. package/dist/adapter/adapter.bindings.d.ts.map +1 -1
  19. package/dist/adapter/adapter.d.ts.map +1 -1
  20. package/dist/adapter-sse/sse-adapter.d.ts.map +1 -1
  21. package/dist/adapter-websockets/websocket-adapter.d.ts.map +1 -1
  22. package/dist/emitter/emitter.d.ts.map +1 -1
  23. package/dist/index.mjs +289 -105
  24. package/dist/index.mjs.map +1 -1
  25. package/dist/listener/listener.d.ts +2 -0
  26. package/dist/listener/listener.d.ts.map +1 -1
  27. package/dist/socket/socket.d.ts +1 -1
  28. package/dist/socket/socket.utils.d.ts +11 -3
  29. package/dist/socket/socket.utils.d.ts.map +1 -1
  30. package/dist/utils/topic.utils.d.ts +10 -0
  31. package/dist/utils/topic.utils.d.ts.map +1 -0
  32. package/package.json +1 -1
  33. package/src/adapter/adapter.bindings.ts +44 -20
  34. package/src/adapter/adapter.ts +29 -10
  35. package/src/adapter-sse/sse-adapter.ts +101 -13
  36. package/src/adapter-websockets/websocket-adapter.ts +126 -41
  37. package/src/emitter/emitter.ts +16 -9
  38. package/src/listener/listener.ts +7 -8
  39. package/src/socket/socket.utils.ts +20 -6
  40. package/src/utils/topic.utils.ts +26 -0
@@ -0,0 +1,382 @@
1
+ import { createBatchDeliveryStrategy, createDeliveryStrategy, createLatestDeliveryStrategy } from "delivery";
2
+ import { Socket } from "socket";
3
+
4
+ type Tick = { id: number };
5
+
6
+ /** Pushes messages straight into the adapter - the same path a transport uses, without any network */
7
+ const createStream = (socket: Socket, topic: string) => {
8
+ return (id: number) => socket.adapter.triggerListeners({ topic, data: { id }, extra: { id } as any });
9
+ };
10
+
11
+ describe("Delivery [ Back-pressure ]", () => {
12
+ let socket: Socket;
13
+
14
+ beforeEach(() => {
15
+ socket = new Socket({ url: "ws://delivery", adapterOptions: { autoConnect: false } });
16
+ vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
17
+ });
18
+
19
+ afterEach(() => {
20
+ vi.useRealTimers();
21
+ });
22
+
23
+ describe("When batching a fast stream", () => {
24
+ it("should deliver 10000 messages of one window as a single ordered batch", () => {
25
+ const listener = socket.createListener<Tick>()({
26
+ topic: "ticks",
27
+ delivery: { strategy: "batch", interval: 100 },
28
+ });
29
+ const push = createStream(socket, "ticks");
30
+ const batches: Tick[][] = [];
31
+ listener.listen(({ data }) => batches.push(data));
32
+
33
+ for (let i = 0; i < 10_000; i += 1) {
34
+ push(i);
35
+ }
36
+ expect(batches).toHaveLength(0);
37
+ vi.advanceTimersByTime(100);
38
+
39
+ expect(batches).toHaveLength(1);
40
+ expect(batches[0]).toHaveLength(10_000);
41
+ expect(batches[0].every((tick, index) => tick.id === index)).toBeTrue();
42
+ expect(vi.getTimerCount()).toBe(0);
43
+ });
44
+
45
+ it("should split a long stream into windows without losing or reordering messages", () => {
46
+ const listener = socket.createListener<Tick>()({
47
+ topic: "ticks",
48
+ delivery: { strategy: "batch", interval: 100 },
49
+ });
50
+ const push = createStream(socket, "ticks");
51
+ const batches: Tick[][] = [];
52
+ listener.listen(({ data }) => batches.push(data));
53
+
54
+ // 5000 messages, one every 1ms
55
+ for (let i = 0; i < 5000; i += 1) {
56
+ push(i);
57
+ vi.advanceTimersByTime(1);
58
+ }
59
+ vi.advanceTimersByTime(100);
60
+
61
+ expect(batches).toHaveLength(50);
62
+ expect(batches.every((batch) => batch.length === 100)).toBeTrue();
63
+ expect(batches.flat().every((tick, index) => tick.id === index)).toBeTrue();
64
+ });
65
+
66
+ it("should flush early every time the max size is reached", () => {
67
+ const listener = socket.createListener<Tick>()({
68
+ topic: "ticks",
69
+ delivery: { strategy: "batch", interval: 1000, maxSize: 250 },
70
+ });
71
+ const push = createStream(socket, "ticks");
72
+ const sizes: number[] = [];
73
+ listener.listen(({ data }) => sizes.push(data.length));
74
+
75
+ for (let i = 0; i < 1100; i += 1) {
76
+ push(i);
77
+ }
78
+ expect(sizes).toStrictEqual([250, 250, 250, 250]);
79
+
80
+ vi.advanceTimersByTime(1000);
81
+ expect(sizes).toStrictEqual([250, 250, 250, 250, 100]);
82
+ expect(vi.getTimerCount()).toBe(0);
83
+ });
84
+
85
+ it("should pass the extra of the last message of the batch", () => {
86
+ const listener = socket.createListener<Tick>()({
87
+ topic: "ticks",
88
+ delivery: { strategy: "batch", interval: 100 },
89
+ });
90
+ const push = createStream(socket, "ticks");
91
+ const extras: unknown[] = [];
92
+ listener.listen(({ extra }) => extras.push(extra));
93
+
94
+ push(1);
95
+ push(2);
96
+ push(3);
97
+ vi.advanceTimersByTime(100);
98
+
99
+ expect(extras).toStrictEqual([{ id: 3 }]);
100
+ });
101
+
102
+ it("should not open a window when no message arrives", () => {
103
+ const listener = socket.createListener<Tick>()({
104
+ topic: "ticks",
105
+ delivery: { strategy: "batch", interval: 100 },
106
+ });
107
+ const spy = vi.fn();
108
+ listener.listen(spy);
109
+
110
+ vi.advanceTimersByTime(1000);
111
+
112
+ expect(spy).not.toHaveBeenCalled();
113
+ expect(vi.getTimerCount()).toBe(0);
114
+ });
115
+ });
116
+
117
+ describe("When sampling a fast stream", () => {
118
+ it("should deliver the first message at once and the newest one per window", () => {
119
+ const listener = socket.createListener<Tick>()({
120
+ topic: "ticks",
121
+ delivery: { strategy: "latest", interval: 100 },
122
+ });
123
+ const push = createStream(socket, "ticks");
124
+ const delivered: number[] = [];
125
+ listener.listen(({ data }) => delivered.push(data.id));
126
+
127
+ for (let i = 0; i < 10_000; i += 1) {
128
+ push(i);
129
+ }
130
+ expect(delivered).toStrictEqual([0]);
131
+
132
+ vi.advanceTimersByTime(100);
133
+ expect(delivered).toStrictEqual([0, 9999]);
134
+ });
135
+
136
+ it("should deliver at most one message per window for a continuous stream", () => {
137
+ const listener = socket.createListener<Tick>()({
138
+ topic: "ticks",
139
+ delivery: { strategy: "latest", interval: 100 },
140
+ });
141
+ const push = createStream(socket, "ticks");
142
+ const delivered: number[] = [];
143
+ listener.listen(({ data }) => delivered.push(data.id));
144
+
145
+ // 3000 messages, one every 1ms - 3 seconds of traffic
146
+ for (let i = 0; i < 3000; i += 1) {
147
+ push(i);
148
+ vi.advanceTimersByTime(1);
149
+ }
150
+
151
+ expect(delivered).toHaveLength(31);
152
+ expect(delivered[0]).toBe(0);
153
+ expect(delivered.every((id, index) => index === 0 || id > delivered[index - 1])).toBeTrue();
154
+ });
155
+
156
+ it("should end on the newest message and go idle", () => {
157
+ const listener = socket.createListener<Tick>()({
158
+ topic: "ticks",
159
+ delivery: { strategy: "latest", interval: 100 },
160
+ });
161
+ const push = createStream(socket, "ticks");
162
+ const delivered: number[] = [];
163
+ listener.listen(({ data }) => delivered.push(data.id));
164
+
165
+ push(1);
166
+ push(2);
167
+ push(3);
168
+ vi.advanceTimersByTime(1000);
169
+
170
+ expect(delivered).toStrictEqual([1, 3]);
171
+ expect(vi.getTimerCount()).toBe(0);
172
+ });
173
+
174
+ it("should wait for the window before the first delivery without leading", () => {
175
+ const listener = socket.createListener<Tick>()({
176
+ topic: "ticks",
177
+ delivery: { strategy: "latest", interval: 100, leading: false },
178
+ });
179
+ const push = createStream(socket, "ticks");
180
+ const delivered: number[] = [];
181
+ listener.listen(({ data }) => delivered.push(data.id));
182
+
183
+ push(1);
184
+ push(2);
185
+ expect(delivered).toStrictEqual([]);
186
+
187
+ vi.advanceTimersByTime(100);
188
+ expect(delivered).toStrictEqual([2]);
189
+ });
190
+ });
191
+
192
+ describe("When the subscription ends", () => {
193
+ it.each([
194
+ { name: "batch", delivery: { strategy: "batch", interval: 100 } as const },
195
+ { name: "latest", delivery: { strategy: "latest", interval: 100 } as const },
196
+ ])("should drop pending $name messages and clear the timer on unsubscribe", ({ delivery }) => {
197
+ const listener = socket.createListener<Tick>()({ topic: "ticks", delivery });
198
+ const push = createStream(socket, "ticks");
199
+ const spy = vi.fn();
200
+ const stop = listener.listen(spy);
201
+ push(1);
202
+ push(2);
203
+ spy.mockClear();
204
+
205
+ stop();
206
+ vi.advanceTimersByTime(1000);
207
+
208
+ expect(spy).not.toHaveBeenCalled();
209
+ expect(vi.getTimerCount()).toBe(0);
210
+ });
211
+
212
+ it("should allow unsubscribing inside the callback of a flushed batch", () => {
213
+ const listener = socket.createListener<Tick>()({
214
+ topic: "ticks",
215
+ delivery: { strategy: "batch", interval: 100 },
216
+ });
217
+ const push = createStream(socket, "ticks");
218
+ const batches: Tick[][] = [];
219
+ const stop = listener.listen(({ data }) => {
220
+ batches.push(data);
221
+ stop();
222
+ });
223
+
224
+ push(1);
225
+ vi.advanceTimersByTime(100);
226
+ push(2);
227
+ vi.advanceTimersByTime(100);
228
+
229
+ expect(batches).toStrictEqual([[{ id: 1 }]]);
230
+ expect(vi.getTimerCount()).toBe(0);
231
+ });
232
+
233
+ it("should allow unsubscribing inside the callback of a sampled message", () => {
234
+ const listener = socket.createListener<Tick>()({
235
+ topic: "ticks",
236
+ delivery: { strategy: "latest", interval: 100 },
237
+ });
238
+ const push = createStream(socket, "ticks");
239
+ const delivered: number[] = [];
240
+ const stop = listener.listen(({ data }) => {
241
+ delivered.push(data.id);
242
+ if (data.id === 2) {
243
+ stop();
244
+ }
245
+ });
246
+
247
+ push(1);
248
+ push(2);
249
+ vi.advanceTimersByTime(100);
250
+ push(3);
251
+ vi.advanceTimersByTime(1000);
252
+
253
+ expect(delivered).toStrictEqual([1, 2]);
254
+ expect(vi.getTimerCount()).toBe(0);
255
+ });
256
+
257
+ it("should keep the buffers of other subscriptions when one ends", () => {
258
+ const listener = socket.createListener<Tick>()({
259
+ topic: "ticks",
260
+ delivery: { strategy: "batch", interval: 100 },
261
+ });
262
+ const push = createStream(socket, "ticks");
263
+ const first = vi.fn();
264
+ const second = vi.fn();
265
+ const stopFirst = listener.listen(({ data }) => first(data));
266
+ listener.listen(({ data }) => second(data));
267
+
268
+ push(1);
269
+ stopFirst();
270
+ push(2);
271
+ vi.advanceTimersByTime(100);
272
+
273
+ expect(first).not.toHaveBeenCalled();
274
+ expect(second).toHaveBeenCalledWith([{ id: 1 }, { id: 2 }]);
275
+ });
276
+
277
+ it("should be safe to dispose a strategy many times", () => {
278
+ const deliver = vi.fn();
279
+ const batch = createBatchDeliveryStrategy<Tick>({ interval: 100 })({ deliver });
280
+ const latest = createLatestDeliveryStrategy<Tick>({ interval: 100 })({ deliver });
281
+
282
+ batch.push({ data: { id: 1 }, extra: null });
283
+ latest.push({ data: { id: 1 }, extra: null });
284
+ deliver.mockClear();
285
+ batch.dispose();
286
+ batch.dispose();
287
+ latest.dispose();
288
+ latest.dispose();
289
+ batch.push({ data: { id: 2 }, extra: null });
290
+ latest.push({ data: { id: 2 }, extra: null });
291
+ vi.advanceTimersByTime(1000);
292
+
293
+ expect(deliver).not.toHaveBeenCalled();
294
+ expect(vi.getTimerCount()).toBe(0);
295
+ });
296
+
297
+ it("should dispose a custom strategy once per subscription", () => {
298
+ const dispose = vi.fn();
299
+ const strategy = createDeliveryStrategy<Tick>(({ deliver }) => ({ push: deliver, dispose }));
300
+ const listener = socket.createListener<Tick>()({ topic: "ticks", delivery: strategy });
301
+ const stopFirst = listener.listen(() => null);
302
+ const stopSecond = listener.listen(() => null);
303
+
304
+ stopFirst();
305
+ stopSecond();
306
+
307
+ expect(dispose).toHaveBeenCalledTimes(2);
308
+ });
309
+ });
310
+
311
+ describe("When many subscriptions share a stream", () => {
312
+ it("should keep a separate window for every subscription", () => {
313
+ const listener = socket.createListener<Tick>()({
314
+ topic: "ticks",
315
+ delivery: { strategy: "batch", interval: 100 },
316
+ });
317
+ const push = createStream(socket, "ticks");
318
+ const early: Tick[][] = [];
319
+ const late: Tick[][] = [];
320
+ listener.listen(({ data }) => early.push(data));
321
+
322
+ push(1);
323
+ vi.advanceTimersByTime(50);
324
+ listener.listen(({ data }) => late.push(data));
325
+ push(2);
326
+ vi.advanceTimersByTime(50);
327
+
328
+ expect(early).toStrictEqual([[{ id: 1 }, { id: 2 }]]);
329
+ expect(late).toStrictEqual([]);
330
+
331
+ vi.advanceTimersByTime(50);
332
+ expect(late).toStrictEqual([[{ id: 2 }]]);
333
+ });
334
+
335
+ it("should serve differently configured listeners of one topic from the same messages", () => {
336
+ const push = createStream(socket, "ticks");
337
+ const raw: number[] = [];
338
+ const sampled: number[] = [];
339
+ const batched: number[][] = [];
340
+ socket
341
+ .createListener<Tick>()({ topic: "ticks" })
342
+ .listen(({ data }) => raw.push(data.id));
343
+ socket
344
+ .createListener<Tick>()({ topic: "ticks", delivery: { strategy: "latest", interval: 100 } })
345
+ .listen(({ data }) => sampled.push(data.id));
346
+ socket
347
+ .createListener<Tick>()({ topic: "ticks", delivery: { strategy: "batch", interval: 100 } })
348
+ .listen(({ data }) => batched.push(data.map((tick) => tick.id)));
349
+
350
+ for (let i = 0; i < 100; i += 1) {
351
+ push(i);
352
+ }
353
+ vi.advanceTimersByTime(100);
354
+
355
+ expect(raw).toHaveLength(100);
356
+ expect(sampled).toStrictEqual([0, 99]);
357
+ expect(batched).toHaveLength(1);
358
+ expect(batched[0]).toHaveLength(100);
359
+ });
360
+
361
+ it("should handle a thousand batching subscriptions with one timer each", () => {
362
+ const listener = socket.createListener<Tick>()({
363
+ topic: "ticks",
364
+ delivery: { strategy: "batch", interval: 100 },
365
+ });
366
+ const push = createStream(socket, "ticks");
367
+ const spy = vi.fn();
368
+ const stops = Array.from({ length: 1000 }, () => listener.listen(spy));
369
+
370
+ push(1);
371
+ push(2);
372
+ expect(vi.getTimerCount()).toBe(1000);
373
+
374
+ vi.advanceTimersByTime(100);
375
+ expect(spy).toHaveBeenCalledTimes(1000);
376
+
377
+ stops.forEach((stop) => stop());
378
+ expect(vi.getTimerCount()).toBe(0);
379
+ expect(socket.adapter.listeners.get("ticks")?.size).toBe(0);
380
+ });
381
+ });
382
+ });