@hyper-fetch/sockets 8.2.4 → 9.0.1

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 (32) hide show
  1. package/__tests__/features/adapter/adapter.bindings.spec.ts +139 -0
  2. package/__tests__/features/adapter/adapter.sse.spec.ts +37 -3
  3. package/__tests__/features/adapter/adapter.websocket.connect.spec.ts +271 -0
  4. package/__tests__/features/adapter/adapter.websocket.spec.ts +30 -0
  5. package/__tests__/features/socket/socket.base.spec.ts +10 -2
  6. package/__tests__/features/socket/socket.callbacks.spec.ts +25 -1
  7. package/__tests__/features/socket/socket.methods.spec.ts +1 -1
  8. package/__tests__/features/socket/socket.utils.spec.ts +38 -1
  9. package/dist/adapter/adapter.bindings.d.ts +7 -4
  10. package/dist/adapter/adapter.bindings.d.ts.map +1 -1
  11. package/dist/adapter-sse/sse-adapter.d.ts.map +1 -1
  12. package/dist/adapter-websockets/websocket-adapter.d.ts.map +1 -1
  13. package/dist/adapter-websockets/websocket-adapter.types.d.ts +5 -1
  14. package/dist/adapter-websockets/websocket-adapter.types.d.ts.map +1 -1
  15. package/dist/adapter-websockets/websocket-adapter.utils.d.ts.map +1 -1
  16. package/dist/index.mjs +149 -57
  17. package/dist/index.mjs.map +1 -1
  18. package/dist/socket/socket.d.ts +18 -1
  19. package/dist/socket/socket.d.ts.map +1 -1
  20. package/dist/socket/socket.types.d.ts +18 -0
  21. package/dist/socket/socket.types.d.ts.map +1 -1
  22. package/dist/socket/socket.utils.d.ts +6 -1
  23. package/dist/socket/socket.utils.d.ts.map +1 -1
  24. package/package.json +1 -1
  25. package/src/adapter/adapter.bindings.ts +74 -15
  26. package/src/adapter-sse/sse-adapter.ts +32 -23
  27. package/src/adapter-websockets/websocket-adapter.ts +48 -30
  28. package/src/adapter-websockets/websocket-adapter.types.ts +5 -1
  29. package/src/adapter-websockets/websocket-adapter.utils.ts +3 -1
  30. package/src/socket/socket.ts +24 -1
  31. package/src/socket/socket.types.ts +20 -0
  32. package/src/socket/socket.utils.ts +25 -3
@@ -79,4 +79,143 @@ describe("Socket Adapter [ Bindings ]", () => {
79
79
 
80
80
  expect(getQueryParams()).toBe("?test=123");
81
81
  });
