@hyper-fetch/sockets 9.6.1 → 9.6.2
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.lifecycle.spec.ts +258 -0
- package/__tests__/features/adapter/adapter.connection.spec.ts +27 -6
- package/__tests__/features/adapter/adapter.sse.lifecycle.spec.ts +514 -0
- package/__tests__/features/adapter/adapter.sse.spec.ts +20 -6
- package/__tests__/features/adapter/adapter.websocket.heartbeat.timers.spec.ts +337 -0
- package/__tests__/features/adapter/adapter.websocket.lifecycle.spec.ts +528 -0
- package/__tests__/features/adapter/adapter.websocket.reconnection.spec.ts +669 -0
- package/__tests__/features/delivery/delivery.backpressure.spec.ts +382 -0
- package/__tests__/features/emitter/emitter.sending.spec.ts +493 -0
- package/__tests__/features/emitter/emitter.typescript.spec.ts +153 -0
- package/__tests__/features/listener/listener.dispatch.spec.ts +427 -0
- package/__tests__/features/listener/listener.params.spec.ts +192 -0
- package/__tests__/features/socket/socket.app-manager.spec.ts +24 -2
- package/__tests__/features/socket/socket.interceptors.spec.ts +430 -0
- package/__tests__/utils/controlled-event-source.ts +149 -0
- package/__tests__/utils/controlled-websocket.ts +213 -0
- package/dist/adapter/adapter.bindings.d.ts.map +1 -1
- package/dist/adapter/adapter.d.ts.map +1 -1
- package/dist/adapter-sse/sse-adapter.d.ts.map +1 -1
- package/dist/adapter-websockets/websocket-adapter.d.ts.map +1 -1
- package/dist/emitter/emitter.d.ts.map +1 -1
- package/dist/index.mjs +284 -105
- package/dist/index.mjs.map +1 -1
- package/dist/listener/listener.d.ts +2 -0
- package/dist/listener/listener.d.ts.map +1 -1
- package/dist/socket/socket.d.ts +1 -1
- package/dist/socket/socket.utils.d.ts +11 -3
- package/dist/socket/socket.utils.d.ts.map +1 -1
- package/dist/utils/topic.utils.d.ts +10 -0
- package/dist/utils/topic.utils.d.ts.map +1 -0
- package/package.json +1 -1
- package/src/adapter/adapter.bindings.ts +44 -20
- package/src/adapter/adapter.ts +29 -10
- package/src/adapter-sse/sse-adapter.ts +95 -15
- package/src/adapter-websockets/websocket-adapter.ts +124 -41
- package/src/emitter/emitter.ts +16 -9
- package/src/listener/listener.ts +7 -8
- package/src/socket/socket.utils.ts +20 -6
- package/src/utils/topic.utils.ts +26 -0
package/dist/index.mjs
CHANGED
|
@@ -82,7 +82,6 @@ var getAdapterBindings = (socket) => {
|
|
|
82
82
|
const currentConnectionId = connectionId;
|
|
83
83
|
socket.adapter.setForceClosed(false);
|
|
84
84
|
socket.adapter.setConnecting(true);
|
|
85
|
-
socket.adapter.setReconnectionAttempts(0);
|
|
86
85
|
socket.events.emitConnecting({ connecting: true });
|
|
87
86
|
const defaults = {
|
|
88
87
|
url: socket.url,
|
|
@@ -138,7 +137,6 @@ var getAdapterBindings = (socket) => {
|
|
|
138
137
|
extra: { reconnectionAttempts: nextAttempts }
|
|
139
138
|
});
|
|
140
139
|
await connect();
|
|
141
|
-
if (!adapter.connected) socket.adapter.setReconnectionAttempts(nextAttempts);
|
|
142
140
|
return true;
|
|
143
141
|
}
|
|
144
142
|
logger.error({
|
|
@@ -159,25 +157,50 @@ var getAdapterBindings = (socket) => {
|
|
|
159
157
|
callback
|
|
160
158
|
});
|
|
161
159
|
};
|
|
160
|
+
const onEmitError = ({ emitter, error }) => {
|
|
161
|
+
socket.events.emitEmitterError({
|
|
162
|
+
error,
|
|
163
|
+
emitter
|
|
164
|
+
});
|
|
165
|
+
};
|
|
166
|
+
/**
|
|
167
|
+
* Prepares an emitter for sending - maps the payload and runs the `onSend` interceptors.
|
|
168
|
+
* Returns `null` when the message cannot be sent; the reason is reported with the emitter error event
|
|
169
|
+
* (and to the `onError` callbacks when the payload mapper or an interceptor failed), it never rejects.
|
|
170
|
+
*/
|
|
162
171
|
const onEmit = async ({ emitter }) => {
|
|
163
172
|
if (adapter.connecting || !adapter.connected) {
|
|
173
|
+
const error = /* @__PURE__ */ new Error("Cannot emit event when connection is not open");
|
|
164
174
|
logger.error({
|
|
165
|
-
title:
|
|
175
|
+
title: error.message,
|
|
166
176
|
type: "system",
|
|
167
177
|
extra: {}
|
|
168
178
|
});
|
|
179
|
+
onEmitError({
|
|
180
|
+
emitter,
|
|
181
|
+
error
|
|
182
|
+
});
|
|
183
|
+
return null;
|
|
184
|
+
}
|
|
185
|
+
try {
|
|
186
|
+
emitter.payload = emitter.unstable_payloadMapper ? await emitter.unstable_payloadMapper(emitter.payload) : emitter.payload;
|
|
187
|
+
const emitterInstance = await socket.unstable__modifySend(emitter);
|
|
188
|
+
socket.events.emitEmitterStartEvent({ emitter: emitterInstance });
|
|
189
|
+
return emitterInstance;
|
|
190
|
+
} catch (error) {
|
|
191
|
+
const emitError = error instanceof Error ? error : new Error(String(error));
|
|
192
|
+
logger.error({
|
|
193
|
+
title: "Cannot prepare event to emit",
|
|
194
|
+
type: "system",
|
|
195
|
+
extra: { error: emitError }
|
|
196
|
+
});
|
|
197
|
+
onEmitError({
|
|
198
|
+
emitter,
|
|
199
|
+
error: emitError
|
|
200
|
+
});
|
|
201
|
+
onError({ error: emitError });
|
|
169
202
|
return null;
|
|
170
203
|
}
|
|
171
|
-
emitter.payload = emitter.unstable_payloadMapper ? emitter.unstable_payloadMapper(emitter.payload) : emitter.payload;
|
|
172
|
-
const emitterInstance = await socket.unstable__modifySend(emitter);
|
|
173
|
-
socket.events.emitEmitterStartEvent({ emitter: emitterInstance });
|
|
174
|
-
return emitterInstance;
|
|
175
|
-
};
|
|
176
|
-
const onEmitError = ({ emitter, error }) => {
|
|
177
|
-
socket.events.emitEmitterError({
|
|
178
|
-
error,
|
|
179
|
-
emitter
|
|
180
|
-
});
|
|
181
204
|
};
|
|
182
205
|
const onConnected = () => {
|
|
183
206
|
logger.info({
|
|
@@ -218,20 +241,29 @@ var getAdapterBindings = (socket) => {
|
|
|
218
241
|
extra
|
|
219
242
|
}
|
|
220
243
|
});
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
244
|
+
let message;
|
|
245
|
+
try {
|
|
246
|
+
message = socket.unstable__modifyResponse({
|
|
247
|
+
data,
|
|
248
|
+
extra
|
|
249
|
+
});
|
|
250
|
+
} catch (error) {
|
|
251
|
+
onError({ error: error instanceof Error ? error : new Error(String(error)) });
|
|
252
|
+
return;
|
|
253
|
+
}
|
|
254
|
+
try {
|
|
255
|
+
socket.adapter.triggerListeners({
|
|
256
|
+
topic,
|
|
257
|
+
data: message.data,
|
|
258
|
+
extra: message.extra
|
|
259
|
+
});
|
|
260
|
+
} finally {
|
|
261
|
+
socket.events.emitListenerEvent({
|
|
262
|
+
topic,
|
|
263
|
+
data: message.data,
|
|
264
|
+
extra: message.extra
|
|
265
|
+
});
|
|
266
|
+
}
|
|
235
267
|
};
|
|
236
268
|
/** Maps query params to the format required by the adapter (defaults to the adapter's stored query params) */
|
|
237
269
|
const getQueryParams = (queryParams = adapter.queryParams) => socket.adapter.unstable_queryParamsMapper(queryParams, socket.adapter.queryParamsConfig);
|
|
@@ -339,23 +371,30 @@ var SocketAdapter = class {
|
|
|
339
371
|
};
|
|
340
372
|
removeListener = ({ topic, callback }) => {
|
|
341
373
|
const listenerGroup = this.listeners.get(topic);
|
|
342
|
-
if (listenerGroup)
|
|
343
|
-
|
|
344
|
-
|
|
345
|
-
|
|
346
|
-
|
|
347
|
-
|
|
348
|
-
}
|
|
349
|
-
return false;
|
|
374
|
+
if (!listenerGroup?.has(callback)) return false;
|
|
375
|
+
const unmount = listenerGroup.get(callback);
|
|
376
|
+
listenerGroup.delete(callback);
|
|
377
|
+
this.socket.events.emitListenerRemoveEvent({ topic });
|
|
378
|
+
unmount?.();
|
|
379
|
+
return true;
|
|
350
380
|
};
|
|
351
381
|
triggerListeners = ({ topic, data, extra }) => {
|
|
352
382
|
const listenerGroup = this.listeners.get(topic);
|
|
353
|
-
if (listenerGroup)
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
|
|
357
|
-
|
|
383
|
+
if (!listenerGroup?.size) return;
|
|
384
|
+
const callbacks = [...listenerGroup.keys()];
|
|
385
|
+
const errors = [];
|
|
386
|
+
callbacks.forEach((action) => {
|
|
387
|
+
if (!listenerGroup.has(action)) return;
|
|
388
|
+
try {
|
|
389
|
+
action({
|
|
390
|
+
data,
|
|
391
|
+
extra
|
|
392
|
+
});
|
|
393
|
+
} catch (error) {
|
|
394
|
+
errors.push(error);
|
|
395
|
+
}
|
|
358
396
|
});
|
|
397
|
+
if (errors.length > 0) throw errors[0];
|
|
359
398
|
};
|
|
360
399
|
setConnected = (connected) => {
|
|
361
400
|
this.connected = connected;
|
|
@@ -453,14 +492,21 @@ var getWebsocketAdapter = (url, adapterOptions) => {
|
|
|
453
492
|
//#endregion
|
|
454
493
|
//#region src/adapter-websockets/websocket-adapter.ts
|
|
455
494
|
/** Create a preconfigured socket adapter for native WebSocket connections. */
|
|
456
|
-
var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryParamsMapper(stringifyQueryParams).setConnector(({ socket, getQueryParams, onConnect, onConnectFailed, onReconnect, onDisconnect, onListen, onEmit, onConnected, onDisconnected, onError, onEvent }) => {
|
|
495
|
+
var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryParamsMapper(stringifyQueryParams).setConnector(({ socket, getQueryParams, onConnect, onConnectFailed, onReconnect, onDisconnect, onListen, onEmit, onEmitError, onConnected, onDisconnected, onError, onEvent }) => {
|
|
457
496
|
const autoConnect = typeof socket.adapter.adapterOptions?.autoConnect === "boolean" ? socket.adapter.adapterOptions?.autoConnect : true;
|
|
458
497
|
let websocket;
|
|
459
498
|
let options = socket.adapter.adapterOptions;
|
|
499
|
+
let pendingConnection;
|
|
460
500
|
let pingTimer;
|
|
461
501
|
let pongTimer;
|
|
462
502
|
let timeout;
|
|
463
|
-
const
|
|
503
|
+
const scheduleReconnect = () => {
|
|
504
|
+
clearTimeout(timeout);
|
|
505
|
+
timeout = setTimeout(() => {
|
|
506
|
+
reconnect();
|
|
507
|
+
}, socket.reconnectTime);
|
|
508
|
+
};
|
|
509
|
+
const openConnection = async () => {
|
|
464
510
|
const connection = await onConnect();
|
|
465
511
|
if (!connection) return socket.adapter.connected;
|
|
466
512
|
clearTimeout(timeout);
|
|
@@ -468,31 +514,30 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
|
|
|
468
514
|
websocket?.close(1e3);
|
|
469
515
|
options = connection.adapterOptions;
|
|
470
516
|
const newWebsocket = createWebsocket(getSocketUrl(connection.url, getQueryParams(connection.queryParams)), options);
|
|
471
|
-
websocket = newWebsocket;
|
|
517
|
+
websocket = newWebsocket ?? void 0;
|
|
472
518
|
if (!newWebsocket) return false;
|
|
473
|
-
|
|
474
|
-
|
|
475
|
-
reconnect();
|
|
476
|
-
}, socket.reconnectTime);
|
|
519
|
+
const isCurrent = () => websocket === newWebsocket;
|
|
520
|
+
scheduleReconnect();
|
|
477
521
|
/**
|
|
478
522
|
* Mount listeners
|
|
479
523
|
*/
|
|
480
524
|
newWebsocket.addEventListener("open", () => {
|
|
525
|
+
if (!isCurrent()) return;
|
|
481
526
|
clearTimeout(timeout);
|
|
482
527
|
onConnected();
|
|
483
528
|
onHeartbeat();
|
|
484
529
|
});
|
|
485
530
|
newWebsocket.addEventListener("close", (event) => {
|
|
531
|
+
if (!isCurrent()) return;
|
|
486
532
|
clearTimeout(timeout);
|
|
487
|
-
onDisconnected();
|
|
488
533
|
clearTimers();
|
|
534
|
+
onDisconnected();
|
|
489
535
|
const error = getSocketError(event);
|
|
490
536
|
onError({ error: new Error(error) });
|
|
491
|
-
if (event.code !== 1e3)
|
|
492
|
-
reconnect();
|
|
493
|
-
}, socket.reconnectTime);
|
|
537
|
+
if (event.code !== 1e3) scheduleReconnect();
|
|
494
538
|
});
|
|
495
539
|
newWebsocket.addEventListener("message", (newEvent) => {
|
|
540
|
+
if (!isCurrent()) return;
|
|
496
541
|
onHeartbeat();
|
|
497
542
|
const message = decodeMessage(newEvent);
|
|
498
543
|
if (message) onEvent({
|
|
@@ -526,31 +571,55 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
|
|
|
526
571
|
newWebsocket.addEventListener("error", resolveError, { disableCleanup: true });
|
|
527
572
|
});
|
|
528
573
|
};
|
|
529
|
-
const
|
|
574
|
+
const connect = () => {
|
|
575
|
+
if (socket.adapter.connecting && pendingConnection) return pendingConnection;
|
|
576
|
+
const connection = openConnection();
|
|
577
|
+
pendingConnection = connection;
|
|
578
|
+
const release = () => {
|
|
579
|
+
if (pendingConnection === connection) pendingConnection = void 0;
|
|
580
|
+
};
|
|
581
|
+
connection.then(release, release);
|
|
582
|
+
return connection;
|
|
583
|
+
};
|
|
584
|
+
/**
|
|
585
|
+
* Closes the transport and resets the connection state. From this point the closed transport is detached -
|
|
586
|
+
* whatever it reports later (close code, errors, late frames) does not reach the socket anymore,
|
|
587
|
+
* so closing on purpose is never treated as a lost connection.
|
|
588
|
+
*/
|
|
589
|
+
const closeConnection = async ({ manual }) => {
|
|
530
590
|
clearTimeout(timeout);
|
|
591
|
+
clearTimers();
|
|
531
592
|
const currentWebsocket = websocket;
|
|
532
|
-
|
|
533
|
-
|
|
534
|
-
|
|
535
|
-
|
|
536
|
-
|
|
537
|
-
|
|
538
|
-
|
|
593
|
+
websocket = void 0;
|
|
594
|
+
const wasActive = socket.adapter.connected || socket.adapter.connecting;
|
|
595
|
+
onDisconnect();
|
|
596
|
+
if (!manual) socket.adapter.setForceClosed(false);
|
|
597
|
+
if (wasActive) onDisconnected();
|
|
598
|
+
if (!currentWebsocket || currentWebsocket.readyState === WebSocket.CLOSED) return true;
|
|
599
|
+
return new Promise((resolve) => {
|
|
539
600
|
const resolveDisconnected = () => {
|
|
540
601
|
resolve(true);
|
|
541
602
|
currentWebsocket.removeEventListener("close", resolveDisconnected);
|
|
542
603
|
};
|
|
543
604
|
currentWebsocket.addEventListener("close", resolveDisconnected, { disableCleanup: true });
|
|
605
|
+
currentWebsocket.close(1e3);
|
|
544
606
|
});
|
|
545
|
-
|
|
546
|
-
|
|
547
|
-
|
|
548
|
-
return
|
|
607
|
+
};
|
|
608
|
+
/** Manual disconnect - the socket stays closed until `connect()` or `reconnect()` is called */
|
|
609
|
+
const disconnect = () => {
|
|
610
|
+
return closeConnection({ manual: true });
|
|
549
611
|
};
|
|
550
612
|
const reconnect = async () => {
|
|
613
|
+
socket.adapter.setForceClosed(false);
|
|
551
614
|
await onReconnect({
|
|
552
|
-
disconnect,
|
|
553
|
-
connect
|
|
615
|
+
disconnect: () => closeConnection({ manual: false }),
|
|
616
|
+
connect: async () => {
|
|
617
|
+
if (socket.adapter.forceClosed) {
|
|
618
|
+
socket.adapter.setReconnectionAttempts(0);
|
|
619
|
+
return false;
|
|
620
|
+
}
|
|
621
|
+
return connect();
|
|
622
|
+
}
|
|
554
623
|
});
|
|
555
624
|
};
|
|
556
625
|
/** Creates the transport, reporting a failed attempt when the environment or the connection details are invalid */
|
|
@@ -582,8 +651,9 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
|
|
|
582
651
|
return null;
|
|
583
652
|
}
|
|
584
653
|
};
|
|
654
|
+
/** Encodes and sends a message. Returns the error instead of throwing, so callers decide how to report it. */
|
|
585
655
|
const sendEventMessage = ({ topic, payload }) => {
|
|
586
|
-
if (!websocket) return
|
|
656
|
+
if (!websocket) return /* @__PURE__ */ new Error("Cannot send event when connection is not open");
|
|
587
657
|
try {
|
|
588
658
|
const frame = options?.encode ? options.encode({
|
|
589
659
|
topic,
|
|
@@ -593,10 +663,9 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
|
|
|
593
663
|
data: payload
|
|
594
664
|
});
|
|
595
665
|
websocket.send(frame);
|
|
596
|
-
return
|
|
666
|
+
return null;
|
|
597
667
|
} catch (error) {
|
|
598
|
-
|
|
599
|
-
return false;
|
|
668
|
+
return error instanceof Error ? error : new Error(String(error));
|
|
600
669
|
}
|
|
601
670
|
};
|
|
602
671
|
const onHeartbeat = () => {
|
|
@@ -606,15 +675,31 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
|
|
|
606
675
|
if (socket.adapter.connecting || !heartbeat) return;
|
|
607
676
|
clearTimers();
|
|
608
677
|
pingTimer = setTimeout(() => {
|
|
609
|
-
sendEventMessage({
|
|
678
|
+
const error = sendEventMessage({
|
|
610
679
|
topic: "heartbeat",
|
|
611
680
|
payload: heartbeatMessage
|
|
612
681
|
});
|
|
682
|
+
if (error) onError({ error });
|
|
613
683
|
pongTimer = setTimeout(() => {
|
|
614
|
-
|
|
684
|
+
onHeartbeatTimeout();
|
|
615
685
|
}, pongTimeout);
|
|
616
686
|
}, pingTimeout);
|
|
617
687
|
};
|
|
688
|
+
/**
|
|
689
|
+
* The server did not answer the ping - the connection is dead. On a dead connection the closing handshake
|
|
690
|
+
* may take very long (or never finish), so the socket is marked as disconnected right away instead of
|
|
691
|
+
* waiting for the `close` event of the transport.
|
|
692
|
+
*/
|
|
693
|
+
const onHeartbeatTimeout = () => {
|
|
694
|
+
const deadWebsocket = websocket;
|
|
695
|
+
if (!deadWebsocket) return;
|
|
696
|
+
websocket = void 0;
|
|
697
|
+
clearTimers();
|
|
698
|
+
deadWebsocket.close();
|
|
699
|
+
onDisconnected();
|
|
700
|
+
onError({ error: /* @__PURE__ */ new Error("Heartbeat timeout - the server did not respond to the ping in time") });
|
|
701
|
+
scheduleReconnect();
|
|
702
|
+
};
|
|
618
703
|
const listen = (listener, callback) => {
|
|
619
704
|
return onListen({
|
|
620
705
|
listener,
|
|
@@ -624,11 +709,20 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
|
|
|
624
709
|
const emit = async (emitter) => {
|
|
625
710
|
const mappedEmitter = await onEmit({ emitter });
|
|
626
711
|
if (!mappedEmitter) return;
|
|
627
|
-
|
|
712
|
+
const error = sendEventMessage(mappedEmitter);
|
|
713
|
+
if (error) {
|
|
714
|
+
onEmitError({
|
|
715
|
+
emitter: mappedEmitter,
|
|
716
|
+
error
|
|
717
|
+
});
|
|
718
|
+
onError({ error });
|
|
719
|
+
return false;
|
|
720
|
+
}
|
|
721
|
+
return true;
|
|
628
722
|
};
|
|
629
723
|
if (autoConnect) connect();
|
|
630
724
|
socket.appManager.events.onOnline(() => {
|
|
631
|
-
if (autoConnect && !socket.adapter.connected) connect();
|
|
725
|
+
if (autoConnect && !socket.adapter.connected && !socket.adapter.forceClosed) connect();
|
|
632
726
|
});
|
|
633
727
|
return {
|
|
634
728
|
connect,
|
|
@@ -639,6 +733,24 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
|
|
|
639
733
|
};
|
|
640
734
|
});
|
|
641
735
|
//#endregion
|
|
736
|
+
//#region src/utils/topic.utils.ts
|
|
737
|
+
/**
|
|
738
|
+
* Fills the `:param` segments of a topic template, e.g. `chat/:roomId` + `{ roomId: 1 }` gives `chat/1`.
|
|
739
|
+
*
|
|
740
|
+
* Every `:` segment is replaced once, with the longest matching name. This way `:id` does not eat the beginning
|
|
741
|
+
* of `:idx`, and a value is never parsed again - neither as another param nor as a replacement pattern like `$&`.
|
|
742
|
+
* Segments without a matching param are left untouched.
|
|
743
|
+
*/
|
|
744
|
+
var mapTopicParams = (topic, params) => {
|
|
745
|
+
const names = params ? Object.keys(params) : [];
|
|
746
|
+
if (!params || names.length === 0) return topic;
|
|
747
|
+
const [start, ...segments] = topic.split(":");
|
|
748
|
+
return [start, ...segments.map((segment) => {
|
|
749
|
+
const name = names.reduce((longest, current) => segment.startsWith(current) && current.length > longest.length ? current : longest, "");
|
|
750
|
+
return name ? `${params[name]}${segment.slice(name.length)}` : `:${segment}`;
|
|
751
|
+
})].join("");
|
|
752
|
+
};
|
|
753
|
+
//#endregion
|
|
642
754
|
//#region src/emitter/emitter.ts
|
|
643
755
|
/**
|
|
644
756
|
* Represents a socket message emitter bound to a specific topic. Use it to send typed payloads
|
|
@@ -679,11 +791,7 @@ var Emitter = class Emitter {
|
|
|
679
791
|
return this.clone({ params });
|
|
680
792
|
}
|
|
681
793
|
paramsMapper = (params) => {
|
|
682
|
-
|
|
683
|
-
if (params) Object.entries(params).forEach(([key, value]) => {
|
|
684
|
-
topic = topic.replaceAll(new RegExp(`:${key}`, "g"), String(value));
|
|
685
|
-
});
|
|
686
|
-
return topic;
|
|
794
|
+
return mapTopicParams(this.emitterOptions.topic, params);
|
|
687
795
|
};
|
|
688
796
|
/** Create a new emitter instance with optional configuration overrides. */
|
|
689
797
|
clone(config) {
|
|
@@ -702,7 +810,18 @@ var Emitter = class Emitter {
|
|
|
702
810
|
emit = (options = {}) => {
|
|
703
811
|
const typedOptions = options;
|
|
704
812
|
const instance = this.clone(typedOptions);
|
|
705
|
-
this.socket.adapter.emit(instance);
|
|
813
|
+
const result = this.socket.adapter.emit(instance);
|
|
814
|
+
if (result instanceof Promise) result.catch((error) => {
|
|
815
|
+
const emitError = error instanceof Error ? error : new Error(String(error));
|
|
816
|
+
this.socket.events.emitEmitterError({
|
|
817
|
+
error: emitError,
|
|
818
|
+
emitter: instance
|
|
819
|
+
});
|
|
820
|
+
this.socket.unstable_onErrorCallbacks.forEach((callback) => {
|
|
821
|
+
callback({ error: emitError });
|
|
822
|
+
});
|
|
823
|
+
this.socket.events.emitError({ error: emitError });
|
|
824
|
+
});
|
|
706
825
|
};
|
|
707
826
|
};
|
|
708
827
|
//#endregion
|
|
@@ -1186,11 +1305,14 @@ var Listener = class Listener {
|
|
|
1186
1305
|
delivery = void 0;
|
|
1187
1306
|
/** Stored with an `any` response for the same covariance reason as `delivery`. */
|
|
1188
1307
|
listenerOptions;
|
|
1308
|
+
/** Topic as it was declared (e.g. `chat/:roomId`) - clones keep it, so params can be set again */
|
|
1309
|
+
topicTemplate;
|
|
1189
1310
|
constructor(socket, listenerOptions) {
|
|
1190
1311
|
this.socket = socket;
|
|
1191
1312
|
this.listenerOptions = listenerOptions;
|
|
1192
1313
|
const { topic, options, delivery, params } = listenerOptions;
|
|
1193
1314
|
this.topic = topic;
|
|
1315
|
+
this.topicTemplate = topic;
|
|
1194
1316
|
this.options = options;
|
|
1195
1317
|
this.params = params;
|
|
1196
1318
|
this.delivery = delivery;
|
|
@@ -1213,11 +1335,13 @@ var Listener = class Listener {
|
|
|
1213
1335
|
}
|
|
1214
1336
|
/** Create a new listener instance with optional configuration overrides. */
|
|
1215
1337
|
clone(options) {
|
|
1216
|
-
|
|
1338
|
+
const newInstance = new Listener(this.socket, {
|
|
1217
1339
|
...this.listenerOptions,
|
|
1218
1340
|
...options,
|
|
1219
1341
|
topic: this.paramsMapper(options?.params || this.params)
|
|
1220
1342
|
});
|
|
1343
|
+
newInstance.topicTemplate = this.topicTemplate;
|
|
1344
|
+
return newInstance;
|
|
1221
1345
|
}
|
|
1222
1346
|
/** Start listening for messages on the configured topic. Returns a function to unsubscribe. */
|
|
1223
1347
|
listen = (callback) => {
|
|
@@ -1234,11 +1358,7 @@ var Listener = class Listener {
|
|
|
1234
1358
|
return removeListener;
|
|
1235
1359
|
};
|
|
1236
1360
|
paramsMapper = (params) => {
|
|
1237
|
-
|
|
1238
|
-
if (params) Object.entries(params).forEach(([key, value]) => {
|
|
1239
|
-
topic = topic.replaceAll(new RegExp(`:${key}`, "g"), String(value));
|
|
1240
|
-
});
|
|
1241
|
-
return topic;
|
|
1361
|
+
return mapTopicParams(this.topicTemplate, params);
|
|
1242
1362
|
};
|
|
1243
1363
|
};
|
|
1244
1364
|
//#endregion
|
|
@@ -1473,18 +1593,30 @@ var getListenerRemoveByTopicKey = (event) => `${event}_listener_remove`;
|
|
|
1473
1593
|
var getListenerEventByTopicKey = (event) => `${event}_listener_event`;
|
|
1474
1594
|
var getEmitterStartEventByTopicKey = (event) => `${event}_emitter_start_event`;
|
|
1475
1595
|
var getEmitterErrorByTopicKey = (event) => `${event}_emitter_error`;
|
|
1596
|
+
/**
|
|
1597
|
+
* Runs the `onMessage` interceptors over the data of an incoming message. Every interceptor receives the data
|
|
1598
|
+
* returned by the previous one - the adapter `extra` is never touched.
|
|
1599
|
+
*/
|
|
1476
1600
|
var interceptListener = (interceptors, event) => {
|
|
1477
|
-
let
|
|
1601
|
+
let { data } = event;
|
|
1478
1602
|
for (const interceptor of interceptors) {
|
|
1479
|
-
|
|
1480
|
-
if (
|
|
1603
|
+
const newData = interceptor({ event: data });
|
|
1604
|
+
if ((newData === void 0 || newData === null && data !== null) && data !== void 0) throw new Error("Listener modifier must return data");
|
|
1605
|
+
data = newData;
|
|
1481
1606
|
}
|
|
1482
|
-
return
|
|
1607
|
+
return {
|
|
1608
|
+
data,
|
|
1609
|
+
extra: event.extra
|
|
1610
|
+
};
|
|
1483
1611
|
};
|
|
1612
|
+
/**
|
|
1613
|
+
* Runs the `onSend` interceptors over an emitter. Every interceptor receives the emitter
|
|
1614
|
+
* returned by the previous one.
|
|
1615
|
+
*/
|
|
1484
1616
|
var interceptEmitter = (interceptors, emitter) => {
|
|
1485
1617
|
let newEmitter = emitter;
|
|
1486
1618
|
for (const interceptor of interceptors) {
|
|
1487
|
-
newEmitter = interceptor({ emitter });
|
|
1619
|
+
newEmitter = interceptor({ emitter: newEmitter });
|
|
1488
1620
|
if (!newEmitter) throw new Error("Send modifier must return emitter");
|
|
1489
1621
|
}
|
|
1490
1622
|
return newEmitter;
|
|
@@ -1663,6 +1795,7 @@ var getServerSentEventsAdapter = (url, adapterOptions) => {
|
|
|
1663
1795
|
/** Create a preconfigured socket adapter for Server-Sent Events (EventSource) connections. */
|
|
1664
1796
|
var ServerSentEventsAdapter = () => new SocketAdapter({ name: "sse" }).setQueryParamsMapper(stringifyQueryParams).setConnector(({ socket, adapter, getQueryParams, onConnect, onConnectFailed, onReconnect, onDisconnect, onListen, onConnected, onDisconnected, onError, onEvent }) => {
|
|
1665
1797
|
let sse;
|
|
1798
|
+
let pendingConnection;
|
|
1666
1799
|
let timeout;
|
|
1667
1800
|
const autoConnect = typeof socket.adapter.adapterOptions?.autoConnect === "boolean" ? socket.adapter.adapterOptions?.autoConnect : true;
|
|
1668
1801
|
/** Maps an incoming message to the listener event, reporting decoder failures instead of throwing */
|
|
@@ -1679,31 +1812,47 @@ var ServerSentEventsAdapter = () => new SocketAdapter({ name: "sse" }).setQueryP
|
|
|
1679
1812
|
return null;
|
|
1680
1813
|
}
|
|
1681
1814
|
};
|
|
1682
|
-
const
|
|
1815
|
+
const scheduleReconnect = () => {
|
|
1816
|
+
clearTimeout(timeout);
|
|
1817
|
+
timeout = setTimeout(() => {
|
|
1818
|
+
reconnect();
|
|
1819
|
+
}, socket.reconnectTime);
|
|
1820
|
+
};
|
|
1821
|
+
const openConnection = async () => {
|
|
1683
1822
|
const connection = await onConnect();
|
|
1684
1823
|
if (!connection) return socket.adapter.connected;
|
|
1685
1824
|
clearTimeout(timeout);
|
|
1686
1825
|
sse?.clearListeners();
|
|
1687
1826
|
sse?.close();
|
|
1688
1827
|
const eventSource = createEventSource(getSocketUrl(connection.url, getQueryParams(connection.queryParams)), connection.adapterOptions);
|
|
1689
|
-
sse = eventSource;
|
|
1828
|
+
sse = eventSource ?? void 0;
|
|
1690
1829
|
if (!eventSource) return false;
|
|
1691
|
-
|
|
1692
|
-
|
|
1693
|
-
}, socket.reconnectTime);
|
|
1830
|
+
const isCurrent = () => sse === eventSource;
|
|
1831
|
+
scheduleReconnect();
|
|
1694
1832
|
/**
|
|
1695
1833
|
* Mount listeners
|
|
1696
1834
|
*/
|
|
1697
1835
|
eventSource.addEventListener("open", () => {
|
|
1836
|
+
if (!isCurrent()) return;
|
|
1698
1837
|
clearTimeout(timeout);
|
|
1699
1838
|
onConnected();
|
|
1700
1839
|
});
|
|
1701
1840
|
eventSource.addEventListener("error", (event) => {
|
|
1841
|
+
if (!isCurrent()) return;
|
|
1702
1842
|
const error = getSocketError(event);
|
|
1703
1843
|
onError({ error: new Error(error) });
|
|
1844
|
+
if (adapter.connected && eventSource.readyState !== EventSource.OPEN) {
|
|
1845
|
+
onDisconnected();
|
|
1846
|
+
if (eventSource.readyState === EventSource.CONNECTING) {
|
|
1847
|
+
adapter.setConnecting(true);
|
|
1848
|
+
socket.events.emitConnecting({ connecting: true });
|
|
1849
|
+
}
|
|
1850
|
+
scheduleReconnect();
|
|
1851
|
+
}
|
|
1704
1852
|
});
|
|
1705
1853
|
const { decode } = connection.adapterOptions || {};
|
|
1706
1854
|
eventSource.addEventListener("message", (newEvent) => {
|
|
1855
|
+
if (!isCurrent()) return;
|
|
1707
1856
|
const message = decodeMessage(newEvent, decode);
|
|
1708
1857
|
if (message) onEvent({
|
|
1709
1858
|
topic: message.topic,
|
|
@@ -1731,20 +1880,50 @@ var ServerSentEventsAdapter = () => new SocketAdapter({ name: "sse" }).setQueryP
|
|
|
1731
1880
|
eventSource.addEventListener("error", resolveError, { disableCleanup: true });
|
|
1732
1881
|
});
|
|
1733
1882
|
};
|
|
1734
|
-
const
|
|
1883
|
+
const connect = () => {
|
|
1884
|
+
if (adapter.connecting && pendingConnection) return pendingConnection;
|
|
1885
|
+
const connection = openConnection();
|
|
1886
|
+
pendingConnection = connection;
|
|
1887
|
+
const release = () => {
|
|
1888
|
+
if (pendingConnection === connection) pendingConnection = void 0;
|
|
1889
|
+
};
|
|
1890
|
+
connection.then(release, release);
|
|
1891
|
+
return connection;
|
|
1892
|
+
};
|
|
1893
|
+
/**
|
|
1894
|
+
* Closes the transport and resets the connection state. From this point the closed transport is detached -
|
|
1895
|
+
* whatever it reports later does not reach the socket anymore.
|
|
1896
|
+
*/
|
|
1897
|
+
const closeConnection = async ({ manual }) => {
|
|
1735
1898
|
clearTimeout(timeout);
|
|
1736
1899
|
const currentSse = sse;
|
|
1900
|
+
sse = void 0;
|
|
1737
1901
|
const hasTransport = currentSse && currentSse.readyState !== EventSource.CLOSED;
|
|
1738
|
-
const
|
|
1902
|
+
const wasActive = adapter.connected || adapter.connecting;
|
|
1739
1903
|
onDisconnect();
|
|
1740
|
-
if (
|
|
1741
|
-
if (hasTransport
|
|
1904
|
+
if (!manual) adapter.setForceClosed(false);
|
|
1905
|
+
if (hasTransport) {
|
|
1906
|
+
currentSse.clearListeners();
|
|
1907
|
+
currentSse.close();
|
|
1908
|
+
}
|
|
1909
|
+
if (hasTransport || wasActive) onDisconnected();
|
|
1742
1910
|
return true;
|
|
1743
1911
|
};
|
|
1744
|
-
|
|
1745
|
-
|
|
1746
|
-
|
|
1747
|
-
|
|
1912
|
+
/** Manual disconnect - the socket stays closed until `connect()` or `reconnect()` is called */
|
|
1913
|
+
const disconnect = () => {
|
|
1914
|
+
return closeConnection({ manual: true });
|
|
1915
|
+
};
|
|
1916
|
+
const reconnect = async () => {
|
|
1917
|
+
adapter.setForceClosed(false);
|
|
1918
|
+
await onReconnect({
|
|
1919
|
+
disconnect: () => closeConnection({ manual: false }),
|
|
1920
|
+
connect: async () => {
|
|
1921
|
+
if (adapter.forceClosed) {
|
|
1922
|
+
adapter.setReconnectionAttempts(0);
|
|
1923
|
+
return false;
|
|
1924
|
+
}
|
|
1925
|
+
return connect();
|
|
1926
|
+
}
|
|
1748
1927
|
});
|
|
1749
1928
|
};
|
|
1750
1929
|
/** Creates the transport, reporting a failed attempt when the environment or the connection details are invalid */
|
|
@@ -1764,12 +1943,12 @@ var ServerSentEventsAdapter = () => new SocketAdapter({ name: "sse" }).setQueryP
|
|
|
1764
1943
|
callback
|
|
1765
1944
|
});
|
|
1766
1945
|
};
|
|
1767
|
-
const emit =
|
|
1946
|
+
const emit = () => {
|
|
1768
1947
|
throw new Error("Cannot emit events in SSE adapter");
|
|
1769
1948
|
};
|
|
1770
1949
|
if (autoConnect) connect();
|
|
1771
1950
|
socket.appManager.events.onOnline(() => {
|
|
1772
|
-
if (autoConnect && !adapter.connected) connect();
|
|
1951
|
+
if (autoConnect && !adapter.connected && !adapter.forceClosed) connect();
|
|
1773
1952
|
});
|
|
1774
1953
|
return {
|
|
1775
1954
|
connect,
|