@hyper-fetch/sockets 9.0.3 → 9.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (59) hide show
  1. package/__tests__/e2e/e2e.delivery.spec.ts +81 -0
  2. package/__tests__/features/adapter/adapter.sse.codec.spec.ts +101 -0
  3. package/__tests__/features/adapter/adapter.websocket.codec.spec.ts +208 -0
  4. package/__tests__/features/delivery/delivery.batch.spec.ts +203 -0
  5. package/__tests__/features/delivery/delivery.latest.spec.ts +254 -0
  6. package/__tests__/features/delivery/delivery.typescript.spec.ts +143 -0
  7. package/__tests__/features/delivery/delivery.utils.spec.ts +122 -0
  8. package/__tests__/features/listener/listener.delivery.spec.ts +385 -0
  9. package/__tests__/features/listener/listener.delivery.sse.spec.ts +55 -0
  10. package/__tests__/features/sdk/sdk.configuration.spec.ts +60 -0
  11. package/__tests__/features/sdk/sdk.types.spec.ts +41 -17
  12. package/__tests__/features/socket/socket.methods.spec.ts +40 -0
  13. package/dist/adapter-sse/sse-adapter.d.ts.map +1 -1
  14. package/dist/adapter-sse/sse-adapter.types.d.ts +11 -0
  15. package/dist/adapter-sse/sse-adapter.types.d.ts.map +1 -1
  16. package/dist/adapter-websockets/websocket-adapter.d.ts.map +1 -1
  17. package/dist/adapter-websockets/websocket-adapter.types.d.ts +23 -0
  18. package/dist/adapter-websockets/websocket-adapter.types.d.ts.map +1 -1
  19. package/dist/delivery/delivery.batch.d.ts +19 -0
  20. package/dist/delivery/delivery.batch.d.ts.map +1 -0
  21. package/dist/delivery/delivery.latest.d.ts +18 -0
  22. package/dist/delivery/delivery.latest.d.ts.map +1 -0
  23. package/dist/delivery/delivery.types.d.ts +113 -0
  24. package/dist/delivery/delivery.types.d.ts.map +1 -0
  25. package/dist/delivery/delivery.utils.d.ts +50 -0
  26. package/dist/delivery/delivery.utils.d.ts.map +1 -0
  27. package/dist/delivery/index.d.ts +5 -0
  28. package/dist/delivery/index.d.ts.map +1 -0
  29. package/dist/index.d.ts +1 -0
  30. package/dist/index.d.ts.map +1 -1
  31. package/dist/index.mjs +261 -20
  32. package/dist/index.mjs.map +1 -1
  33. package/dist/listener/listener.d.ts +22 -7
  34. package/dist/listener/listener.d.ts.map +1 -1
  35. package/dist/listener/listener.types.d.ts +29 -9
  36. package/dist/listener/listener.types.d.ts.map +1 -1
  37. package/dist/sdk/sdk.d.ts +6 -2
  38. package/dist/sdk/sdk.d.ts.map +1 -1
  39. package/dist/socket/socket.d.ts +8 -1
  40. package/dist/socket/socket.d.ts.map +1 -1
  41. package/dist/types/extract.types.d.ts +10 -4
  42. package/dist/types/extract.types.d.ts.map +1 -1
  43. package/package.json +1 -1
  44. package/src/adapter-sse/sse-adapter.ts +23 -4
  45. package/src/adapter-sse/sse-adapter.types.ts +9 -0
  46. package/src/adapter-websockets/websocket-adapter.ts +31 -6
  47. package/src/adapter-websockets/websocket-adapter.types.ts +20 -0
  48. package/src/delivery/delivery.batch.ts +71 -0
  49. package/src/delivery/delivery.latest.ts +64 -0
  50. package/src/delivery/delivery.types.ts +129 -0
  51. package/src/delivery/delivery.utils.ts +96 -0
  52. package/src/delivery/index.ts +4 -0
  53. package/src/index.ts +1 -0
  54. package/src/listener/listener.ts +48 -9
  55. package/src/listener/listener.types.ts +45 -10
  56. package/src/sdk/sdk.ts +27 -7
  57. package/src/socket/socket.ts +18 -2
  58. package/src/types/extract.types.ts +10 -4
  59. package/tsconfig.json +2 -0
