@hyper-fetch/sockets 6.0.1 → 7.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 (41) hide show
  1. package/.eslintrc.json +8 -3
  2. package/README.md +6 -6
  3. package/dist/index.d.ts +523 -296
  4. package/dist/index.js +1246 -0
  5. package/dist/index.js.map +7 -0
  6. package/package.json +8 -9
  7. package/src/adapter/adapter.bindings.ts +128 -101
  8. package/src/adapter/adapter.ts +231 -0
  9. package/src/adapter/adapter.types.ts +10 -101
  10. package/src/adapter/index.ts +4 -4
  11. package/src/adapter-sse/index.ts +3 -0
  12. package/src/adapter-sse/sse-adapter.ts +192 -0
  13. package/src/adapter-sse/sse-adapter.types.ts +6 -0
  14. package/src/adapter-sse/sse-adapter.utils.ts +77 -0
  15. package/src/adapter-websockets/index.ts +3 -0
  16. package/src/adapter-websockets/websocket-adapter.ts +259 -0
  17. package/src/adapter-websockets/websocket-adapter.types.ts +8 -0
  18. package/src/adapter-websockets/websocket-adapter.utils.ts +53 -0
  19. package/src/emitter/emitter.ts +60 -102
  20. package/src/emitter/emitter.types.ts +82 -49
  21. package/src/index.ts +3 -0
  22. package/src/listener/listener.ts +34 -49
  23. package/src/listener/listener.types.ts +69 -17
  24. package/src/socket/socket.events.ts +147 -112
  25. package/src/socket/socket.ts +78 -100
  26. package/src/socket/socket.types.ts +13 -18
  27. package/src/socket/socket.utils.ts +12 -14
  28. package/src/types/connect.types.ts +2 -2
  29. package/src/types/extract.types.ts +43 -10
  30. package/src/utils/index.ts +3 -0
  31. package/src/utils/message-event.utils.ts +6 -0
  32. package/src/utils/socket.errors.ts +48 -0
  33. package/src/utils/socket.utils.ts +4 -0
  34. package/tsconfig.json +7 -3
  35. package/dist/index.cjs.js +0 -853
  36. package/dist/index.cjs.js.map +0 -7
  37. package/dist/index.esm.js +0 -833
  38. package/dist/index.esm.js.map +0 -7
  39. package/src/adapter/adapter.sse.ts +0 -127
  40. package/src/adapter/adapter.utils.ts +0 -20
  41. package/src/adapter/adapter.websocket.ts +0 -187