82
+
83
+ it("should map explicitly provided query params", () => {
84
+ const { getQueryParams } = getAdapterBindings(socket);
85
+
86
+ socket.adapter.queryParams = { test: 123 };
87
+
88
+ expect(getQueryParams({ other: "value" })).toBe("?other=value");
89
+ expect(getQueryParams({})).toBe("");
90
+ });
91
+
92
+ it("should not open a connection attempt when offline, already connecting or already connected", async () => {
93
+ const { onConnect } = getAdapterBindings(socket);
94
+
95
+ socket.appManager.setOnline(false);
96
+ await expect(onConnect()).resolves.toBeNull();
97
+
98
+ socket.appManager.setOnline(true);
99
+ socket.adapter.setConnecting(true);
100
+ await expect(onConnect()).resolves.toBeNull();
101
+
102
+ socket.adapter.setConnecting(false);
103
+ socket.adapter.setConnected(true);
104
+ await expect(onConnect()).resolves.toBeNull();
105
+ });
106
+
107
+ it("should prepare the connection from socket defaults and mark the adapter as connecting", async () => {
108
+ socket = createSocket({ adapterOptions: { autoConnect: false, protocols: "v1" }, queryParams: { a: 1 } });
109
+ const connectingSpy = vi.fn();
110
+ socket.events.onConnecting(connectingSpy);
111
+ const { onConnect } = getAdapterBindings(socket);
112
+
113
+ await expect(onConnect()).resolves.toEqual({
114
+ url: "ws://localhost:1234",
115
+ queryParams: { a: 1 },
116
+ adapterOptions: { autoConnect: false, protocols: "v1" },
117
+ });
118
+ expect(socket.adapter.connecting).toBe(true);
119
+ expect(socket.adapter.forceClosed).toBe(false);
120
+ expect(connectingSpy).toHaveBeenCalledWith({ connecting: true });
121
+ });
122
+
123
+ it("should pass the connection through onConnect interceptors in order", async () => {
124
+ socket.onConnect(({ connection }) => ({ ...connection, url: `${connection.url}/first` }));
125
+ socket.onConnect(async ({ connection, attempt }) => ({
126
+ ...connection,
127
+ url: `${connection.url}/second`,
128
+ queryParams: { attempt },
129
+ }));
130
+ const { onConnect } = getAdapterBindings(socket);
131
+
132
+ await expect(onConnect()).resolves.toEqual({
133
+ url: "ws://localhost:1234/first/second",
134
+ queryParams: { attempt: 0 },
135
+ adapterOptions: { autoConnect: false },
136
+ });
137
+ });
138
+
139
+ it("should pass the reconnection attempt number to onConnect interceptors", async () => {
140
+ const attemptSpy = vi.fn();
141
+ socket.onConnect(({ connection, attempt }) => {
142
+ attemptSpy(attempt);
143
+ return connection;
144
+ });
145
+ const { onConnect } = getAdapterBindings(socket);
146
+
147
+ socket.adapter.setReconnectionAttempts(3);
148
+ await onConnect();
149
+
150
+ expect(attemptSpy).toHaveBeenCalledWith(3);
151
+ });
152
+
153
+ it("should fail the attempt when an onConnect interceptor throws", async () => {
154
+ const errorSpy = vi.fn();
155
+ const connectingSpy = vi.fn();
156
+ socket.events.onError(errorSpy);
157
+ socket.events.onConnecting(connectingSpy);
158
+ socket.onConnect(() => {
159
+ throw new Error("boom");
160
+ });
161
+ const { onConnect } = getAdapterBindings(socket);
162
+
163
+ await expect(onConnect()).resolves.toBeNull();
164
+
165
+ expect(socket.adapter.connecting).toBe(false);
166
+ expect(connectingSpy).toHaveBeenLastCalledWith({ connecting: false });
167
+ expect(errorSpy).toHaveBeenCalledWith({ error: new Error("boom") });
168
+ });
169
+
170
+ it("should wrap non-error values thrown by onConnect interceptors", async () => {
171
+ const errorSpy = vi.fn();
172
+ socket.events.onError(errorSpy);
173
+ socket.onConnect(() => {
174
+ // eslint-disable-next-line @typescript-eslint/only-throw-error
175
+ throw "boom";
176
+ });
177
+ const { onConnect } = getAdapterBindings(socket);
178
+
179
+ await expect(onConnect()).resolves.toBeNull();
180
+
181
+ expect(errorSpy.mock.calls[0][0].error).toBeInstanceOf(Error);
182
+ expect(errorSpy.mock.calls[0][0].error.message).toBe("boom");
183
+ });
184
+
185
+ it("should cancel the attempt when the adapter stops connecting while preparing", async () => {
186
+ let resolveConnection: () => void = () => null;
187
+ const interceptorStarted = new Promise<void>((started) => {
188
+ socket.onConnect(
189
+ ({ connection }) =>
190
+ new Promise((resolve) => {
191
+ resolveConnection = () => resolve(connection);
192
+ started();
193
+ }),
194
+ );
195
+ });
196
+ const { onConnect } = getAdapterBindings(socket);
197
+
198
+ const promise = onConnect();
199
+ await interceptorStarted;
200
+ socket.adapter.setConnecting(false);
201
+ resolveConnection();
202
+
203
+ await expect(promise).resolves.toBeNull();
204
+ });
205
+
206
+ it("should reset connecting state and emit error on onConnectFailed", async () => {
207
+ const errorSpy = vi.fn();
208
+ const connectingSpy = vi.fn();
209
+ socket.events.onError(errorSpy);
210
+ socket.events.onConnecting(connectingSpy);
211
+ socket.adapter.setConnecting(true);
212
+ const { onConnectFailed } = getAdapterBindings(socket);
213
+
214
+ const error = new Error("transport");
215
+ onConnectFailed({ error });
216
+
217
+ expect(socket.adapter.connecting).toBe(false);
218
+ expect(connectingSpy).toHaveBeenCalledWith({ connecting: false });
219
+ expect(errorSpy).toHaveBeenCalledWith({ error });
220
+ });
82
221
  });
@@ -28,7 +28,7 @@ describe("Socket Adapter [ SSE ]", () => {
28
28
  });
29
29
 
