@hyper-fetch/sockets 8.0.0 → 8.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (41) hide show
  1. package/__tests__/e2e/e2e.callbacks.spec.ts +224 -0
  2. package/__tests__/e2e/e2e.connection.spec.ts +162 -0
  3. package/__tests__/e2e/e2e.edge-cases.spec.ts +232 -0
  4. package/__tests__/e2e/e2e.emitters.spec.ts +160 -0
  5. package/__tests__/e2e/e2e.heartbeat.spec.ts +162 -0
  6. package/__tests__/e2e/e2e.listeners.spec.ts +215 -0
  7. package/__tests__/e2e/e2e.reconnection.spec.ts +240 -0
  8. package/__tests__/e2e/e2e.sse.spec.ts +191 -0
  9. package/__tests__/features/adapter/adapter.sse.connection.spec.ts +1 -1
  10. package/__tests__/features/sdk/sdk.base.spec.ts +125 -0
  11. package/__tests__/features/sdk/sdk.configuration.spec.ts +341 -0
  12. package/__tests__/vitest.setup.ts +19 -6
  13. package/dist/adapter/adapter.bindings.d.ts.map +1 -1
  14. package/dist/adapter-sse/sse-adapter.d.ts.map +1 -1
  15. package/dist/adapter-sse/sse-adapter.utils.d.ts +1 -1
  16. package/dist/adapter-sse/sse-adapter.utils.d.ts.map +1 -1
  17. package/dist/adapter-websockets/websocket-adapter.utils.d.ts +1 -1
  18. package/dist/adapter-websockets/websocket-adapter.utils.d.ts.map +1 -1
  19. package/dist/index.d.ts +1 -0
  20. package/dist/index.d.ts.map +1 -1
  21. package/dist/index.mjs +153 -32
  22. package/dist/index.mjs.map +1 -1
  23. package/dist/sdk/index.d.ts +2 -0
  24. package/dist/sdk/index.d.ts.map +1 -0
  25. package/dist/sdk/sdk.d.ts +70 -0
  26. package/dist/sdk/sdk.d.ts.map +1 -0
  27. package/dist/socket/index.d.ts +1 -0
  28. package/dist/socket/index.d.ts.map +1 -1
  29. package/dist/socket/socket.create.d.ts +5 -0
  30. package/dist/socket/socket.create.d.ts.map +1 -0
  31. package/package.json +1 -1
  32. package/src/adapter/adapter.bindings.ts +15 -6
  33. package/src/adapter-sse/sse-adapter.ts +6 -14
  34. package/src/adapter-sse/sse-adapter.utils.ts +8 -7
  35. package/src/adapter-websockets/websocket-adapter.utils.ts +5 -4
  36. package/src/index.ts +1 -0
  37. package/src/sdk/index.ts +1 -0
  38. package/src/sdk/sdk.ts +268 -0
  39. package/src/socket/index.ts +1 -0
  40. package/src/socket/socket.create.ts +10 -0
  41. package/vite.config.ts +1 -0
