@hyper-fetch/sockets 8.0.1 → 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,160 @@
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 wsServer = createWebsocketE2EServer();
8
+
9
+ describe("E2E [ WebSocket Emitters ]", () => {
10
+ let url: string;
11
+
12
+ beforeAll(async () => {
13
+ url = await wsServer.startServer();
14
+ });
15
+
16
+ afterAll(async () => {
17
+ await wsServer.stopServer();
18
+ });
19
+
20
+ it("should send a message to the server", async () => {
21
+ const socket = new Socket({ url });
22
+ await waitForConnection(socket);
23
+
24
+ const emitter = socket.createEmitter<{ greeting: string }>()({ topic: "hello" });
25
+
26
+ const messagePromise = wsServer.waitForMessage();
27
+ await emitter.setPayload({ greeting: "world" }).emit();
28
+ const received = await messagePromise;
29
+
30
+ expect(received).toStrictEqual({ topic: "hello", data: { greeting: "world" } });
31
+
32
+ await socket.disconnect();
33
+ });
34
+
35
+ it("should send payload correctly", async () => {
36
+ const socket = new Socket({ url });
37
+ await waitForConnection(socket);
38
+
39
+ const emitter = socket.createEmitter<{ items: number[] }>()({ topic: "data" });
40
+
41
+ const messagePromise = wsServer.waitForMessage();
42
+ await emitter.setPayload({ items: [1, 2, 3] }).emit();
43
+ const received = await messagePromise;
44
+
45
+ expect(received.topic).toBe("data");
46
+ expect(received.data).toStrictEqual({ items: [1, 2, 3] });
47
+
48
+ await socket.disconnect();
49
+ });
50
+
51
+ it("should resolve topic params before sending", async () => {
52
+ const socket = new Socket({ url });
53
+ await waitForConnection(socket);
54
+
55
+ const emitter = socket.createEmitter<{ action: string }>()({ topic: "room/:roomId/action" });
56
+
57
+ const messagePromise = wsServer.waitForMessage();
58
+ await emitter.setParams({ roomId: "main" }).setPayload({ action: "join" }).emit();
59
+ const received = await messagePromise;
60
+
61
+ expect(received.topic).toBe("room/main/action");
62
+ expect(received.data).toStrictEqual({ action: "join" });
63
+
64
+ await socket.disconnect();
65
+ });
66
+
67
+ it("should block emit when disconnected", async () => {
68
+ const socket = new Socket({ url, adapterOptions: { autoConnect: false } });
69
+
70
+ const emitter = socket.createEmitter<{ v: number }>()({ topic: "blocked" });
71
+
72
+ socket.events.onError(() => {
73
+ // expected — emit while disconnected
74
+ });
75
+
76
+ // Should not throw but should not send
77
+ await emitter.setPayload({ v: 1 }).emit();
78
+ await sleep(100);
79
+
80
+ // The emit was blocked silently (onEmit returns null)
81
+ expect(socket.adapter.connected).toBe(false);
82
+ });
83
+
84
+ it("should apply payload mapper before sending", async () => {
85
+ const socket = new Socket({ url });
86
+ await waitForConnection(socket);
87
+
88
+ const emitter = socket
89
+ .createEmitter<{ raw: string }>()({ topic: "mapped" })
90
+ .setPayloadMapper((payload: any) => ({
91
+ raw: payload.raw.toUpperCase(),
92
+ transformed: true,
93
+ }));
94
+
95
+ const messagePromise = wsServer.waitForMessage();
96
+ await emitter.setPayload({ raw: "hello" }).emit();
97
+ const received = await messagePromise;
98
+
99
+ expect(received.topic).toBe("mapped");
100
+ expect(received.data).toStrictEqual({ raw: "HELLO", transformed: true });
101
+
102
+ await socket.disconnect();
103
+ });
104
+
105
+ it("should emit after reconnection", async () => {
106
+ const localServer = createWebsocketE2EServer();
107
+ const localUrl = await localServer.startServer();
108
+
109
+ const socket = new Socket({ url: localUrl, reconnectTime: 200 });
110
+ await waitForConnection(socket);
111
+
112
+ const emitter = socket.createEmitter<{ v: number }>()({ topic: "after-reconnect" });
113
+
114
+ // Send before disruption
115
+ let messagePromise = localServer.waitForMessage();
116
+ await emitter.setPayload({ v: 1 }).emit();
117
+ const first = await messagePromise;
118
+ expect(first.data).toStrictEqual({ v: 1 });
119
+
120
+ // Cause reconnection
121
+ localServer.terminateAllClients();
122
+ await sleep(600);
123
+ await waitForConnection(socket, 3000);
124
+
125
+ // Send after reconnection
126
+ messagePromise = localServer.waitForMessage();
127
+ await emitter.setPayload({ v: 2 }).emit();
128
+ const second = await messagePromise;
129
+ expect(second.data).toStrictEqual({ v: 2 });
130
+
131
+ await socket.disconnect();
132
+ await localServer.stopServer();
133
+ });
134
+
135
+ it("should send multiple messages sequentially", async () => {
136
+ const socket = new Socket({ url });
137
+ await waitForConnection(socket);
138
+
139
+ const emitter = socket.createEmitter<{ i: number }>()({ topic: "sequential" });
140
+
141
+ const messages: any[] = [];
142
+ wsServer.onMessage((msg) => {
143
+ if (msg.topic === "sequential") messages.push(msg);
144
+ });
145
+
146
+ for (let i = 0; i < 5; i += 1) {
147
+ // eslint-disable-next-line no-await-in-loop
148
+ await emitter.setPayload({ i }).emit();
149
+ }
150
+
151
+ await sleep(300);
152
+
153
+ expect(messages).toHaveLength(5);
154
+ messages.forEach((msg, idx) => {
155
+ expect(msg.data).toStrictEqual({ i: idx });
156
+ });
157
+
158
+ await socket.disconnect();
159
+ });
160
+ });
@@ -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
+ describe("E2E [ WebSocket Heartbeat ]", () => {
8
+ it("should send heartbeat messages at configured interval", async () => {
9
+ const { startServer, stopServer, onMessage } = createWebsocketE2EServer();
10
+ const url = await startServer();
11
+
12
+ const socket = new Socket({
13
+ url,
14
+ adapterOptions: {
15
+ heartbeat: true,
16
+ pingTimeout: 200,
17
+ pongTimeout: 5000,
18
+ },
19
+ });
20
+
21
+ await waitForConnection(socket);
22
+
23
+ const heartbeats: any[] = [];
24
+ onMessage((msg) => {
25
+ if (msg.topic === "heartbeat") heartbeats.push(msg);
26
+ });
27
+
28
+ // Wait for at least one heartbeat
29
+ await sleep(600);
30
+
31
+ expect(heartbeats.length).toBeGreaterThanOrEqual(1);
32
+ expect(heartbeats[0].data).toBe("heartbeat");
33
+
34
+ await socket.disconnect();
35
+ await stopServer();
36
+ });
37
+
38
+ it("should trigger reconnection when pong times out", async () => {
39
+ const { startServer, stopServer } = createWebsocketE2EServer();
40
+ const url = await startServer();
41
+
42
+ const socket = new Socket({
43
+ url,
44
+ reconnectTime: 200,
45
+ adapterOptions: {
46
+ heartbeat: true,
47
+ pingTimeout: 100,
48
+ pongTimeout: 100,
49
+ },
50
+ });
51
+
52
+ await waitForConnection(socket);
53
+
54
+ let reconnectFired = false;
55
+ socket.onReconnect(() => {
56
+ reconnectFired = true;
57
+ });
58
+
59
+ // Server doesn't respond to heartbeat, so pong times out -> close -> reconnect
60
+ await sleep(800);
61
+
62
+ expect(reconnectFired).toBe(true);
63
+
64
+ await socket.disconnect();
65
+ await stopServer();
66
+ });
67
+
68
+ it("should reset heartbeat timer on incoming messages", async () => {
69
+ const { startServer, stopServer, sendToAll, onMessage } = createWebsocketE2EServer();
70
+ const url = await startServer();
71
+
72
+ const socket = new Socket({
73
+ url,
74
+ adapterOptions: {
75
+ heartbeat: true,
76
+ pingTimeout: 300,
77
+ pongTimeout: 5000,
78
+ },
79
+ });
80
+
81
+ await waitForConnection(socket);
82
+
83
+ const heartbeats: any[] = [];
84
+ onMessage((msg) => {
85
+ if (msg.topic === "heartbeat") heartbeats.push(msg);
86
+ });
87
+
88
+ // Send activity messages to keep resetting the heartbeat timer
89
+ for (let i = 0; i < 3; i += 1) {
90
+ // eslint-disable-next-line no-await-in-loop
91
+ await sleep(150);
92
+ sendToAll("activity", { i });
93
+ }
94
+
95
+ // The heartbeat timer resets on each message, so fewer heartbeats should have been sent
96
+ const heartbeatsBefore = heartbeats.length;
97
+
98
+ // Now wait without activity for heartbeat to fire
99
+ await sleep(600);
100
+
101
+ expect(heartbeats.length).toBeGreaterThan(heartbeatsBefore);
102
+
103
+ await socket.disconnect();
104
+ await stopServer();
105
+ });
106
+
107
+ it("should not send heartbeats when heartbeat is disabled", async () => {
108
+ const { startServer, stopServer, onMessage } = createWebsocketE2EServer();
109
+ const url = await startServer();
110
+
111
+ const socket = new Socket({
112
+ url,
113
+ adapterOptions: {
114
+ heartbeat: false,
115
+ },
116
+ });
117
+
118
+ await waitForConnection(socket);
119
+
120
+ const heartbeats: any[] = [];
121
+ onMessage((msg) => {
122
+ if (msg.topic === "heartbeat") heartbeats.push(msg);
123
+ });
124
+
125
+ await sleep(600);
126
+
127
+ expect(heartbeats).toHaveLength(0);
128
+
129
+ await socket.disconnect();
130
+ await stopServer();
131
+ });
132
+
133
+ it("should use custom heartbeat message", async () => {
134
+ const { startServer, stopServer, onMessage } = createWebsocketE2EServer();
135
+ const url = await startServer();
136
+
137
+ const socket = new Socket({
138
+ url,
139
+ adapterOptions: {
140
+ heartbeat: true,
141
+ pingTimeout: 150,
142
+ pongTimeout: 5000,
143
+ heartbeatMessage: "ping",
144
+ },
145
+ });
146
+
147
+ await waitForConnection(socket);
148
+
149
+ const heartbeats: any[] = [];
150
+ onMessage((msg) => {
151
+ if (msg.topic === "heartbeat") heartbeats.push(msg);
152
+ });
153
+
154
+ await sleep(500);
155
+
156
+ expect(heartbeats.length).toBeGreaterThanOrEqual(1);
157
+ expect(heartbeats[0].data).toBe("ping");
158
+
159
+ await socket.disconnect();
160
+ await stopServer();
161
+ });
162
+ });
@@ -0,0 +1,215 @@
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 wsServer = createWebsocketE2EServer();
8
+
9
+ describe("E2E [ WebSocket Listeners ]", () => {
10
+ let url: string;
11
+
12
+ beforeAll(async () => {
13
+ url = await wsServer.startServer();
14
+ });
15
+
16
+ afterAll(async () => {
17
+ await wsServer.stopServer();
18
+ });
19
+
20
+ it("should receive a message on a matching topic", async () => {
21
+ const socket = new Socket({ url });
22
+ await waitForConnection(socket);
23
+
24
+ const listener = socket.createListener<{ name: string }>()({ topic: "user-update" });
25
+
26
+ const received: { data: { name: string } }[] = [];
27
+ listener.listen(({ data }) => {
28
+ received.push({ data });
29
+ });
30
+
31
+ await sleep(50);
32
+ wsServer.sendToAll("user-update", { name: "John" });
33
+ await sleep(200);
34
+
35
+ expect(received).toHaveLength(1);
36
+ expect(received[0].data).toStrictEqual({ name: "John" });
37
+
38
+ await socket.disconnect();
39
+ });
40
+
41
+ it("should route messages to correct listeners by topic", async () => {
42
+ const socket = new Socket({ url });
43
+ await waitForConnection(socket);
44
+
45
+ const userListener = socket.createListener<{ id: number }>()({ topic: "users" });
46
+ const orderListener = socket.createListener<{ orderId: string }>()({ topic: "orders" });
47
+
48
+ const userMessages: any[] = [];
49
+ const orderMessages: any[] = [];
50
+
51
+ userListener.listen(({ data }) => userMessages.push(data));
52
+ orderListener.listen(({ data }) => orderMessages.push(data));
53
+
54
+ await sleep(50);
55
+ wsServer.sendToAll("users", { id: 1 });
56
+ wsServer.sendToAll("orders", { orderId: "abc" });
57
+ wsServer.sendToAll("users", { id: 2 });
58
+ await sleep(200);
59
+
60
+ expect(userMessages).toStrictEqual([{ id: 1 }, { id: 2 }]);
61
+ expect(orderMessages).toStrictEqual([{ orderId: "abc" }]);
62
+
63
+ await socket.disconnect();
64
+ });
65
+
66
+ it("should deliver messages to multiple listeners on same topic", async () => {
67
+ const socket = new Socket({ url });
68
+ await waitForConnection(socket);
69
+
70
+ const listener1 = socket.createListener<{ v: number }>()({ topic: "shared" });
71
+ const listener2 = socket.createListener<{ v: number }>()({ topic: "shared" });
72
+
73
+ const results1: any[] = [];
74
+ const results2: any[] = [];
75
+
76
+ listener1.listen(({ data }) => results1.push(data));
77
+ listener2.listen(({ data }) => results2.push(data));
78
+
79
+ await sleep(50);
80
+ wsServer.sendToAll("shared", { v: 42 });
81
+ await sleep(200);
82
+
83
+ expect(results1).toStrictEqual([{ v: 42 }]);
84
+ expect(results2).toStrictEqual([{ v: 42 }]);
85
+
86
+ await socket.disconnect();
87
+ });
88
+
89
+ it("should stop receiving after remove listener", async () => {
90
+ const socket = new Socket({ url });
91
+ await waitForConnection(socket);
92
+
93
+ const listener = socket.createListener<{ v: number }>()({ topic: "removable" });
94
+
95
+ const received: any[] = [];
96
+ const remove = listener.listen(({ data }) => received.push(data));
97
+
98
+ await sleep(50);
99
+ wsServer.sendToAll("removable", { v: 1 });
100
+ await sleep(200);
101
+
102
+ expect(received).toHaveLength(1);
103
+
104
+ remove();
105
+
106
+ wsServer.sendToAll("removable", { v: 2 });
107
+ await sleep(200);
108
+
109
+ expect(received).toHaveLength(1);
110
+
111
+ await socket.disconnect();
112
+ });
113
+
114
+ it("should handle listener with params in topic", async () => {
115
+ const socket = new Socket({ url });
116
+ await waitForConnection(socket);
117
+
118
+ const listener = socket.createListener<{ status: string }>()({ topic: "room/:roomId/status" });
119
+ const boundListener = listener.setParams({ roomId: "lobby" });
120
+
121
+ const received: any[] = [];
122
+ boundListener.listen(({ data }) => received.push(data));
123
+
124
+ await sleep(50);
125
+ wsServer.sendToAll("room/lobby/status", { status: "active" });
126
+ await sleep(200);
127
+
128
+ expect(received).toStrictEqual([{ status: "active" }]);
129
+
130
+ await socket.disconnect();
131
+ });
132
+
133
+ it("should continue receiving messages after reconnection", async () => {
134
+ const localServer = createWebsocketE2EServer();
135
+ const localUrl = await localServer.startServer();
136
+
137
+ const socket = new Socket({ url: localUrl, reconnectTime: 200 });
138
+ await waitForConnection(socket);
139
+
140
+ const listener = socket.createListener<{ v: number }>()({ topic: "persist" });
141
+ const received: any[] = [];
142
+ listener.listen(({ data }) => received.push(data));
143
+
144
+ await sleep(50);
145
+ localServer.sendToAll("persist", { v: 1 });
146
+ await sleep(200);
147
+
148
+ expect(received).toStrictEqual([{ v: 1 }]);
149
+
150
+ // Trigger reconnection
151
+ localServer.terminateAllClients();
152
+ await sleep(600);
153
+ await waitForConnection(socket, 3000);
154
+
155
+ // Send after reconnect
156
+ localServer.sendToAll("persist", { v: 2 });
157
+ await sleep(200);
158
+
159
+ expect(received).toStrictEqual([{ v: 1 }, { v: 2 }]);
160
+
161
+ await socket.disconnect();
162
+ await localServer.stopServer();
163
+ });
164
+
165
+ it("should receive rapid messages in order", async () => {
166
+ const socket = new Socket({ url });
167
+ await waitForConnection(socket);
168
+
169
+ const listener = socket.createListener<{ i: number }>()({ topic: "rapid" });
170
+ const received: number[] = [];
171
+ listener.listen(({ data }) => received.push(data.i));
172
+
173
+ await sleep(50);
174
+
175
+ const count = 50;
176
+ for (let i = 0; i < count; i += 1) {
177
+ wsServer.sendToAll("rapid", { i });
178
+ }
179
+
180
+ await sleep(500);
181
+
182
+ expect(received).toHaveLength(count);
183
+ expect(received).toStrictEqual(Array.from({ length: count }, (_, i) => i));
184
+
185
+ await socket.disconnect();
186
+ });
187
+
188
+ it("should handle large payloads", async () => {
189
+ const socket = new Socket({ url });
190
+ await waitForConnection(socket);
191
+
192
+ const listener = socket.createListener<{ items: { id: number; name: string }[] }>()({ topic: "large" });
193
+
194
+ const largeData = {
195
+ items: Array.from({ length: 1000 }, (_, i) => ({
196
+ id: i,
197
+ name: `item-${i}-${"x".repeat(100)}`,
198
+ })),
199
+ };
200
+
201
+ const received: any[] = [];
202
+ listener.listen(({ data }) => received.push(data));
203
+
204
+ await sleep(50);
205
+ wsServer.sendToAll("large", largeData);
206
+ await sleep(500);
207
+
208
+ expect(received).toHaveLength(1);
209
+ expect(received[0].items).toHaveLength(1000);
210
+ expect(received[0].items[0].id).toBe(0);
211
+ expect(received[0].items[999].id).toBe(999);
212
+
213
+ await socket.disconnect();
214
+ });
215
+ });