30
30
  it("should emit event on disconnect", async () => {
31
- startServer();
31
+ await startServer();
32
32
 
33
33
  const spy = vi.fn();
34
34
  socket.onDisconnected(spy);
@@ -40,9 +40,9 @@ describe("Socket Adapter [ SSE ]", () => {
40
40
  });
41
41
 
42
42
  it("should throw error when emitting", async () => {
43
- startServer();
43
+ await startServer();
44
44
 
45
- expect(() => socket.adapter.emit({} as any)).rejects.toThrow();
45
+ await expect(() => socket.adapter.emit({} as any)).rejects.toThrow();
46
46
  });
47
47
 
48
48
  it("should reconnect when going online", async () => {
@@ -281,4 +281,38 @@ describe("Socket Adapter [ SSE ]", () => {
281
281
  expect(errorSpy).toHaveBeenCalled();
282
282
  expect(socket.adapter.connected).toBe(false);
283
283
  });
284
+
285
+ it("should use connection details returned from onConnect interceptors", async () => {
286
+ const newUrl = "http://localhost:4321/events";
287
+ const { startServer: startNewServer, getServer: getNewServer } = createSseMockingServer(`${newUrl}?token=B`);
288
+ const connectSpy = vi.fn();
289
+
290
+ const newSocket = createSocket<ServerSentEventsAdapterType>({
291
+ adapter: ServerSentEventsAdapter,
292
+ queryParams: { token: "A" },
293
+ adapterOptions: { autoConnect: false, eventSourceInit: { withCredentials: false } },
294
+ }).onConnect(({ connection, attempt }) => {
295
+ connectSpy({ connection, attempt });
296
+ return {
297
+ url: newUrl,
298
+ queryParams: { token: "B" },
299
+ adapterOptions: { ...connection.adapterOptions, eventSourceInit: { withCredentials: true } },
300
+ };
301
+ });
302
+
303
+ const connectPromise = newSocket.adapter.connect();
304
+ await startNewServer();
305
+ await expect(connectPromise).resolves.toBe(true);
306
+
307
+ expect(connectSpy).toHaveBeenCalledWith({
308
+ connection: {
309
+ url: "ws://localhost:1234",
310
+ queryParams: { token: "A" },
311
+ adapterOptions: { autoConnect: false, eventSourceInit: { withCredentials: false } },
312
+ },
313
+ attempt: 0,
314
+ });
315
+ expect(getNewServer().url).toBe(`${newUrl}?token=B`);
316
+ expect(getNewServer().withCredentials).toBe(true);
317
+ });
284
318
  });
@@ -0,0 +1,271 @@
1
+ import { createWebsocketMockingServer, waitForConnection } from "@hyper-fetch/testing";
2
+ import { waitFor } from "@testing-library/dom";
3
+
4
+ import { WebsocketAdapter } from "../../../src/adapter-websockets/websocket-adapter";
5
+ import { createSocket } from "../../utils/socket.utils";
6
+
7
+ type ConstructedWebsocket = { url: string; protocols: string | string[] | undefined };
8
+
9
+ describe("Websocket Adapter [ Connect ]", () => {
10
+ const { url, getServer, startServer, stopServer } = createWebsocketMockingServer();
11
+ let constructed: ConstructedWebsocket[] = [];
12
+
13
+ // The mocking server swaps the global WebSocket every time it (re)starts,
14
+ // so the spy has to be installed after each startServer() call.
15
+ const installWebSocketSpy = () => {
16
+ const BaseWebSocket = window.WebSocket;
17
+ class SpyWebSocket extends BaseWebSocket {
18
+ constructor(u: string | URL, protocols?: string | string[]) {
19
+ super(u, protocols);
20
+ constructed.push({ url: String(u), protocols });
21
+ }
22
+ }
23
+ window.WebSocket = SpyWebSocket;
24
+ };
25
+
26
+ beforeEach(() => {
27
+ vi.resetAllMocks();
28
+ constructed = [];
29
+ startServer();
30
+ installWebSocketSpy();
31
+ });
32
+
33
+ afterEach(() => {
34
+ stopServer();
35
+ });
36
+
37
+ it("should pass static protocols to the WebSocket constructor", async () => {
38
+ const socket = createSocket({
39
+ url,
40
+ adapter: WebsocketAdapter(),
41
+ adapterOptions: { protocols: ["authorization", "token-A"] },
42
+ });
43
+
44
+ await waitForConnection(socket);
45
+
46
+ expect(constructed).toEqual([{ url, protocols: ["authorization", "token-A"] }]);
47
+ });
48
+
49
+ it("should connect with url, query params and protocols returned from onConnect", async () => {
50
+ const connectSpy = vi.fn();
51
+ const socket = createSocket({
52
+ url,
53
+ adapter: WebsocketAdapter(),
54
+ queryParams: { room: "lobby" },
55
+ adapterOptions: { protocols: "v1" },
56
+ }).onConnect(({ connection, attempt }) => {
57
+ connectSpy({ connection, attempt });
58
+ return {
59
+ ...connection,
60
+ queryParams: { room: "lobby", token: "token-A" },
61
+ adapterOptions: { ...connection.adapterOptions, protocols: ["authorization", "token-A"] },
62
+ };
63
+ });
64
+
65
+ await waitForConnection(socket);
66
+
67
+ expect(connectSpy).toHaveBeenCalledTimes(1);
68
+ expect(connectSpy).toHaveBeenCalledWith({
69
+ connection: { url, queryParams: { room: "lobby" }, adapterOptions: { protocols: "v1" } },
70
+ attempt: 0,
71
+ });
72
+ expect(constructed).toEqual([{ url: `${url}?room=lobby&token=token-A`, protocols: ["authorization", "token-A"] }]);
73
+ });
74
+
75
+ it("should support async onConnect interceptors", async () => {
76
+ const socket = createSocket({ url, adapter: WebsocketAdapter() }).onConnect(async ({ connection }) => {
77
+ await new Promise((resolve) => {
78
+ setTimeout(resolve, 10);
79
+ });
80
+ return { ...connection, adapterOptions: { protocols: ["authorization", "token-A"] } };
81
+ });
82
+
83
+ await waitForConnection(socket);
84
+
85
+ expect(constructed).toEqual([{ url, protocols: ["authorization", "token-A"] }]);
86
+ expect(socket.adapter.connected).toBe(true);
87
+ });
88
+
89
+ it("should run onConnect on manual reconnect with the latest values", async () => {
90
+ let token = "token-A";
91
+ const connectSpy = vi.fn();
92
+ const socket = createSocket({ url, adapter: WebsocketAdapter() }).onConnect(({ connection, attempt }) => {
93
+ connectSpy(attempt);
94
+ return { ...connection, adapterOptions: { protocols: ["authorization", token] } };
95
+ });
96
+
97
+ await waitForConnection(socket);
98
+ expect(constructed.map((ws) => ws.protocols)).toEqual([["authorization", "token-A"]]);
99
+
100
+ // Token refreshed while the connection is alive - nothing reconnects yet
101
+ token = "token-B";
102
+ expect(connectSpy).toHaveBeenCalledTimes(1);
103
+
104
+ await socket.adapter.reconnect();
105
+ await waitForConnection(socket);
106
+
107
+ expect(connectSpy).toHaveBeenCalledTimes(2);
108
+ expect(constructed.map((ws) => ws.protocols)).toEqual([
109
+ ["authorization", "token-A"],
110
+ ["authorization", "token-B"],
111
+ ]);
112
+ });
113
+
114
+ it("should run onConnect on automatic reconnect with the reconnection attempt number", async () => {
115
+ let token = "token-A";
116
+ const attempts: number[] = [];
117
+ const socket = createSocket({ url, adapter: WebsocketAdapter(), reconnectTime: 10 }).onConnect(
118
+ ({ connection, attempt }) => {
119
+ attempts.push(attempt);
120
+ return { ...connection, adapterOptions: { protocols: ["authorization", token] } };
121
+ },
122
+ );
123
+ const disconnectedSpy = vi.fn();
124
+ socket.events.onDisconnected(disconnectedSpy);
125
+
126
+ await waitForConnection(socket);
127
+
128
+ token = "token-B";
129
+ getServer().close({ code: 1006, reason: "Abnormal closure", wasClean: false });
130
+
131
+ await waitFor(
132
+ () => {
133
+ expect(disconnectedSpy).toHaveBeenCalled();
134
+ },
135
+ { timeout: 2000 },
136
+ );
137
+
138
+ startServer();
139
+ installWebSocketSpy();
140
+
141
+ await waitFor(
142
+ () => {
143
+ expect(constructed.length).toBeGreaterThanOrEqual(2);
144
+ },
145
+ { timeout: 2000 },
146
+ );
147
+
148
+ expect(attempts[0]).toBe(0);
149
+ expect(attempts[1]).toBe(1);
150
+ expect(constructed.at(-1)?.protocols).toEqual(["authorization", "token-B"]);
151
+ });
152
+
153
+ it("should fail the attempt and emit an error when an onConnect interceptor throws", async () => {
154
+ const errorSpy = vi.fn();
155
+ const connectedSpy = vi.fn();
156
+ const socket = createSocket({
157
+ url,
158
+ adapter: WebsocketAdapter(),
159
+ adapterOptions: { autoConnect: false },
160
+ }).onConnect(async () => {
161
+ throw new Error("Cannot get token");
162
+ });
163
+ socket.events.onError(errorSpy);
164
+ socket.events.onConnected(connectedSpy);
165
+
166
+ await expect(socket.adapter.connect()).resolves.toBe(false);
167
+
168
+ expect(constructed).toEqual([]);
169
+ expect(socket.adapter.connecting).toBe(false);
170
+ expect(socket.adapter.connected).toBe(false);
171
+ expect(connectedSpy).not.toHaveBeenCalled();
172
+ expect(errorSpy).toHaveBeenCalledTimes(1);
173
+ expect(errorSpy.mock.calls[0][0].error.message).toBe("Cannot get token");
174
+ });
175
+
176
+ it("should fail the attempt and emit an error when the connection details are invalid", async () => {
177
+ const errorSpy = vi.fn();
178
+ const socket = createSocket({
179
+ url,
180
+ adapter: WebsocketAdapter(),
181
+ adapterOptions: { autoConnect: false },
182
+ }).onConnect(({ connection }) => ({ ...connection, url: "not-a-websocket-url" }));
183
+ socket.events.onError(errorSpy);
184
+
185
+ await expect(socket.adapter.connect()).resolves.toBe(false);
186
+
187
+ expect(socket.adapter.connecting).toBe(false);
188
+ expect(socket.adapter.connected).toBe(false);
189
+ expect(errorSpy).toHaveBeenCalledTimes(1);
190
+
191
+ // The adapter must be usable again after a failed attempt
192
+ socket.unstable_onConnectCallbacks = [];
193
+ await expect(socket.adapter.connect()).resolves.toBe(true);
194
+ });
195
+
196
+ it("should cancel the attempt when disconnect is called while onConnect is pending", async () => {
197
+ let resolveConnection: () => void = () => null;
198
+ let interceptorStarted: () => void = () => null;
199
+ const disconnectedSpy = vi.fn();
200
+ const socket = createSocket({
201
+ url,
202
+ adapter: WebsocketAdapter(),
203
+ adapterOptions: { autoConnect: false },
204
+ }).onConnect(
205
+ ({ connection }) =>
206
+ new Promise((resolve) => {
207
+ resolveConnection = () => resolve(connection);
208
+ interceptorStarted();
209
+ }),
210
+ );
211
+ socket.events.onDisconnected(disconnectedSpy);
212
+
213
+ const started = new Promise<void>((resolve) => {
214
+ interceptorStarted = resolve;
215
+ });
216
+ const connectPromise = socket.adapter.connect();
217
+ expect(socket.adapter.connecting).toBe(true);
218
+ await started;
219
+
220
+ await socket.adapter.disconnect();
221
+ resolveConnection();
222
+
223
+ await expect(connectPromise).resolves.toBe(false);
224
+ expect(constructed).toEqual([]);
225
+ expect(socket.adapter.connecting).toBe(false);
226
+ expect(socket.adapter.connected).toBe(false);
227
+ expect(disconnectedSpy).toHaveBeenCalledTimes(1);
228
+ });
229
+
230
+ it("should discard a superseded attempt when a newer connect starts while onConnect is pending", async () => {
231
+ const resolvers: ((value: string) => void)[] = [];
232
+ const socket = createSocket({
233
+ url,
234
+ adapter: WebsocketAdapter(),
235
+ adapterOptions: { autoConnect: false },
236
+ }).onConnect(
237
+ ({ connection }) =>
238
+ new Promise((resolve) => {
239
+ resolvers.push((token) =>
240
+ resolve({ ...connection, adapterOptions: { protocols: ["authorization", token] } }),
241
+ );
242
+ }),
243
+ );
244
+
245
+ const first = socket.adapter.connect();
246
+ await waitFor(() => expect(resolvers).toHaveLength(1));
247
+ await socket.adapter.disconnect();
248
+ const second = socket.adapter.connect();
249
+ await waitFor(() => expect(resolvers).toHaveLength(2));
250
+
251
+ resolvers[1]("token-B");
252
+ resolvers[0]("token-A");
253
+
254
+ await expect(first).resolves.toBe(false);
255
+ await expect(second).resolves.toBe(true);
256
+ expect(constructed.map((ws) => ws.protocols)).toEqual([["authorization", "token-B"]]);
257
+ });
258
+
259
+ it("should keep the open connection when connect is called again", async () => {
260
+ const connectSpy = vi.fn(({ connection }) => connection);
261
+ const socket = createSocket({ url, adapter: WebsocketAdapter() }).onConnect(connectSpy);
262
+
263
+ await waitForConnection(socket);
264
+
265
+ await expect(socket.adapter.connect()).resolves.toBe(true);
266
+
267
+ expect(connectSpy).toHaveBeenCalledTimes(1);
268
+ expect(constructed).toHaveLength(1);
269
+ expect(socket.adapter.connected).toBe(true);
270
+ });
271
+ });
@@ -251,4 +251,34 @@ describe("Websocket Adapter [ Base ]", () => {
251
251
 
252
252
  expect(result).toBeUndefined();
253
253
  });
254
+
255
+ it("should cancel the scheduled automatic reconnect when disconnect is called", async () => {
256
+ const reconnectingSpy = vi.fn();
257
+ const disconnectedSpy = vi.fn();
258
+ const newSocket = createSocket({
259
+ url,
260
+ adapter: WebsocketAdapter(),
261
+ reconnectTime: 50,
262
+ adapterOptions: { autoConnect: false },
263
+ });
264
+ newSocket.events.onReconnecting(reconnectingSpy);
265
+ newSocket.events.onDisconnected(disconnectedSpy);
266
+
267
+ await newSocket.adapter.connect();
268
+ await waitForConnection(newSocket);
269
+
270
+ getServer().close({ code: 1006, reason: "Abnormal closure", wasClean: false });
271
+ await waitFor(() => {
272
+ expect(disconnectedSpy).toHaveBeenCalled();
273
+ });
274
+
275
+ await newSocket.adapter.disconnect();
276
+ startServer();
277
+
278
+ await new Promise((resolve) => {
279
+ setTimeout(resolve, 150);
280
+ });
281
+ expect(reconnectingSpy).not.toHaveBeenCalled();
282
+ expect(newSocket.adapter.connected).toBe(false);
283
+ });
254
284
  });