@@ -0,0 +1,224 @@
1
+ /**
2
+ * @vitest-environment node
3
+ */
4
+ import { Socket } from "@hyper-fetch/sockets";
5
+ import { createWebsocketE2EServer, sleep, waitForConnection } from "@hyper-fetch/testing";
6
+
7
+ describe("E2E [ WebSocket Callbacks & Interceptors ]", () => {
8
+ it("should fire onConnected callback", async () => {
9
+ const { startServer, stopServer } = createWebsocketE2EServer();
10
+ const url = await startServer();
11
+
12
+ let fired = false;
13
+ const socket = new Socket({ url, adapterOptions: { autoConnect: false } });
14
+ socket.onConnected(() => {
15
+ fired = true;
16
+ });
17
+
18
+ await socket.connect();
19
+ await waitForConnection(socket);
20
+
21
+ expect(fired).toBe(true);
22
+
23
+ await socket.disconnect();
24
+ await stopServer();
25
+ });
26
+
27
+ it("should fire onDisconnected callback", async () => {
28
+ const { startServer, stopServer } = createWebsocketE2EServer();
29
+ const url = await startServer();
30
+
31
+ const socket = new Socket({ url });
32
+ await waitForConnection(socket);
33
+
34
+ let fired = false;
35
+ socket.onDisconnected(() => {
36
+ fired = true;
37
+ });
38
+
39
+ await socket.disconnect();
40
+ await sleep(100);
41
+
42
+ expect(fired).toBe(true);
43
+
44
+ await stopServer();
45
+ });
46
+
47
+ it("should fire onReconnect callback on each attempt", async () => {
48
+ const { startServer, stopServer, terminateAllClients } = createWebsocketE2EServer();
49
+ const url = await startServer();
50
+
51
+ const socket = new Socket({ url, reconnectTime: 150, reconnect: 3 });
52
+ await waitForConnection(socket);
53
+
54
+ let reconnectCount = 0;
55
+ socket.onReconnect(() => {
56
+ reconnectCount += 1;
57
+ });
58
+
59
+ terminateAllClients();
60
+ await sleep(1000);
61
+
62
+ expect(reconnectCount).toBeGreaterThanOrEqual(1);
63
+
64
+ await socket.disconnect();
65
+ await stopServer();
66
+ });
67
+
68
+ it("should fire onReconnectFailed when attempts are exhausted", async () => {
69
+ const wsServer = createWebsocketE2EServer();
70
+ const url = await wsServer.startServer();
71
+
72
+ const socket = new Socket({ url, reconnect: 1, reconnectTime: 200 });
73
+ await waitForConnection(socket);
74
+
75
+ let failedFired = false;
76
+ socket.onReconnectFailed(() => {
77
+ failedFired = true;
78
+ });
79
+
80
+ // Stop server completely so reconnect fails
81
+ await wsServer.stopServer();
82
+ await sleep(3000);
83
+
84
+ expect(failedFired).toBe(true);
85
+ });
86
+
87
+ it("should fire onError callback on connection errors", async () => {
88
+ const { startServer, stopServer, terminateAllClients } = createWebsocketE2EServer();
89
+ const url = await startServer();
90
+
91
+ const socket = new Socket({ url, reconnectTime: 200 });
92
+ await waitForConnection(socket);
93
+
94
+ const errors: Error[] = [];
95
+ socket.onError(({ error }: { error: Error }) => {
96
+ errors.push(error);
97
+ });
98
+
99
+ terminateAllClients();
100
+ await sleep(500);
101
+
102
+ expect(errors.length).toBeGreaterThanOrEqual(1);
103
+
104
+ await socket.disconnect();
105
+ await stopServer();
106
+ });
107
+
108
+ it("should intercept incoming messages with onMessage", async () => {
109
+ const { startServer, stopServer, sendToAll } = createWebsocketE2EServer();
110
+ const url = await startServer();
111
+
112
+ const socket = new Socket({ url, adapterOptions: { autoConnect: false } });
113
+ socket.onMessage(({ event }: any) => {
114
+ return {
115
+ ...event,
116
+ data: { ...event.data, intercepted: true },
117
+ extra: event.extra,
118
+ };
119
+ });
120
+
121
+ await socket.connect();
122
+ await waitForConnection(socket);
123
+
124
+ const listener = socket.createListener<{ value: number; intercepted?: boolean }>()({ topic: "intercept-test" });
125
+
126
+ const received: any[] = [];
127
+ listener.listen(({ data }) => received.push(data));
128
+
129
+ await sleep(50);
130
+ sendToAll("intercept-test", { value: 42 });
131
+ await sleep(200);
132
+
133
+ expect(received.length).toBeGreaterThanOrEqual(1);
134
+
135
+ await socket.disconnect();
136
+ await stopServer();
137
+ });
138
+
139
+ it("should intercept outgoing messages with onSend", async () => {
140
+ const { startServer, stopServer, waitForMessage } = createWebsocketE2EServer();
141
+ const url = await startServer();
142
+
143
+ const socket = new Socket({ url, adapterOptions: { autoConnect: false } });
144
+ socket.onSend(({ emitter }) => {
145
+ return emitter.clone({ payload: { ...(emitter.payload as any), modified: true } });
146
+ });
147
+
148
+ await socket.connect();
149
+ await waitForConnection(socket);
150
+
151
+ const emitter = socket.createEmitter<{ value: number }>()({ topic: "send-intercept" });
152
+
153
+ const messagePromise = waitForMessage();
154
+ await emitter.setPayload({ value: 10 }).emit();
155
+ const received = await messagePromise;
156
+
157
+ expect(received.data).toMatchObject({ value: 10, modified: true });
158
+
159
+ await socket.disconnect();
160
+ await stopServer();
161
+ });
162
+
163
+ it("should emit events accessible via socket.events bus", async () => {
164
+ const { startServer, stopServer, sendToAll } = createWebsocketE2EServer();
165
+ const url = await startServer();
166
+
167
+ const socket = new Socket({ url, adapterOptions: { autoConnect: false } });
168
+
169
+ const connectedEvents: any[] = [];
170
+ const disconnectedEvents: any[] = [];
171
+ const listenerEvents: any[] = [];
172
+
173
+ socket.events.onConnected(() => connectedEvents.push(true));
174
+ socket.events.onDisconnected(() => disconnectedEvents.push(true));
175
+ socket.events.onListenerEvent(({ topic, data }: any) => listenerEvents.push({ topic, data }));
176
+
177
+ await socket.connect();
178
+ await waitForConnection(socket);
179
+ expect(connectedEvents).toHaveLength(1);
180
+
181
+ const listener = socket.createListener<{ x: number }>()({ topic: "event-bus" });
182
+ listener.listen(() => {});
183
+
184
+ await sleep(50);
185
+ sendToAll("event-bus", { x: 1 });
186
+ await sleep(200);
187
+
188
+ expect(listenerEvents.length).toBeGreaterThanOrEqual(1);
189
+ expect(listenerEvents[0]).toMatchObject({ topic: "event-bus", data: { x: 1 } });
190
+
191
+ await socket.disconnect();
192
+ await sleep(100);
193
+
194
+ expect(disconnectedEvents).toHaveLength(1);
195
+
196
+ await stopServer();
197
+ });
198
+
199
+ it("should support chaining multiple callbacks", async () => {
200
+ const { startServer, stopServer } = createWebsocketE2EServer();
201
+ const url = await startServer();
202
+
203
+ const calls: string[] = [];
204
+
205
+ const socket = new Socket({ url, adapterOptions: { autoConnect: false } });
206
+ socket
207
+ .onConnected(() => calls.push("connected-1"))
208
+ .onConnected(() => calls.push("connected-2"))
209
+ .onDisconnected(() => calls.push("disconnected-1"))
210
+ .onDisconnected(() => calls.push("disconnected-2"));
211
+
212
+ await socket.connect();
213
+ await waitForConnection(socket);
214
+
215
+ expect(calls).toStrictEqual(["connected-1", "connected-2"]);
216
+
217
+ await socket.disconnect();
218
+ await sleep(100);
219
+
220
+ expect(calls).toStrictEqual(["connected-1", "connected-2", "disconnected-1", "disconnected-2"]);
221
+
222
+ await stopServer();
223
+ });
224
+ });
@@ -0,0 +1,162 @@
1
+ /**
2
+ * @vitest-environment node
3
+ */
4
+ import { Socket } from "@hyper-fetch/sockets";
5
+ import { createWebsocketE2EServer, sleep, waitForConnection } from "@hyper-fetch/testing";
6
+
7
+ const { startServer, stopServer, waitForClient } = createWebsocketE2EServer();
8
+
9
+ describe("E2E [ WebSocket Connection ]", () => {
10
+ let url: string;
11
+
12
+ beforeAll(async () => {
13
+ url = await startServer();
14
+ });
15
+
16
+ afterAll(async () => {
17
+ await stopServer();
18
+ });
19
+
20
+ it("should connect to a real WebSocket server", async () => {
21
+ const socket = new Socket({ url, adapterOptions: { autoConnect: false } });
22
+
23
+ expect(socket.adapter.connected).toBe(false);
24
+
25
+ await socket.connect();
26
+ await waitForConnection(socket);
27
+
28
+ expect(socket.adapter.connected).toBe(true);
29
+ await socket.disconnect();
30
+ });
31
+
32
+ it("should fire connecting and connected events in order", async () => {
33
+ const events: string[] = [];
34
+
35
+ const socket = new Socket({ url, adapterOptions: { autoConnect: false } });
36
+
37
+ socket.events.onConnecting(({ connecting }) => {
38
+ if (connecting) events.push("connecting");
39
+ });
40
+ socket.events.onConnected(() => {
41
+ events.push("connected");
42
+ });
43
+
44
+ await socket.connect();
45
+ await waitForConnection(socket);
46
+
47
+ expect(events).toStrictEqual(["connecting", "connected"]);
48
+ await socket.disconnect();
49
+ });
50
+
51
+ it("should not connect when autoConnect is false", async () => {
52
+ const socket = new Socket({ url, adapterOptions: { autoConnect: false } });
53
+ await sleep(200);
54
+
55
+ expect(socket.adapter.connected).toBe(false);
56
+ expect(socket.adapter.connecting).toBe(false);
57
+
58
+ await socket.connect();
59
+ await waitForConnection(socket);
60
+
61
+ expect(socket.adapter.connected).toBe(true);
62
+ await socket.disconnect();
63
+ });
64
+
65
+ it("should auto-connect by default", async () => {
66
+ const socket = new Socket({ url });
67
+
68
+ await waitForConnection(socket);
69
+
70
+ expect(socket.adapter.connected).toBe(true);
71
+ await socket.disconnect();
72
+ });
73
+
74
+ it("should pass query params in the URL", async () => {
75
+ const clientPromise = waitForClient();
76
+ const socket = new Socket({
77
+ url,
78
+ queryParams: { token: "abc123", mode: "test" },
79
+ });
80
+
81
+ const serverClient = await clientPromise;
82
+ await waitForConnection(socket);
83
+
84
+ // The ws server client doesn't directly expose URL, but connection succeeded with params
85
+ expect(socket.adapter.connected).toBe(true);
86
+
87
+ // Verify by checking the server received the connection
88
+ expect(serverClient).toBeDefined();
89
+ await socket.disconnect();
90
+ });
91
+
92
+ it("should disconnect manually", async () => {
93
+ const socket = new Socket({ url });
94
+ await waitForConnection(socket);
95
+
96
+ expect(socket.adapter.connected).toBe(true);
97
+
98
+ let disconnected = false;
99
+ socket.events.onDisconnected(() => {
100
+ disconnected = true;
101
+ });
102
+
103
+ await socket.disconnect();
104
+ await sleep(100);
105
+
106
+ expect(socket.adapter.connected).toBe(false);
107
+ expect(disconnected).toBe(true);
108
+ });
109
+
110
+ it("should not auto-reconnect on clean close (code 1000)", async () => {
111
+ const socket = new Socket({ url, reconnectTime: 100 });
112
+ await waitForConnection(socket);
113
+
114
+ let reconnectAttempted = false;
115
+ socket.onReconnect(() => {
116
+ reconnectAttempted = true;
117
+ });
118
+
119
+ await socket.disconnect();
120
+ await sleep(300);
121
+
122
+ expect(reconnectAttempted).toBe(false);
123
+ });
124
+
125
+ it("should support multiple sockets to the same server", async () => {
126
+ const socket1 = new Socket({ url });
127
+ const socket2 = new Socket({ url });
128
+
129
+ await waitForConnection(socket1);
130
+ await waitForConnection(socket2);
131
+
132
+ expect(socket1.adapter.connected).toBe(true);
133
+ expect(socket2.adapter.connected).toBe(true);
134
+
135
+ await socket1.disconnect();
136
+
137
+ expect(socket1.adapter.connected).toBe(false);
138
+ expect(socket2.adapter.connected).toBe(true);
139
+
140
+ await socket2.disconnect();
141
+ });
142
+
143
+ it("should fire disconnected event on server-initiated clean close", async () => {
144
+ const { startServer: startLocal, stopServer: stopLocal, closeAllClients } = createWebsocketE2EServer();
145
+ const localUrl = await startLocal();
146
+
147
+ const socket = new Socket({ url: localUrl, reconnectTime: 100 });
148
+ await waitForConnection(socket);
149
+
150
+ let disconnectedFired = false;
151
+ socket.events.onDisconnected(() => {
152
+ disconnectedFired = true;
153
+ });
154
+
155
+ closeAllClients(1000, "normal close");
156
+ await sleep(200);
157
+
158
+ expect(disconnectedFired).toBe(true);
159
+
160
+ await stopLocal();
161
+ });
162
+ });
@@ -0,0 +1,232 @@
1
+ /* eslint-disable no-await-in-loop */
2
+ /**
3
+ * @vitest-environment node
4
+ */
5
+ import { Socket } from "@hyper-fetch/sockets";
6
+ import { createWebsocketE2EServer, sleep, waitForConnection } from "@hyper-fetch/testing";
7
+
8
+ describe("E2E [ WebSocket Edge Cases ]", () => {
9
+ it("should handle rapid connect/disconnect cycles without crashing", async () => {
10
+ const { startServer, stopServer } = createWebsocketE2EServer();
11
+ const url = await startServer();
12
+
13
+ const socket = new Socket({ url, adapterOptions: { autoConnect: false }, reconnectTime: 100 });
14
+
15
+ for (let i = 0; i < 5; i += 1) {
16
+ await socket.connect();
17
+ await sleep(50);
18
+ await socket.disconnect();
19
+ await sleep(50);
20
+ }
21
+
22
+ // Should be in a clean disconnected state
23
+ expect(socket.adapter.connected).toBe(false);
24
+ expect(socket.adapter.connecting).toBe(false);
25
+
26
+ // Should still be able to connect
27
+ await socket.connect();
28
+ await waitForConnection(socket, 3000);
29
+ expect(socket.adapter.connected).toBe(true);
30
+
31
+ await socket.disconnect();
32
+ await stopServer();
33
+ });
34
+
35
+ it("should survive malformed JSON from server", async () => {
36
+ const { startServer, stopServer, sendRawToAll } = createWebsocketE2EServer();
37
+ const url = await startServer();
38
+
39
+ const socket = new Socket({ url });
40
+ await waitForConnection(socket);
41
+
42
+ const errors: any[] = [];
43
+ socket.onError(({ error }: any) => errors.push(error));
44
+
45
+ // Send malformed JSON
46
+ sendRawToAll("this is not json{{{");
47
+ await sleep(200);
48
+
49
+ // Connection should still be alive
50
+ expect(socket.adapter.connected).toBe(true);
51
+
52
+ await socket.disconnect();
53
+ await stopServer();
54
+ });
55
+
56
+ it("should handle multiple concurrent sockets independently", async () => {
57
+ const { startServer, stopServer, sendToAll } = createWebsocketE2EServer();
58
+ const url = await startServer();
59
+
60
+ const socket1 = new Socket({ url });
61
+ const socket2 = new Socket({ url });
62
+ const socket3 = new Socket({ url });
63
+
64
+ await waitForConnection(socket1);
65
+ await waitForConnection(socket2);
66
+ await waitForConnection(socket3);
67
+
68
+ const received1: any[] = [];
69
+ const received2: any[] = [];
70
+ const received3: any[] = [];
71
+
72
+ socket1
73
+ .createListener<{ v: number }>()({ topic: "multi" })
74
+ .listen(({ data }) => received1.push(data));
75
+ socket2
76
+ .createListener<{ v: number }>()({ topic: "multi" })
77
+ .listen(({ data }) => received2.push(data));
78
+ socket3
79
+ .createListener<{ v: number }>()({ topic: "multi" })
80
+ .listen(({ data }) => received3.push(data));
81
+
82
+ await sleep(50);
83
+ sendToAll("multi", { v: 1 });
84
+ await sleep(200);
85
+
86
+ expect(received1).toStrictEqual([{ v: 1 }]);
87
+ expect(received2).toStrictEqual([{ v: 1 }]);
88
+ expect(received3).toStrictEqual([{ v: 1 }]);
89
+
90
+ // Disconnect one, others should still work
91
+ await socket2.disconnect();
92
+
93
+ sendToAll("multi", { v: 2 });
94
+ await sleep(200);
95
+
96
+ expect(received1).toStrictEqual([{ v: 1 }, { v: 2 }]);
97
+ expect(received2).toStrictEqual([{ v: 1 }]); // No new message
98
+ expect(received3).toStrictEqual([{ v: 1 }, { v: 2 }]);
99
+
100
+ await socket1.disconnect();
101
+ await socket3.disconnect();
102
+ await stopServer();
103
+ });
104
+
105
+ it("should handle disconnect during reconnection gracefully", async () => {
106
+ const { startServer, stopServer } = createWebsocketE2EServer();
107
+ const url = await startServer();
108
+
109
+ const socket = new Socket({ url, reconnectTime: 500 });
110
+ await waitForConnection(socket);
111
+
112
+ // Stop the server so reconnect cannot succeed
113
+ await stopServer();
114
+ await sleep(100);
115
+
116
+ // Disconnect while reconnection is pending
117
+ await socket.disconnect();
118
+ await sleep(800);
119
+
120
+ expect(socket.adapter.connected).toBe(false);
121
+ });
122
+
123
+ it("should handle server sending empty message", async () => {
124
+ const { startServer, stopServer, sendRawToAll } = createWebsocketE2EServer();
125
+ const url = await startServer();
126
+
127
+ const socket = new Socket({ url });
128
+ await waitForConnection(socket);
129
+
130
+ sendRawToAll("");
131
+ await sleep(200);
132
+
133
+ // Should not crash
134
+ expect(socket.adapter.connected).toBe(true);
135
+
136
+ await socket.disconnect();
137
+ await stopServer();
138
+ });
139
+
140
+ it("should handle many listeners without issues", async () => {
141
+ const { startServer, stopServer, sendToAll } = createWebsocketE2EServer();
142
+ const url = await startServer();
143
+
144
+ const socket = new Socket({ url });
145
+ await waitForConnection(socket);
146
+
147
+ const listenerCount = 100;
148
+ const receivedCounts = new Array(listenerCount).fill(0);
149
+
150
+ for (let i = 0; i < listenerCount; i += 1) {
151
+ const idx = i;
152
+ socket
153
+ .createListener<{ v: number }>()({ topic: "many-listeners" })
154
+ .listen(() => {
155
+ receivedCounts[idx] += 1;
156
+ });
157
+ }
158
+
159
+ await sleep(50);
160
+ sendToAll("many-listeners", { v: 1 });
161
+ await sleep(300);
162
+
163
+ // All listeners should have received the message
164
+ receivedCounts.forEach((count) => {
165
+ expect(count).toBe(1);
166
+ });
167
+
168
+ await socket.disconnect();
169
+ await stopServer();
170
+ });
171
+
172
+ it("should handle connecting to an unreachable server", async () => {
173
+ const socket = new Socket({
174
+ url: "ws://127.0.0.1:19999",
175
+ reconnect: 1,
176
+ reconnectTime: 100,
177
+ adapterOptions: { autoConnect: false },
178
+ });
179
+
180
+ let errorFired = false;
181
+
182
+ socket.onError(() => {
183
+ errorFired = true;
184
+ });
185
+
186
+ await socket.connect();
187
+ await sleep(1000);
188
+
189
+ expect(errorFired).toBe(true);
190
+ });
191
+
192
+ it("should handle bidirectional communication", async () => {
193
+ const { startServer, stopServer, onMessage } = createWebsocketE2EServer();
194
+ const url = await startServer();
195
+
196
+ const socket = new Socket({ url });
197
+ await waitForConnection(socket);
198
+
199
+ // Set up echo behavior on server
200
+ const serverReceived: any[] = [];
201
+ onMessage((msg, ws) => {
202
+ serverReceived.push(msg);
203
+ if (msg.topic === "echo-request") {
204
+ ws.send(JSON.stringify({ topic: "echo-response", data: msg.data }));
205
+ }
206
+ });
207
+
208
+ // Set up client listener for response
209
+ const clientReceived: any[] = [];
210
+ socket
211
+ .createListener<{ message: string }>()({ topic: "echo-response" })
212
+ .listen(({ data }) => {
213
+ clientReceived.push(data);
214
+ });
215
+
216
+ await sleep(50);
217
+
218
+ // Client sends, server echoes back
219
+ const emitter = socket.createEmitter<{ message: string }>()({ topic: "echo-request" });
220
+ await emitter.setPayload({ message: "ping" }).emit();
221
+
222
+ await sleep(300);
223
+
224
+ expect(serverReceived).toHaveLength(1);
225
+ expect(serverReceived[0].data).toStrictEqual({ message: "ping" });
226
+ expect(clientReceived).toHaveLength(1);
227
+ expect(clientReceived[0]).toStrictEqual({ message: "ping" });
228
+
229
+ await socket.disconnect();
230
+ await stopServer();
231
+ });
232
+ });