@hyper-fetch/sockets 1.0.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.
- package/.eslintrc.json +7 -0
- package/README.md +76 -0
- package/dist/client/client.d.ts +28 -0
- package/dist/client/client.types.d.ts +30 -0
- package/dist/client/client.utils.d.ts +2 -0
- package/dist/client/index.d.ts +3 -0
- package/dist/emitter/emitter.d.ts +20 -0
- package/dist/emitter/emitter.types.d.ts +10 -0
- package/dist/emitter/index.d.ts +2 -0
- package/dist/index.cjs.js +2 -0
- package/dist/index.cjs.js.map +7 -0
- package/dist/index.d.ts +5 -0
- package/dist/index.esm.js +2 -0
- package/dist/index.esm.js.map +7 -0
- package/dist/listener/index.d.ts +2 -0
- package/dist/listener/listener.d.ts +14 -0
- package/dist/listener/listener.types.d.ts +6 -0
- package/dist/socket/index.d.ts +4 -0
- package/dist/socket/socket.d.ts +139 -0
- package/dist/socket/socket.events.d.ts +27 -0
- package/dist/socket/socket.types.d.ts +29 -0
- package/dist/socket/socket.utils.d.ts +16 -0
- package/dist/types/extract.types.d.ts +7 -0
- package/dist/types/index.d.ts +2 -0
- package/dist/types/tuple.types.d.ts +1 -0
- package/package.json +65 -0
- package/src/client/client.ts +230 -0
- package/src/client/client.types.ts +36 -0
- package/src/client/client.utils.ts +15 -0
- package/src/client/index.ts +3 -0
- package/src/emitter/emitter.ts +77 -0
- package/src/emitter/emitter.types.ts +15 -0
- package/src/emitter/index.ts +2 -0
- package/src/index.ts +5 -0
- package/src/listener/index.ts +2 -0
- package/src/listener/listener.ts +44 -0
- package/src/listener/listener.types.ts +8 -0
- package/src/socket/index.ts +4 -0
- package/src/socket/socket.events.ts +119 -0
- package/src/socket/socket.ts +235 -0
- package/src/socket/socket.types.ts +33 -0
- package/src/socket/socket.utils.ts +43 -0
- package/src/types/extract.types.ts +16 -0
- package/src/types/index.ts +2 -0
- package/src/types/tuple.types.ts +1 -0
- package/tsconfig.json +8 -0
|
@@ -0,0 +1,139 @@
|
|
|
1
|
+
/// <reference types="node" />
|
|
2
|
+
import EventEmitter from "events";
|
|
3
|
+
import { StringifyCallbackType, QueryStringifyOptions, LoggerManager, SeverityType, AppManager, ClientQueryParamsType } from "@hyper-fetch/core";
|
|
4
|
+
import { SocketConfig, ReconnectCallbackType, ReconnectStopCallbackType, OpenCallbackType, CloseCallbackType, MessageCallbackType, SendCallbackType, ErrorCallbackType } from "socket";
|
|
5
|
+
import { WebsocketClientType } from "client";
|
|
6
|
+
import { Listener, ListenerOptionsType } from "listener";
|
|
7
|
+
import { Emitter, EmitterInstance, EmitterOptionsType } from "emitter";
|
|
8
|
+
export declare class Socket<ClientType extends Record<keyof WebsocketClientType, any>> {
|
|
9
|
+
options: SocketConfig<ClientType>;
|
|
10
|
+
emitter: EventEmitter;
|
|
11
|
+
events: {
|
|
12
|
+
emitError: <ResponseType_1 = MessageEvent<any>>(event: ResponseType_1) => void;
|
|
13
|
+
emitOpen: () => void;
|
|
14
|
+
emitClose: () => void;
|
|
15
|
+
emitConnecting: () => void;
|
|
16
|
+
emitReconnecting: (attempts: number) => void;
|
|
17
|
+
emitReconnectingStop: (attempts: number) => void;
|
|
18
|
+
emitListenerEvent: <ResponseType_2 = MessageEvent<any>>(name: string, data: ResponseType_2, event: MessageEvent<ResponseType_2>) => void;
|
|
19
|
+
emitListenerRemoveEvent: (name: string) => void;
|
|
20
|
+
emitEmitterEvent: <EmitterType extends EmitterInstance>(emitter: EmitterType) => void;
|
|
21
|
+
onError: (callback: <ResponseType_3 = MessageEvent<any>>(event: ResponseType_3) => void) => VoidFunction;
|
|
22
|
+
onOpen: (callback: () => void) => VoidFunction;
|
|
23
|
+
onClose: (callback: () => void) => VoidFunction;
|
|
24
|
+
onConnecting: (callback: () => void) => VoidFunction;
|
|
25
|
+
onReconnecting: (callback: (attempts: number) => void) => VoidFunction;
|
|
26
|
+
onReconnectingStop: (callback: (attempts: number) => void) => VoidFunction;
|
|
27
|
+
onListenerEvent: <ResponseType_4 = Event>(callback: (data: ResponseType_4, event: MessageEvent<ResponseType_4>) => void) => VoidFunction;
|
|
28
|
+
onEmitterEvent: <EmitterType_1 extends EmitterInstance>(callback: (emitter: EmitterType_1) => void) => VoidFunction;
|
|
29
|
+
onListenerEventByName: <ListenerType extends import("listener").ListenerInstance>(listener: ListenerType, callback: (data: import("..").ExtractListenerResponseType<ListenerType>, event: MessageEvent<import("..").ExtractListenerResponseType<ListenerType>>) => void) => VoidFunction;
|
|
30
|
+
onListenerRemove: (callback: (name: string) => void) => VoidFunction;
|
|
31
|
+
onListenerRemoveByName: <ListenerType_1 extends import("listener").ListenerInstance>(listener: ListenerType_1, callback: () => void) => VoidFunction;
|
|
32
|
+
onEmitterEventByName: <EmitterType_2 extends EmitterInstance>(emitter: EmitterType_2, callback: (emitter: EmitterType_2) => void) => VoidFunction;
|
|
33
|
+
};
|
|
34
|
+
url: string;
|
|
35
|
+
reconnect: number;
|
|
36
|
+
reconnectTime: number;
|
|
37
|
+
auth?: ClientQueryParamsType | string;
|
|
38
|
+
queryParams?: ClientQueryParamsType | string;
|
|
39
|
+
debug: boolean;
|
|
40
|
+
autoConnect: boolean;
|
|
41
|
+
__onOpenCallbacks: OpenCallbackType<Socket<ClientType>, any>[];
|
|
42
|
+
__onCloseCallbacks: CloseCallbackType<Socket<ClientType>, any>[];
|
|
43
|
+
__onReconnectCallbacks: ReconnectCallbackType<Socket<ClientType>>[];
|
|
44
|
+
__onReconnectStopCallbacks: ReconnectStopCallbackType<Socket<ClientType>>[];
|
|
45
|
+
__onMessageCallbacks: MessageCallbackType<Socket<ClientType>, any>[];
|
|
46
|
+
__onSendCallbacks: SendCallbackType<EmitterInstance>[];
|
|
47
|
+
__onErrorCallbacks: ErrorCallbackType<Socket<ClientType>, any>[];
|
|
48
|
+
client: ClientType;
|
|
49
|
+
loggerManager: LoggerManager;
|
|
50
|
+
appManager: AppManager;
|
|
51
|
+
queryParamsConfig?: QueryStringifyOptions;
|
|
52
|
+
logger: LoggerType;
|
|
53
|
+
/**
|
|
54
|
+
* Method to stringify query params from objects.
|
|
55
|
+
*/
|
|
56
|
+
queryParamsStringify: StringifyCallbackType;
|
|
57
|
+
constructor(options: SocketConfig<ClientType>);
|
|
58
|
+
/**
|
|
59
|
+
* This method enables the logger usage and display the logs in console
|
|
60
|
+
*/
|
|
61
|
+
setDebug: (debug: boolean) => this;
|
|
62
|
+
/**
|
|
63
|
+
* Set the logger severity of the messages displayed to the console
|
|
64
|
+
*/
|
|
65
|
+
setLoggerSeverity: (severity: SeverityType) => this;
|
|
66
|
+
/**
|
|
67
|
+
* Set the new logger instance to the socket
|
|
68
|
+
*/
|
|
69
|
+
setLogger: (callback: (socket: Socket<ClientType>) => LoggerManager) => this;
|
|
70
|
+
/**
|
|
71
|
+
* Callbacks
|
|
72
|
+
*/
|
|
73
|
+
/**
|
|
74
|
+
* Triggered when connection is opened
|
|
75
|
+
* @param callback
|
|
76
|
+
* @returns
|
|
77
|
+
*/
|
|
78
|
+
onOpen<Event = MessageEvent>(callback: OpenCallbackType<Socket<ClientType>, Event>): this;
|
|
79
|
+
/**
|
|
80
|
+
* Triggered when connection is closed
|
|
81
|
+
* @param callback
|
|
82
|
+
* @returns
|
|
83
|
+
*/
|
|
84
|
+
onClose<Event = MessageEvent>(callback: CloseCallbackType<Socket<ClientType>, Event>): this;
|
|
85
|
+
/**
|
|
86
|
+
* Triggered when connection is getting reconnected
|
|
87
|
+
* @param callback
|
|
88
|
+
* @returns
|
|
89
|
+
*/
|
|
90
|
+
onReconnect(callback: ReconnectCallbackType<Socket<ClientType>>): this;
|
|
91
|
+
/**
|
|
92
|
+
* Triggered when connection attempts are stopped
|
|
93
|
+
* @param callback
|
|
94
|
+
* @returns
|
|
95
|
+
*/
|
|
96
|
+
onReconnectStop(callback: ReconnectStopCallbackType<Socket<ClientType>>): this;
|
|
97
|
+
/**
|
|
98
|
+
* Triggered when any message is received
|
|
99
|
+
* @param callback
|
|
100
|
+
* @returns
|
|
101
|
+
*/
|
|
102
|
+
onMessage<Event = MessageEvent>(callback: MessageCallbackType<Socket<ClientType>, Event>): this;
|
|
103
|
+
/**
|
|
104
|
+
* Triggered when any event is emitted
|
|
105
|
+
* @param callback
|
|
106
|
+
* @returns
|
|
107
|
+
*/
|
|
108
|
+
onSend<EmitterType extends EmitterInstance>(callback: SendCallbackType<EmitterType>): this;
|
|
109
|
+
/**
|
|
110
|
+
* Triggered when we receive error
|
|
111
|
+
* @param callback
|
|
112
|
+
* @returns
|
|
113
|
+
*/
|
|
114
|
+
onError<Event = MessageEvent>(callback: ErrorCallbackType<Socket<ClientType>, Event>): this;
|
|
115
|
+
/**
|
|
116
|
+
* ********************
|
|
117
|
+
* Interceptors
|
|
118
|
+
* ********************
|
|
119
|
+
*/
|
|
120
|
+
__modifySend: (emitter: EmitterInstance) => EmitterInstance;
|
|
121
|
+
__modifyResponse: (response: MessageEvent) => MessageEvent<any>;
|
|
122
|
+
/**
|
|
123
|
+
* ********************
|
|
124
|
+
* Creators
|
|
125
|
+
* ********************
|
|
126
|
+
*/
|
|
127
|
+
/**
|
|
128
|
+
* Create event listener
|
|
129
|
+
* @param options
|
|
130
|
+
* @returns
|
|
131
|
+
*/
|
|
132
|
+
createListener: <ResponseType_1>(options: ListenerOptionsType<ClientType>) => Listener<ResponseType_1, ClientType>;
|
|
133
|
+
/**
|
|
134
|
+
* Create event emitter
|
|
135
|
+
* @param options
|
|
136
|
+
* @returns
|
|
137
|
+
*/
|
|
138
|
+
createEmitter: <RequestDataType, ResponseDataType = never>(options: EmitterOptionsType<ClientType>) => Emitter<RequestDataType, ResponseDataType, ClientType, void>;
|
|
139
|
+
}
|
|
@@ -0,0 +1,27 @@
|
|
|
1
|
+
import EventEmitter from "events";
|
|
2
|
+
import { EmitterInstance } from "emitter";
|
|
3
|
+
import { ListenerInstance } from "listener";
|
|
4
|
+
import { ExtractListenerResponseType } from "types/extract.types";
|
|
5
|
+
export declare const getSocketEvents: (eventEmitter: EventEmitter) => {
|
|
6
|
+
emitError: <ResponseType_1 = MessageEvent<any>>(event: ResponseType_1) => void;
|
|
7
|
+
emitOpen: () => void;
|
|
8
|
+
emitClose: () => void;
|
|
9
|
+
emitConnecting: () => void;
|
|
10
|
+
emitReconnecting: (attempts: number) => void;
|
|
11
|
+
emitReconnectingStop: (attempts: number) => void;
|
|
12
|
+
emitListenerEvent: <ResponseType_2 = MessageEvent<any>>(name: string, data: ResponseType_2, event: MessageEvent<ResponseType_2>) => void;
|
|
13
|
+
emitListenerRemoveEvent: (name: string) => void;
|
|
14
|
+
emitEmitterEvent: <EmitterType extends EmitterInstance>(emitter: EmitterType) => void;
|
|
15
|
+
onError: (callback: <ResponseType_3 = MessageEvent<any>>(event: ResponseType_3) => void) => VoidFunction;
|
|
16
|
+
onOpen: (callback: () => void) => VoidFunction;
|
|
17
|
+
onClose: (callback: () => void) => VoidFunction;
|
|
18
|
+
onConnecting: (callback: () => void) => VoidFunction;
|
|
19
|
+
onReconnecting: (callback: (attempts: number) => void) => VoidFunction;
|
|
20
|
+
onReconnectingStop: (callback: (attempts: number) => void) => VoidFunction;
|
|
21
|
+
onListenerEvent: <ResponseType_4 = Event>(callback: (data: ResponseType_4, event: MessageEvent<ResponseType_4>) => void) => VoidFunction;
|
|
22
|
+
onEmitterEvent: <EmitterType_1 extends EmitterInstance>(callback: (emitter: EmitterType_1) => void) => VoidFunction;
|
|
23
|
+
onListenerEventByName: <ListenerType extends ListenerInstance>(listener: ListenerType, callback: (data: ExtractListenerResponseType<ListenerType>, event: MessageEvent<ExtractListenerResponseType<ListenerType>>) => void) => VoidFunction;
|
|
24
|
+
onListenerRemove: (callback: (name: string) => void) => VoidFunction;
|
|
25
|
+
onListenerRemoveByName: <ListenerType_1 extends ListenerInstance>(listener: ListenerType_1, callback: () => void) => VoidFunction;
|
|
26
|
+
onEmitterEventByName: <EmitterType_2 extends EmitterInstance>(emitter: EmitterType_2, callback: (emitter: EmitterType_2) => void) => VoidFunction;
|
|
27
|
+
};
|
|
@@ -0,0 +1,29 @@
|
|
|
1
|
+
import { ClientQueryParamsType, QueryStringifyOptions, StringifyCallbackType } from "@hyper-fetch/core";
|
|
2
|
+
import { Socket } from "socket";
|
|
3
|
+
import { ServerSentEventsClientOptionsType, WebsocketClientOptionsType } from "client";
|
|
4
|
+
import { EmitterInstance } from "emitter";
|
|
5
|
+
export type SocketInstance = Socket<any>;
|
|
6
|
+
export type SocketConfigBaseType<SocketClientType> = {
|
|
7
|
+
url: string;
|
|
8
|
+
client?: SocketClientType;
|
|
9
|
+
auth?: ClientQueryParamsType;
|
|
10
|
+
queryParams?: ClientQueryParamsType | string;
|
|
11
|
+
reconnect?: number;
|
|
12
|
+
reconnectTime?: number;
|
|
13
|
+
autoConnect?: boolean;
|
|
14
|
+
queryParamsConfig?: QueryStringifyOptions;
|
|
15
|
+
queryParamsStringify?: StringifyCallbackType;
|
|
16
|
+
};
|
|
17
|
+
export type SocketConfig<SocketClientType> = (SocketConfigBaseType<SocketClientType> & {
|
|
18
|
+
isSSE: true;
|
|
19
|
+
clientOptions?: ServerSentEventsClientOptionsType;
|
|
20
|
+
}) | (SocketConfigBaseType<SocketClientType> & {
|
|
21
|
+
clientOptions?: WebsocketClientOptionsType;
|
|
22
|
+
});
|
|
23
|
+
export type ReconnectCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
|
|
24
|
+
export type ReconnectStopCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
|
|
25
|
+
export type OpenCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => void;
|
|
26
|
+
export type CloseCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => void;
|
|
27
|
+
export type MessageCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => Event;
|
|
28
|
+
export type SendCallbackType<EmitterType extends EmitterInstance> = (emitter: EmitterType) => EmitterInstance;
|
|
29
|
+
export type ErrorCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => void;
|
|
@@ -0,0 +1,16 @@
|
|
|
1
|
+
import { EmitterInstance } from "emitter";
|
|
2
|
+
import { MessageCallbackType, SendCallbackType, SocketInstance } from "./socket.types";
|
|
3
|
+
export declare const getErrorKey: () => string;
|
|
4
|
+
export declare const getOpenKey: () => string;
|
|
5
|
+
export declare const getCloseKey: () => string;
|
|
6
|
+
export declare const getConnectingKey: () => string;
|
|
7
|
+
export declare const getReconnectingKey: () => string;
|
|
8
|
+
export declare const getReconnectingStopKey: () => string;
|
|
9
|
+
export declare const getListenerEventKey: () => string;
|
|
10
|
+
export declare const getListenerRemoveKey: () => string;
|
|
11
|
+
export declare const getEmitterEventKey: () => string;
|
|
12
|
+
export declare const getListenerRemoveByNameKey: (event: string) => string;
|
|
13
|
+
export declare const getListenerEventByNameKey: (event: string) => string;
|
|
14
|
+
export declare const getEmitterEventByNameKey: (event: string) => string;
|
|
15
|
+
export declare const interceptListener: <SocketType extends SocketInstance>(interceptors: MessageCallbackType<SocketType, MessageEvent<any>>[], response: MessageEvent, socket: SocketType) => MessageEvent<any>;
|
|
16
|
+
export declare const interceptEmitter: <EmitterType extends EmitterInstance>(interceptors: SendCallbackType<EmitterType>[], emitter: EmitterType) => EmitterType;
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
import { WebsocketClientType } from "client";
|
|
2
|
+
import { Emitter } from "emitter";
|
|
3
|
+
import { Listener } from "listener";
|
|
4
|
+
export type ExtractEmitterOptionsType<T extends Record<keyof WebsocketClientType | string, any>> = T["emitterOptions"];
|
|
5
|
+
export type ExtractListenerOptionsType<T extends Record<keyof WebsocketClientType | string, any>> = T["listenerOptions"];
|
|
6
|
+
export type ExtractListenerResponseType<T> = T extends Listener<infer R, any> ? R : never;
|
|
7
|
+
export type ExtractListenerDataType<T> = T extends Emitter<infer D, any, any> ? D : never;
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
export type TupleRestType<T> = T extends [first: any, ...rest: infer Rest] ? (Rest extends Array<any> ? Rest : []) : [];
|
package/package.json
ADDED
|
@@ -0,0 +1,65 @@
|
|
|
1
|
+
{
|
|
2
|
+
"name": "@hyper-fetch/sockets",
|
|
3
|
+
"version": "1.0.0",
|
|
4
|
+
"private": false,
|
|
5
|
+
"description": "",
|
|
6
|
+
"author": "Maciej Pyrc <m.pyrc@interia.pl>",
|
|
7
|
+
"homepage": "https://hyperfetch.bettertyped.com/",
|
|
8
|
+
"license": "Apache-2.0",
|
|
9
|
+
"main": "dist/index.cjs.js",
|
|
10
|
+
"module": "dist/index.esm.js",
|
|
11
|
+
"types": "dist/index.d.ts",
|
|
12
|
+
"source": "src/index.ts",
|
|
13
|
+
"scripts": {
|
|
14
|
+
"prepublishOnly": "yarn build",
|
|
15
|
+
"clean": "npx rimraf dist",
|
|
16
|
+
"test": "jest --watchAll --maxWorkers=3",
|
|
17
|
+
"test-pipeline": "jest --watchAll=false --maxWorkers=1 --no-cache",
|
|
18
|
+
"start": "yarn build && npx run-when-changed --watch 'src/**/*.ts' --exec 'yarn build'",
|
|
19
|
+
"build": "yarn clean && node ../../scripts/build.js",
|
|
20
|
+
"postbuild": "ttsc --project tsconfig.json --outDir dist",
|
|
21
|
+
"lint": "eslint . --ext .js,.jsx,.tsx,.ts --fix",
|
|
22
|
+
"format": "prettier --write .",
|
|
23
|
+
"typecheck": "tsc --noEmit --emitDeclarationOnly false",
|
|
24
|
+
"precommit": "yarn lint-staged",
|
|
25
|
+
"release": "yarn semantic-release --extends ../../release.config.js -t 'hyper-fetch-sockets-v${version}'"
|
|
26
|
+
},
|
|
27
|
+
"publishConfig": {
|
|
28
|
+
"access": "public",
|
|
29
|
+
"registry": "https://registry.npmjs.com/"
|
|
30
|
+
},
|
|
31
|
+
"repository": {
|
|
32
|
+
"type": "git",
|
|
33
|
+
"url": "git+https://github.com/BetterTyped/hyper-fetch.git",
|
|
34
|
+
"directory": "packages/sockets"
|
|
35
|
+
},
|
|
36
|
+
"bugs": {
|
|
37
|
+
"url": "https://github.com/BetterTyped/hyper-fetch/issues"
|
|
38
|
+
},
|
|
39
|
+
"peerDependencies": {
|
|
40
|
+
"@hyper-fetch/core": "*"
|
|
41
|
+
},
|
|
42
|
+
"dependencies": {
|
|
43
|
+
"events": "^3.3.0"
|
|
44
|
+
},
|
|
45
|
+
"devDependencies": {
|
|
46
|
+
"eventsourcemock": "^2.0.0"
|
|
47
|
+
},
|
|
48
|
+
"lint-staged": {
|
|
49
|
+
"*.{js,jsx,ts,tsx}": [
|
|
50
|
+
"yarn jest --passWithNoTests"
|
|
51
|
+
]
|
|
52
|
+
},
|
|
53
|
+
"keywords": [
|
|
54
|
+
"websockets",
|
|
55
|
+
"sse",
|
|
56
|
+
"server sent events",
|
|
57
|
+
"heartbeat",
|
|
58
|
+
"reconnect",
|
|
59
|
+
"offline",
|
|
60
|
+
"listener",
|
|
61
|
+
"emitter",
|
|
62
|
+
"socket",
|
|
63
|
+
"events"
|
|
64
|
+
]
|
|
65
|
+
}
|
|
@@ -0,0 +1,230 @@
|
|
|
1
|
+
import { DateInterval, LoggerType, parseResponse } from "@hyper-fetch/core";
|
|
2
|
+
|
|
3
|
+
import { EmitterInstance } from "emitter";
|
|
4
|
+
import { ListenerInstance } from "listener";
|
|
5
|
+
import { SocketInstance } from "socket";
|
|
6
|
+
import { getClient, WebsocketClientOptionsType, ListenerCallbackType, WSMessageType } from "client";
|
|
7
|
+
|
|
8
|
+
export class SocketClient<SocketType extends SocketInstance> {
|
|
9
|
+
client: WebSocket | EventSource | undefined;
|
|
10
|
+
listeners: Map<string, Set<ListenerCallbackType>> = new Map();
|
|
11
|
+
open = false;
|
|
12
|
+
connecting = false;
|
|
13
|
+
forceClosed = false;
|
|
14
|
+
reconnectionAttempts = 0;
|
|
15
|
+
pingTimer: ReturnType<typeof setTimeout> | undefined;
|
|
16
|
+
pongTimer: ReturnType<typeof setTimeout> | undefined;
|
|
17
|
+
|
|
18
|
+
init: () => WebSocket | EventSource;
|
|
19
|
+
logger: LoggerType;
|
|
20
|
+
|
|
21
|
+
constructor(readonly socket: SocketType) {
|
|
22
|
+
this.init = () => getClient(socket);
|
|
23
|
+
this.logger = this.socket.loggerManager.init("Socket Client");
|
|
24
|
+
|
|
25
|
+
this.socket.appManager.events.onOnline(() => {
|
|
26
|
+
if (this.socket.autoConnect && !this.open) {
|
|
27
|
+
this.logger.info("Auto re-connecting");
|
|
28
|
+
this.connect();
|
|
29
|
+
}
|
|
30
|
+
});
|
|
31
|
+
|
|
32
|
+
if (this.socket.autoConnect) {
|
|
33
|
+
this.logger.info("Auto connecting");
|
|
34
|
+
this.connect();
|
|
35
|
+
}
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
connect = () => {
|
|
39
|
+
if (this.socket.appManager.isNodeJs || !this.socket.appManager.isOnline || this.connecting) return;
|
|
40
|
+
const { reconnectTimeout = DateInterval.second * 2 } = this.socket.options.clientOptions || {};
|
|
41
|
+
|
|
42
|
+
this.socket.events.emitConnecting();
|
|
43
|
+
|
|
44
|
+
// Clean environment
|
|
45
|
+
this.forceClosed = false;
|
|
46
|
+
this.client?.close();
|
|
47
|
+
|
|
48
|
+
// Start connection
|
|
49
|
+
this.connecting = true;
|
|
50
|
+
|
|
51
|
+
// Initialize new client instance
|
|
52
|
+
this.client = this.init();
|
|
53
|
+
|
|
54
|
+
// Reconnection timeout
|
|
55
|
+
const timeout = setTimeout(() => {
|
|
56
|
+
this.reconnect();
|
|
57
|
+
}, reconnectTimeout);
|
|
58
|
+
|
|
59
|
+
/**
|
|
60
|
+
* Mount listeners
|
|
61
|
+
*/
|
|
62
|
+
|
|
63
|
+
this.client.onopen = (event) => {
|
|
64
|
+
this.logger.info("Connection open", { event });
|
|
65
|
+
clearTimeout(timeout);
|
|
66
|
+
this.socket.__onOpenCallbacks.forEach((callback) => {
|
|
67
|
+
callback(event, this.socket);
|
|
68
|
+
});
|
|
69
|
+
this.open = true;
|
|
70
|
+
this.connecting = false;
|
|
71
|
+
this.reconnectionAttempts = 0;
|
|
72
|
+
this.socket.events.emitOpen();
|
|
73
|
+
this.heartbeat();
|
|
74
|
+
};
|
|
75
|
+
|
|
76
|
+
if (this.client && "onclose" in this.client) {
|
|
77
|
+
this.client.onclose = (event) => {
|
|
78
|
+
this.logger.info("Connection closed", { event });
|
|
79
|
+
this.socket.__onCloseCallbacks.forEach((callback) => {
|
|
80
|
+
callback(event, this.socket);
|
|
81
|
+
});
|
|
82
|
+
this.open = false;
|
|
83
|
+
this.connecting = false;
|
|
84
|
+
this.socket.events.emitClose();
|
|
85
|
+
this.clearTimers();
|
|
86
|
+
};
|
|
87
|
+
}
|
|
88
|
+
|
|
89
|
+
this.client.onerror = (event) => {
|
|
90
|
+
this.logger.info("Error message", { event });
|
|
91
|
+
this.socket.__onErrorCallbacks.forEach((callback) => {
|
|
92
|
+
callback(event, this.socket);
|
|
93
|
+
});
|
|
94
|
+
this.socket.events.emitError(event);
|
|
95
|
+
};
|
|
96
|
+
|
|
97
|
+
this.client.onmessage = (event) => {
|
|
98
|
+
this.logger.info("New event message", { event });
|
|
99
|
+
|
|
100
|
+
const response = this.socket.__modifyResponse(event);
|
|
101
|
+
const data = parseResponse(response.data);
|
|
102
|
+
const listeners = this.listeners.get(data.name) || [];
|
|
103
|
+
listeners.forEach((callback) => {
|
|
104
|
+
callback(data, event);
|
|
105
|
+
});
|
|
106
|
+
this.socket.events.emitListenerEvent(data.name, data, event);
|
|
107
|
+
this.heartbeat();
|
|
108
|
+
};
|
|
109
|
+
};
|
|
110
|
+
|
|
111
|
+
disconnect = () => {
|
|
112
|
+
this.logger.debug("Disconnecting", { reconnectionAttempts: this.reconnectionAttempts });
|
|
113
|
+
this.open = false;
|
|
114
|
+
this.connecting = false;
|
|
115
|
+
this.forceClosed = true;
|
|
116
|
+
this.client.close();
|
|
117
|
+
this.clearTimers();
|
|
118
|
+
const isSSE = !(this.client && "onclose" in this.client);
|
|
119
|
+
if (isSSE) {
|
|
120
|
+
this.socket.__onCloseCallbacks.forEach((callback) => {
|
|
121
|
+
callback({}, this.socket);
|
|
122
|
+
});
|
|
123
|
+
this.socket.events.emitClose();
|
|
124
|
+
}
|
|
125
|
+
};
|
|
126
|
+
|
|
127
|
+
reconnect = () => {
|
|
128
|
+
this.disconnect();
|
|
129
|
+
if (this.reconnectionAttempts < this.socket.reconnect) {
|
|
130
|
+
this.reconnectionAttempts += 1;
|
|
131
|
+
this.logger.debug("Reconnecting", { reconnectionAttempts: this.reconnectionAttempts });
|
|
132
|
+
this.connect();
|
|
133
|
+
this.socket.__onReconnectCallbacks.forEach((callback) => {
|
|
134
|
+
callback(this.socket);
|
|
135
|
+
});
|
|
136
|
+
this.socket.events.emitReconnecting(this.reconnectionAttempts);
|
|
137
|
+
return true;
|
|
138
|
+
}
|
|
139
|
+
this.logger.debug("Stopped reconnecting", { reconnectionAttempts: this.reconnectionAttempts });
|
|
140
|
+
this.socket.__onReconnectStopCallbacks.forEach((callback) => {
|
|
141
|
+
callback(this.socket);
|
|
142
|
+
});
|
|
143
|
+
this.socket.events.emitReconnectingStop(this.reconnectionAttempts);
|
|
144
|
+
return false;
|
|
145
|
+
};
|
|
146
|
+
|
|
147
|
+
clearTimers = () => {
|
|
148
|
+
clearTimeout(this.pingTimer);
|
|
149
|
+
clearTimeout(this.pongTimer);
|
|
150
|
+
};
|
|
151
|
+
|
|
152
|
+
sendEventMessage = (payload: WSMessageType) => {
|
|
153
|
+
if (this.client && "send" in this.client) {
|
|
154
|
+
this.client.send(JSON.stringify({ id: payload.id, name: payload.name, data: payload.data }));
|
|
155
|
+
}
|
|
156
|
+
};
|
|
157
|
+
|
|
158
|
+
heartbeat = () => {
|
|
159
|
+
const options = (this.socket.options.clientOptions || {}) as WebsocketClientOptionsType;
|
|
160
|
+
const {
|
|
161
|
+
heartbeat = false,
|
|
162
|
+
pingTimeout = DateInterval.second * 5,
|
|
163
|
+
pongTimeout = DateInterval.second * 5,
|
|
164
|
+
heartbeatMessage = "heartbeat",
|
|
165
|
+
} = options;
|
|
166
|
+
if (this.connecting || !heartbeat) return;
|
|
167
|
+
if (this.client && "send" in this.client) {
|
|
168
|
+
this.clearTimers();
|
|
169
|
+
this.pingTimer = setTimeout(() => {
|
|
170
|
+
if (this.client && "send" in this.client) {
|
|
171
|
+
this.logger.debug("[Heartbeat]: Start");
|
|
172
|
+
const id = "heartbeat";
|
|
173
|
+
this.sendEventMessage({ id, data: heartbeatMessage, name: "heartbeat" });
|
|
174
|
+
this.pongTimer = setTimeout(() => {
|
|
175
|
+
this.logger.debug("[Heartbeat]: No response, closing connection");
|
|
176
|
+
this.client.close();
|
|
177
|
+
}, pongTimeout);
|
|
178
|
+
}
|
|
179
|
+
}, pingTimeout);
|
|
180
|
+
}
|
|
181
|
+
};
|
|
182
|
+
|
|
183
|
+
removeListener = (event: string, callback: (...args: any[]) => void) => {
|
|
184
|
+
const listenerGroup = this.listeners.get(event);
|
|
185
|
+
if (listenerGroup && listenerGroup.has(callback)) {
|
|
186
|
+
this.logger.debug("Removed event listener", { event });
|
|
187
|
+
this.socket.events.emitListenerRemoveEvent(event);
|
|
188
|
+
listenerGroup.delete(callback);
|
|
189
|
+
return true;
|
|
190
|
+
}
|
|
191
|
+
return false;
|
|
192
|
+
};
|
|
193
|
+
|
|
194
|
+
listen = (listener: Pick<ListenerInstance, "name">, callback: (...args: any[]) => void) => {
|
|
195
|
+
const listenerGroup =
|
|
196
|
+
this.listeners.get(listener.name) || this.listeners.set(listener.name, new Set()).get(listener.name);
|
|
197
|
+
|
|
198
|
+
listenerGroup.add(callback);
|
|
199
|
+
return () => this.removeListener(listener.name, callback);
|
|
200
|
+
};
|
|
201
|
+
|
|
202
|
+
emit = async (
|
|
203
|
+
eventMessageId: string,
|
|
204
|
+
emitter: EmitterInstance,
|
|
205
|
+
ack?: (error: Error | null, response: any) => void,
|
|
206
|
+
) => {
|
|
207
|
+
if (!this.connecting || !this.open) {
|
|
208
|
+
this.logger.error("Cannot emit event when connection is not open");
|
|
209
|
+
}
|
|
210
|
+
if (this.client && "send" in this.client) {
|
|
211
|
+
if (ack) {
|
|
212
|
+
let timeout;
|
|
213
|
+
const unmount = this.listen({ name: emitter.name }, (response) => {
|
|
214
|
+
ack(null, response);
|
|
215
|
+
clearTimeout(timeout);
|
|
216
|
+
});
|
|
217
|
+
timeout = setTimeout(() => {
|
|
218
|
+
unmount();
|
|
219
|
+
ack(new Error("Server did not acknowledge the event"), null);
|
|
220
|
+
}, emitter.timeout);
|
|
221
|
+
}
|
|
222
|
+
|
|
223
|
+
const emitterInstance = await this.socket.__modifySend(emitter);
|
|
224
|
+
this.sendEventMessage({ id: eventMessageId, data: emitterInstance.data, name: emitterInstance.name });
|
|
225
|
+
this.socket.events.emitEmitterEvent(emitterInstance);
|
|
226
|
+
} else {
|
|
227
|
+
throw new Error("Cannot emit events in SSE mode");
|
|
228
|
+
}
|
|
229
|
+
};
|
|
230
|
+
}
|
|
@@ -0,0 +1,36 @@
|
|
|
1
|
+
import { EmitterInstance } from "emitter";
|
|
2
|
+
import { ListenerInstance } from "listener";
|
|
3
|
+
|
|
4
|
+
export type RemoveListenerCallbackType = () => void;
|
|
5
|
+
|
|
6
|
+
export type ListenerCallbackType<D = any> = (data: D, event: MessageEvent<D>) => void;
|
|
7
|
+
|
|
8
|
+
export type WebsocketClientType = {
|
|
9
|
+
connecting: boolean;
|
|
10
|
+
listeners: Map<string, Set<ListenerCallbackType>>;
|
|
11
|
+
emit: (eventMessageId: string, emitter: EmitterInstance, ack?: (error: Error | null, response: any) => void) => void;
|
|
12
|
+
listen: (listener: ListenerInstance, callback: ListenerCallbackType) => RemoveListenerCallbackType;
|
|
13
|
+
removeListener: (name: string, callback: (...args: any) => void) => void;
|
|
14
|
+
connect: () => void;
|
|
15
|
+
disconnect: () => void;
|
|
16
|
+
};
|
|
17
|
+
|
|
18
|
+
export type ServerSentEventsClientOptionsType = {
|
|
19
|
+
eventSourceInit?: EventSourceInit;
|
|
20
|
+
reconnectTimeout?: number;
|
|
21
|
+
};
|
|
22
|
+
|
|
23
|
+
export type WebsocketClientOptionsType = {
|
|
24
|
+
protocols?: string[];
|
|
25
|
+
pingTimeout?: number;
|
|
26
|
+
pongTimeout?: number;
|
|
27
|
+
reconnectTimeout?: number;
|
|
28
|
+
heartbeatMessage?: string;
|
|
29
|
+
heartbeat?: boolean;
|
|
30
|
+
};
|
|
31
|
+
|
|
32
|
+
export type WSMessageType = {
|
|
33
|
+
id: string;
|
|
34
|
+
name: string;
|
|
35
|
+
data: string;
|
|
36
|
+
};
|
|
@@ -0,0 +1,15 @@
|
|
|
1
|
+
import { SocketInstance } from "socket";
|
|
2
|
+
|
|
3
|
+
export const getClient = (socket: SocketInstance) => {
|
|
4
|
+
const queryParams = socket.queryParamsStringify(socket.queryParams).substring(1);
|
|
5
|
+
const authParams = socket.queryParamsStringify(socket.auth).substring(1);
|
|
6
|
+
const connector = queryParams && authParams ? "&" : "";
|
|
7
|
+
const fullUrl = `${socket.url}?${authParams}${connector}${queryParams}`;
|
|
8
|
+
|
|
9
|
+
if ("isSSE" in socket.options) {
|
|
10
|
+
if (!window?.EventSource) return null;
|
|
11
|
+
return new EventSource(fullUrl, socket.options.clientOptions?.eventSourceInit);
|
|
12
|
+
}
|
|
13
|
+
if (!window?.WebSocket) return null;
|
|
14
|
+
return new WebSocket(fullUrl, socket.options.clientOptions?.protocols);
|
|
15
|
+
};
|
|
@@ -0,0 +1,77 @@
|
|
|
1
|
+
import { DateInterval, getUniqueRequestId } from "@hyper-fetch/core";
|
|
2
|
+
|
|
3
|
+
import { Socket } from "socket";
|
|
4
|
+
import { EmitterOptionsType, EmitterCloneOptionsType } from "emitter";
|
|
5
|
+
import { WebsocketClientType } from "client";
|
|
6
|
+
import { ExtractEmitterOptionsType } from "types/extract.types";
|
|
7
|
+
|
|
8
|
+
export class Emitter<RequestDataType, ResponseDataType, ClientType extends WebsocketClientType, MappedData = void> {
|
|
9
|
+
readonly name: string;
|
|
10
|
+
timeout: number;
|
|
11
|
+
data: RequestDataType | null = null;
|
|
12
|
+
options: ExtractEmitterOptionsType<ClientType>;
|
|
13
|
+
|
|
14
|
+
constructor(
|
|
15
|
+
readonly socket: Socket<ClientType>,
|
|
16
|
+
readonly emitterOptions: EmitterOptionsType<ExtractEmitterOptionsType<ClientType>>,
|
|
17
|
+
dump?: Partial<Emitter<RequestDataType, ResponseDataType, ClientType, MappedData>>,
|
|
18
|
+
readonly dataMapper?: (data: RequestDataType) => MappedData,
|
|
19
|
+
) {
|
|
20
|
+
const { name, timeout = DateInterval.second * 3, options } = emitterOptions;
|
|
21
|
+
this.name = dump?.name ?? name;
|
|
22
|
+
this.data = dump?.data;
|
|
23
|
+
this.timeout = dump?.timeout ?? timeout;
|
|
24
|
+
this.options = dump?.options ?? options;
|
|
25
|
+
}
|
|
26
|
+
|
|
27
|
+
setOptions(options: ExtractEmitterOptionsType<ClientType>) {
|
|
28
|
+
return this.clone({ options });
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
setTimeout(timeout: number) {
|
|
32
|
+
return this.clone({ timeout });
|
|
33
|
+
}
|
|
34
|
+
|
|
35
|
+
setData(data: RequestDataType) {
|
|
36
|
+
if (this.dataMapper) {
|
|
37
|
+
return this.clone<MappedData>({ data: this.dataMapper(data) });
|
|
38
|
+
}
|
|
39
|
+
return this.clone({ data });
|
|
40
|
+
}
|
|
41
|
+
|
|
42
|
+
setDataMapper = <MapperData>(mapper: (data: RequestDataType) => MapperData) => {
|
|
43
|
+
return this.clone<RequestDataType, MapperData>(undefined, mapper);
|
|
44
|
+
};
|
|
45
|
+
|
|
46
|
+
clone<NewRequestDataType = RequestDataType, MapperData = MappedData>(
|
|
47
|
+
config?: Partial<EmitterCloneOptionsType<NewRequestDataType, ExtractEmitterOptionsType<ClientType>>>,
|
|
48
|
+
mapper?: (data: NewRequestDataType) => MapperData,
|
|
49
|
+
): Emitter<NewRequestDataType, ResponseDataType, ClientType, MapperData> {
|
|
50
|
+
const dump: Partial<Emitter<NewRequestDataType, ResponseDataType, ClientType, MapperData>> = {
|
|
51
|
+
timeout: this.timeout,
|
|
52
|
+
options: this.options,
|
|
53
|
+
data: this.data as unknown as NewRequestDataType,
|
|
54
|
+
...config,
|
|
55
|
+
name: this.name,
|
|
56
|
+
};
|
|
57
|
+
const mapperFn = (mapper || this.dataMapper) as typeof mapper;
|
|
58
|
+
|
|
59
|
+
return new Emitter<NewRequestDataType, ResponseDataType, ClientType, MapperData>(
|
|
60
|
+
this.socket,
|
|
61
|
+
this.emitterOptions,
|
|
62
|
+
dump,
|
|
63
|
+
mapperFn,
|
|
64
|
+
);
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
emit(
|
|
68
|
+
options?: Partial<EmitterCloneOptionsType<RequestDataType, ExtractEmitterOptionsType<ClientType>>>,
|
|
69
|
+
ack?: (error: Error | null, response: ResponseDataType) => void,
|
|
70
|
+
) {
|
|
71
|
+
const instance = this.clone(options);
|
|
72
|
+
const eventMessageId = getUniqueRequestId(this.name);
|
|
73
|
+
|
|
74
|
+
this.socket.client.emit(eventMessageId, instance, ack);
|
|
75
|
+
return eventMessageId;
|
|
76
|
+
}
|
|
77
|
+
}
|
|
@@ -0,0 +1,15 @@
|
|
|
1
|
+
import { Emitter } from "emitter";
|
|
2
|
+
|
|
3
|
+
export type EmitterInstance = Emitter<any, any, any>;
|
|
4
|
+
|
|
5
|
+
export type EmitterOptionsType<AdditionalEmitterOptions> = {
|
|
6
|
+
name: string;
|
|
7
|
+
timeout?: number;
|
|
8
|
+
options?: AdditionalEmitterOptions;
|
|
9
|
+
};
|
|
10
|
+
|
|
11
|
+
export type EmitterCloneOptionsType<DataType, AdditionalEmitterOptions> = Partial<
|
|
12
|
+
EmitterOptionsType<AdditionalEmitterOptions>
|
|
13
|
+
> & {
|
|
14
|
+
data: DataType;
|
|
15
|
+
};
|