@hyper-fetch/sockets 4.0.2 → 5.0.1

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.
@@ -9,17 +9,17 @@ import {
9
9
  getOpenKey,
10
10
  getReconnectingKey,
11
11
  getReconnectingStopKey,
12
- getListenerEventByNameKey,
13
- getEmitterEventByNameKey,
12
+ getListenerEventByEndpointKey,
13
+ getEmitterEventByEndpointKey,
14
14
  getListenerRemoveKey,
15
- getListenerRemoveByNameKey,
15
+ getListenerRemoveByEndpointKey,
16
16
  } from "socket";
17
17
  import { EmitterInstance } from "emitter";
18
18
  import { ListenerInstance } from "listener";
19
- import { ExtractListenerResponseType } from "types/extract.types";
19
+ import { ExtractSocketExtraType, SocketAdapterInstance } from "adapter";
20
20
 
21
- export const getSocketEvents = (eventEmitter: EventEmitter) => ({
22
- emitError: <ResponseType = MessageEvent>(event: ResponseType): void => {
21
+ export const getSocketEvents = <T extends SocketAdapterInstance>(eventEmitter: EventEmitter) => ({
22
+ emitError: <ResponseType>(event: ResponseType): void => {
23
23
  eventEmitter.emit(getErrorKey(), event);
24
24
  },
25
25
  emitOpen: (): void => {
@@ -37,24 +37,23 @@ export const getSocketEvents = (eventEmitter: EventEmitter) => ({
37
37
  emitReconnectingStop: (attempts: number): void => {
38
38
  eventEmitter.emit(getReconnectingStopKey(), attempts);
39
39
  },
40
- emitListenerEvent: <ResponseType = MessageEvent>(
41
- name: string,
42
- data: ResponseType,
43
- event: MessageEvent<ResponseType>,
40
+ emitListenerEvent: <ResponseType>(
41
+ endpoint: string,
42
+ { data, extra }: { data: ResponseType; extra: ExtractSocketExtraType<T> },
44
43
  ): void => {
45
- eventEmitter.emit(getListenerEventKey(), data, event);
46
- eventEmitter.emit(getListenerEventByNameKey(name), data, event);
44
+ eventEmitter.emit(getListenerEventKey(), { endpoint, data, extra });
45
+ eventEmitter.emit(getListenerEventByEndpointKey(endpoint), { endpoint, data, extra });
47
46
  },
48
- emitListenerRemoveEvent: (name: string): void => {
49
- eventEmitter.emit(getListenerRemoveKey(), name);
50
- eventEmitter.emit(getListenerRemoveByNameKey(name));
47
+ emitListenerRemoveEvent: (endpoint: string): void => {
48
+ eventEmitter.emit(getListenerRemoveKey(), endpoint);
49
+ eventEmitter.emit(getListenerRemoveByEndpointKey(endpoint));
51
50
  },
52
51
  emitEmitterEvent: <EmitterType extends EmitterInstance>(emitter: EmitterType): void => {
53
52
  eventEmitter.emit(getEmitterEventKey(), emitter);
54
- eventEmitter.emit(getEmitterEventByNameKey(emitter.name), emitter);
53
+ eventEmitter.emit(getEmitterEventByEndpointKey(emitter.endpoint), emitter);
55
54
  },
56
55
 
57
- onError: (callback: <ResponseType = MessageEvent>(event: ResponseType) => void): VoidFunction => {
56
+ onError: (callback: <ResponseType>(event: ResponseType) => void): VoidFunction => {
58
57
  eventEmitter.on(getErrorKey(), callback);
59
58
  return () => eventEmitter.removeListener(getErrorKey(), callback);
60
59
  },
@@ -79,7 +78,15 @@ export const getSocketEvents = (eventEmitter: EventEmitter) => ({
79
78
  return () => eventEmitter.removeListener(getReconnectingStopKey(), callback);
80
79
  },
81
80
  onListenerEvent: <ResponseType = Event>(
82
- callback: (data: ResponseType, event: MessageEvent<ResponseType>) => void,
81
+ callback: ({
82
+ endpoint,
83
+ data,
84
+ extra,
85
+ }: {
86
+ endpoint: string;
87
+ data: ResponseType;
88
+ extra: ExtractSocketExtraType<T>;
89
+ }) => void,
83
90
  ): VoidFunction => {
84
91
  eventEmitter.on(getListenerEventKey(), callback);
85
92
  return () => eventEmitter.removeListener(getListenerEventKey(), callback);
@@ -88,32 +95,37 @@ export const getSocketEvents = (eventEmitter: EventEmitter) => ({
88
95
  eventEmitter.on(getEmitterEventKey(), callback);
89
96
  return () => eventEmitter.removeListener(getEmitterEventKey(), callback);
90
97
  },
91
- onListenerEventByName: <ListenerType extends ListenerInstance>(
98
+ onListenerEventByEndpoint: <ListenerType extends ListenerInstance>(
92
99
  listener: ListenerType,
93
- callback: (
94
- data: ExtractListenerResponseType<ListenerType>,
95
- event: MessageEvent<ExtractListenerResponseType<ListenerType>>,
96
- ) => void,
100
+ callback: ({
101
+ endpoint,
102
+ data,
103
+ extra,
104
+ }: {
105
+ endpoint: string;
106
+ data: ResponseType;
107
+ extra: ExtractSocketExtraType<T>;
108
+ }) => void,
97
109
  ): VoidFunction => {
98
- eventEmitter.on(getListenerEventByNameKey(listener.name), callback);
99
- return () => eventEmitter.removeListener(getListenerEventByNameKey(listener.name), callback);
110
+ eventEmitter.on(getListenerEventByEndpointKey(listener.endpoint), callback);
111
+ return () => eventEmitter.removeListener(getListenerEventByEndpointKey(listener.endpoint), callback);
100
112
  },
101
- onListenerRemove: (callback: (name: string) => void): VoidFunction => {
113
+ onListenerRemove: (callback: (endpoint: string) => void): VoidFunction => {
102
114
  eventEmitter.on(getListenerRemoveKey(), callback);
103
115
  return () => eventEmitter.removeListener(getListenerRemoveKey(), callback);
104
116
  },
105
- onListenerRemoveByName: <ListenerType extends ListenerInstance>(
117
+ onListenerRemoveByEndpoint: <ListenerType extends ListenerInstance>(
106
118
  listener: ListenerType,
107
119
  callback: () => void,
108
120
  ): VoidFunction => {
109
- eventEmitter.on(getListenerRemoveByNameKey(listener.name), callback);
110
- return () => eventEmitter.removeListener(getListenerRemoveByNameKey(listener.name), callback);
121
+ eventEmitter.on(getListenerRemoveByEndpointKey(listener.endpoint), callback);
122
+ return () => eventEmitter.removeListener(getListenerRemoveByEndpointKey(listener.endpoint), callback);
111
123
  },
112
- onEmitterEventByName: <EmitterType extends EmitterInstance>(
124
+ onEmitterEventByEndpoint: <EmitterType extends EmitterInstance>(
113
125
  emitter: EmitterType,
114
126
  callback: (emitter: EmitterType) => void,
115
127
  ): VoidFunction => {
116
- eventEmitter.on(getEmitterEventByNameKey(emitter.name), callback);
117
- return () => eventEmitter.removeListener(getEmitterEventByNameKey(emitter.name), callback);
128
+ eventEmitter.on(getEmitterEventByEndpointKey(emitter.endpoint), callback);
129
+ return () => eventEmitter.removeListener(getEmitterEventByEndpointKey(emitter.endpoint), callback);
118
130
  },
119
131
  });
@@ -11,7 +11,7 @@ import {
11
11
  } from "@hyper-fetch/core";
12
12
 
13
13
  import {
14
- SocketAdapterOptionsType,
14
+ SocketOptionsType,
15
15
  ReconnectCallbackType,
16
16
  ReconnectStopCallbackType,
17
17
  OpenCallbackType,
@@ -23,11 +23,11 @@ import {
23
23
  interceptListener,
24
24
  interceptEmitter,
25
25
  } from "socket";
26
- import { AdapterType, SocketAdapter } from "adapter";
27
26
  import { Listener, ListenerOptionsType } from "listener";
28
27
  import { Emitter, EmitterInstance, EmitterOptionsType } from "emitter";
28
+ import { ExtractSocketExtraType, SocketAdapterInstance, WebsocketAdapterType, websocketAdapter } from "adapter";
29
29
 
30
- export class Socket<Adapter extends Record<keyof AdapterType, any>> {
30
+ export class Socket<AdapterType extends SocketAdapterInstance = WebsocketAdapterType> {
31
31
  public emitter = new EventEmitter();
32
32
  public events = getSocketEvents(this.emitter);
33
33
 
@@ -40,16 +40,16 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
40
40
  autoConnect: boolean;
41
41
 
42
42
  // Callbacks
43
- __onOpenCallbacks: OpenCallbackType<Socket<Adapter>, any>[] = [];
44
- __onCloseCallbacks: CloseCallbackType<Socket<Adapter>, any>[] = [];
45
- __onReconnectCallbacks: ReconnectCallbackType<Socket<Adapter>>[] = [];
46
- __onReconnectStopCallbacks: ReconnectStopCallbackType<Socket<Adapter>>[] = [];
47
- __onMessageCallbacks: MessageCallbackType<Socket<Adapter>, any>[] = [];
43
+ __onOpenCallbacks: OpenCallbackType<Socket<AdapterType>>[] = [];
44
+ __onCloseCallbacks: CloseCallbackType<Socket<AdapterType>>[] = [];
45
+ __onReconnectCallbacks: ReconnectCallbackType<Socket<AdapterType>>[] = [];
46
+ __onReconnectStopCallbacks: ReconnectStopCallbackType<Socket<AdapterType>>[] = [];
47
+ __onMessageCallbacks: MessageCallbackType<Socket<AdapterType>, any>[] = [];
48
48
  __onSendCallbacks: SendCallbackType<EmitterInstance>[] = [];
49
- __onErrorCallbacks: ErrorCallbackType<Socket<Adapter>, any>[] = [];
49
+ __onErrorCallbacks: ErrorCallbackType<Socket<AdapterType>, any>[] = [];
50
50
 
51
51
  // Config
52
- adapter: Adapter;
52
+ adapter: ReturnType<AdapterType>;
53
53
  loggerManager = new LoggerManager(this);
54
54
  appManager = new AppManager();
55
55
  queryParamsConfig?: QueryStringifyOptionsType;
@@ -64,7 +64,7 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
64
64
  return stringifyQueryParams(queryParams, this.queryParamsConfig);
65
65
  };
66
66
 
67
- constructor(public options: SocketAdapterOptionsType<Adapter>) {
67
+ constructor(public options: SocketOptionsType<AdapterType>) {
68
68
  const {
69
69
  url,
70
70
  auth,
@@ -92,7 +92,7 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
92
92
  }
93
93
 
94
94
  // Adapter must be initialized at the end
95
- this.adapter = adapter || (new SocketAdapter(this) as unknown as Adapter);
95
+ this.adapter = (adapter ? adapter(this) : websocketAdapter(this)) as unknown as ReturnType<AdapterType>;
96
96
  }
97
97
 
98
98
  /**
@@ -114,7 +114,7 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
114
114
  /**
115
115
  * Set the new logger instance to the socket
116
116
  */
117
- setLogger = (callback: (socket: Socket<Adapter>) => LoggerManager) => {
117
+ setLogger = (callback: (socket: Socket<AdapterType>) => LoggerManager) => {
118
118
  this.loggerManager = callback(this);
119
119
  return this;
120
120
  };
@@ -146,7 +146,7 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
146
146
  * @param callback
147
147
  * @returns
148
148
  */
149
- onOpen<Event = MessageEvent>(callback: OpenCallbackType<Socket<Adapter>, Event>) {
149
+ onOpen(callback: OpenCallbackType<Socket<AdapterType>>) {
150
150
  this.__onOpenCallbacks.push(callback);
151
151
  return this;
152
152
  }
@@ -155,7 +155,7 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
155
155
  * @param callback
156
156
  * @returns
157
157
  */
158
- onClose<Event = MessageEvent>(callback: CloseCallbackType<Socket<Adapter>, Event>) {
158
+ onClose(callback: CloseCallbackType<Socket<AdapterType>>) {
159
159
  this.__onCloseCallbacks.push(callback);
160
160
  return this;
161
161
  }
@@ -165,7 +165,7 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
165
165
  * @param callback
166
166
  * @returns
167
167
  */
168
- onReconnect(callback: ReconnectCallbackType<Socket<Adapter>>) {
168
+ onReconnect(callback: ReconnectCallbackType<Socket<AdapterType>>) {
169
169
  this.__onReconnectCallbacks.push(callback);
170
170
  return this;
171
171
  }
@@ -175,7 +175,7 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
175
175
  * @param callback
176
176
  * @returns
177
177
  */
178
- onReconnectStop(callback: ReconnectStopCallbackType<Socket<Adapter>>) {
178
+ onReconnectStop(callback: ReconnectStopCallbackType<Socket<AdapterType>>) {
179
179
  this.__onReconnectStopCallbacks.push(callback);
180
180
  return this;
181
181
  }
@@ -185,7 +185,7 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
185
185
  * @param callback
186
186
  * @returns
187
187
  */
188
- onMessage<Event = MessageEvent>(callback: MessageCallbackType<Socket<Adapter>, Event>) {
188
+ onMessage<Event = ExtractSocketExtraType<AdapterType>>(callback: MessageCallbackType<Socket<AdapterType>, Event>) {
189
189
  this.__onMessageCallbacks.push(callback);
190
190
  return this;
191
191
  }
@@ -205,7 +205,7 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
205
205
  * @param callback
206
206
  * @returns
207
207
  */
208
- onError<Event = MessageEvent>(callback: ErrorCallbackType<Socket<Adapter>, Event>) {
208
+ onError<Event = ExtractSocketExtraType<AdapterType>>(callback: ErrorCallbackType<Socket<AdapterType>, Event>) {
209
209
  this.__onErrorCallbacks.push(callback);
210
210
  return this;
211
211
  }
@@ -220,8 +220,8 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
220
220
  return interceptEmitter(this.__onSendCallbacks, emitter);
221
221
  };
222
222
 
223
- __modifyResponse = (response: MessageEvent) => {
224
- return interceptListener(this.__onMessageCallbacks, response, this);
223
+ __modifyResponse = (data: { data: any; extra: ExtractSocketExtraType<AdapterType> }) => {
224
+ return interceptListener(this.__onMessageCallbacks, data, this);
225
225
  };
226
226
 
227
227
  /**
@@ -235,8 +235,10 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
235
235
  * @param options
236
236
  * @returns
237
237
  */
238
- createListener = <Response>(options: ListenerOptionsType<Adapter>) => {
239
- return new Listener<Response, Adapter>(this, options as any);
238
+ createListener = <Response>() => {
239
+ return <Endpoint extends string>(options: ListenerOptionsType<Endpoint, AdapterType>) => {
240
+ return new Listener<Response, Endpoint, AdapterType>(this, options);
241
+ };
240
242
  };
241
243
 
242
244
  /**
@@ -244,10 +246,9 @@ export class Socket<Adapter extends Record<keyof AdapterType, any>> {
244
246
  * @param options
245
247
  * @returns
246
248
  */
247
- createEmitter = <Payload, Response = never>(options: EmitterOptionsType<Adapter>) => {
248
- if ("isSSE" in this.options) {
249
- throw new Error("Cannot create emitters for SSE adapter");
250
- }
251
- return new Emitter<Payload, Response, Adapter>(this, options as any);
249
+ createEmitter = <Payload, Response = never>() => {
250
+ return <Endpoint extends string>(options: EmitterOptionsType<Endpoint, AdapterType>) => {
251
+ return new Emitter<Payload, Response, Endpoint, AdapterType>(this, options);
252
+ };
252
253
  };
253
254
  }
@@ -1,33 +1,28 @@
1
1
  import { QueryParamsType, QueryStringifyOptionsType, StringifyCallbackType } from "@hyper-fetch/core";
2
2
 
3
3
  import { Socket } from "socket";
4
- import { SSEAdapterOptionsType, WSAdapterOptionsType } from "adapter";
4
+ import { ExtractSocketOptionsType, SocketAdapterInstance } from "adapter";
5
5
  import { EmitterInstance } from "emitter";
6
6
 
7
- export type SocketInstance = Socket<any>;
7
+ export type SocketInstance = Socket<SocketAdapterInstance>;
8
8
 
9
- export type SocketOptionsType<SocketAdapterType> = {
9
+ export type SocketOptionsType<AdapterType extends SocketAdapterInstance> = {
10
10
  url: string;
11
- adapter?: SocketAdapterType;
11
+ adapter?: AdapterType;
12
12
  auth?: QueryParamsType;
13
- queryParams?: QueryParamsType | string;
14
13
  reconnect?: number;
15
14
  reconnectTime?: number;
15
+ queryParams?: QueryParamsType | string;
16
16
  autoConnect?: boolean;
17
17
  queryParamsConfig?: QueryStringifyOptionsType;
18
18
  queryParamsStringify?: StringifyCallbackType;
19
+ adapterOptions?: ExtractSocketOptionsType<AdapterType>;
19
20
  };
20
21
 
21
- export type SocketAdapterOptionsType<SocketAdapterType> =
22
- | (SocketOptionsType<SocketAdapterType> & { isSSE: true; adapterOptions?: SSEAdapterOptionsType })
23
- | (SocketOptionsType<SocketAdapterType> & {
24
- adapterOptions?: WSAdapterOptionsType;
25
- });
26
-
27
22
  export type ReconnectCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
28
23
  export type ReconnectStopCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
29
- export type OpenCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => void;
30
- export type CloseCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => void;
24
+ export type OpenCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
25
+ export type CloseCallbackType<SocketType extends SocketInstance> = (socket: SocketType) => void;
31
26
  export type MessageCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => Event;
32
27
  export type SendCallbackType<EmitterType extends EmitterInstance> = (emitter: EmitterType) => EmitterInstance;
33
28
  export type ErrorCallbackType<SocketType extends SocketInstance, Event> = (event: Event, socket: SocketType) => void;
@@ -10,19 +10,19 @@ export const getReconnectingStopKey = () => "socket_reconnecting_stop";
10
10
  export const getListenerEventKey = () => `listener_event`;
11
11
  export const getListenerRemoveKey = () => `listener_remove`;
12
12
  export const getEmitterEventKey = () => `emitter_event`;
13
- export const getListenerRemoveByNameKey = (event: string) => `${event}_listener_remove`;
14
- export const getListenerEventByNameKey = (event: string) => `${event}_listener_event`;
15
- export const getEmitterEventByNameKey = (event: string) => `${event}_emitter_event`;
13
+ export const getListenerRemoveByEndpointKey = (event: string) => `${event}_listener_remove`;
14
+ export const getListenerEventByEndpointKey = (event: string) => `${event}_listener_event`;
15
+ export const getEmitterEventByEndpointKey = (event: string) => `${event}_emitter_event`;
16
16
 
17
17
  export const interceptListener = <Socket extends SocketInstance>(
18
- interceptors: MessageCallbackType<Socket, MessageEvent>[],
19
- response: MessageEvent,
18
+ interceptors: MessageCallbackType<Socket, any>[],
19
+ data: { data: any; extra: any },
20
20
  socket: Socket,
21
21
  ) => {
22
- let newResponse = response;
22
+ let newResponse = data;
23
23
  // eslint-disable-next-line no-restricted-syntax
24
24
  for (const interceptor of interceptors) {
25
- newResponse = interceptor(response, socket);
25
+ newResponse = interceptor(data, socket);
26
26
  if (!newResponse) throw new Error("Listener modifier must return data");
27
27
  }
28
28
 
@@ -0,0 +1,6 @@
1
+ import { ListenerCallbackType, SocketAdapterInstance } from "adapter";
2
+
3
+ export type ConnectMethodType<AdapterType extends SocketAdapterInstance, EventType = unknown> = (
4
+ response: Parameters<ListenerCallbackType<AdapterType, EventType>>[0],
5
+ unsubscribe: () => void,
6
+ ) => void;
@@ -1,20 +1,19 @@
1
- import { AdapterType } from "adapter";
2
1
  import { Emitter } from "emitter";
3
2
  import { Listener } from "listener";
4
3
 
5
- // Adapter
6
-
7
- export type ExtractEmitterOptionsType<E extends Record<keyof AdapterType | string, any>> = E["emitterOptions"];
8
- export type ExtractListenerOptionsType<E extends Record<keyof AdapterType | string, any>> = E["listenerOptions"];
9
-
10
4
  // Emitter
11
5
 
12
- export type ExtractEmitterPayloadType<E> = E extends Emitter<infer P, any, any, any> ? P : never;
13
- export type ExtractEmitterResponseType<E> = E extends Emitter<any, infer R, any, any> ? R : never;
14
- export type ExtractEmitterAdapterType<E> = E extends Emitter<any, any, infer A, any> ? A : never;
15
- export type ExtractEmitterMappedDataType<E> = E extends Emitter<any, any, any, infer M> ? M : never;
6
+ export type ExtractEmitterPayloadType<E> = E extends Emitter<infer P, any, any, any, any, any, any> ? P : never;
7
+ export type ExtractEmitterResponseType<E> = E extends Emitter<any, infer R, any, any, any, any, any> ? R : never;
8
+ export type ExtractEmitterEndpointType<E> = E extends Emitter<any, any, infer A, any, any, any, any> ? A : never;
9
+ export type ExtractEmitterAdapterType<E> = E extends Emitter<any, any, any, infer A, any, any, any> ? A : never;
10
+ export type ExtractEmitterMappedDataType<E> = E extends Emitter<any, any, any, any, infer M, any, any> ? M : never;
11
+ export type ExtractEmitterHasParamsType<E> = E extends Emitter<any, any, any, any, any, infer M, any> ? M : never;
12
+ export type ExtractEmitterHasDataType<E> = E extends Emitter<any, any, any, any, any, any, infer D> ? D : never;
16
13
 
17
14
  // Listener
18
15
 
19
- export type ExtractListenerResponseType<T> = T extends Listener<infer R, any> ? R : never;
20
- export type ExtractListenerAdapterType<E> = E extends Listener<any, infer A> ? A : never;
16
+ export type ExtractListenerResponseType<T> = T extends Listener<infer R, any, any, any> ? R : never;
17
+ export type ExtractListenerEndpointType<E> = E extends Listener<any, infer A, any, any> ? A : never;
18
+ export type ExtractListenerAdapterType<E> = E extends Listener<any, any, infer A, any> ? A : never;
19
+ export type ExtractListenerHasParams<E> = E extends Listener<any, any, any, infer P> ? P : never;
@@ -1,2 +1,3 @@
1
1
  export * from "./tuple.types";
2
2
  export * from "./extract.types";
3
+ export * from "./connect.types";
@@ -1,238 +0,0 @@
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 { getAdapter, WSAdapterOptionsType, ListenerCallbackType, WSMessageType } from "adapter";
7
-
8
- export class SocketAdapter<SocketType extends SocketInstance> {
9
- adapter: 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 = () => getAdapter(socket);
23
- this.logger = this.socket.loggerManager.init("Socket Adapter");
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.isOnline || this.connecting)
40
- return this.logger.warning("Cannot initialize adapter.", {
41
- connecting: this.connecting,
42
- online: this.socket.appManager.isOnline,
43
- });
44
- const { reconnectTimeout = DateInterval.second * 2 } = this.socket.options.adapterOptions || {};
45
-
46
- this.socket.events.emitConnecting();
47
-
48
- // Clean environment
49
- this.forceClosed = false;
50
- this.adapter?.close();
51
-
52
- // Start connection
53
- this.connecting = true;
54
-
55
- // Initialize new adapter instance
56
- this.adapter = this.init();
57
-
58
- if (!this.adapter) return this.logger.warning("Cannot initialize adapter.");
59
-
60
- // Reconnection timeout
61
- const timeout = setTimeout(() => {
62
- this.reconnect();
63
- }, reconnectTimeout);
64
-
65
- /**
66
- * Mount listeners
67
- */
68
-
69
- this.adapter.onopen = (event) => {
70
- this.logger.info("Connection open", { event });
71
- clearTimeout(timeout);
72
- this.socket.__onOpenCallbacks.forEach((callback) => {
73
- callback(event, this.socket);
74
- });
75
- this.open = true;
76
- this.connecting = false;
77
- this.reconnectionAttempts = 0;
78
- this.socket.events.emitOpen();
79
- this.heartbeat();
80
- };
81
-
82
- if (this.adapter && "onclose" in this.adapter) {
83
- this.adapter.onclose = (event) => {
84
- this.logger.info("Connection closed", { event });
85
- this.socket.__onCloseCallbacks.forEach((callback) => {
86
- callback(event, this.socket);
87
- });
88
- this.open = false;
89
- this.connecting = false;
90
- this.socket.events.emitClose();
91
- this.clearTimers();
92
- };
93
- }
94
-
95
- this.adapter.onerror = (event) => {
96
- this.logger.info("Error message", { event });
97
- this.socket.__onErrorCallbacks.forEach((callback) => {
98
- callback(event, this.socket);
99
- });
100
- this.socket.events.emitError(event);
101
- };
102
-
103
- this.adapter.onmessage = (event) => {
104
- this.logger.info("New event message", { event });
105
-
106
- const response = this.socket.__modifyResponse(event);
107
- const data = parseResponse(response.data);
108
- const listeners = this.listeners.get(data.name) || [];
109
- listeners.forEach((callback) => {
110
- callback(data, event);
111
- });
112
- this.socket.events.emitListenerEvent(data.name, data, event);
113
- this.heartbeat();
114
- };
115
- };
116
-
117
- disconnect = () => {
118
- this.logger.debug("Disconnecting", { reconnectionAttempts: this.reconnectionAttempts });
119
- this.open = false;
120
- this.connecting = false;
121
- this.forceClosed = true;
122
- this.adapter.close();
123
- this.clearTimers();
124
- const isSSE = !(this.adapter && "onclose" in this.adapter);
125
- if (isSSE) {
126
- this.socket.__onCloseCallbacks.forEach((callback) => {
127
- callback({}, this.socket);
128
- });
129
- this.socket.events.emitClose();
130
- }
131
- };
132
-
133
- reconnect = () => {
134
- this.disconnect();
135
- if (this.reconnectionAttempts < this.socket.reconnect) {
136
- this.reconnectionAttempts += 1;
137
- this.logger.debug("Reconnecting", { reconnectionAttempts: this.reconnectionAttempts });
138
- this.connect();
139
- this.socket.__onReconnectCallbacks.forEach((callback) => {
140
- callback(this.socket);
141
- });
142
- this.socket.events.emitReconnecting(this.reconnectionAttempts);
143
- return true;
144
- }
145
- this.logger.debug("Stopped reconnecting", { reconnectionAttempts: this.reconnectionAttempts });
146
- this.socket.__onReconnectStopCallbacks.forEach((callback) => {
147
- callback(this.socket);
148
- });
149
- this.socket.events.emitReconnectingStop(this.reconnectionAttempts);
150
- return false;
151
- };
152
-
153
- clearTimers = () => {
154
- clearTimeout(this.pingTimer);
155
- clearTimeout(this.pongTimer);
156
- };
157
-
158
- sendEventMessage = (payload: WSMessageType) => {
159
- if (this.adapter && "send" in this.adapter) {
160
- this.adapter.send(JSON.stringify({ id: payload.id, name: payload.name, data: payload.data }));
161
- }
162
- };
163
-
164
- heartbeat = () => {
165
- const options = (this.socket.options.adapterOptions || {}) as WSAdapterOptionsType;
166
- const {
167
- heartbeat = false,
168
- pingTimeout = DateInterval.second * 5,
169
- pongTimeout = DateInterval.second * 5,
170
- heartbeatMessage = "heartbeat",
171
- } = options;
172
- if (this.connecting || !heartbeat) return;
173
- if (this.adapter && "send" in this.adapter) {
174
- this.clearTimers();
175
- this.pingTimer = setTimeout(() => {
176
- if (this.adapter && "send" in this.adapter) {
177
- this.logger.debug("[Heartbeat]: Start");
178
- const id = "heartbeat";
179
- this.sendEventMessage({ id, data: heartbeatMessage, name: "heartbeat" });
180
- this.pongTimer = setTimeout(() => {
181
- this.logger.debug("[Heartbeat]: No response, closing connection");
182
- this.adapter.close();
183
- }, pongTimeout);
184
- }
185
- }, pingTimeout);
186
- }
187
- };
188
-
189
- removeListener = (event: string, callback: (data: any, event: MessageEvent<any>) => void) => {
190
- const listenerGroup = this.listeners.get(event);
191
- if (listenerGroup && listenerGroup.has(callback)) {
192
- this.logger.debug("Removed event listener", { event });
193
- this.socket.events.emitListenerRemoveEvent(event);
194
- listenerGroup.delete(callback);
195
- return true;
196
- }
197
- return false;
198
- };
199
-
200
- listen = (listener: Pick<ListenerInstance, "name">, callback: (data: any, event: MessageEvent<any>) => void) => {
201
- const listenerGroup =
202
- this.listeners.get(listener.name) || this.listeners.set(listener.name, new Set()).get(listener.name);
203
-
204
- listenerGroup.add(callback);
205
- return () => this.removeListener(listener.name, callback);
206
- };
207
-
208
- emit = async (
209
- eventMessageId: string,
210
- emitter: EmitterInstance,
211
- ack?: (error: Error | null, response: MessageEvent<any>) => void,
212
- ) => {
213
- if (!this.connecting || !this.open) {
214
- this.logger.error("Cannot emit event when connection is not open");
215
- }
216
- if (this.adapter && "send" in this.adapter) {
217
- if (ack) {
218
- let timeout;
219
- const unmount = this.listen({ name: emitter.name }, (response) => {
220
- if (response.id === eventMessageId) {
221
- ack(null, response);
222
- clearTimeout(timeout);
223
- }
224
- });
225
- timeout = setTimeout(() => {
226
- unmount();
227
- ack(new Error("Server did not acknowledge the event"), null);
228
- }, emitter.timeout);
229
- }
230
-
231
- const emitterInstance = await this.socket.__modifySend(emitter);
232
- this.sendEventMessage({ id: eventMessageId, data: emitterInstance.data, name: emitterInstance.name });
233
- this.socket.events.emitEmitterEvent(emitterInstance);
234
- } else {
235
- throw new Error("Cannot emit events in SSE mode");
236
- }
237
- };
238
- }