@@ -0,0 +1,385 @@
1
+ import { createWebsocketMockingServer, waitForConnection } from "@hyper-fetch/testing";
2
+ import { createDeliveryStrategy } from "delivery";
3
+
4
+ import { createListener } from "../../utils/listener.utils";
5
+ import { createSocket } from "../../utils/socket.utils";
6
+
7
+ type DataType = { price: number };
8
+
9
+ describe("Listener [ Delivery ]", () => {
10
+ const { startServer, stopServer, emitListenerEvent } = createWebsocketMockingServer();
11
+ let socket = createSocket();
12
+
13
+ beforeEach(async () => {
14
+ startServer();
15
+ socket = createSocket();
16
+ await waitForConnection(socket);
17
+ vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
18
+ });
19
+
20
+ afterEach(() => {
21
+ vi.useRealTimers();
22
+ stopServer();
23
+ });
24
+
25
+ it("should register the original callback when no delivery is configured", () => {
26
+ const listener = createListener<DataType>(socket);
27
+ const spy = vi.fn();
28
+ const stop = listener.listen(spy);
29
+ expect(socket.adapter.listeners.get(listener.topic)?.has(spy)).toBeTrue();
30
+ stop();
31
+ expect(socket.adapter.listeners.get(listener.topic)?.has(spy)).toBeFalse();
32
+ });
33
+
34
+ it("should register a wrapper and remove it on unsubscribe when delivery is configured", () => {
35
+ const listener = createListener<DataType>(socket, { delivery: { strategy: "latest", interval: 100 } });
36
+ const spy = vi.fn();
37
+ const stop = listener.listen(spy);
38
+ const group = socket.adapter.listeners.get(listener.topic);
39
+ expect(group?.size).toBe(1);
40
+ expect(group?.has(spy)).toBeFalse();
41
+ stop();
42
+ expect(group?.size).toBe(0);
43
+ });
44
+
45
+ it("should sample messages with the latest strategy", () => {
46
+ const listener = createListener<DataType>(socket, { delivery: { strategy: "latest", interval: 100 } });
47
+ const spy = vi.fn();
48
+ listener.listen(({ data }) => spy(data));
49
+
50
+ emitListenerEvent(listener, { price: 1 });
51
+ emitListenerEvent(listener, { price: 2 });
52
+ emitListenerEvent(listener, { price: 3 });
53
+ expect(spy).toHaveBeenCalledOnce();
54
+ expect(spy).toHaveBeenCalledWith({ price: 1 });
55
+
56
+ vi.advanceTimersByTime(100);
57
+ expect(spy).toHaveBeenCalledTimes(2);
58
+ expect(spy).toHaveBeenLastCalledWith({ price: 3 });
59
+ });
60
+
61
+ it("should batch messages with the batch strategy", () => {
62
+ const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
63
+ const spy = vi.fn();
64
+ listener.listen(({ data, extra }) => spy(data, extra));
65
+
66
+ emitListenerEvent(listener, { price: 1 });
67
+ emitListenerEvent(listener, { price: 2 });
68
+ expect(spy).not.toHaveBeenCalled();
69
+
70
+ vi.advanceTimersByTime(100);
71
+ expect(spy).toHaveBeenCalledOnce();
72
+ expect(spy.mock.calls[0][0]).toEqual([{ price: 1 }, { price: 2 }]);
73
+ expect(spy.mock.calls[0][1]).toHaveProperty("data");
74
+ });
75
+
76
+ it("should not deliver after unsubscribe", () => {
77
+ const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
78
+ const spy = vi.fn();
79
+ const stop = listener.listen(spy);
80
+ emitListenerEvent(listener, { price: 1 });
81
+ stop();
82
+ vi.advanceTimersByTime(500);
83
+ emitListenerEvent(listener, { price: 2 });
84
+ vi.advanceTimersByTime(500);
85
+ expect(spy).not.toHaveBeenCalled();
86
+ });
87
+
88
+ it("should run a custom strategy", () => {
89
+ const summarize = createDeliveryStrategy<DataType, { count: number; max: number }>(({ deliver }) => {
90
+ let count = 0;
91
+ let max = -Infinity;
92
+ let timer: ReturnType<typeof setTimeout> | undefined;
93
+ return {
94
+ push: ({ data, extra }) => {
95
+ count += 1;
96
+ max = Math.max(max, data.price);
97
+ timer ??= setTimeout(() => {
98
+ timer = undefined;
99
+ deliver({ data: { count, max }, extra });
100
+ count = 0;
101
+ max = -Infinity;
102
+ }, 50);
103
+ },
104
+ dispose: () => clearTimeout(timer),
105
+ };
106
+ });
107
+ const listener = createListener<DataType>(socket, { delivery: summarize });
108
+ const spy = vi.fn();
109
+ listener.listen(({ data }) => spy(data));
110
+
111
+ emitListenerEvent(listener, { price: 5 });
112
+ emitListenerEvent(listener, { price: 9 });
113
+ emitListenerEvent(listener, { price: 2 });
114
+ vi.advanceTimersByTime(50);
115
+ expect(spy).toHaveBeenCalledOnce();
116
+ expect(spy).toHaveBeenCalledWith({ count: 3, max: 9 });
117
+ });
118
+
119
+ it("should give every listen() call its own controller", () => {
120
+ const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
121
+ const first = vi.fn();
122
+ const second = vi.fn();
123
+ const stopFirst = listener.listen(first);
124
+ listener.listen(second);
125
+ emitListenerEvent(listener, { price: 1 });
126
+ stopFirst();
127
+ vi.advanceTimersByTime(100);
128
+ expect(first).not.toHaveBeenCalled();
129
+ expect(second).toHaveBeenCalledOnce();
130
+ });
131
+
132
+ it("should carry delivery through setParams, setOptions and clone", () => {
133
+ const delivery = { strategy: "latest", interval: 16 } as const;
134
+ const listener = socket.createListener<DataType>()({ topic: "prices/:symbol", delivery });
135
+ expect(listener.setParams({ symbol: "BTC" }).delivery).toStrictEqual(delivery);
136
+ expect(listener.setOptions(undefined).delivery).toStrictEqual(delivery);
137
+ expect(listener.clone().delivery).toStrictEqual(delivery);
138
+ });
139
+
140
+ it("should return a clone from setDelivery and allow clearing it", () => {
141
+ const listener = createListener<DataType>(socket);
142
+ const batched = listener.setDelivery({ strategy: "batch", interval: 100 });
143
+ expect(batched).not.toBe(listener);
144
+ expect(listener.delivery).toBeUndefined();
145
+ expect(batched.delivery).toStrictEqual({ strategy: "batch", interval: 100 });
146
+ expect(batched.setDelivery(undefined).delivery).toBeUndefined();
147
+ });
148
+
149
+ it("should throw on an unknown strategy at creation time", () => {
150
+ expect(() =>
151
+ socket.createListener<DataType>()({ topic: "prices", delivery: { strategy: "nope", interval: 1 } as any }),
152
+ ).toThrow(/Unknown delivery strategy/);
153
+ });
154
+
155
+ it("should wrap adapters that call the callback directly (Firebase-style)", () => {
156
+ const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
157
+ const spy = vi.fn();
158
+ listener.listen(({ data }) => spy(data));
159
+ const [registered] = [...socket.adapter.listeners.get(listener.topic)!.keys()];
160
+
161
+ // Simulate an adapter invoking the registered callback directly, bypassing triggerListeners.
162
+ registered({ data: { price: 1 }, extra: null as any });
163
+ registered({ data: { price: 2 }, extra: null as any });
164
+ expect(spy).not.toHaveBeenCalled();
165
+ vi.advanceTimersByTime(100);
166
+ expect(spy).toHaveBeenCalledWith([{ price: 1 }, { price: 2 }]);
167
+ });
168
+
169
+ it("should run onMessage interceptors per raw message before batching", () => {
170
+ const interceptor = vi.fn(({ event }) => event);
171
+ socket.onMessage(interceptor);
172
+ const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
173
+ listener.listen(() => null);
174
+ emitListenerEvent(listener, { price: 1 });
175
+ emitListenerEvent(listener, { price: 2 });
176
+ expect(interceptor).toHaveBeenCalledTimes(2);
177
+ });
178
+
179
+ it("should expose params on the listener", () => {
180
+ const listener = socket.createListener<DataType>()({ topic: "prices/:symbol" }).setParams({ symbol: "BTC" });
181
+ expect(listener.params).toStrictEqual({ symbol: "BTC" });
182
+ expect(listener.topic).toBe("prices/BTC");
183
+ });
184
+
185
+ it("should keep socket.events broadcasts unthrottled", () => {
186
+ const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
187
+ const callback = vi.fn();
188
+ const byTopic = vi.fn();
189
+ const global = vi.fn();
190
+ listener.listen(callback);
191
+ socket.events.onListenerEventByTopic(listener, byTopic);
192
+ socket.events.onListenerEvent(global);
193
+
194
+ emitListenerEvent(listener, { price: 1 });
195
+ emitListenerEvent(listener, { price: 2 });
196
+ emitListenerEvent(listener, { price: 3 });
197
+
198
+ expect(callback).not.toHaveBeenCalled();
199
+ expect(byTopic).toHaveBeenCalledTimes(3);
200
+ expect(global).toHaveBeenCalledTimes(3);
201
+ vi.advanceTimersByTime(100);
202
+ expect(callback).toHaveBeenCalledOnce();
203
+ });
204
+
205
+ it("should isolate delivery per dynamic topic", () => {
206
+ const template = socket.createListener<DataType>()({
207
+ topic: "prices/:symbol",
208
+ delivery: { strategy: "batch", interval: 100 },
209
+ });
210
+ const btc = template.setParams({ symbol: "BTC" });
211
+ const eth = template.setParams({ symbol: "ETH" });
212
+ const btcSpy = vi.fn();
213
+ const ethSpy = vi.fn();
214
+ btc.listen(({ data }) => btcSpy(data));
215
+ eth.listen(({ data }) => ethSpy(data));
216
+
217
+ emitListenerEvent(btc, { price: 1 });
218
+ emitListenerEvent(eth, { price: 10 });
219
+ emitListenerEvent(btc, { price: 2 });
220
+ vi.advanceTimersByTime(100);
221
+
222
+ expect(btcSpy).toHaveBeenCalledWith([{ price: 1 }, { price: 2 }]);
223
+ expect(ethSpy).toHaveBeenCalledWith([{ price: 10 }]);
224
+ });
225
+
226
+ it("should not affect listeners on other topics", () => {
227
+ const batched = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
228
+ const immediate = createListener<DataType>(socket);
229
+ const batchedSpy = vi.fn();
230
+ const immediateSpy = vi.fn();
231
+ batched.listen(batchedSpy);
232
+ immediate.listen(immediateSpy);
233
+
234
+ emitListenerEvent(batched, { price: 1 });
235
+ emitListenerEvent(immediate, { price: 2 });
236
+ expect(batchedSpy).not.toHaveBeenCalled();
237
+ expect(immediateSpy).toHaveBeenCalledOnce();
238
+ });
239
+
240
+ it("should allow mixing immediate and delivered subscriptions on one topic", () => {
241
+ const listener = createListener<DataType>(socket);
242
+ const immediateSpy = vi.fn();
243
+ const batchedSpy = vi.fn();
244
+ listener.listen(immediateSpy);
245
+ listener.setDelivery({ strategy: "batch", interval: 100 }).listen(batchedSpy);
246
+
247
+ emitListenerEvent(listener, { price: 1 });
248
+ emitListenerEvent(listener, { price: 2 });
249
+ expect(immediateSpy).toHaveBeenCalledTimes(2);
250
+ expect(batchedSpy).not.toHaveBeenCalled();
251
+ vi.advanceTimersByTime(100);
252
+ expect(batchedSpy).toHaveBeenCalledOnce();
253
+ });
254
+
255
+ it("should create independent subscriptions for the same callback passed twice", () => {
256
+ const listener = createListener<DataType>(socket, { delivery: { strategy: "latest", interval: 100 } });
257
+ const spy = vi.fn();
258
+ const stopFirst = listener.listen(spy);
259
+ const stopSecond = listener.listen(spy);
260
+ expect(socket.adapter.listeners.get(listener.topic)?.size).toBe(2);
261
+
262
+ emitListenerEvent(listener, { price: 1 });
263
+ expect(spy).toHaveBeenCalledTimes(2);
264
+
265
+ stopFirst();
266
+ expect(socket.adapter.listeners.get(listener.topic)?.size).toBe(1);
267
+ emitListenerEvent(listener, { price: 2 });
268
+ vi.advanceTimersByTime(100);
269
+ expect(spy).toHaveBeenCalledTimes(3);
270
+ stopSecond();
271
+ expect(socket.adapter.listeners.get(listener.topic)?.size).toBe(0);
272
+ });
273
+
274
+ it("should unsubscribe safely from inside the callback", () => {
275
+ const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
276
+ const spy = vi.fn();
277
+ const stop = listener.listen(({ data }) => {
278
+ spy(data);
279
+ stop();
280
+ });
281
+ emitListenerEvent(listener, { price: 1 });
282
+ vi.advanceTimersByTime(100);
283
+ emitListenerEvent(listener, { price: 2 });
284
+ vi.advanceTimersByTime(100);
285
+ expect(spy).toHaveBeenCalledOnce();
286
+ expect(socket.adapter.listeners.get(listener.topic)?.size).toBe(0);
287
+ });
288
+
289
+ it("should handle a large burst with the latest strategy", () => {
290
+ const listener = createListener<DataType>(socket, { delivery: { strategy: "latest", interval: 16 } });
291
+ const spy = vi.fn();
292
+ listener.listen(({ data }) => spy(data));
293
+ for (let i = 1; i <= 500; i += 1) {
294
+ emitListenerEvent(listener, { price: i });
295
+ }
296
+ expect(spy).toHaveBeenCalledOnce();
297
+ vi.advanceTimersByTime(16);
298
+ expect(spy).toHaveBeenCalledTimes(2);
299
+ expect(spy).toHaveBeenLastCalledWith({ price: 500 });
300
+ });
301
+
302
+ it("should handle a large burst with the batch strategy and maxSize", () => {
303
+ const listener = createListener<DataType>(socket, {
304
+ delivery: { strategy: "batch", interval: 100, maxSize: 100 },
305
+ });
306
+ const spy = vi.fn();
307
+ listener.listen(({ data }) => spy(data));
308
+ for (let i = 1; i <= 250; i += 1) {
309
+ emitListenerEvent(listener, { price: i });
310
+ }
311
+ expect(spy).toHaveBeenCalledTimes(2);
312
+ vi.advanceTimersByTime(100);
313
+ expect(spy).toHaveBeenCalledTimes(3);
314
+ const all = spy.mock.calls.flatMap(([batch]) => batch.map((m: DataType) => m.price));
315
+ expect(all).toEqual(Array.from({ length: 250 }, (_, i) => i + 1));
316
+ });
317
+
318
+ it("should expose delivery on listenerOptions and keep options untouched", () => {
319
+ const delivery = { strategy: "batch", interval: 100 } as const;
320
+ const listener = createListener<DataType>(socket, { delivery });
321
+ expect(listener.listenerOptions.delivery).toStrictEqual(delivery);
322
+ expect(listener.options).toBeUndefined();
323
+ expect(listener.setOptions({ anything: true } as any).delivery).toStrictEqual(delivery);
324
+ });
325
+
326
+ it("should allow overriding delivery through clone", () => {
327
+ const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
328
+ const cloned = listener.clone({ delivery: { strategy: "latest", interval: 16 } });
329
+ expect(cloned.delivery).toStrictEqual({ strategy: "latest", interval: 16 });
330
+ expect(listener.delivery).toStrictEqual({ strategy: "batch", interval: 100 });
331
+ });
332
+
333
+ it("should accept a custom strategy through setDelivery", () => {
334
+ const listener = createListener<DataType>(socket);
335
+ const passthrough = createDeliveryStrategy<DataType, number>(({ deliver }) => ({
336
+ push: ({ data, extra }) => deliver({ data: data.price * 2, extra }),
337
+ dispose: () => null,
338
+ }));
339
+ const spy = vi.fn();
340
+ listener.setDelivery(passthrough).listen(({ data }) => spy(data));
341
+ emitListenerEvent(listener, { price: 21 });
342
+ expect(spy).toHaveBeenCalledWith(42);
343
+ });
344
+
345
+ it("should call a custom strategy factory once per listen()", () => {
346
+ const factory = vi.fn((_context: unknown) => ({ push: vi.fn(), dispose: vi.fn() }));
347
+ const listener = createListener<DataType>(socket, { delivery: factory as any });
348
+ const stopA = listener.listen(() => null);
349
+ const stopB = listener.listen(() => null);
350
+ expect(factory).toHaveBeenCalledTimes(2);
351
+ expect(factory.mock.calls[0][0]).toHaveProperty("deliver");
352
+ stopA();
353
+ stopB();
354
+ expect(factory.mock.results[0].value.dispose).toHaveBeenCalledOnce();
355
+ expect(factory.mock.results[1].value.dispose).toHaveBeenCalledOnce();
356
+ });
357
+
358
+ it("should restore immediate delivery after setDelivery(undefined)", () => {
359
+ const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
360
+ const spy = vi.fn();
361
+ listener.setDelivery(undefined).listen(spy);
362
+ emitListenerEvent(listener, { price: 1 });
363
+ expect(spy).toHaveBeenCalledOnce();
364
+ expect(socket.adapter.listeners.get(listener.topic)?.has(spy)).toBeTrue();
365
+ });
366
+
367
+ it("should keep delivering after the socket reconnects", async () => {
368
+ vi.useRealTimers();
369
+ const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 20 } });
370
+ const spy = vi.fn();
371
+ listener.listen(({ data }) => spy(data));
372
+
373
+ socket.disconnect();
374
+ socket.connect();
375
+ await waitForConnection(socket);
376
+
377
+ emitListenerEvent(listener, { price: 1 });
378
+ emitListenerEvent(listener, { price: 2 });
379
+ await new Promise((resolve) => {
380
+ setTimeout(resolve, 60);
381
+ });
382
+ expect(spy).toHaveBeenCalledOnce();
383
+ expect(spy).toHaveBeenCalledWith([{ price: 1 }, { price: 2 }]);
384
+ });
385
+ });
@@ -0,0 +1,55 @@
1
+ import { createSseMockingServer, waitForConnection } from "@hyper-fetch/testing";
2
+ import { ServerSentEventsAdapter } from "adapter-sse/sse-adapter";
3
+
4
+ import { createListener } from "../../utils/listener.utils";
5
+ import { createSocket } from "../../utils/socket.utils";
6
+
7
+ type DataType = { price: number };
8
+
9
+ describe("Listener [ Delivery SSE ]", () => {
10
+ const { startServer, emitListenerEvent } = createSseMockingServer();
11
+ let socket = createSocket({ adapter: ServerSentEventsAdapter });
12
+
13
+ beforeEach(async () => {
14
+ socket = createSocket({ adapter: ServerSentEventsAdapter });
15
+ startServer();
16
+ await waitForConnection(socket);
17
+ vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
18
+ });
19
+
20
+ afterEach(() => {
21
+ vi.useRealTimers();
22
+ });
23
+
24
+ it("should batch SSE messages", () => {
25
+ const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
26
+ const spy = vi.fn();
27
+ listener.listen(({ data }) => spy(data));
28
+ emitListenerEvent(listener, { price: 1 });
29
+ emitListenerEvent(listener, { price: 2 });
30
+ expect(spy).not.toHaveBeenCalled();
31
+ vi.advanceTimersByTime(100);
32
+ expect(spy).toHaveBeenCalledWith([{ price: 1 }, { price: 2 }]);
33
+ });
34
+
35
+ it("should sample SSE messages", () => {
36
+ const listener = createListener<DataType>(socket, { delivery: { strategy: "latest", interval: 100 } });
37
+ const spy = vi.fn();
38
+ listener.listen(({ data }) => spy(data));
39
+ emitListenerEvent(listener, { price: 1 });
40
+ emitListenerEvent(listener, { price: 2 });
41
+ expect(spy).toHaveBeenCalledWith({ price: 1 });
42
+ vi.advanceTimersByTime(100);
43
+ expect(spy).toHaveBeenLastCalledWith({ price: 2 });
44
+ });
45
+
46
+ it("should drop pending SSE messages on unsubscribe", () => {
47
+ const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
48
+ const spy = vi.fn();
49
+ const stop = listener.listen(spy);
50
+ emitListenerEvent(listener, { price: 1 });
51
+ stop();
52
+ vi.advanceTimersByTime(100);
53
+ expect(spy).not.toHaveBeenCalled();
54
+ });
55
+ });
@@ -107,6 +107,66 @@ describe("Socket SDK [ Configuration ]", () => {
107
107
  });