@@ -58,12 +58,20 @@ describe("Socket [ Base ]", () => {
58
58
  });
59
59
  it("should allow to connect", async () => {
60
60
  const spy = vi.fn();
61
- socket.events.onConnected(spy);
62
- socket.adapter.connect();
61
+ const newSocket = createSocket({ adapterOptions: { autoConnect: false } });
62
+ newSocket.events.onConnected(spy);
63
+ newSocket.adapter.connect();
63
64
  await waitFor(() => {
64
65
  expect(spy).toHaveBeenCalledTimes(1);
65
66
  });
66
67
  });
68
+ it("should keep the connection when connect is called on a connected socket", async () => {
69
+ const spy = vi.fn();
70
+ socket.events.onConnected(spy);
71
+ await expect(socket.adapter.connect()).resolves.toBe(true);
72
+ expect(spy).toHaveBeenCalledTimes(0);
73
+ expect(socket.adapter.connected).toBe(true);
74
+ });
67
75
  it("should allow to disconnect", async () => {
68
76
  const spy = vi.fn();
69
77
  socket.events.onDisconnected(spy);
@@ -46,7 +46,8 @@ describe("Socket Client [ Callbacks ]", () => {
46
46
 
47
47
  it("should trigger onMessage callbacks", async () => {
48
48
  const spy = vi.fn().mockImplementation((res) => res);
49
- createSocket().onMessage(spy);
49
+ const socket = createSocket().onMessage(spy);
50
+ await waitForConnection(socket);
50
51
  getServer().send({ data: { topic: "test", data: "test" } });
51
52
 
52
53
  await waitFor(() => {
@@ -87,4 +88,27 @@ describe("Socket Client [ Callbacks ]", () => {
87
88
  expect(spy).toHaveBeenCalledTimes(1);
88
89
  });
89
90
  });
91
+
92
+ it("should register onConnect callbacks and allow chaining", () => {
93
+ const callback = vi.fn(({ connection }) => connection);
94
+ const socket = createSocket({ adapterOptions: { autoConnect: false } });
95
+
96
+ const result = socket.onConnect(callback);
97
+
98
+ expect(result).toBe(socket);
99
+ expect(socket.unstable_onConnectCallbacks).toEqual([callback]);
100
+ });
101
+
102
+ it("should trigger onConnect callbacks before connecting", async () => {
103
+ const spy = vi.fn(({ connection }) => connection);
104
+ const socket = createSocket().onConnect(spy);
105
+
106
+ await waitForConnection(socket);
107
+
108
+ expect(spy).toHaveBeenCalledTimes(1);
109
+ expect(spy).toHaveBeenCalledWith({
110
+ connection: { url: "ws://localhost:1234", queryParams: undefined, adapterOptions: {} },
111
+ attempt: 0,
112
+ });
113
+ });
90
114
  });
@@ -16,7 +16,7 @@ describe("Socket [ Methods ]", () => {
16
16
 
17
17
  it("should allow to set new query params stringify", async () => {
18
18
  const method = () => "testing";
19
- const socket = new Socket({ url: "ws://localhost:1234" });
19
+ const socket = new Socket({ url: "ws://localhost:1234", adapterOptions: { autoConnect: false } });
20
20
  socket.adapter.setQueryParamsMapper(method);
21
21
  const queryParams = socket.adapter.unstable_queryParamsMapper({ test: 1 });
22
22
  expect(queryParams).toBe("testing");
@@ -1,6 +1,6 @@
1
1
  import { createWebsocketMockingServer } from "@hyper-fetch/testing";
2
2
  import type { EmitterInstance } from "emitter";
3
- import { interceptEmitter, interceptListener, Socket } from "socket";
3
+ import { interceptConnection, interceptEmitter, interceptListener, Socket } from "socket";
4
4
 
5
5
  describe("Socket [ Utils ]", () => {
6
6
  const { url, startServer, stopServer } = createWebsocketMockingServer();
@@ -26,4 +26,41 @@ describe("Socket [ Utils ]", () => {
26
26
  socket.onSend(() => null as any);
27
27
  expect(() => interceptEmitter(socket.unstable_onSendCallbacks, {} as EmitterInstance)).toThrow();
28
28
  });
29
+
30
+ it("should throw on invalid connect interceptor", async () => {
31
+ const socket = new Socket({ url, adapterOptions: { autoConnect: false } });
32
+
33
+ socket.onConnect(() => null as any);
34
+ await expect(
35
+ interceptConnection(socket.unstable_onConnectCallbacks, {
36
+ connection: { url, queryParams: undefined, adapterOptions: undefined },
37
+ attempt: 0,
38
+ }),
39
+ ).rejects.toThrow("Connect modifier must return connection");
40
+ });
41
+
42
+ it("should chain connect interceptors sequentially", async () => {
43
+ const socket = new Socket({ url, adapterOptions: { autoConnect: false } });
44
+ const order: string[] = [];
45
+
46
+ socket.onConnect(async ({ connection }) => {
47
+ await new Promise((resolve) => {
48
+ setTimeout(resolve, 5);
49
+ });
50
+ order.push("first");
51
+ return { ...connection, url: `${connection.url}/1` };
52
+ });
53
+ socket.onConnect(({ connection }) => {
54
+ order.push("second");
55
+ return { ...connection, url: `${connection.url}/2` };
56
+ });
57
+
58
+ const result = await interceptConnection(socket.unstable_onConnectCallbacks, {
59
+ connection: { url, queryParams: undefined, adapterOptions: undefined },
60
+ attempt: 0,
61
+ });
62
+
63
+ expect(order).toEqual(["first", "second"]);
64
+ expect(result.url).toBe(`${url}/1/2`);
65
+ });
29
66
  });
@@ -1,14 +1,17 @@
1
1
  import { SocketAdapterInstance } from '.';
2
2
  import { EmitterInstance } from '../emitter';
3
3
  import { ListenerCallbackType, ListenerOfAdapter } from '../listener';
4
- import { Socket } from '../socket';
5
- import { ExtractAdapterExtraType } from '../types';
4
+ import { Socket, SocketConnectionType } from '../socket';
5
+ import { ExtractAdapterExtraType, ExtractAdapterQueryParamsType } from '../types';
6
6
  export declare const getAdapterBindings: <T extends SocketAdapterInstance>(socket: Socket<T>) => {
7
7
  socket: Socket<T>;
8
8
  adapter: T;
9
9
  logger: import('@hyper-fetch/core').LoggerMethods;
10
- getQueryParams: () => any;
11
- onConnect: () => boolean;
10
+ getQueryParams: (queryParams?: ExtractAdapterQueryParamsType<T> | undefined) => any;
11
+ onConnect: () => Promise<SocketConnectionType<T> | null>;
12
+ onConnectFailed: ({ error }: {
13
+ error: Error;
14
+ }) => void;
12
15
  onReconnect: ({ disconnect, connect, }: {
13
16
  disconnect: () => Promise<any>;
14
17
  connect: () => Promise<any>;
@@ -1 +1 @@
1
- {"version":3,"file":"adapter.bindings.d.ts","sourceRoot":"","sources":["../../src/adapter/adapter.bindings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,KAAK,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AACxE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,OAAO,CAAC;AAErD,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,qBAAqB,EAAE,QAAQ,MAAM,CAAC,CAAC,CAAC;;;;;qBAM7D,OAAO;4CAoC1B;QACD,UAAU,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;QAC/B,OAAO,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;KAC7B,KAAG,OAAO,CAAC,OAAO,CAAC;wBAnBK,OAAO;mDA+D7B;QACD,QAAQ,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;QAC9C,QAAQ,EAAE,oBAAoB,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QACvC,SAAS,CAAC,EAAE,YAAY,CAAC;KAC1B,KAAG,CAAC,MAAM,IAAI,CAAC;0BAamB;QAAE,OAAO,EAAE,eAAe,CAAA;KAAE,KAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;kBAiB5E,SAAS,SAAS,KAAK,sBAAsB;QAAE,OAAO,EAAE,eAAe,CAAC;QAAC,KAAK,EAAE,SAAS,CAAA;KAAE;;;yBA6BpF;QAAE,KAAK,EAAE,KAAK,CAAA;KAAE;sCAQH;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,GAAG,CAAC;QAAC,KAAK,EAAE,uBAAuB,CAAC,CAAC,CAAC,CAAA;KAAE;CA2BzG,CAAC"}
1
+ {"version":3,"file":"adapter.bindings.d.ts","sourceRoot":"","sources":["../../src/adapter/adapter.bindings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,KAAK,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AACxE,OAAO,KAAK,EAAE,MAAM,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAC3D,OAAO,KAAK,EAAE,uBAAuB,EAAE,6BAA6B,EAAE,MAAM,OAAO,CAAC;AAEpF,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,qBAAqB,EAAE,QAAQ,MAAM,CAAC,CAAC,CAAC;;;;mCAkO9C,6BAA6B,CAAC,CAAC,CAAC,GAAG,SAAS;qBAhMrD,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;iCAZ/B;QAAE,KAAK,EAAE,KAAK,CAAA;KAAE;4CAqFjD;QACD,UAAU,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;QAC/B,OAAO,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;KAC7B,KAAG,OAAO,CAAC,OAAO,CAAC;wBAnBK,OAAO;mDA+D7B;QACD,QAAQ,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;QAC9C,QAAQ,EAAE,oBAAoB,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QACvC,SAAS,CAAC,EAAE,YAAY,CAAC;KAC1B,KAAG,CAAC,MAAM,IAAI,CAAC;0BAamB;QAAE,OAAO,EAAE,eAAe,CAAA;KAAE,KAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;kBAiB5E,SAAS,SAAS,KAAK,sBAAsB;QAAE,OAAO,EAAE,eAAe,CAAC;QAAC,KAAK,EAAE,SAAS,CAAA;KAAE;;;yBApLpF;QAAE,KAAK,EAAE,KAAK,CAAA;KAAE;sCAiNH;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,GAAG,CAAC;QAAC,KAAK,EAAE,uBAAuB,CAAC,CAAC,CAAC,CAAA;KAAE;CA6BzG,CAAC"}
@@ -1 +1 @@
1
- {"version":3,"file":"sse-adapter.d.ts","sourceRoot":"","sources":["../../src/adapter-sse/sse-adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAEzD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAKhD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAGjE;;;;GAIG;AAEH,MAAM,MAAM,2BAA2B,GAAG,aAAa,CACrD,YAAY,CAAC,GAAG,CAAC,EACjB,qBAAqB,EACrB,SAAS,EACT,SAAS,EACT,eAAe,GAAG,MAAM,EACxB,OAAO,oBAAoB,CAC5B,CAAC;AAEF,8FAA8F;AAC9F,eAAO,MAAM,uBAAuB,QAAO,2BA4JtC,CAAC"}
1
+ {"version":3,"file":"sse-adapter.d.ts","sourceRoot":"","sources":["../../src/adapter-sse/sse-adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAc,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAEzD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAKhD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAGjE;;;;GAIG;AAEH,MAAM,MAAM,2BAA2B,GAAG,aAAa,CACrD,YAAY,CAAC,GAAG,CAAC,EACjB,qBAAqB,EACrB,SAAS,EACT,SAAS,EACT,eAAe,GAAG,MAAM,EACxB,OAAO,oBAAoB,CAC5B,CAAC;AAEF,8FAA8F;AAC9F,eAAO,MAAM,uBAAuB,QAAO,2BAqKtC,CAAC"}
@@ -1 +1 @@
1
- {"version":3,"file":"websocket-adapter.d.ts","sourceRoot":"","sources":["../../src/adapter-websockets/websocket-adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAQ,MAAM,mBAAmB,CAAC;AAE/D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAMhD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,2BAA2B,CAAC;AAG7E;;;;GAIG;AAEH,MAAM,MAAM,oBAAoB,GAAG,aAAa,CAC9C,YAAY,CAAC,GAAG,CAAC,EACjB,2BAA2B,EAC3B,SAAS,EACT,SAAS,EACT,eAAe,GAAG,MAAM,EACxB,OAAO,oBAAoB,CAC5B,CAAC;AAEF,8EAA8E;AAC9E,eAAO,MAAM,gBAAgB,QAAO,oBAsO/B,CAAC"}
1
+ {"version":3,"file":"websocket-adapter.d.ts","sourceRoot":"","sources":["../../src/adapter-websockets/websocket-adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAc,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,EAAE,oBAAoB,EAAQ,MAAM,mBAAmB,CAAC;AAE/D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAMhD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,2BAA2B,CAAC;AAG7E;;;;GAIG;AAEH,MAAM,MAAM,oBAAoB,GAAG,aAAa,CAC9C,YAAY,CAAC,GAAG,CAAC,EACjB,2BAA2B,EAC3B,SAAS,EACT,SAAS,EACT,eAAe,GAAG,MAAM,EACxB,OAAO,oBAAoB,CAC5B,CAAC;AAEF,8EAA8E;AAC9E,eAAO,MAAM,gBAAgB,QAAO,oBAwP/B,CAAC"}