@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.
- package/__tests__/e2e/e2e.delivery.spec.ts +81 -0
- package/__tests__/features/adapter/adapter.sse.codec.spec.ts +101 -0
- package/__tests__/features/adapter/adapter.websocket.codec.spec.ts +208 -0
- package/__tests__/features/delivery/delivery.batch.spec.ts +203 -0
- package/__tests__/features/delivery/delivery.latest.spec.ts +254 -0
- package/__tests__/features/delivery/delivery.typescript.spec.ts +143 -0
- package/__tests__/features/delivery/delivery.utils.spec.ts +122 -0
- package/__tests__/features/listener/listener.delivery.spec.ts +385 -0
- package/__tests__/features/listener/listener.delivery.sse.spec.ts +55 -0
- package/__tests__/features/sdk/sdk.configuration.spec.ts +60 -0
- package/__tests__/features/sdk/sdk.types.spec.ts +41 -17
- package/__tests__/features/socket/socket.methods.spec.ts +40 -0
- package/dist/adapter-sse/sse-adapter.d.ts.map +1 -1
- package/dist/adapter-sse/sse-adapter.types.d.ts +11 -0
- package/dist/adapter-sse/sse-adapter.types.d.ts.map +1 -1
- package/dist/adapter-websockets/websocket-adapter.d.ts.map +1 -1
- package/dist/adapter-websockets/websocket-adapter.types.d.ts +23 -0
- package/dist/adapter-websockets/websocket-adapter.types.d.ts.map +1 -1
- package/dist/delivery/delivery.batch.d.ts +19 -0
- package/dist/delivery/delivery.batch.d.ts.map +1 -0
- package/dist/delivery/delivery.latest.d.ts +18 -0
- package/dist/delivery/delivery.latest.d.ts.map +1 -0
- package/dist/delivery/delivery.types.d.ts +113 -0
- package/dist/delivery/delivery.types.d.ts.map +1 -0
- package/dist/delivery/delivery.utils.d.ts +50 -0
- package/dist/delivery/delivery.utils.d.ts.map +1 -0
- package/dist/delivery/index.d.ts +5 -0
- package/dist/delivery/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 +261 -20
- package/dist/index.mjs.map +1 -1
- package/dist/listener/listener.d.ts +22 -7
- package/dist/listener/listener.d.ts.map +1 -1
- package/dist/listener/listener.types.d.ts +29 -9
- package/dist/listener/listener.types.d.ts.map +1 -1
- package/dist/sdk/sdk.d.ts +6 -2
- package/dist/sdk/sdk.d.ts.map +1 -1
- package/dist/socket/socket.d.ts +8 -1
- package/dist/socket/socket.d.ts.map +1 -1
- package/dist/types/extract.types.d.ts +10 -4
- package/dist/types/extract.types.d.ts.map +1 -1
- package/package.json +1 -1
- package/src/adapter-sse/sse-adapter.ts +23 -4
- package/src/adapter-sse/sse-adapter.types.ts +9 -0
- package/src/adapter-websockets/websocket-adapter.ts +31 -6
- package/src/adapter-websockets/websocket-adapter.types.ts +20 -0
- package/src/delivery/delivery.batch.ts +71 -0
- package/src/delivery/delivery.latest.ts +64 -0
- package/src/delivery/delivery.types.ts +129 -0
- package/src/delivery/delivery.utils.ts +96 -0
- package/src/delivery/index.ts +4 -0
- package/src/index.ts +1 -0
- package/src/listener/listener.ts +48 -9
- package/src/listener/listener.types.ts +45 -10
- package/src/sdk/sdk.ts +27 -7
- package/src/socket/socket.ts +18 -2
- package/src/types/extract.types.ts +10 -4
- 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 =
|
|
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
|
+
});
|