@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,254 @@
|
|
|
1
|
+
import { createLatestDeliveryStrategy } from "delivery";
|
|
2
|
+
|
|
3
|
+
type Message = { data: number; extra: { id: number } };
|
|
4
|
+
|
|
5
|
+
const message = (data: number): Message => ({ data, extra: { id: data } });
|
|
6
|
+
|
|
7
|
+
describe("Delivery [ Latest ]", () => {
|
|
8
|
+
const setup = (options: { interval: number; leading?: boolean }) => {
|
|
9
|
+
const deliver = vi.fn();
|
|
10
|
+
const controller = createLatestDeliveryStrategy<number, { id: number }>(options)({ deliver });
|
|
11
|
+
return { deliver, controller };
|
|
12
|
+
};
|
|
13
|
+
|
|
14
|
+
beforeEach(() => {
|
|
15
|
+
vi.useFakeTimers();
|
|
16
|
+
});
|
|
17
|
+
|
|
18
|
+
afterEach(() => {
|
|
19
|
+
vi.useRealTimers();
|
|
20
|
+
});
|
|
21
|
+
|
|
22
|
+
it("should deliver the first message immediately", () => {
|
|
23
|
+
const { deliver, controller } = setup({ interval: 100 });
|
|
24
|
+
controller.push(message(1));
|
|
25
|
+
expect(deliver).toHaveBeenCalledOnce();
|
|
26
|
+
expect(deliver).toHaveBeenCalledWith(message(1));
|
|
27
|
+
});
|
|
28
|
+
|
|
29
|
+
it("should deliver only the newest message when the window closes", () => {
|
|
30
|
+
const { deliver, controller } = setup({ interval: 100 });
|
|
31
|
+
controller.push(message(1));
|
|
32
|
+
controller.push(message(2));
|
|
33
|
+
controller.push(message(3));
|
|
34
|
+
expect(deliver).toHaveBeenCalledOnce();
|
|
35
|
+
vi.advanceTimersByTime(100);
|
|
36
|
+
expect(deliver).toHaveBeenCalledTimes(2);
|
|
37
|
+
expect(deliver).toHaveBeenLastCalledWith(message(3));
|
|
38
|
+
});
|
|
39
|
+
|
|
40
|
+
it("should not deliver a trailing message when nothing followed the leading one", () => {
|
|
41
|
+
const { deliver, controller } = setup({ interval: 100 });
|
|
42
|
+
controller.push(message(1));
|
|
43
|
+
vi.advanceTimersByTime(500);
|
|
44
|
+
expect(deliver).toHaveBeenCalledOnce();
|
|
45
|
+
});
|
|
46
|
+
|
|
47
|
+
it("should open the next window after a trailing delivery", () => {
|
|
48
|
+
const { deliver, controller } = setup({ interval: 100 });
|
|
49
|
+
controller.push(message(1)); // t=0 leading
|
|
50
|
+
controller.push(message(2)); // pending
|
|
51
|
+
vi.advanceTimersByTime(100); // t=100 trailing → 2, new window
|
|
52
|
+
expect(deliver).toHaveBeenLastCalledWith(message(2));
|
|
53
|
+
controller.push(message(3)); // inside the new window → must wait
|
|
54
|
+
expect(deliver).toHaveBeenCalledTimes(2);
|
|
55
|
+
vi.advanceTimersByTime(100); // t=200 → 3
|
|
56
|
+
expect(deliver).toHaveBeenCalledTimes(3);
|
|
57
|
+
expect(deliver).toHaveBeenLastCalledWith(message(3));
|
|
58
|
+
});
|
|
59
|
+
|
|
60
|
+
it("should lead again after going idle", () => {
|
|
61
|
+
const { deliver, controller } = setup({ interval: 100 });
|
|
62
|
+
controller.push(message(1));
|
|
63
|
+
vi.advanceTimersByTime(100); // window closes with nothing pending → idle
|
|
64
|
+
controller.push(message(2));
|
|
65
|
+
expect(deliver).toHaveBeenCalledTimes(2);
|
|
66
|
+
expect(deliver).toHaveBeenLastCalledWith(message(2));
|
|
67
|
+
});
|
|
68
|
+
|
|
69
|
+
it("should wait for the interval when leading is disabled", () => {
|
|
70
|
+
const { deliver, controller } = setup({ interval: 100, leading: false });
|
|
71
|
+
controller.push(message(1));
|
|
72
|
+
controller.push(message(2));
|
|
73
|
+
expect(deliver).not.toHaveBeenCalled();
|
|
74
|
+
vi.advanceTimersByTime(100);
|
|
75
|
+
expect(deliver).toHaveBeenCalledOnce();
|
|
76
|
+
expect(deliver).toHaveBeenCalledWith(message(2));
|
|
77
|
+
});
|
|
78
|
+
|
|
79
|
+
it("should deliver the extra of the delivered message", () => {
|
|
80
|
+
const { deliver, controller } = setup({ interval: 100 });
|
|
81
|
+
controller.push(message(1));
|
|
82
|
+
controller.push(message(2));
|
|
83
|
+
controller.push(message(3));
|
|
84
|
+
vi.advanceTimersByTime(100);
|
|
85
|
+
expect(deliver).toHaveBeenLastCalledWith({ data: 3, extra: { id: 3 } });
|
|
86
|
+
});
|
|
87
|
+
|
|
88
|
+
it("should drop pending messages on dispose", () => {
|
|
89
|
+
const { deliver, controller } = setup({ interval: 100 });
|
|
90
|
+
controller.push(message(1));
|
|
91
|
+
controller.push(message(2));
|
|
92
|
+
controller.dispose();
|
|
93
|
+
controller.dispose(); // idempotent
|
|
94
|
+
vi.advanceTimersByTime(500);
|
|
95
|
+
expect(deliver).toHaveBeenCalledOnce();
|
|
96
|
+
});
|
|
97
|
+
|
|
98
|
+
it("should ignore messages pushed after dispose", () => {
|
|
99
|
+
const { deliver, controller } = setup({ interval: 100 });
|
|
100
|
+
controller.dispose();
|
|
101
|
+
controller.push(message(1));
|
|
102
|
+
vi.advanceTimersByTime(500);
|
|
103
|
+
expect(deliver).not.toHaveBeenCalled();
|
|
104
|
+
});
|
|
105
|
+
|
|
106
|
+
it("should allow disposing from inside the callback", () => {
|
|
107
|
+
const deliver = vi.fn();
|
|
108
|
+
const controller = createLatestDeliveryStrategy<number>({ interval: 100 })({
|
|
109
|
+
deliver: (msg) => {
|
|
110
|
+
deliver(msg);
|
|
111
|
+
controller.dispose();
|
|
112
|
+
},
|
|
113
|
+
});
|
|
114
|
+
controller.push(message(1)); // leading → disposes
|
|
115
|
+
controller.push(message(2));
|
|
116
|
+
vi.advanceTimersByTime(500);
|
|
117
|
+
expect(deliver).toHaveBeenCalledOnce();
|
|
118
|
+
});
|
|
119
|
+
|
|
120
|
+
it("should coalesce messages per macrotask with interval 0", () => {
|
|
121
|
+
const { deliver, controller } = setup({ interval: 0 });
|
|
122
|
+
controller.push(message(1));
|
|
123
|
+
controller.push(message(2));
|
|
124
|
+
controller.push(message(3));
|
|
125
|
+
expect(deliver).toHaveBeenCalledOnce();
|
|
126
|
+
vi.advanceTimersByTime(0);
|
|
127
|
+
expect(deliver).toHaveBeenCalledTimes(2);
|
|
128
|
+
expect(deliver).toHaveBeenLastCalledWith(message(3));
|
|
129
|
+
});
|
|
130
|
+
|
|
131
|
+
it("should deliver exactly leading + trailing for a burst of 1000 messages", () => {
|
|
132
|
+
const { deliver, controller } = setup({ interval: 100 });
|
|
133
|
+
for (let i = 1; i <= 1000; i += 1) {
|
|
134
|
+
controller.push(message(i));
|
|
135
|
+
}
|
|
136
|
+
expect(deliver).toHaveBeenCalledOnce();
|
|
137
|
+
vi.advanceTimersByTime(100);
|
|
138
|
+
expect(deliver).toHaveBeenCalledTimes(2);
|
|
139
|
+
expect(deliver).toHaveBeenLastCalledWith(message(1000));
|
|
140
|
+
vi.advanceTimersByTime(1000);
|
|
141
|
+
expect(deliver).toHaveBeenCalledTimes(2);
|
|
142
|
+
});
|
|
143
|
+
|
|
144
|
+
it("should preserve order across many windows", () => {
|
|
145
|
+
const { deliver, controller } = setup({ interval: 100 });
|
|
146
|
+
controller.push(message(1));
|
|
147
|
+
controller.push(message(2));
|
|
148
|
+
vi.advanceTimersByTime(100);
|
|
149
|
+
controller.push(message(3));
|
|
150
|
+
controller.push(message(4));
|
|
151
|
+
vi.advanceTimersByTime(100);
|
|
152
|
+
controller.push(message(5));
|
|
153
|
+
vi.advanceTimersByTime(100);
|
|
154
|
+
vi.advanceTimersByTime(100); // idle
|
|
155
|
+
controller.push(message(6));
|
|
156
|
+
expect(deliver.mock.calls.map(([m]) => m.data)).toEqual([1, 2, 4, 5, 6]);
|
|
157
|
+
});
|
|
158
|
+
|
|
159
|
+
it("should treat a message arriving right after an idle window as leading", () => {
|
|
160
|
+
const { deliver, controller } = setup({ interval: 100 });
|
|
161
|
+
controller.push(message(1));
|
|
162
|
+
vi.advanceTimersByTime(100); // closes with nothing pending → idle
|
|
163
|
+
controller.push(message(2));
|
|
164
|
+
expect(deliver).toHaveBeenCalledTimes(2);
|
|
165
|
+
expect(deliver).toHaveBeenLastCalledWith(message(2));
|
|
166
|
+
});
|
|
167
|
+
|
|
168
|
+
it("should keep working after the callback throws", () => {
|
|
169
|
+
const deliver = vi.fn().mockImplementationOnce(() => {
|
|
170
|
+
throw new Error("boom");
|
|
171
|
+
});
|
|
172
|
+
const controller = createLatestDeliveryStrategy<number>({ interval: 100 })({ deliver });
|
|
173
|
+
expect(() => controller.push(message(1))).toThrow("boom");
|
|
174
|
+
controller.push(message(2));
|
|
175
|
+
vi.advanceTimersByTime(100);
|
|
176
|
+
expect(deliver).toHaveBeenCalledTimes(2);
|
|
177
|
+
expect(deliver).toHaveBeenLastCalledWith(message(2));
|
|
178
|
+
controller.push(message(3));
|
|
179
|
+
vi.advanceTimersByTime(100);
|
|
180
|
+
expect(deliver).toHaveBeenLastCalledWith(message(3));
|
|
181
|
+
});
|
|
182
|
+
|
|
183
|
+
it("should keep working after a trailing callback throws", () => {
|
|
184
|
+
const deliver = vi.fn();
|
|
185
|
+
const controller = createLatestDeliveryStrategy<number>({ interval: 100 })({ deliver });
|
|
186
|
+
controller.push(message(1));
|
|
187
|
+
controller.push(message(2));
|
|
188
|
+
deliver.mockImplementationOnce(() => {
|
|
189
|
+
throw new Error("boom");
|
|
190
|
+
});
|
|
191
|
+
expect(() => vi.advanceTimersByTime(100)).toThrow("boom");
|
|
192
|
+
controller.push(message(3)); // still inside the window re-armed before the throw
|
|
193
|
+
vi.advanceTimersByTime(100);
|
|
194
|
+
expect(deliver).toHaveBeenLastCalledWith(message(3));
|
|
195
|
+
});
|
|
196
|
+
|
|
197
|
+
it("should go idle and lead again when leading is disabled", () => {
|
|
198
|
+
const { deliver, controller } = setup({ interval: 100, leading: false });
|
|
199
|
+
controller.push(message(1));
|
|
200
|
+
vi.advanceTimersByTime(100);
|
|
201
|
+
expect(deliver).toHaveBeenCalledWith(message(1));
|
|
202
|
+
vi.advanceTimersByTime(100); // nothing pending → idle
|
|
203
|
+
controller.push(message(2));
|
|
204
|
+
expect(deliver).toHaveBeenCalledOnce(); // not immediate
|
|
205
|
+
vi.advanceTimersByTime(100);
|
|
206
|
+
expect(deliver).toHaveBeenLastCalledWith(message(2));
|
|
207
|
+
});
|
|
208
|
+
|
|
209
|
+
it("should deliver the same object reference that was pushed", () => {
|
|
210
|
+
const { deliver, controller } = setup({ interval: 100 });
|
|
211
|
+
const first = message(1);
|
|
212
|
+
const last = message(3);
|
|
213
|
+
controller.push(first);
|
|
214
|
+
controller.push(message(2));
|
|
215
|
+
controller.push(last);
|
|
216
|
+
vi.advanceTimersByTime(100);
|
|
217
|
+
expect(deliver.mock.calls[0][0]).toBe(first);
|
|
218
|
+
expect(deliver.mock.calls[1][0]).toBe(last);
|
|
219
|
+
});
|
|
220
|
+
|
|
221
|
+
it("should be a no-op to dispose while idle", () => {
|
|
222
|
+
const { deliver, controller } = setup({ interval: 100 });
|
|
223
|
+
expect(() => controller.dispose()).not.toThrow();
|
|
224
|
+
vi.advanceTimersByTime(100);
|
|
225
|
+
expect(deliver).not.toHaveBeenCalled();
|
|
226
|
+
});
|
|
227
|
+
|
|
228
|
+
it("should not create timers before the first message", () => {
|
|
229
|
+
setup({ interval: 100 });
|
|
230
|
+
expect(vi.getTimerCount()).toBe(0);
|
|
231
|
+
});
|
|
232
|
+
|
|
233
|
+
it("should clear all timers on dispose", () => {
|
|
234
|
+
const { controller } = setup({ interval: 100 });
|
|
235
|
+
controller.push(message(1));
|
|
236
|
+
expect(vi.getTimerCount()).toBe(1);
|
|
237
|
+
controller.dispose();
|
|
238
|
+
expect(vi.getTimerCount()).toBe(0);
|
|
239
|
+
});
|
|
240
|
+
|
|
241
|
+
it("should give independent state to controllers created from one factory", () => {
|
|
242
|
+
const factory = createLatestDeliveryStrategy<number>({ interval: 100 });
|
|
243
|
+
const first = vi.fn();
|
|
244
|
+
const second = vi.fn();
|
|
245
|
+
const a = factory({ deliver: first });
|
|
246
|
+
const b = factory({ deliver: second });
|
|
247
|
+
a.push(message(1));
|
|
248
|
+
a.push(message(2));
|
|
249
|
+
b.push(message(10));
|
|
250
|
+
vi.advanceTimersByTime(100);
|
|
251
|
+
expect(first.mock.calls.map(([m]) => m.data)).toEqual([1, 2]);
|
|
252
|
+
expect(second.mock.calls.map(([m]) => m.data)).toEqual([10]);
|
|
253
|
+
});
|
|
254
|
+
});
|
|
@@ -0,0 +1,143 @@
|
|
|
1
|
+
import type { ListenerDeliveryType } from "delivery";
|
|
2
|
+
import { createDeliveryStrategy } from "delivery";
|
|
3
|
+
import type { ExtendListener, Listener, ListenerInstance, ListenerModel } from "listener";
|
|
4
|
+
import { Socket } from "socket";
|
|
5
|
+
import type { ExtractListenerDeliveredType, ExtractListenerResponseType } from "types";
|
|
6
|
+
import { expectTypeOf } from "vitest";
|
|
7
|
+
|
|
8
|
+
type Price = { symbol: string; value: number };
|
|
9
|
+
type Summary = { count: number; last: Price };
|
|
10
|
+
|
|
11
|
+
const socket = new Socket({ url: "ws://localhost:3000" });
|
|
12
|
+
|
|
13
|
+
const summarize = createDeliveryStrategy<Price, Summary>(({ deliver }) => ({
|
|
14
|
+
push: ({ data, extra }) => deliver({ data: { count: 1, last: data }, extra }),
|
|
15
|
+
dispose: () => null,
|
|
16
|
+
}));
|
|
17
|
+
|
|
18
|
+
const plain = socket.createListener<Price>()({ topic: "prices" });
|
|
19
|
+
const latest = socket.createListener<Price>()({ topic: "prices", delivery: { strategy: "latest", interval: 16 } });
|
|
20
|
+
const batch = socket.createListener<Price>()({ topic: "prices", delivery: { strategy: "batch", interval: 100 } });
|
|
21
|
+
const custom = socket.createListener<Price>()({ topic: "prices", delivery: summarize });
|
|
22
|
+
|
|
23
|
+
describe("Delivery [ TypeScript ]", () => {
|
|
24
|
+
it("should type callback data by strategy", () => {
|
|
25
|
+
plain.listen(({ data }) => expectTypeOf(data).toEqualTypeOf<Price>());
|
|
26
|
+
latest.listen(({ data }) => expectTypeOf(data).toEqualTypeOf<Price>());
|
|
27
|
+
batch.listen(({ data }) => expectTypeOf(data).toEqualTypeOf<Price[]>());
|
|
28
|
+
custom.listen(({ data }) => expectTypeOf(data).toEqualTypeOf<Summary>());
|
|
29
|
+
expect(true).toBeTrue();
|
|
30
|
+
});
|
|
31
|
+
|
|
32
|
+
it("should keep the response type as the wire type", () => {
|
|
33
|
+
expectTypeOf<ExtractListenerResponseType<typeof batch>>().toEqualTypeOf<Price>();
|
|
34
|
+
expectTypeOf<ExtractListenerDeliveredType<typeof batch>>().toEqualTypeOf<Price[]>();
|
|
35
|
+
expectTypeOf<ExtractListenerResponseType<typeof custom>>().toEqualTypeOf<Price>();
|
|
36
|
+
expectTypeOf<ExtractListenerDeliveredType<typeof custom>>().toEqualTypeOf<Summary>();
|
|
37
|
+
expectTypeOf<ExtractListenerDeliveredType<typeof plain>>().toEqualTypeOf<Price>();
|
|
38
|
+
expect(true).toBeTrue();
|
|
39
|
+
});
|
|
40
|
+
|
|
41
|
+
it("should re-type through setDelivery", () => {
|
|
42
|
+
const rebatched = plain.setDelivery({ strategy: "batch", interval: 50 });
|
|
43
|
+
expectTypeOf<ExtractListenerDeliveredType<typeof rebatched>>().toEqualTypeOf<Price[]>();
|
|
44
|
+
const cleared = batch.setDelivery(undefined);
|
|
45
|
+
expectTypeOf<ExtractListenerDeliveredType<typeof cleared>>().toEqualTypeOf<Price>();
|
|
46
|
+
const withParams = socket
|
|
47
|
+
.createListener<Price>()({ topic: "prices/:symbol", delivery: { strategy: "batch", interval: 50 } })
|
|
48
|
+
.setParams({ symbol: "BTC" });
|
|
49
|
+
expectTypeOf<ExtractListenerDeliveredType<typeof withParams>>().toEqualTypeOf<Price[]>();
|
|
50
|
+
expect(true).toBeTrue();
|
|
51
|
+
});
|
|
52
|
+
|
|
53
|
+
it("should satisfy ListenerInstance constraints regardless of delivery", () => {
|
|
54
|
+
expectTypeOf(batch).toMatchTypeOf<ListenerInstance>();
|
|
55
|
+
expectTypeOf(batch).toMatchTypeOf<ListenerInstance<{ response: Price }>>();
|
|
56
|
+
expectTypeOf(custom).toMatchTypeOf<ListenerInstance<{ response: Price }>>();
|
|
57
|
+
// covariance guard - partial constraints keep matching wider responses
|
|
58
|
+
expectTypeOf(plain).toMatchTypeOf<ListenerInstance<{ response: { symbol: string } }>>();
|
|
59
|
+
expectTypeOf(batch).toMatchTypeOf<ListenerInstance<{ response: { symbol: string } }>>();
|
|
60
|
+
expect(true).toBeTrue();
|
|
61
|
+
});
|
|
62
|
+
|
|
63
|
+
it("should default ListenerModel delivered to response", () => {
|
|
64
|
+
type Model = ListenerModel<{ response: Price; topic: "prices" }>;
|
|
65
|
+
type Batched = ListenerModel<{ response: Price; topic: "prices"; delivered: Price[] }>;
|
|
66
|
+
expectTypeOf<ExtractListenerDeliveredType<Model>>().toEqualTypeOf<Price>();
|
|
67
|
+
expectTypeOf<ExtractListenerDeliveredType<Batched>>().toEqualTypeOf<Price[]>();
|
|
68
|
+
expect(true).toBeTrue();
|
|
69
|
+
});
|
|
70
|
+
|
|
71
|
+
it("should follow the response override in ExtendListener", () => {
|
|
72
|
+
type Overridden = ExtendListener<ListenerInstance, { response: Price }>;
|
|
73
|
+
type Kept = ExtendListener<typeof batch, { topic: "other" }>;
|
|
74
|
+
type Explicit = ExtendListener<typeof plain, { delivered: Summary }>;
|
|
75
|
+
expectTypeOf<ExtractListenerDeliveredType<Overridden>>().toEqualTypeOf<Price>();
|
|
76
|
+
expectTypeOf<ExtractListenerDeliveredType<Kept>>().toEqualTypeOf<Price[]>();
|
|
77
|
+
expectTypeOf<ExtractListenerDeliveredType<Explicit>>().toEqualTypeOf<Summary>();
|
|
78
|
+
expect(true).toBeTrue();
|
|
79
|
+
});
|
|
80
|
+
|
|
81
|
+
it("should reject invalid presets", () => {
|
|
82
|
+
const invalid = () => {
|
|
83
|
+
// @ts-expect-error unknown strategy
|
|
84
|
+
socket.createListener<Price>()({ topic: "prices", delivery: { strategy: "nope", interval: 1 } });
|
|
85
|
+
// @ts-expect-error interval is required
|
|
86
|
+
socket.createListener<Price>()({ topic: "prices", delivery: { strategy: "latest" } });
|
|
87
|
+
};
|
|
88
|
+
expect(invalid).toBeFunction();
|
|
89
|
+
});
|
|
90
|
+
|
|
91
|
+
it("should accept preset options", () => {
|
|
92
|
+
const withLeading = socket.createListener<Price>()({
|
|
93
|
+
topic: "prices",
|
|
94
|
+
delivery: { strategy: "latest", interval: 16, leading: false },
|
|
95
|
+
});
|
|
96
|
+
const withMax = socket.createListener<Price>()({
|
|
97
|
+
topic: "prices",
|
|
98
|
+
delivery: { strategy: "batch", interval: 16, maxSize: 10 },
|
|
99
|
+
});
|
|
100
|
+
expectTypeOf<ExtractListenerDeliveredType<typeof withLeading>>().toEqualTypeOf<Price>();
|
|
101
|
+
expectTypeOf<ExtractListenerDeliveredType<typeof withMax>>().toEqualTypeOf<Price[]>();
|
|
102
|
+
expect(true).toBeTrue();
|
|
103
|
+
});
|
|
104
|
+
|
|
105
|
+
it("should type setDelivery with a custom strategy", () => {
|
|
106
|
+
const summarized = plain.setDelivery(summarize);
|
|
107
|
+
expectTypeOf<ExtractListenerDeliveredType<typeof summarized>>().toEqualTypeOf<Summary>();
|
|
108
|
+
expectTypeOf<ExtractListenerResponseType<typeof summarized>>().toEqualTypeOf<Price>();
|
|
109
|
+
summarized.listen(({ data }) => expectTypeOf(data).toEqualTypeOf<Summary>());
|
|
110
|
+
expect(true).toBeTrue();
|
|
111
|
+
});
|
|
112
|
+
|
|
113
|
+
it("should reject a strategy whose input does not match the response", () => {
|
|
114
|
+
const wrongInput = createDeliveryStrategy<{ other: string }, number>(({ deliver }) => ({
|
|
115
|
+
push: ({ extra }) => deliver({ data: 1, extra }),
|
|
116
|
+
dispose: () => null,
|
|
117
|
+
}));
|
|
118
|
+
// @ts-expect-error input type mismatch
|
|
119
|
+
const invalid = () => socket.createListener<Price>()({ topic: "prices", delivery: wrongInput });
|
|
120
|
+
expect(invalid).toBeFunction();
|
|
121
|
+
});
|
|
122
|
+
|
|
123
|
+
it("should keep the delivered type through clone and params", () => {
|
|
124
|
+
const cloned = batch.clone();
|
|
125
|
+
expectTypeOf<ExtractListenerDeliveredType<typeof cloned>>().toEqualTypeOf<Price[]>();
|
|
126
|
+
const dynamic = socket.createListener<Price>()({ topic: "prices/:id", delivery: summarize });
|
|
127
|
+
const bound = dynamic.setParams({ id: 1 });
|
|
128
|
+
expectTypeOf<ExtractListenerDeliveredType<typeof bound>>().toEqualTypeOf<Summary>();
|
|
129
|
+
bound.listen(({ data }) => expectTypeOf(data).toEqualTypeOf<Summary>());
|
|
130
|
+
expect(true).toBeTrue();
|
|
131
|
+
});
|
|
132
|
+
|
|
133
|
+
it("should expose delivery with a loose type on the instance", () => {
|
|
134
|
+
expectTypeOf(batch.delivery).toMatchTypeOf<ListenerDeliveryType | undefined>();
|
|
135
|
+
expectTypeOf(batch.listenerOptions.delivery).toMatchTypeOf<ListenerDeliveryType | undefined>();
|
|
136
|
+
expect(true).toBeTrue();
|
|
137
|
+
});
|
|
138
|
+
|
|
139
|
+
it("should type the raw Listener generics", () => {
|
|
140
|
+
expectTypeOf<Listener<Price, "prices", typeof socket>>().toMatchTypeOf<ListenerInstance<{ delivered: Price }>>();
|
|
141
|
+
expect(true).toBeTrue();
|
|
142
|
+
});
|
|
143
|
+
});
|
|
@@ -0,0 +1,122 @@
|
|
|
1
|
+
import type { DeliveryControllerType } from "delivery";
|
|
2
|
+
import {
|
|
3
|
+
assertDelivery,
|
|
4
|
+
createDeliveryController,
|
|
5
|
+
createDeliveryStrategy,
|
|
6
|
+
getDeliveryKey,
|
|
7
|
+
isDeliveryStrategy,
|
|
8
|
+
} from "delivery";
|
|
9
|
+
|
|
10
|
+
describe("Delivery [ Utils ]", () => {
|
|
11
|
+
describe("createDeliveryStrategy", () => {
|
|
12
|
+
it("should return the given strategy untouched", () => {
|
|
13
|
+
const strategy = createDeliveryStrategy<number, string>(({ deliver }) => ({
|
|
14
|
+
push: ({ data, extra }) => deliver({ data: String(data), extra }),
|
|
15
|
+
dispose: () => null,
|
|
16
|
+
}));
|
|
17
|
+
expect(typeof strategy).toBe("function");
|
|
18
|
+
expect(isDeliveryStrategy(strategy)).toBeTrue();
|
|
19
|
+
expect(isDeliveryStrategy({ strategy: "latest", interval: 1 })).toBeFalse();
|
|
20
|
+
});
|
|
21
|
+
});
|
|
22
|
+
|
|
23
|
+
describe("assertDelivery", () => {
|
|
24
|
+
it("should accept presets and custom strategies", () => {
|
|
25
|
+
expect(() => assertDelivery({ strategy: "latest", interval: 10 })).not.toThrow();
|
|
26
|
+
expect(() => assertDelivery({ strategy: "batch", interval: 10 })).not.toThrow();
|
|
27
|
+
expect(() => assertDelivery(() => ({ push: () => null, dispose: () => null }))).not.toThrow();
|
|
28
|
+
});
|
|
29
|
+
it("should throw for an unknown preset", () => {
|
|
30
|
+
expect(() => assertDelivery({ strategy: "nope", interval: 10 } as any)).toThrow(
|
|
31
|
+
/Unknown delivery strategy: nope/,
|
|
32
|
+
);
|
|
33
|
+
});
|
|
34
|
+
});
|
|
35
|
+
|
|
36
|
+
describe("createDeliveryController", () => {
|
|
37
|
+
it("should call a custom strategy with the context", () => {
|
|
38
|
+
const controller: DeliveryControllerType<number> = { push: vi.fn(), dispose: vi.fn() };
|
|
39
|
+
const strategy = vi.fn(() => controller);
|
|
40
|
+
const deliver = vi.fn();
|
|
41
|
+
const result = createDeliveryController<number, number, unknown>(strategy, { deliver });
|
|
42
|
+
expect(strategy).toHaveBeenCalledOnce();
|
|
43
|
+
expect(strategy).toHaveBeenCalledWith({ deliver });
|
|
44
|
+
expect(result).toBe(controller);
|
|
45
|
+
});
|
|
46
|
+
it("should build the latest preset", () => {
|
|
47
|
+
const deliver = vi.fn();
|
|
48
|
+
const controller = createDeliveryController({ strategy: "latest", interval: 100 }, { deliver });
|
|
49
|
+
controller.push({ data: 1, extra: null });
|
|
50
|
+
expect(deliver).toHaveBeenCalledWith({ data: 1, extra: null });
|
|
51
|
+
controller.dispose();
|
|
52
|
+
});
|
|
53
|
+
it("should build the batch preset", () => {
|
|
54
|
+
vi.useFakeTimers();
|
|
55
|
+
const deliver = vi.fn();
|
|
56
|
+
const controller = createDeliveryController({ strategy: "batch", interval: 100 }, { deliver });
|
|
57
|
+
controller.push({ data: 1, extra: null });
|
|
58
|
+
controller.push({ data: 2, extra: null });
|
|
59
|
+
vi.advanceTimersByTime(100);
|
|
60
|
+
expect(deliver).toHaveBeenCalledWith({ data: [1, 2], extra: null });
|
|
61
|
+
controller.dispose();
|
|
62
|
+
vi.useRealTimers();
|
|
63
|
+
});
|
|
64
|
+
});
|
|
65
|
+
|
|
66
|
+
describe("getDeliveryKey", () => {
|
|
67
|
+
it("should compare presets by value and strategies by identity", () => {
|
|
68
|
+
const strategy = () => ({ push: () => null, dispose: () => null });
|
|
69
|
+
expect(getDeliveryKey()).toBe("");
|
|
70
|
+
expect(getDeliveryKey({ strategy: "latest", interval: 16 })).toBe(
|
|
71
|
+
getDeliveryKey({ strategy: "latest", interval: 16 }),
|
|
72
|
+
);
|
|
73
|
+
expect(getDeliveryKey({ strategy: "latest", interval: 16 })).not.toBe(
|
|
74
|
+
getDeliveryKey({ strategy: "latest", interval: 32 }),
|
|
75
|
+
);
|
|
76
|
+
expect(getDeliveryKey(strategy)).toBe(strategy);
|
|
77
|
+
});
|
|
78
|
+
});
|
|
79
|
+
|
|
80
|
+
describe("edge cases", () => {
|
|
81
|
+
it("should throw a helpful error when the strategy key is missing", () => {
|
|
82
|
+
expect(() => assertDelivery({ interval: 10 } as any)).toThrow(/Unknown delivery strategy: undefined/);
|
|
83
|
+
expect(() => assertDelivery({ interval: 10 } as any)).toThrow(/createDeliveryStrategy/);
|
|
84
|
+
});
|
|
85
|
+
it("should build latest without leading", () => {
|
|
86
|
+
vi.useFakeTimers();
|
|
87
|
+
const deliver = vi.fn();
|
|
88
|
+
const controller = createDeliveryController({ strategy: "latest", interval: 100, leading: false }, { deliver });
|
|
89
|
+
controller.push({ data: 1, extra: null });
|
|
90
|
+
expect(deliver).not.toHaveBeenCalled();
|
|
91
|
+
vi.advanceTimersByTime(100);
|
|
92
|
+
expect(deliver).toHaveBeenCalledWith({ data: 1, extra: null });
|
|
93
|
+
controller.dispose();
|
|
94
|
+
vi.useRealTimers();
|
|
95
|
+
});
|
|
96
|
+
it("should build batch with maxSize", () => {
|
|
97
|
+
const deliver = vi.fn();
|
|
98
|
+
const controller = createDeliveryController({ strategy: "batch", interval: 100, maxSize: 2 }, { deliver });
|
|
99
|
+
controller.push({ data: 1, extra: null });
|
|
100
|
+
controller.push({ data: 2, extra: null });
|
|
101
|
+
expect(deliver).toHaveBeenCalledWith({ data: [1, 2], extra: null });
|
|
102
|
+
controller.dispose();
|
|
103
|
+
});
|
|
104
|
+
it("should produce different keys for different presets", () => {
|
|
105
|
+
expect(getDeliveryKey({ strategy: "latest", interval: 16 })).not.toBe(
|
|
106
|
+
getDeliveryKey({ strategy: "batch", interval: 16 }),
|
|
107
|
+
);
|
|
108
|
+
expect(getDeliveryKey({ strategy: "batch", interval: 16 })).not.toBe(
|
|
109
|
+
getDeliveryKey({ strategy: "batch", interval: 16, maxSize: 5 }),
|
|
110
|
+
);
|
|
111
|
+
expect(getDeliveryKey({ strategy: "latest", interval: 16, leading: false })).not.toBe(
|
|
112
|
+
getDeliveryKey({ strategy: "latest", interval: 16 }),
|
|
113
|
+
);
|
|
114
|
+
});
|
|
115
|
+
it("should produce different keys for different strategy functions", () => {
|
|
116
|
+
const a = () => ({ push: () => null, dispose: () => null });
|
|
117
|
+
const b = () => ({ push: () => null, dispose: () => null });
|
|
118
|
+
expect(getDeliveryKey(a)).not.toBe(getDeliveryKey(b));
|
|
119
|
+
expect(getDeliveryKey(a)).toBe(getDeliveryKey(a));
|
|
120
|
+
});
|
|
121
|
+
});
|
|
122
|
+
});
|