@hyper-fetch/sockets 9.6.0 → 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 +63 -6
- package/__tests__/features/adapter/adapter.sse.connection.spec.ts +45 -0
- 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 +289 -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 +101 -13
- package/src/adapter-websockets/websocket-adapter.ts +126 -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({
|
|
@@ -503,6 +548,7 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
|
|
|
503
548
|
});
|
|
504
549
|
return new Promise((resolve) => {
|
|
505
550
|
if (newWebsocket.readyState === WebSocket.OPEN) {
|
|
551
|
+
clearTimeout(timeout);
|
|
506
552
|
resolve(true);
|
|
507
553
|
socket.adapter.setConnected(true);
|
|
508
554
|
socket.adapter.setConnecting(false);
|
|
@@ -525,31 +571,55 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
|
|
|
525
571
|
newWebsocket.addEventListener("error", resolveError, { disableCleanup: true });
|
|
526
572
|
});
|
|
527
573
|
};
|
|
528
|
-
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 }) => {
|
|
529
590
|
clearTimeout(timeout);
|
|
591
|
+
clearTimers();
|
|
530
592
|
const currentWebsocket = websocket;
|
|
531
|
-
|
|
532
|
-
|
|
533
|
-
|
|
534
|
-
|
|
535
|
-
|
|
536
|
-
|
|
537
|
-
|
|
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) => {
|
|
538
600
|
const resolveDisconnected = () => {
|
|
539
601
|
resolve(true);
|
|
540
602
|
currentWebsocket.removeEventListener("close", resolveDisconnected);
|
|
541
603
|
};
|
|
542
604
|
currentWebsocket.addEventListener("close", resolveDisconnected, { disableCleanup: true });
|
|
605
|
+
currentWebsocket.close(1e3);
|
|
543
606
|
});
|
|
544
|
-
|
|
545
|
-
|
|
546
|
-
|
|
547
|
-
return
|
|
607
|
+
};
|
|
608
|
+
/** Manual disconnect - the socket stays closed until `connect()` or `reconnect()` is called */
|
|
609
|
+
const disconnect = () => {
|
|
610
|
+
return closeConnection({ manual: true });
|
|
548
611
|
};
|
|
549
612
|
const reconnect = async () => {
|
|
613
|
+
socket.adapter.setForceClosed(false);
|
|
550
614
|
await onReconnect({
|
|
551
|
-
disconnect,
|
|
552
|
-
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
|
+
}
|
|
553
623
|
});
|
|
554
624
|
};
|
|
555
625
|
/** Creates the transport, reporting a failed attempt when the environment or the connection details are invalid */
|
|
@@ -581,8 +651,9 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
|
|
|
581
651
|
return null;
|
|
582
652
|
}
|
|
583
653
|
};
|
|
654
|
+
/** Encodes and sends a message. Returns the error instead of throwing, so callers decide how to report it. */
|
|
584
655
|
const sendEventMessage = ({ topic, payload }) => {
|
|
585
|
-
if (!websocket) return
|
|
656
|
+
if (!websocket) return /* @__PURE__ */ new Error("Cannot send event when connection is not open");
|
|
586
657
|
try {
|
|
587
658
|
const frame = options?.encode ? options.encode({
|
|
588
659
|
topic,
|
|
@@ -592,10 +663,9 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
|
|
|
592
663
|
data: payload
|
|
593
664
|
});
|
|
594
665
|
websocket.send(frame);
|
|
595
|
-
return
|
|
666
|
+
return null;
|
|
596
667
|
} catch (error) {
|
|
597
|
-
|
|
598
|
-
return false;
|
|
668
|
+
return error instanceof Error ? error : new Error(String(error));
|
|
599
669
|
}
|
|
600
670
|
};
|
|
601
671
|
const onHeartbeat = () => {
|
|
@@ -605,15 +675,31 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
|
|
|
605
675
|
if (socket.adapter.connecting || !heartbeat) return;
|
|
606
676
|
clearTimers();
|
|
607
677
|
pingTimer = setTimeout(() => {
|
|
608
|
-
sendEventMessage({
|
|
678
|
+
const error = sendEventMessage({
|
|
609
679
|
topic: "heartbeat",
|
|
610
680
|
payload: heartbeatMessage
|
|
611
681
|
});
|
|
682
|
+
if (error) onError({ error });
|
|
612
683
|
pongTimer = setTimeout(() => {
|
|
613
|
-
|
|
684
|
+
onHeartbeatTimeout();
|
|
614
685
|
}, pongTimeout);
|
|
615
686
|
}, pingTimeout);
|
|
616
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
|
+
};
|
|
617
703
|
const listen = (listener, callback) => {
|
|
618
704
|
return onListen({
|
|
619
705
|
listener,
|
|
@@ -623,11 +709,20 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
|
|
|
623
709
|
const emit = async (emitter) => {
|
|
624
710
|
const mappedEmitter = await onEmit({ emitter });
|
|
625
711
|
if (!mappedEmitter) return;
|
|
626
|
-
|
|
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;
|
|
627
722
|
};
|
|
628
723
|
if (autoConnect) connect();
|
|
629
724
|
socket.appManager.events.onOnline(() => {
|
|
630
|
-
if (autoConnect && !socket.adapter.connected) connect();
|
|
725
|
+
if (autoConnect && !socket.adapter.connected && !socket.adapter.forceClosed) connect();
|
|
631
726
|
});
|
|
632
727
|
return {
|
|
633
728
|
connect,
|
|
@@ -638,6 +733,24 @@ var WebsocketAdapter = () => new SocketAdapter({ name: "websockets" }).setQueryP
|
|
|
638
733
|
};
|
|
639
734
|
});
|
|
640
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
|
|
641
754
|
//#region src/emitter/emitter.ts
|
|
642
755
|
/**
|
|
643
756
|
* Represents a socket message emitter bound to a specific topic. Use it to send typed payloads
|
|
@@ -678,11 +791,7 @@ var Emitter = class Emitter {
|
|
|
678
791
|
return this.clone({ params });
|
|
679
792
|
}
|
|
680
793
|
paramsMapper = (params) => {
|
|
681
|
-
|
|
682
|
-
if (params) Object.entries(params).forEach(([key, value]) => {
|
|
683
|
-
topic = topic.replaceAll(new RegExp(`:${key}`, "g"), String(value));
|
|
684
|
-
});
|
|
685
|
-
return topic;
|
|
794
|
+
return mapTopicParams(this.emitterOptions.topic, params);
|
|
686
795
|
};
|
|
687
796
|
/** Create a new emitter instance with optional configuration overrides. */
|
|
688
797
|
clone(config) {
|
|
@@ -701,7 +810,18 @@ var Emitter = class Emitter {
|
|
|
701
810
|
emit = (options = {}) => {
|
|
702
811
|
const typedOptions = options;
|
|
703
812
|
const instance = this.clone(typedOptions);
|
|
704
|
-
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
|
+
});
|
|
705
825
|
};
|
|
706
826
|
};
|
|
707
827
|
//#endregion
|
|
@@ -1185,11 +1305,14 @@ var Listener = class Listener {
|
|
|
1185
1305
|
delivery = void 0;
|
|
1186
1306
|
/** Stored with an `any` response for the same covariance reason as `delivery`. */
|
|
1187
1307
|
listenerOptions;
|
|
1308
|
+
/** Topic as it was declared (e.g. `chat/:roomId`) - clones keep it, so params can be set again */
|
|
1309
|
+
topicTemplate;
|
|
1188
1310
|
constructor(socket, listenerOptions) {
|
|
1189
1311
|
this.socket = socket;
|
|
1190
1312
|
this.listenerOptions = listenerOptions;
|
|
1191
1313
|
const { topic, options, delivery, params } = listenerOptions;
|
|
1192
1314
|
this.topic = topic;
|
|
1315
|
+
this.topicTemplate = topic;
|
|
1193
1316
|
this.options = options;
|
|
1194
1317
|
this.params = params;
|
|
1195
1318
|
this.delivery = delivery;
|
|
@@ -1212,11 +1335,13 @@ var Listener = class Listener {
|
|
|
1212
1335
|
}
|
|
1213
1336
|
/** Create a new listener instance with optional configuration overrides. */
|
|
1214
1337
|
clone(options) {
|
|
1215
|
-
|
|
1338
|
+
const newInstance = new Listener(this.socket, {
|
|
1216
1339
|
...this.listenerOptions,
|
|
1217
1340
|
...options,
|
|
1218
1341
|
topic: this.paramsMapper(options?.params || this.params)
|
|
1219
1342
|
});
|
|
1343
|
+
newInstance.topicTemplate = this.topicTemplate;
|
|
1344
|
+
return newInstance;
|
|
1220
1345
|
}
|
|
1221
1346
|
/** Start listening for messages on the configured topic. Returns a function to unsubscribe. */
|
|
1222
1347
|
listen = (callback) => {
|
|
@@ -1233,11 +1358,7 @@ var Listener = class Listener {
|
|
|
1233
1358
|
return removeListener;
|
|
1234
1359
|
};
|
|
1235
1360
|
paramsMapper = (params) => {
|
|
1236
|
-
|
|
1237
|
-
if (params) Object.entries(params).forEach(([key, value]) => {
|
|
1238
|
-
topic = topic.replaceAll(new RegExp(`:${key}`, "g"), String(value));
|
|
1239
|
-
});
|
|
1240
|
-
return topic;
|
|
1361
|
+
return mapTopicParams(this.topicTemplate, params);
|
|
1241
1362
|
};
|
|
1242
1363
|
};
|
|
1243
1364
|
//#endregion
|
|
@@ -1472,18 +1593,30 @@ var getListenerRemoveByTopicKey = (event) => `${event}_listener_remove`;
|
|
|
1472
1593
|
var getListenerEventByTopicKey = (event) => `${event}_listener_event`;
|
|
1473
1594
|
var getEmitterStartEventByTopicKey = (event) => `${event}_emitter_start_event`;
|
|
1474
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
|
+
*/
|
|
1475
1600
|
var interceptListener = (interceptors, event) => {
|
|
1476
|
-
let
|
|
1601
|
+
let { data } = event;
|
|
1477
1602
|
for (const interceptor of interceptors) {
|
|
1478
|
-
|
|
1479
|
-
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;
|
|
1480
1606
|
}
|
|
1481
|
-
return
|
|
1607
|
+
return {
|
|
1608
|
+
data,
|
|
1609
|
+
extra: event.extra
|
|
1610
|
+
};
|
|
1482
1611
|
};
|
|
1612
|
+
/**
|
|
1613
|
+
* Runs the `onSend` interceptors over an emitter. Every interceptor receives the emitter
|
|
1614
|
+
* returned by the previous one.
|
|
1615
|
+
*/
|
|
1483
1616
|
var interceptEmitter = (interceptors, emitter) => {
|
|
1484
1617
|
let newEmitter = emitter;
|
|
1485
1618
|
for (const interceptor of interceptors) {
|
|
1486
|
-
newEmitter = interceptor({ emitter });
|
|
1619
|
+
newEmitter = interceptor({ emitter: newEmitter });
|
|
1487
1620
|
if (!newEmitter) throw new Error("Send modifier must return emitter");
|
|
1488
1621
|
}
|
|
1489
1622
|
return newEmitter;
|
|
@@ -1662,6 +1795,8 @@ var getServerSentEventsAdapter = (url, adapterOptions) => {
|
|
|
1662
1795
|
/** Create a preconfigured socket adapter for Server-Sent Events (EventSource) connections. */
|
|
1663
1796
|
var ServerSentEventsAdapter = () => new SocketAdapter({ name: "sse" }).setQueryParamsMapper(stringifyQueryParams).setConnector(({ socket, adapter, getQueryParams, onConnect, onConnectFailed, onReconnect, onDisconnect, onListen, onConnected, onDisconnected, onError, onEvent }) => {
|
|
1664
1797
|
let sse;
|
|
1798
|
+
let pendingConnection;
|
|
1799
|
+
let timeout;
|
|
1665
1800
|
const autoConnect = typeof socket.adapter.adapterOptions?.autoConnect === "boolean" ? socket.adapter.adapterOptions?.autoConnect : true;
|
|
1666
1801
|
/** Maps an incoming message to the listener event, reporting decoder failures instead of throwing */
|
|
1667
1802
|
const decodeMessage = (event, decode) => {
|
|
@@ -1677,30 +1812,47 @@ var ServerSentEventsAdapter = () => new SocketAdapter({ name: "sse" }).setQueryP
|
|
|
1677
1812
|
return null;
|
|
1678
1813
|
}
|
|
1679
1814
|
};
|
|
1680
|
-
const
|
|
1815
|
+
const scheduleReconnect = () => {
|
|
1816
|
+
clearTimeout(timeout);
|
|
1817
|
+
timeout = setTimeout(() => {
|
|
1818
|
+
reconnect();
|
|
1819
|
+
}, socket.reconnectTime);
|
|
1820
|
+
};
|
|
1821
|
+
const openConnection = async () => {
|
|
1681
1822
|
const connection = await onConnect();
|
|
1682
1823
|
if (!connection) return socket.adapter.connected;
|
|
1824
|
+
clearTimeout(timeout);
|
|
1683
1825
|
sse?.clearListeners();
|
|
1684
1826
|
sse?.close();
|
|
1685
1827
|
const eventSource = createEventSource(getSocketUrl(connection.url, getQueryParams(connection.queryParams)), connection.adapterOptions);
|
|
1686
|
-
sse = eventSource;
|
|
1828
|
+
sse = eventSource ?? void 0;
|
|
1687
1829
|
if (!eventSource) return false;
|
|
1688
|
-
const
|
|
1689
|
-
|
|
1690
|
-
}, socket.reconnectTime);
|
|
1830
|
+
const isCurrent = () => sse === eventSource;
|
|
1831
|
+
scheduleReconnect();
|
|
1691
1832
|
/**
|
|
1692
1833
|
* Mount listeners
|
|
1693
1834
|
*/
|
|
1694
1835
|
eventSource.addEventListener("open", () => {
|
|
1836
|
+
if (!isCurrent()) return;
|
|
1695
1837
|
clearTimeout(timeout);
|
|
1696
1838
|
onConnected();
|
|
1697
1839
|
});
|
|
1698
1840
|
eventSource.addEventListener("error", (event) => {
|
|
1841
|
+
if (!isCurrent()) return;
|
|
1699
1842
|
const error = getSocketError(event);
|
|
1700
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
|
+
}
|
|
1701
1852
|
});
|
|
1702
1853
|
const { decode } = connection.adapterOptions || {};
|
|
1703
1854
|
eventSource.addEventListener("message", (newEvent) => {
|
|
1855
|
+
if (!isCurrent()) return;
|
|
1704
1856
|
const message = decodeMessage(newEvent, decode);
|
|
1705
1857
|
if (message) onEvent({
|
|
1706
1858
|
topic: message.topic,
|
|
@@ -1710,6 +1862,7 @@ var ServerSentEventsAdapter = () => new SocketAdapter({ name: "sse" }).setQueryP
|
|
|
1710
1862
|
});
|
|
1711
1863
|
return new Promise((resolve) => {
|
|
1712
1864
|
if (eventSource.readyState === EventSource.OPEN) {
|
|
1865
|
+
clearTimeout(timeout);
|
|
1713
1866
|
resolve(true);
|
|
1714
1867
|
adapter.setConnected(true);
|
|
1715
1868
|
adapter.setConnecting(false);
|
|
@@ -1727,19 +1880,50 @@ var ServerSentEventsAdapter = () => new SocketAdapter({ name: "sse" }).setQueryP
|
|
|
1727
1880
|
eventSource.addEventListener("error", resolveError, { disableCleanup: true });
|
|
1728
1881
|
});
|
|
1729
1882
|
};
|
|
1730
|
-
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 }) => {
|
|
1898
|
+
clearTimeout(timeout);
|
|
1731
1899
|
const currentSse = sse;
|
|
1900
|
+
sse = void 0;
|
|
1732
1901
|
const hasTransport = currentSse && currentSse.readyState !== EventSource.CLOSED;
|
|
1733
|
-
const
|
|
1902
|
+
const wasActive = adapter.connected || adapter.connecting;
|
|
1734
1903
|
onDisconnect();
|
|
1735
|
-
if (
|
|
1736
|
-
if (hasTransport
|
|
1904
|
+
if (!manual) adapter.setForceClosed(false);
|
|
1905
|
+
if (hasTransport) {
|
|
1906
|
+
currentSse.clearListeners();
|
|
1907
|
+
currentSse.close();
|
|
1908
|
+
}
|
|
1909
|
+
if (hasTransport || wasActive) onDisconnected();
|
|
1737
1910
|
return true;
|
|
1738
1911
|
};
|
|
1739
|
-
|
|
1740
|
-
|
|
1741
|
-
|
|
1742
|
-
|
|
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
|
+
}
|
|
1743
1927
|
});
|
|
1744
1928
|
};
|
|
1745
1929
|
/** Creates the transport, reporting a failed attempt when the environment or the connection details are invalid */
|
|
@@ -1759,12 +1943,12 @@ var ServerSentEventsAdapter = () => new SocketAdapter({ name: "sse" }).setQueryP
|
|
|
1759
1943
|
callback
|
|
1760
1944
|
});
|
|
1761
1945
|
};
|
|
1762
|
-
const emit =
|
|
1946
|
+
const emit = () => {
|
|
1763
1947
|
throw new Error("Cannot emit events in SSE adapter");
|
|
1764
1948
|
};
|
|
1765
1949
|
if (autoConnect) connect();
|
|
1766
1950
|
socket.appManager.events.onOnline(() => {
|
|
1767
|
-
if (autoConnect && !adapter.connected) connect();
|
|
1951
|
+
if (autoConnect && !adapter.connected && !adapter.forceClosed) connect();
|
|
1768
1952
|
});
|
|
1769
1953
|
return {
|
|
1770
1954
|
connect,
|