@@ -0,0 +1,259 @@
1
+ /* eslint-disable @typescript-eslint/no-use-before-define */
2
+ import { QueryParamsType, stringifyQueryParams, Time } from "@hyper-fetch/core";
3
+
4
+ import { EmitterInstance } from "emitter";
5
+ import { ExtendListener, ListenerCallbackType, ListenerInstance } from "listener";
6
+ import { SocketData } from "adapter";
7
+ import { SocketAdapter } from "adapter/adapter";
8
+ import { WebsocketAdapterOptionsType } from "./websocket-adapter.types";
9
+ import { getWebsocketAdapter } from "./websocket-adapter.utils";
10
+ import { getSocketUrl, parseMessageEvent } from "../utils";
11
+ import { getSocketError } from "../utils/socket.errors";
12
+ import { Socket } from "socket";
13
+
14
+ /**
15
+ * -------------------------------------------
16
+ * Websocket
17
+ * -------------------------------------------
18
+ */
19
+
20
+ export type WebsocketAdapterType = SocketAdapter<
21
+ MessageEvent<any>,
22
+ WebsocketAdapterOptionsType,
23
+ undefined,
24
+ undefined,
25
+ QueryParamsType | string,
26
+ typeof stringifyQueryParams
27
+ >;
28
+
29
+ export const WebsocketAdapter = (): WebsocketAdapterType =>
30
+ new SocketAdapter<
31
+ MessageEvent<any>,
32
+ WebsocketAdapterOptionsType,
33
+ undefined,
34
+ undefined,
35
+ QueryParamsType | string,
36
+ typeof stringifyQueryParams
37
+ >({
38
+ name: "websockets",
39
+ })
40
+ .setQueryParamsMapper(stringifyQueryParams)
41
+ .setConnector(
42
+ ({
43
+ socket,
44
+ logger,
45
+ getQueryParams,
46
+ onConnect,
47
+ onReconnect,
48
+ onDisconnect,
49
+ onListen,
50
+ onEmit,
51
+ onConnected,
52
+ onDisconnected,
53
+ onError,
54
+ onEvent,
55
+ }) => {
56
+ const autoConnect =
57
+ typeof socket.adapter.adapterOptions?.autoConnect === "boolean"
58
+ ? socket.adapter.adapterOptions?.autoConnect
59
+ : true;
60
+
61
+ let websocket: ReturnType<typeof getWebsocketAdapter> | undefined;
62
+
63
+ let pingTimer: ReturnType<typeof setTimeout> | undefined;
64
+ let pongTimer: ReturnType<typeof setTimeout> | undefined;
65
+ let timeout: ReturnType<typeof setTimeout> | undefined;
66
+
67
+ const connect = async (): Promise<boolean> => {
68
+ const url = getSocketUrl(socket.url, getQueryParams());
69
+ const enabled = onConnect();
70
+ if (!enabled) {
71
+ return Promise.resolve(false);
72
+ }
73
+
74
+ clearTimeout(timeout);
75
+ websocket?.clearListeners();
76
+ websocket?.close(1000);
77
+
78
+ const newWebsocket = getWebsocketAdapter(url, socket.adapter.adapterOptions);
79
+ websocket = newWebsocket;
80
+
81
+ // Make sure we picked good environment
82
+ if (!newWebsocket) {
83
+ logger.error({
84
+ title: "Cannot connect to websocket",
85
+ type: "system",
86
+ extra: {
87
+ websocket,
88
+ },
89
+ });
90
+ return Promise.resolve(false);
91
+ }
92
+
93
+ // Clear listeners
94
+ newWebsocket.clearListeners();
95
+
96
+ // Reconnection timeout
97
+ timeout = setTimeout(() => {
98
+ reconnect();
99
+ }, socket.reconnectTime);
100
+
101
+ /**
102
+ * Mount listeners
103
+ */
104
+
105
+ newWebsocket.addEventListener("open", () => {
106
+ clearTimeout(timeout);
107
+ onConnected();
108
+ onHeartbeat();
109
+ });
110
+
111
+ newWebsocket.addEventListener("close", (event) => {
112
+ clearTimeout(timeout);
113
+ onDisconnected();
114
+ clearTimers();
115
+ const error = getSocketError(event);
116
+ onError({ error: new Error(error) });
117
+
118
+ // If close was not by calling disconnect method, reconnect
119
+ if (event.code !== 1000) {
120
+ timeout = setTimeout(() => {
121
+ reconnect();
122
+ }, socket.reconnectTime);
123
+ }
124
+ });
125
+
126
+ newWebsocket.addEventListener("message", (newEvent: MessageEvent<SocketData>) => {
127
+ const { topic, data, event } = parseMessageEvent(newEvent);
128
+
129
+ onEvent({ topic, data, extra: event });
130
+ onHeartbeat();
131
+ });
132
+
133
+ return new Promise((resolve) => {
134
+ if (newWebsocket.readyState === WebSocket.OPEN) {
135
+ resolve(true);
136
+ socket.adapter.setConnected(true);
137
+ socket.adapter.setConnecting(false);
138
+ return;
139
+ }
140
+
141
+ // Promise lifecycle
142
+ const resolveConnected = () => {
143
+ resolve(true);
144
+ newWebsocket.removeEventListener("open", resolveConnected);
145
+ };
146
+ const resolveDisconnected = () => {
147
+ resolve(false);
148
+ newWebsocket.removeEventListener("close", resolveDisconnected);
149
+ };
150
+ const resolveError = () => {
151
+ resolve(false);
152
+ newWebsocket.removeEventListener("error", resolveError);
153
+ };
154
+
155
+ newWebsocket.addEventListener("open", resolveConnected, { disableCleanup: true });
156
+ newWebsocket.addEventListener("close", resolveDisconnected, { disableCleanup: true });
157
+ newWebsocket.addEventListener("error", resolveError, { disableCleanup: true });
158
+ });
159
+ };
160
+
161
+ const disconnect = async (): Promise<boolean> => {
162
+ if (!websocket) {
163
+ socket.adapter.setConnected(false);
164
+ socket.adapter.setConnecting(false);
165
+ return Promise.resolve(true);
166
+ }
167
+ const currentWebsocket = websocket;
168
+ const promise = new Promise<boolean>((resolve) => {
169
+ if (currentWebsocket.readyState === WebSocket.CLOSED) {
170
+ resolve(true);
171
+ socket.adapter.setConnected(false);
172
+ socket.adapter.setConnecting(false);
173
+ return;
174
+ }
175
+
176
+ const resolveDisconnected = () => {
177
+ resolve(true);
178
+ currentWebsocket.removeEventListener("close", resolveDisconnected);
179
+ };
180
+ currentWebsocket.addEventListener("close", resolveDisconnected, { disableCleanup: true });
181
+ });
182
+
183
+ onDisconnect();
184
+ currentWebsocket.close(1000);
185
+ clearTimers();
186
+
187
+ return promise;
188
+ };
189
+
190
+ const reconnect = async () => {
191
+ await onReconnect({ disconnect, connect });
192
+ };
193
+
194
+ const clearTimers = () => {
195
+ clearTimeout(pingTimer);
196
+ clearTimeout(pongTimer);
197
+ };
198
+
199
+ const sendEventMessage = ({ topic, payload }: Pick<EmitterInstance, "topic" | "payload">) => {
200
+ if (!websocket) return false;
201
+ websocket!.send(JSON.stringify({ topic, data: payload }));
202
+ return true;
203
+ };
204
+
205
+ const onHeartbeat = () => {
206
+ const {
207
+ heartbeat = false,
208
+ pingTimeout = Time.SEC * 5,
209
+ pongTimeout = Time.SEC * 5,
210
+ heartbeatMessage = "heartbeat",
211
+ } = socket.adapter.adapterOptions ||
212
+ /* istanbul ignore next */
213
+ {};
214
+
215
+ if (socket.adapter.connecting || !heartbeat) return;
216
+ clearTimers();
217
+ pingTimer = setTimeout(() => {
218
+ sendEventMessage({ topic: "heartbeat", payload: heartbeatMessage });
219
+ pongTimer = setTimeout(() => {
220
+ // this should trigger reconnect
221
+ websocket?.close();
222
+ }, pongTimeout);
223
+ }, pingTimeout);
224
+ };
225
+
226
+ const listen = (
227
+ listener: ExtendListener<ListenerInstance, { socket: Socket<WebsocketAdapterType> }>,
228
+ callback: ListenerCallbackType<WebsocketAdapterType, any>,
229
+ ) => {
230
+ return onListen({ listener, callback });
231
+ };
232
+
233
+ const emit = async (emitter: EmitterInstance) => {
234
+ const mappedEmitter = await onEmit({ emitter });
235
+ if (!mappedEmitter) return;
236
+
237
+ return sendEventMessage(mappedEmitter);
238
+ };
239
+
240
+ // Initialize
241
+ if (autoConnect) {
242
+ connect();
243
+ }
244
+
245
+ socket.appManager.events.onOnline(() => {
246
+ if (autoConnect && !socket.adapter.connected) {
247
+ connect();
248
+ }
249
+ });
250
+
251
+ return {
252
+ connect,
253
+ reconnect,
254
+ disconnect,
255
+ listen,
256
+ emit,
257
+ };
258
+ },
259
+ );
@@ -0,0 +1,8 @@
1
+ export type WebsocketAdapterOptionsType = {
2
+ protocols?: string[];
3
+ pingTimeout?: number;
4
+ pongTimeout?: number;
5
+ heartbeatMessage?: string;
6
+ heartbeat?: boolean;
7
+ autoConnect?: boolean;
8
+ };
@@ -0,0 +1,53 @@
1
+ import { EmptyTypes } from "@hyper-fetch/core";
2
+
3
+ import { WebsocketAdapterOptionsType } from "./websocket-adapter.types";
4
+
5
+ export const getWebsocketAdapter = (url: string, adapterOptions: WebsocketAdapterOptionsType | EmptyTypes) => {
6
+ /** istanbul ignore next */
7
+ try {
8
+ /** istanbul ignore next */
9
+ if (!window?.WebSocket) return null;
10
+ } catch (error) {
11
+ return null;
12
+ }
13
+
14
+ class HyperFetchWebsocket extends WebSocket {
15
+ public listeners: Map<
16
+ (...args: any[]) => any,
17
+ { type: keyof WebSocketEventMap; listener: (...args: any[]) => void; options: any }
18
+ > = new Map();
19
+
20
+ // eslint-disable-next-line @typescript-eslint/no-useless-constructor
21
+ constructor(socketUrl: string, protocols?: string | string[]) {
22
+ super(socketUrl, protocols);
23
+ }
24
+
25
+ addEventListener = <K extends keyof WebSocketEventMap>(
26
+ type: K,
27
+ listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any,
28
+ options?: boolean | (AddEventListenerOptions & { disableCleanup?: boolean }),
29
+ ) => {
30
+ super.addEventListener(type, listener, options);
31
+ this.listeners.set(listener, { type, listener, options });
32
+ };
33
+
34
+ removeEventListener = <K extends keyof WebSocketEventMap>(
35
+ type: K,
36
+ listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any,
37
+ options?: boolean | EventListenerOptions,
38
+ ) => {
39
+ super.removeEventListener(type, listener, options);
40
+ this.listeners.delete(listener);
41
+ };
42
+
43
+ clearListeners = () => {
44
+ this.listeners.forEach(({ type, listener, options }) => {
45
+ if (!options?.disableCleanup) {
46
+ this.removeEventListener(type, listener, options);
47
+ }
48
+ });
49
+ };
50
+ }
51
+
52
+ return new HyperFetchWebsocket(url, adapterOptions?.protocols);
53
+ };
@@ -1,145 +1,103 @@
1
- import { DateInterval, ExtractRouteParams, ParamsType, getUniqueRequestId } from "@hyper-fetch/core";
1
+ import { ExtractRouteParams, ParamsType, PayloadMapperType, EmptyTypes } from "@hyper-fetch/core";
2
2
 