108
108
  });
109
109
 
110
+ describe("delivery defaults", () => {
111
+ it("should apply delivery via plain object to listeners only", () => {
112
+ const sdk = createSocketSdk<TestSocket, TestSchema>(socket);
113
+ const configured = sdk.$configure({
114
+ "*": { delivery: { strategy: "batch", interval: 100 } },
115
+ });
116
+
117
+ expect(configured.chat.messages.$listener.delivery).toStrictEqual({ strategy: "batch", interval: 100 });
118
+ expect(configured.notifications.$listener.delivery).toStrictEqual({ strategy: "batch", interval: 100 });
119
+ expect((configured.chat.messages.$emitter as any).delivery).toBeUndefined();
120
+ });
121
+
122
+ it("should apply delivery together with options", () => {
123
+ const sdk = createSocketSdk<TestSocket, TestSchema>(socket);
124
+ const configured = sdk.$configure({
125
+ "chat/messages": { options: { fast: true }, delivery: { strategy: "latest", interval: 16 } },
126
+ });
127
+
128
+ const listener = configured.chat.messages.$listener;
129
+ expect(listener.options).toStrictEqual({ fast: true });
130
+ expect(listener.delivery).toStrictEqual({ strategy: "latest", interval: 16 });
131
+ expect(configured.notifications.$listener.delivery).toBeUndefined();
132
+ });
133
+ });
134
+
135
+ describe("delivery via function configuration", () => {
136
+ it("should allow setDelivery inside a function configuration", () => {
137
+ const sdk = createSocketSdk<TestSocket, TestSchema>(socket);
138
+ const configured = sdk.$configure({
139
+ "chat.messages.$listener": (instance) =>
140
+ "setDelivery" in instance ? instance.setDelivery({ strategy: "latest", interval: 16 }) : instance,
141
+ });
142
+ expect(configured.chat.messages.$listener.delivery).toStrictEqual({ strategy: "latest", interval: 16 });
143
+ expect(configured.chat.rooms.$listener.delivery).toBeUndefined();
144
+ });
145
+
146
+ it("should apply delivery on a topic prefix", () => {
147
+ const sdk = createSocketSdk<TestSocket, TestSchema>(socket);
148
+ const configured = sdk.$configure({
149
+ "chat/*": { delivery: { strategy: "batch", interval: 50 } },
150
+ });
151
+ expect(configured.chat.messages.$listener.delivery).toStrictEqual({ strategy: "batch", interval: 50 });
152
+ expect(configured.chat.rooms.$listener.delivery).toStrictEqual({ strategy: "batch", interval: 50 });
153
+ expect(configured.notifications.$listener.delivery).toBeUndefined();
154
+ });
155
+
156
+ it("should keep listeners working after SDK delivery configuration", () => {
157
+ const sdk = createSocketSdk<TestSocket, TestSchema>(socket);
158
+ const configured = sdk.$configure({
159
+ "*": { delivery: { strategy: "batch", interval: 100 } },
160
+ });
161
+ const listener = configured.notifications.$listener;
162
+ const spy = vi.fn();
163
+ const stop = listener.listen(spy);
164
+ expect(socket.adapter.listeners.get(listener.topic)?.size).toBe(1);
165
+ stop();
166
+ expect(socket.adapter.listeners.get(listener.topic)?.size).toBe(0);
167
+ });
168
+ });
169
+
110
170
  describe("topic group matching", () => {
111
171
  it("should apply config to an exact topic", () => {
112
172
  const sdk = createSocketSdk<TestSocket, TestSchema>(socket);
@@ -20,28 +20,28 @@ type ChatMessage = { text: string; user: string };
20
20
  describe("ListenerModel - defaults for omitted fields", () => {
21
21
  it("should default response to unknown", () => {
22
22
  type L = ListenerModel<{ topic: "chat/messages" }>;
23
- type Response = L extends Listener<infer R, any, any, any> ? R : never;
23
+ type Response = L extends Listener<infer R, any, any, any, any> ? R : never;
24
24
  expectTypeOf<Response>().toEqualTypeOf<unknown>();
25
25
  expect(true).toBe(true);
26
26
  });
27
27
 
28
28
  it("should default topic to string when not provided", () => {
29
29
  type L = ListenerModel<{ response: ChatMessage }>;
30
- type Topic = L extends Listener<any, infer T, any, any> ? T : never;
30
+ type Topic = L extends Listener<any, infer T, any, any, any> ? T : never;
31
31
  expectTypeOf<Topic>().toEqualTypeOf<string>();
32
32
  expect(true).toBe(true);
33
33
  });
34
34
 
35
35
  it("should default socket to SocketInstance when not provided", () => {
36
36
  type L = ListenerModel<{ response: ChatMessage; topic: "chat" }>;
37
- type Sock = L extends Listener<any, any, infer S, any> ? S : never;
37
+ type Sock = L extends Listener<any, any, infer S, any, any> ? S : never;
38
38
  expectTypeOf<Sock>().toEqualTypeOf<SocketInstance>();
39
39
  expect(true).toBe(true);
40
40
  });
41
41
 
42
42
  it("should default hasParams to false", () => {
43
43
  type L = ListenerModel<{ topic: "chat" }>;
44
- type HasParams = L extends Listener<any, any, any, infer Hp> ? Hp : never;
44
+ type HasParams = L extends Listener<any, any, any, infer Hp, any> ? Hp : never;
45
45
  expectTypeOf<HasParams>().toEqualTypeOf<false>();
46
46
  expect(true).toBe(true);
47
47
  });
@@ -82,8 +82,8 @@ describe("EmitterModel - defaults for omitted fields", () => {
82
82
  describe("ListenerModel / EmitterModel - user-provided fields override defaults", () => {
83
83
  it("should narrow response and topic on a Listener when provided", () => {
84
84
  type L = ListenerModel<{ response: ChatMessage; topic: "chat/messages" }>;
85
- type Response = L extends Listener<infer R, any, any, any> ? R : never;
86
- type Topic = L extends Listener<any, infer T, any, any> ? T : never;
85
+ type Response = L extends Listener<infer R, any, any, any, any> ? R : never;
86
+ type Topic = L extends Listener<any, infer T, any, any, any> ? T : never;
87
87
  expectTypeOf<Response>().toEqualTypeOf<ChatMessage>();
88
88
  expectTypeOf<Topic>().toEqualTypeOf<"chat/messages">();
89
89
  expect(true).toBe(true);
@@ -102,7 +102,7 @@ describe("ListenerModel / EmitterModel - user-provided fields override defaults"
102
102
  describe("ListenerInstance / EmitterInstance - keep `any` defaults (constraint use)", () => {
103
103
  it("should keep ListenerInstance wide so concrete listeners satisfy it", () => {
104
104
  type LI = ListenerInstance;
105
- type Response = LI extends Listener<infer R, any, any, any> ? R : never;
105
+ type Response = LI extends Listener<infer R, any, any, any, any> ? R : never;
106
106
  expectTypeOf<Response>().toEqualTypeOf<any>();
107
107
  expect(true).toBe(true);
108
108
  });
@@ -126,7 +126,7 @@ describe("InjectSocket - schema-level socket injection", () => {
126
126
  $listener: ListenerModel<{ response: ChatMessage; topic: "chat" }>;
127
127
  };
128
128
  type Injected = InjectSocket<Schema, TestSocket>;
129
- type ResolvedSocket = Injected["$listener"] extends Listener<any, any, infer S, any> ? S : never;
129
+ type ResolvedSocket = Injected["$listener"] extends Listener<any, any, infer S, any, any> ? S : never;
130
130
  expectTypeOf<ResolvedSocket>().toEqualTypeOf<TestSocket>();
131
131
  expect(true).toBe(true);
132
132
  });
@@ -155,9 +155,10 @@ describe("InjectSocket - schema-level socket injection", () => {
155
155
  };
156
156
  type Injected = InjectSocket<Schema, TestSocket>;
157
157
 
158
- type LSocket = Injected["chat"]["messages"]["$listener"] extends Listener<any, any, infer S, any> ? S : never;
158
+ type LSocket = Injected["chat"]["messages"]["$listener"] extends Listener<any, any, infer S, any, any> ? S : never;
159
159
  type ESocket = Injected["chat"]["messages"]["$emitter"] extends Emitter<any, any, infer S, any, any> ? S : never;
160
- type NestedLSocket = Injected["chat"]["$roomId"]["$listener"] extends Listener<any, any, infer S, any> ? S : never;
160
+ type NestedLSocket =
161
+ Injected["chat"]["$roomId"]["$listener"] extends Listener<any, any, infer S, any, any> ? S : never;
161
162
 
162
163
  expectTypeOf<LSocket>().toEqualTypeOf<TestSocket>();
163
164
  expectTypeOf<ESocket>().toEqualTypeOf<TestSocket>();
@@ -174,8 +175,8 @@ describe("InjectSocket - schema-level socket injection", () => {
174
175
  };
175
176
  type Injected = InjectSocket<Schema, TestSocket>;
176
177
 
177
- type LResp = Injected["chat"]["$listener"] extends Listener<infer R, any, any, any> ? R : never;
178
- type LTopic = Injected["chat"]["$listener"] extends Listener<any, infer T, any, any> ? T : never;
178
+ type LResp = Injected["chat"]["$listener"] extends Listener<infer R, any, any, any, any> ? R : never;
179
+ type LTopic = Injected["chat"]["$listener"] extends Listener<any, infer T, any, any, any> ? T : never;
179
180
  type EPayload = Injected["chat"]["$emitter"] extends Emitter<infer P, any, any, any, any> ? P : never;
180
181
  type ETopic = Injected["chat"]["$emitter"] extends Emitter<any, infer T, any, any, any> ? T : never;
181
182
 
@@ -205,9 +206,9 @@ describe("createSocketSdk - produces a fully resolved SDK type", () => {
205
206
  const sdk = createSocketSdk<typeof socket, Schema>(socket);
206
207
 
207
208
  type ChatListener = typeof sdk.chat.messages.$listener;
208
- type ResolvedSocket = ChatListener extends Listener<any, any, infer S, any> ? S : never;
209
- type ResolvedResponse = ChatListener extends Listener<infer R, any, any, any> ? R : never;
210
- type ResolvedTopic = ChatListener extends Listener<any, infer T, any, any> ? T : never;
209
+ type ResolvedSocket = ChatListener extends Listener<any, any, infer S, any, any> ? S : never;
210
+ type ResolvedResponse = ChatListener extends Listener<infer R, any, any, any, any> ? R : never;
211
+ type ResolvedTopic = ChatListener extends Listener<any, infer T, any, any, any> ? T : never;
211
212
 
212
213
  expectTypeOf<ResolvedSocket>().toEqualTypeOf<typeof socket>();
213
214
  expectTypeOf<ResolvedResponse>().toEqualTypeOf<ChatMessage>();
@@ -233,8 +234,8 @@ describe("createSocketSdk - produces a fully resolved SDK type", () => {
233
234
  const sdk = createSocketSdk<typeof socket, Schema>(socket);
234
235
 
235
236
  type RoomListener = typeof sdk.chat.$roomId.$listener;
236
- type ResolvedSocket = RoomListener extends Listener<any, any, infer S, any> ? S : never;
237
- type ResolvedTopic = RoomListener extends Listener<any, infer T, any, any> ? T : never;
237
+ type ResolvedSocket = RoomListener extends Listener<any, any, infer S, any, any> ? S : never;
238
+ type ResolvedTopic = RoomListener extends Listener<any, infer T, any, any, any> ? T : never;
238
239
 
239
240
  expectTypeOf<ResolvedSocket>().toEqualTypeOf<typeof socket>();
240
241
  expectTypeOf<ResolvedTopic>().toEqualTypeOf<"chat/:roomId">();
@@ -301,3 +302,26 @@ describe("$configure - dot-path callback narrowing", () => {
301
302
  expect(true).toBe(true);
302
303
  });
303
304
  });
305
+
306
+ describe("ListenerModel - delivered type", () => {
307
+ it("should default delivered to response", () => {
308
+ type L = ListenerModel<{ response: ChatMessage; topic: "chat/messages" }>;
309
+ type Delivered = L extends Listener<any, any, any, any, infer D> ? D : never;
310
+ expectTypeOf<Delivered>().toEqualTypeOf<ChatMessage>();
311
+ expect(true).toBe(true);
312
+ });
313
+
314
+ it("should keep an explicit delivered type through InjectSocket", () => {
315
+ type Schema = {
316
+ trades: {
317
+ $listener: ListenerModel<{ response: ChatMessage; topic: "trades"; delivered: ChatMessage[] }>;
318
+ };
319
+ };
320
+ type Injected = InjectSocket<Schema, TestSocket>;
321
+ type Delivered = Injected["trades"]["$listener"] extends Listener<any, any, any, any, infer D> ? D : never;
322
+ type Response = Injected["trades"]["$listener"] extends Listener<infer R, any, any, any, any> ? R : never;
323
+ expectTypeOf<Delivered>().toEqualTypeOf<ChatMessage[]>();
324
+ expectTypeOf<Response>().toEqualTypeOf<ChatMessage>();
325
+ expect(true).toBe(true);
326
+ });
327
+ });