@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.
Files changed (46) hide show
  1. package/.eslintrc.json +7 -0
  2. package/README.md +76 -0
  3. package/dist/client/client.d.ts +28 -0
  4. package/dist/client/client.types.d.ts +30 -0
  5. package/dist/client/client.utils.d.ts +2 -0
  6. package/dist/client/index.d.ts +3 -0
  7. package/dist/emitter/emitter.d.ts +20 -0
  8. package/dist/emitter/emitter.types.d.ts +10 -0
  9. package/dist/emitter/index.d.ts +2 -0
  10. package/dist/index.cjs.js +2 -0
  11. package/dist/index.cjs.js.map +7 -0
  12. package/dist/index.d.ts +5 -0
  13. package/dist/index.esm.js +2 -0
  14. package/dist/index.esm.js.map +7 -0
  15. package/dist/listener/index.d.ts +2 -0
  16. package/dist/listener/listener.d.ts +14 -0
  17. package/dist/listener/listener.types.d.ts +6 -0
  18. package/dist/socket/index.d.ts +4 -0
  19. package/dist/socket/socket.d.ts +139 -0
  20. package/dist/socket/socket.events.d.ts +27 -0
  21. package/dist/socket/socket.types.d.ts +29 -0
  22. package/dist/socket/socket.utils.d.ts +16 -0
  23. package/dist/types/extract.types.d.ts +7 -0
  24. package/dist/types/index.d.ts +2 -0
  25. package/dist/types/tuple.types.d.ts +1 -0
  26. package/package.json +65 -0
  27. package/src/client/client.ts +230 -0
  28. package/src/client/client.types.ts +36 -0
  29. package/src/client/client.utils.ts +15 -0
  30. package/src/client/index.ts +3 -0
  31. package/src/emitter/emitter.ts +77 -0
  32. package/src/emitter/emitter.types.ts +15 -0
  33. package/src/emitter/index.ts +2 -0
  34. package/src/index.ts +5 -0
  35. package/src/listener/index.ts +2 -0
  36. package/src/listener/listener.ts +44 -0
  37. package/src/listener/listener.types.ts +8 -0
  38. package/src/socket/index.ts +4 -0
  39. package/src/socket/socket.events.ts +119 -0
  40. package/src/socket/socket.ts +235 -0
  41. package/src/socket/socket.types.ts +33 -0
  42. package/src/socket/socket.utils.ts +43 -0
  43. package/src/types/extract.types.ts +16 -0
  44. package/src/types/index.ts +2 -0
  45. package/src/types/tuple.types.ts +1 -0
  46. 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,2 @@
1
+ export * from "./tuple.types";
2
+ export * from "./extract.types";
@@ -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,3 @@
1
+ export * from "./client";
2
+ export * from "./client.types";
3
+ export * from "./client.utils";
@@ -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
+ };