3
- import { Socket } from "socket";
4
- import { EmitterAcknowledgeType, EmitterOptionsType, EmitType } from "emitter";
5
- import { SocketAdapterType, ExtractEmitterOptionsType } from "adapter";
6
- import { ConnectMethodType } from "types";
3
+ import { SocketInstance } from "socket";
4
+ import { EmitMethodOptionsType, EmitterCloneOptionsType, EmitterOptionsType, EmitType } from "emitter";
5
+ import { ExtractAdapterEmitterOptionsType, ExtractSocketAdapterType } from "types";
7
6
 
8
7
  export class Emitter<
9
8
  Payload,
10
- Response,
11
- Endpoint extends string,
12
- AdapterType extends SocketAdapterType,
13
- MappedData = void,
9
+ Topic extends string,
10
+ Socket extends SocketInstance,
11
+ HasPayload extends boolean = false,
14
12
  HasParams extends boolean = false,
15
- HasData extends boolean = false,
16
13
  > {
17
- readonly endpoint: Endpoint;
14
+ readonly topic: Topic;
18
15
  params?: ParamsType;
19
- timeout: number;
20
- data: Payload | null = null;
21
- options: ExtractEmitterOptionsType<AdapterType>;
22
- connections: Set<ConnectMethodType<AdapterType, Response>> = new Set();
16
+ payload: Payload | undefined;
17
+ options: ExtractAdapterEmitterOptionsType<ExtractSocketAdapterType<Socket>> | undefined;
18
+ /** @internal */
19
+ unstable_payloadMapper?: PayloadMapperType<any>;
23
20
 
24
21
  constructor(
25
- readonly socket: Socket<AdapterType>,
26
- readonly emitterOptions: EmitterOptionsType<Endpoint, AdapterType>,
27
- json?: Partial<Emitter<Payload, Response, Endpoint, AdapterType, MappedData>>,
28
- readonly dataMapper?: (data: Payload) => MappedData,
22
+ readonly socket: Socket,
23
+ readonly emitterOptions: EmitterOptionsType<Topic, ExtractSocketAdapterType<Socket>>,
24
+ /**
25
+ * Used to recreate the emitter with the same state
26
+ * @internal
27
+ */
28
+ snapshot?: Partial<Emitter<Payload, Topic, Socket, any, any>>,
29
29
  ) {
30
- const { endpoint, timeout = DateInterval.second * 2, options } = emitterOptions;
30
+ const { topic, options } = emitterOptions;
31
31
 
32
- this.endpoint = json?.endpoint ?? endpoint;
33
- this.data = json?.data;
34
- this.timeout = json?.timeout ?? timeout;
35
- this.options = json?.options ?? options;
36
- this.params = json?.params;
32
+ this.topic = snapshot?.topic ?? topic;
33
+ this.payload = snapshot?.payload;
34
+ this.options = snapshot?.options ?? options;
35
+ this.params = snapshot?.params;
37
36
  }
38
37
 
39
- setOptions(options: ExtractEmitterOptionsType<AdapterType>) {
38
+ setOptions(options: ExtractAdapterEmitterOptionsType<ExtractSocketAdapterType<Socket>> | undefined) {
40
39
  return this.clone({ options });
41
40
  }
42
41
 
43
- setTimeout(timeout: number) {
44
- return this.clone({ timeout });
45
- }
46
-
47
- setData(data: Payload) {
48
- if (this.dataMapper) {
49
- return this.clone<MappedData, MappedData, HasParams, true>({ data: this.dataMapper(data) });
50
- }
51
- return this.clone<Payload, MappedData, HasParams, true>({ data });
52
- }
53
-
54
- setDataMapper = <MapperData>(mapper: (data: Payload) => MapperData) => {
55
- return this.clone<Payload, MapperData>(undefined, mapper);
42
+ setPayload = <D extends Payload>(payload: D) => {
43
+ return this.clone<D, D extends EmptyTypes ? false : true, HasParams>({
44
+ payload,
45
+ });
56
46
  };
57
47
 
58
- setParams(params: ExtractRouteParams<Endpoint>) {
59
- return this.clone<Payload, MappedData, true>({ params });
60
- }
48
+ setPayloadMapper = <DataMapper extends (payload: Payload) => any | Promise<any>>(payloadMapper: DataMapper) => {
49
+ const cloned = this.clone<Payload, HasPayload, HasParams>(undefined);
50
+
51
+ cloned.unstable_payloadMapper = payloadMapper;
61
52
 
62
- /**
63
- * Attach global logic to the received events
64
- * @param callback
65
- */
66
- onData(callback: ConnectMethodType<AdapterType, Response>) {
67
- this.connections.add(callback);
53
+ return cloned;
54
+ };
68
55
 
69
- return this;
56
+ setParams(params: NonNullable<ExtractRouteParams<Topic>>) {
57
+ return this.clone<Payload, HasPayload, true>({ params });
70
58
  }
71
59
 
72
- private paramsMapper = (params: ParamsType | null | undefined): Endpoint => {
73
- let endpoint = this.emitterOptions.endpoint as string;
60
+ private paramsMapper = (params: ParamsType | null | undefined): Topic => {
61
+ let topic = this.emitterOptions.topic as string;
74
62
  if (params) {
75
63
  Object.entries(params).forEach(([key, value]) => {
76
- endpoint = endpoint.replace(new RegExp(`:${key}`, "g"), String(value));
64
+ topic = topic.replace(new RegExp(`:${key}`, "g"), String(value));
77
65
  });
78
66
  }
79
67
 
80
- return endpoint as Endpoint;
68
+ return topic as Topic;
81
69
  };
82
70
 
83
71
  clone<
84
- NewPayload = Payload,
85
- MapperData = MappedData,
86
- Params extends boolean = HasParams,
87
- Data extends boolean = HasData,
72
+ NewPayload extends Payload = Payload,
73
+ NewHasPayload extends boolean = HasPayload,
74
+ NewHasParams extends boolean = HasParams,
88
75
  >(
89
- options?: Partial<EmitterOptionsType<Endpoint, AdapterType>> & { params?: ParamsType; data?: NewPayload },
90
- mapper?: (data: NewPayload) => MapperData,
91
- ) {
92
- const json: Partial<Emitter<NewPayload, Response, Endpoint, AdapterType, MapperData, Params, Data>> = {
93
- timeout: this.timeout,
76
+ config?: EmitterCloneOptionsType<NewPayload, ParamsType, Topic, Socket>,
77
+ ): Emitter<NewPayload, Topic, Socket, NewHasPayload, NewHasParams> {
78
+ const snapshot: Partial<Emitter<Payload, Topic, Socket, NewHasPayload, NewHasParams>> = {
94
79
  options: this.options,
95
- data: this.data as unknown as NewPayload,
96
- params: options?.params || this.params,
97
- ...options,
98
- endpoint: this.paramsMapper(options?.params || this.params),
80
+ payload: this.payload as unknown as Payload,
81
+ ...config,
82
+ params: config?.params || this.params,
83
+ topic: this.paramsMapper(config?.params || this.params),
99
84
  };
100
- const mapperFn = (mapper || this.dataMapper) as typeof mapper;
101
85
 
102
- const newInstance = new Emitter<NewPayload, Response, Endpoint, AdapterType, MapperData, Params, Data>(
86
+ const newInstance = new Emitter<NewPayload, Topic, Socket, NewHasPayload, NewHasParams>(
103
87
  this.socket,
104
88
  this.emitterOptions,
105
- json,
106
- mapperFn,
89
+ snapshot as Partial<Emitter<NewPayload, Topic, Socket, NewHasPayload, NewHasParams>>,
107
90
  );
108
- newInstance.connections = this.connections;
91
+
92
+ newInstance.unstable_payloadMapper = this.unstable_payloadMapper;
93
+
109
94
  return newInstance;
110
95
  }
111
96
 
112
- getAck = (ack?: EmitterAcknowledgeType<any, AdapterType>) => {
113
- if (ack) {
114
- return (response: { data: any; extra: any; error: any }) => {
115
- this.connections.forEach((connection) => connection(response, () => this.connections.delete(connection)));
116
- return ack(response as any);
117
- };
118
- }
119
- if (this.connections.size) {
120
- return (response: { data: any; extra: any; error: any }) => {
121
- this.connections.forEach((connection) => connection(response, () => this.connections.delete(connection)));
122
- };
123
- }
124
- return undefined;
125
- };
97
+ emit: EmitType<Emitter<Payload, Topic, Socket, HasPayload, HasParams>> = (options = {}) => {
98
+ const typedOptions = options as EmitMethodOptionsType<Emitter<Payload, Topic, Socket, HasPayload, HasParams>>;
99
+ const instance = this.clone<Payload, HasPayload, HasParams>(typedOptions);
126
100
 
127
- emit: EmitType<this> = ({
128
- data,
129
- params,
130
- options,
131
- ack,
132
- }: {
133
- data?: Payload;
134
- params?: ExtractRouteParams<Endpoint>;
135
- options?: Partial<EmitterOptionsType<Endpoint, AdapterType>>;
136
- ack?: EmitterAcknowledgeType<any, AdapterType>;
137
- } = {}) => {
138
- const instance = this.clone({ ...options, data, params });
139
-
140
- const eventMessageId = getUniqueRequestId(instance.endpoint);
141
-
142
- this.socket.adapter.emit(eventMessageId, instance, instance.getAck(ack));
143
- return eventMessageId;
101
+ this.socket.adapter.emit(instance);
144
102
  };
145
103
  }