7707910534

Committed 30 Jan 2024 07:51AM UTC coverage: 85.239% (-0.3%) from 85.573%

Build # 7707910534

Build Type

Pull #43

github

Committed by

web-flow

Commit Message

Merge 345213129 into 3ade194d3

Pull Request Pull Request #43: fix mpaas miniprogram socket issue

Run Details

1332 of 1476 branches covered (0.0%)

Branch coverage included in aggregate %.

94 of 136 new or added lines in 4 files covered. (69.12%)

5 existing lines in 3 files now uncovered.

5118 of 6091 relevant lines covered (84.03%)

45.79 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.85

/packages/base/src/socket-base.ts

/**
 * socket base class
 * 不同平台 socket 的 api 不同但功能相同，这里抽象一层
 */

import type {
  SpyMessage,
  SpySocket,
  SpyBase,
} from '@huolala-tech/page-spy-types';
import { PackedEvent } from '@huolala-tech/page-spy-types/lib/socket-event';
import { getRandomId, psLog, stringifyData } from './index';
import {
  DEBUG_MESSAGE_TYPE,
  makeMessage,
  makeBroadcastMessage,
  makeUnicastMessage,
} from './message';
import * as SERVER_MESSAGE_TYPE from './message/server-type';
import atom from './atom';
import {
  ATOM_DETAIL,
  ATOM_GETTER,
  DATABASE_PAGINATION,
  DEBUG,
  DEBUGGER_ONLINE,
  PUBLIC_DATA,
  REFRESH,
} from './message/debug-type';

interface GetterMember {
  key: string; // 属性名
  id: string; // 当前键的 id
  parentId: string; // 当前属性所在容器的 id
  instanceId: string; // 当前实例的 id
}

export type WebSocketEvents = keyof WebSocketEventMap;
type CallbackType = (data?: any) => void;

// fork WebSocket state
export enum SocketState {
  CONNECTING = 0,
  OPEN = 1,
  CLOSING = 2,
  CLOSED = 3,
}

const HEARTBEAT_INTERVAL = 5000;

// 封装不同平台的 socket
export abstract class SocketWrapper {
  abstract init(url: string): void;
  abstract send(data: string): void;
  abstract close(data?: {}): void;
  abstract getState(): SocketState;
  protected events: Record<WebSocketEvents, CallbackType[]> = {
    open: [],
    close: [],
    error: [],
    message: [],
  };

  protected emit(event: WebSocketEvents, data: any) {
    this.events[event].forEach((fun) => {
      fun(data);
    });
    // for close and error, clear all listeners or they will be called on next socket instance.
    if (event === 'close' || event === 'error') {
      this.clearListeners();
    }
  }

  onOpen(fun: (res: { header?: Record<string, string> }) => void) {
    this.events.open.push(fun);
  }

  onClose(fun: (res: { code: number; reason: string }) => void) {
    this.events.close.push(fun);
  }

  onError(fun: (msg: string) => void) {
    this.events.error.push(fun);
  }

  onMessage(fun: (data: string | ArrayBuffer) => void) {
    this.events.message.push(fun);
  }

  protected clearListeners() {
    // clear listeners
    Object.entries(this.events).forEach(([, funs]) => {
      funs.splice(0);
    });
  }
}

export abstract class SocketStoreBase {
  protected abstract socketWrapper: SocketWrapper;

  private socketUrl: string = '';

  private socketConnection: SpySocket.Connection | null = null;

  // ping timer used for send next ping.
  // a ping is sent after last msg (normal msg or pong) received.
  private pingTimer: ReturnType<typeof setTimeout> | null = null;

  // pong timer used for waiting for pong, if pong not received, close the connection
  private pongTimer: ReturnType<typeof setTimeout> | null = null;

  private retryTimer: ReturnType<typeof setTimeout> | null = null;

  // messages store
  private messages: (SpySocket.BroadcastEvent | SpySocket.UnicastEvent)[] = [];

  // events center
  private events: Record<
    SpyMessage.InteractiveType | SpyMessage.InternalType,
    SpyBase.EventCallback[]
  > = {
    [REFRESH]: [],
    [DEBUG]: [],
    [ATOM_DETAIL]: [],
    [ATOM_GETTER]: [],
    [DEBUGGER_ONLINE]: [],
    [DATABASE_PAGINATION]: [],
    [PUBLIC_DATA]: [],
  };

  // Don't try to reconnect if error occupied
  private reconnectable: boolean = true;

  private reconnectTimes = 3;

  // indicated connected  whether or not
  public connectionStatus: boolean = false;

  // response message filters, to handle some wired messages
  public static messageFilters: ((data: any) => any)[] = [];

  constructor() {
    this.addListener('debug', SocketStoreBase.handleDebugger);
    this.addListener('atom-detail', SocketStoreBase.handleResolveAtom);
    this.addListener('atom-getter', SocketStoreBase.handleAtomPropertyGetter);
    this.addListener('debugger-online', this.handleFlushBuffer);
  }

  // Simple offline listener
  abstract onOffline(): void;

  public init(url: string) {
    try {
      if (!url) {
        throw Error('WebSocket url cannot be empty');
      }
      // close existing connection
      if (this.socketWrapper.getState() === SocketState.OPEN) {
        this.socketWrapper.close();
      }
      this.socketWrapper?.onOpen(() => {
        this.connectOnline();
      });
      // Strictly, the onMessage should be called after onOpen. But for some platform(alipay,)
      // this may cause some message losing.
      this.socketWrapper?.onMessage((evt) => {
        this.handleMessage(evt);
      });
      this.socketWrapper?.onClose(() => {
        this.connectOffline();
      });
      this.socketWrapper?.onError(() => {
        // we treat on error the same with on close.
        this.connectOffline();
      });
      this.socketUrl = url;
      this.socketWrapper?.init(url);
    } catch (e: any) {
      psLog.error(e.message);
    }
  }

  public addListener(
    type: SpyMessage.InteractiveType,
    fn: SpyBase.InteractiveEventCallback,
  ): void;
  public addListener(
    type: SpyMessage.InternalType,
    fn: SpyBase.InternalEventCallback,
  ): void;
  public addListener(type: any, fn: any) {
    /* c8 ignore next 3 */
    if (!this.events[type]) {
      this.events[type] = [];
    }
    this.events[type].push(fn);
  }

  public broadcastMessage(
    msg: SpyMessage.MessageItem,
    noCache: boolean = false,
  ) {
    const message = makeBroadcastMessage(msg);
    this.send(message, noCache);
  }

  public close() {
    this.clearPing();
    this.reconnectTimes = 0;
    this.reconnectable = false;
    this.socketWrapper?.close();
    this.messages = [];
    Object.entries(this.events).forEach(([, fns]) => {
      fns.splice(0);
    });
  }

  private connectOnline() {
    this.connectionStatus = true;
    this.reconnectTimes = 3;
    this.ping();
  }

  private connectOffline() {
    this.connectionStatus = false;
    this.socketConnection = null;
    this.clearPing();
    if (!this.reconnectable || this.reconnectTimes <= 0) {
      this.onOffline();
      return;
    }

    if (this.retryTimer) {
      clearTimeout(this.retryTimer);
    }

    this.retryTimer = setTimeout(() => {
      this.retryTimer = null;
      this.tryReconnect();
    }, 2000);
  }

  tryReconnect() {
    this.reconnectTimes -= 1;
    if (this.reconnectTimes <= 0) {
      this.reconnectable = false;
    }
    this.init(this.socketUrl);
  }

  private ping() {
    if (this.pingTimer) {
      clearTimeout(this.pingTimer);
    }
    if (this.pongTimer) {
      clearTimeout(this.pongTimer);
    }
    /* c8 ignore start */
    this.pingTimer = setTimeout(() => {
      this.send({
        type: 'ping',
        content: null,
      });
      this.pingTimer = null;
      this.pongTimer = setTimeout(() => {
        // lost connection
        this.connectOffline();
        this.pongTimer = null;
      }, HEARTBEAT_INTERVAL);
    }, HEARTBEAT_INTERVAL);
    /* c8 ignore stop */
  }

  private clearPing() {
    if (this.pingTimer) {
      clearTimeout(this.pingTimer);
      this.pingTimer = null;
    }
    if (this.pongTimer) {
      clearTimeout(this.pongTimer);
      this.pongTimer = null;
    }
  }

  private handlePong() {
    clearTimeout(this.pongTimer!);
    this.pongTimer = null;
    this.ping();
  }

  // get the data which we expected from nested structure of the message
  protected handleMessage(evt: any) {
    if (SocketStoreBase.messageFilters.length) {
      SocketStoreBase.messageFilters.forEach((filter) => {
        evt = filter(evt);
      });
    }
    const {
      CONNECT,
      MESSAGE,
      ERROR,
      JOIN,
      PING,
      PONG,
      LEAVE,
      CLOSE,
      BROADCAST,
    } = SERVER_MESSAGE_TYPE;
    const result = JSON.parse(evt.data) as SpySocket.Event;
    const { type } = result;
    switch (type) {
      case CONNECT:
        const { selfConnection } = result.content;
        this.socketConnection = selfConnection;
        break;
      case MESSAGE:
        const { data, from, to } = result.content;
        if (to.address === this.socketConnection?.address) {
          this.dispatchEvent(data.type as SpyMessage.InteractiveType, {
            source: data,
            from,
            to,
          });
        }
        break;
      case ERROR:
        // TODO: we should handle this error
        // if (result.content.code === 'RoomNotFoundError') {
        //   // Room not exist, might because used an old connection.
        // }
        this.reconnectable = false;
        this.connectOffline();
        break;
      /* c8 ignore start */
      case PONG:
      case JOIN:
      case PING:
      case LEAVE:
      case CLOSE:
      case BROADCAST:
      default:
        // noting
        break;
      /* c8 ignore stop */
    }
    // whatever the type is, we should handle pong
    this.handlePong();
  }

  public dispatchEvent(
    type: SpyMessage.InteractiveType,
    data: SpyBase.InteractiveEvent,
  ): void;
  public dispatchEvent(type: SpyMessage.InternalType, data: any): void;
  public dispatchEvent(type: any, data: any) {
    if ([PUBLIC_DATA].includes(type)) {
      this.events[type].forEach((fn) => {
        (fn as SpyBase.InternalEventCallback)(data);
      });
      return;
    }
    this.events[type].forEach((fn) => {
      (fn as SpyBase.InteractiveEventCallback).call(
        this,
        data,
        (d: SpyMessage.MessageItem) => {
          this.unicastMessage(d, data.from);
        },
      );
    });
  }

  private unicastMessage(
    msg: SpyMessage.MessageItem,
    to: SpySocket.Connection,
  ) {
    const message = makeUnicastMessage(msg, this.socketConnection!, to);
    this.send(message);
  }

  private handleFlushBuffer(
    message: SpyBase.InteractiveEvent<{ latestId: string }>,
  ) {
    const { latestId } = message.source.data;

    const msgIndex = this.messages.findIndex(
      (i) => i.content.data.data.id === latestId,
    );

    /* c8 ignore start */
    this.messages
      .slice(msgIndex + 1)
      .forEach((msg: SpySocket.BroadcastEvent | SpySocket.UnicastEvent) => {
        const data = {
          type: SERVER_MESSAGE_TYPE.MESSAGE,
          content: {
            data: msg.content.data,
            from: this.socketConnection!,
            to: message.from,
          },
        } as const;
        this.send(data, true);
      });
    /* c8 ignore stop */
  }

  // run executable code which received from remote and send back the result
  private static handleDebugger(
    { source }: SpyBase.InteractiveEvent<string>,
    reply: (data: any) => void,
  ) {
    const { type, data } = source;
    if (type === DEBUG_MESSAGE_TYPE.DEBUG) {
      const originMsg = makeMessage(DEBUG_MESSAGE_TYPE.CONSOLE, {
        logType: 'debug-origin',
        logs: [
          {
            id: getRandomId(),
            type: 'debug-origin',
            value: data,
          },
        ],
      });
      reply(originMsg);
      try {
        // eslint-disable-next-line no-new-func, @typescript-eslint/no-implied-eval
        const result = new Function(`return ${data}`)();
        const evalMsg = makeMessage(DEBUG_MESSAGE_TYPE.CONSOLE, {
          logType: 'debug-eval',
          logs: [atom.transformToAtom(result)],
        });
        reply(evalMsg);
      } catch (err) {
        const errMsg = makeMessage(DEBUG_MESSAGE_TYPE.CONSOLE, {
          logType: 'error',
          logs: [
            {
              type: 'error',
              value: (err as Error).stack,
            },
          ],
        });
        reply(errMsg);
      }
    }
  }

  private static handleResolveAtom(
    { source }: SpyBase.InteractiveEvent<string>,
    reply: (data: any) => void,
  ) {
    const { type, data } = source;
    if (type === DEBUG_MESSAGE_TYPE.ATOM_DETAIL) {
      const atomData = atom.get(data) || {};
      const msg = makeMessage(`atom-detail-${data}`, atomData, false);
      reply(msg);
    }
  }

  private static handleAtomPropertyGetter(
    { source }: SpyBase.InteractiveEvent<GetterMember>,
    reply: (data: any) => void,
  ) {
    const { type, data } = source;
    if (type === DEBUG_MESSAGE_TYPE.ATOM_GETTER) {
      const { id, parentId, key, instanceId } = data;
      const instance = atom.getOrigin(instanceId);
      const current = atom.getOrigin(parentId);
      let value = {};
      /* c8 ignore start */
      if (instance && current) {
        value = Object.getOwnPropertyDescriptor(current, key)?.get?.call(
          instance,
        );
      } else {
        value = new Error('Getter computed failed');
      }
      /* c8 ignore stop */
      const msg = makeMessage(`atom-getter-${id}`, atom.transformToAtom(value));
      reply(msg);
    }
  }

  private send(msg: SpySocket.ClientEvent, noCache: boolean = false) {
    if (this.connectionStatus) {
      /* c8 ignore start */
      try {
        const pkMsg = msg as PackedEvent;
        pkMsg.createdAt = Date.now();
        pkMsg.requestId = getRandomId();
        const dataString = stringifyData(pkMsg);
        this.socketWrapper?.send(dataString);
      } catch (e) {
        throw Error(`Incompatible: ${(e as Error).message}`);
      }
      /* c8 ignore stop */
    }
    if (!noCache) {
      if (
        [SERVER_MESSAGE_TYPE.MESSAGE, SERVER_MESSAGE_TYPE.PING].indexOf(
          msg.type,
        ) > -1
      ) {
        return;
      }
      this.messages.push(
        msg as Exclude<SpySocket.ClientEvent, SpySocket.PingEvent>,
      );
    }
  }
}

1	/**	2✔
2	* socket base class	2✔
3	* 不同平台 socket 的 api 不同但功能相同，这里抽象一层	2✔
4	*/	2✔
5		2✔
6	import type {	2✔
7	SpyMessage,	2✔
8	SpySocket,	2✔
9	SpyBase,	2✔
10	} from '@huolala-tech/page-spy-types';	2✔
11	import { PackedEvent } from '@huolala-tech/page-spy-types/lib/socket-event';	2✔
12	import { getRandomId, psLog, stringifyData } from './index';	2✔
13	import {	2✔
14	DEBUG_MESSAGE_TYPE,	2✔
15	makeMessage,	2✔
16	makeBroadcastMessage,	2✔
17	makeUnicastMessage,	2✔
18	} from './message';	2✔
19	import * as SERVER_MESSAGE_TYPE from './message/server-type';	2✔
20	import atom from './atom';	2✔
21	import {	2✔
22	ATOM_DETAIL,	2✔
23	ATOM_GETTER,	2✔
24	DATABASE_PAGINATION,	2✔
25	DEBUG,	2✔
26	DEBUGGER_ONLINE,	2✔
27	PUBLIC_DATA,	2✔
28	REFRESH,	2✔
29	} from './message/debug-type';	2✔
30		2✔
31	interface GetterMember {	2✔
32	key: string; // 属性名	2✔
33	id: string; // 当前键的 id	2✔
34	parentId: string; // 当前属性所在容器的 id	2✔
35	instanceId: string; // 当前实例的 id	2✔
36	}	2✔
37		2✔
38	export type WebSocketEvents = keyof WebSocketEventMap;	2✔
39	type CallbackType = (data?: any) => void;	2✔
40		2✔
41	// fork WebSocket state	2✔
42	export enum SocketState {	34✔
43	CONNECTING = 0,	34✔
44	OPEN = 1,	34✔
45	CLOSING = 2,	34✔
46	CLOSED = 3,	34✔
47	}	34✔
48		2✔
49	const HEARTBEAT_INTERVAL = 5000;	2✔
50		2✔
51	// 封装不同平台的 socket	2✔
52	export abstract class SocketWrapper {	2✔
53	abstract init(url: string): void;	2✔
54	abstract send(data: string): void;	2✔
55	abstract close(data?: {}): void;	2✔
56	abstract getState(): SocketState;	2✔
57	protected events: Record<WebSocketEvents, CallbackType[]> = {	2✔
58	open: [],	40✔
59	close: [],	40✔
60	error: [],	40✔
61	message: [],	40✔
62	};	40✔
63		2✔
64	protected emit(event: WebSocketEvents, data: any) {	2✔
65	this.events[event].forEach((fun) => {	×
66	fun(data);	×
67	});	×
68	// for close and error, clear all listeners or they will be called on next socket instance.	×
69	if (event === 'close' \|\| event === 'error') {	×
70	this.clearListeners();	×
71	}	×
72	}	×
73		2✔
74	onOpen(fun: (res: { header?: Record<string, string> }) => void) {	2✔
75	this.events.open.push(fun);	28✔
76	}	28✔
77		2✔
78	onClose(fun: (res: { code: number; reason: string }) => void) {	2✔
79	this.events.close.push(fun);	28✔
80	}	28✔
81		2✔
82	onError(fun: (msg: string) => void) {	2✔
83	this.events.error.push(fun);	28✔
84	}	28✔
85		2✔
86	onMessage(fun: (data: string \| ArrayBuffer) => void) {	2✔
87	this.events.message.push(fun);	28✔
88	}	28✔
89		2✔
90	protected clearListeners() {	2✔
91	// clear listeners	10✔
92	Object.entries(this.events).forEach(([, funs]) => {	10✔
93	funs.splice(0);	40✔
94	});	10✔
95	}	10✔
96	}	2✔
97		2✔
98	export abstract class SocketStoreBase {	2✔
99	protected abstract socketWrapper: SocketWrapper;	2✔
100		2✔
101	private socketUrl: string = '';	2✔
102		40✔
103	private socketConnection: SpySocket.Connection \| null = null;	40✔
104		40✔
105	// ping timer used for send next ping.	40✔
106	// a ping is sent after last msg (normal msg or pong) received.	40✔
107	private pingTimer: ReturnType<typeof setTimeout> \| null = null;	40✔
108		40✔
109	// pong timer used for waiting for pong, if pong not received, close the connection	40✔
110	private pongTimer: ReturnType<typeof setTimeout> \| null = null;	40✔
111		40✔
112	private retryTimer: ReturnType<typeof setTimeout> \| null = null;	40✔
113		40✔
114	// messages store	40✔
115	private messages: (SpySocket.BroadcastEvent \| SpySocket.UnicastEvent)[] = [];	40✔
116		40✔
117	// events center	40✔
118	private events: Record<	40✔
119	SpyMessage.InteractiveType \| SpyMessage.InternalType,	40✔
120	SpyBase.EventCallback[]	40✔
121	> = {	40✔
122	[REFRESH]: [],	40✔
123	[DEBUG]: [],	40✔
124	[ATOM_DETAIL]: [],	40✔
125	[ATOM_GETTER]: [],	40✔
126	[DEBUGGER_ONLINE]: [],	40✔
127	[DATABASE_PAGINATION]: [],	40✔
128	[PUBLIC_DATA]: [],	40✔
129	};	40✔
130		40✔
131	// Don't try to reconnect if error occupied	40✔
132	private reconnectable: boolean = true;	40✔
133		40✔
134	private reconnectTimes = 3;	40✔
135		40✔
136	// indicated connected whether or not	40✔
137	public connectionStatus: boolean = false;	2✔
138		2✔
139	// response message filters, to handle some wired messages	2✔
140	public static messageFilters: ((data: any) => any)[] = [];	2✔
141		2✔
142	constructor() {	2✔
143	this.addListener('debug', SocketStoreBase.handleDebugger);	40✔
144	this.addListener('atom-detail', SocketStoreBase.handleResolveAtom);	40✔
145	this.addListener('atom-getter', SocketStoreBase.handleAtomPropertyGetter);	40✔
146	this.addListener('debugger-online', this.handleFlushBuffer);	40✔
147	}	40✔
148		2✔
149	// Simple offline listener	2✔
150	abstract onOffline(): void;	2✔
151		2✔
152	public init(url: string) {	2✔
153	try {	30✔
154	if (!url) {	30✔
155	throw Error('WebSocket url cannot be empty');	2✔
156	}	2✔
157	// close existing connection	28✔
158	if (this.socketWrapper.getState() === SocketState.OPEN) {	30!
UNCOV 159	this.socketWrapper.close();	×
UNCOV 160	}	×
161	this.socketWrapper?.onOpen(() => {	30✔
162	this.connectOnline();	12✔
163	});	30✔
164	// Strictly, the onMessage should be called after onOpen. But for some platform(alipay,)	30✔
165	// this may cause some message losing.	30✔
166	this.socketWrapper?.onMessage((evt) => {	30✔
167	this.handleMessage(evt);	12✔
168	});	30✔
169	this.socketWrapper?.onClose(() => {	30✔
170	this.connectOffline();	30✔
171	});	30✔
172	this.socketWrapper?.onError(() => {	30✔
173	// we treat on error the same with on close.	18✔
174	this.connectOffline();	18✔
175	});	30✔
176	this.socketUrl = url;	30✔
177	this.socketWrapper?.init(url);	30✔
178	} catch (e: any) {	30✔
179	psLog.error(e.message);	2✔
180	}	2✔
181	}	30✔
182		2✔
183	public addListener(	2✔
184	type: SpyMessage.InteractiveType,	2✔
185	fn: SpyBase.InteractiveEventCallback,	2✔
186	): void;	2✔
187	public addListener(	2✔
188	type: SpyMessage.InternalType,	2✔
189	fn: SpyBase.InternalEventCallback,	2✔
190	): void;	2✔
191	public addListener(type: any, fn: any) {	2✔
192	/* c8 ignore next 3 */	2✔
193	if (!this.events[type]) {	2✔
194	this.events[type] = [];	2✔
195	}	2✔
196	this.events[type].push(fn);	226✔
197	}	226✔
198		2✔
199	public broadcastMessage(	2✔
200	msg: SpyMessage.MessageItem,	1,954✔
201	noCache: boolean = false,	1,954✔
202	) {	1,954✔
203	const message = makeBroadcastMessage(msg);	1,954✔
204	this.send(message, noCache);	1,954✔
205	}	1,954✔
206		2✔
207	public close() {	2✔
208	this.clearPing();	18✔
209	this.reconnectTimes = 0;	18✔
210	this.reconnectable = false;	18✔
211	this.socketWrapper?.close();	18✔
212	this.messages = [];	18✔
213	Object.entries(this.events).forEach(([, fns]) => {	18✔
214	fns.splice(0);	126✔
215	});	18✔
216	}	18✔
217		2✔
218	private connectOnline() {	2✔
219	this.connectionStatus = true;	12✔
220	this.reconnectTimes = 3;	12✔
221	this.ping();	12✔
222	}	12✔
223		2✔
224	private connectOffline() {	2✔
225	this.connectionStatus = false;	50✔
226	this.socketConnection = null;	50✔
227	this.clearPing();	50✔
228	if (!this.reconnectable \|\| this.reconnectTimes <= 0) {	50✔
229	this.onOffline();	22✔
230	return;	22✔
231	}	22✔
232		28✔
233	if (this.retryTimer) {	50✔
234	clearTimeout(this.retryTimer);	18✔
235	}	18✔
236		28✔
237	this.retryTimer = setTimeout(() => {	28✔
238	this.retryTimer = null;	8✔
239	this.tryReconnect();	8✔
240	}, 2000);	28✔
241	}	28✔
242		2✔
243	tryReconnect() {	2✔
244	this.reconnectTimes -= 1;	8✔
245	if (this.reconnectTimes <= 0) {	8✔
246	this.reconnectable = false;	2✔
247	}	2✔
248	this.init(this.socketUrl);	8✔
249	}	8✔
250		2✔
251	private ping() {	2✔
252	if (this.pingTimer) {	24✔
253	clearTimeout(this.pingTimer);	12✔
254	}	12✔
255	if (this.pongTimer) {	24!
256	clearTimeout(this.pongTimer);	×
257	}	×
258	/* c8 ignore start */	2✔
259	this.pingTimer = setTimeout(() => {	2✔
260	this.send({	2✔
261	type: 'ping',	2✔
262	content: null,	2✔
263	});	2✔
264	this.pingTimer = null;	2✔
265	this.pongTimer = setTimeout(() => {	2✔
266	// lost connection	2✔
267	this.connectOffline();	2✔
268	this.pongTimer = null;	2✔
269	}, HEARTBEAT_INTERVAL);	2✔
270	}, HEARTBEAT_INTERVAL);	2✔
271	/* c8 ignore stop */	2✔
272	}	24✔
273		2✔
274	private clearPing() {	2✔
275	if (this.pingTimer) {	68✔
276	clearTimeout(this.pingTimer);	12✔
277	this.pingTimer = null;	12✔
278	}	12✔
279	if (this.pongTimer) {	68!
280	clearTimeout(this.pongTimer);	×
281	this.pongTimer = null;	×
282	}	×
283	}	68✔
284		2✔
285	private handlePong() {	2✔
286	clearTimeout(this.pongTimer!);	12✔
287	this.pongTimer = null;	12✔
288	this.ping();	12✔
289	}	12✔
290		2✔
291	// get the data which we expected from nested structure of the message	2✔
292	protected handleMessage(evt: any) {	2✔
293	if (SocketStoreBase.messageFilters.length) {	12!
294	SocketStoreBase.messageFilters.forEach((filter) => {	×
295	evt = filter(evt);	×
296	});	×
297	}	×
298	const {	12✔
299	CONNECT,	12✔
300	MESSAGE,	12✔
301	ERROR,	12✔
302	JOIN,	12✔
303	PING,	12✔
304	PONG,	12✔
305	LEAVE,	12✔
306	CLOSE,	12✔
307	BROADCAST,	12✔
308	} = SERVER_MESSAGE_TYPE;	12✔
309	const result = JSON.parse(evt.data) as SpySocket.Event;	12✔
310	const { type } = result;	12✔
311	switch (type) {	12✔
312	case CONNECT:	12✔
313	const { selfConnection } = result.content;	2✔
314	this.socketConnection = selfConnection;	2✔
315	break;	2✔
316	case MESSAGE:	12✔
317	const { data, from, to } = result.content;	8✔
318	if (to.address === this.socketConnection?.address) {	8✔
319	this.dispatchEvent(data.type as SpyMessage.InteractiveType, {	8✔
320	source: data,	8✔
321	from,	8✔
322	to,	8✔
323	});	8✔
324	}	8✔
325	break;	8✔
326	case ERROR:	12✔
327	// TODO: we should handle this error	2✔
328	// if (result.content.code === 'RoomNotFoundError') {	2✔
329	// // Room not exist, might because used an old connection.	2✔
330	// }	2✔
331	this.reconnectable = false;	2✔
332	this.connectOffline();	2✔
333	break;	2✔
334	/* c8 ignore start */	2✔
335	case PONG:	2✔
336	case JOIN:	2✔
337	case PING:	2✔
338	case LEAVE:	2✔
339	case CLOSE:	2✔
340	case BROADCAST:	2✔
341	default:	2✔
342	// noting	2✔
343	break;	2✔
344	/* c8 ignore stop */	2✔
345	}	12✔
346	// whatever the type is, we should handle pong	12✔
347	this.handlePong();	12✔
348	}	12✔
349		2✔
350	public dispatchEvent(	2✔
351	type: SpyMessage.InteractiveType,	2✔
352	data: SpyBase.InteractiveEvent,	2✔
353	): void;	2✔
354	public dispatchEvent(type: SpyMessage.InternalType, data: any): void;	2✔
355	public dispatchEvent(type: any, data: any) {	2✔
356	if ([PUBLIC_DATA].includes(type)) {	322✔
357	this.events[type].forEach((fn) => {	308✔
358	(fn as SpyBase.InternalEventCallback)(data);	×
359	});	308✔
360	return;	308✔
361	}	308✔
362	this.events[type].forEach((fn) => {	14✔
363	(fn as SpyBase.InteractiveEventCallback).call(	14✔
364	this,	14✔
365	data,	14✔
366	(d: SpyMessage.MessageItem) => {	14✔
367	this.unicastMessage(d, data.from);	10✔
368	},	14✔
369	);	14✔
370	});	14✔
371	}	14✔
372		2✔
373	private unicastMessage(	2✔
374	msg: SpyMessage.MessageItem,	10✔
375	to: SpySocket.Connection,	10✔
376	) {	10✔
377	const message = makeUnicastMessage(msg, this.socketConnection!, to);	10✔
378	this.send(message);	10✔
379	}	10✔
380		2✔
381	private handleFlushBuffer(	2✔
382	message: SpyBase.InteractiveEvent<{ latestId: string }>,	2✔
383	) {	2✔
384	const { latestId } = message.source.data;	2✔
385		2✔
386	const msgIndex = this.messages.findIndex(	2✔
387	(i) => i.content.data.data.id === latestId,	2✔
388	);	2✔
389		2✔
390	/* c8 ignore start */	2✔
391	this.messages	2✔
392	.slice(msgIndex + 1)	2✔
393	.forEach((msg: SpySocket.BroadcastEvent \| SpySocket.UnicastEvent) => {	2✔
394	const data = {	2✔
395	type: SERVER_MESSAGE_TYPE.MESSAGE,	2✔
396	content: {	2✔
397	data: msg.content.data,	2✔
398	from: this.socketConnection!,	2✔
399	to: message.from,	2✔
400	},	2✔
401	} as const;	2✔
402	this.send(data, true);	2✔
403	});	2✔
404	/* c8 ignore stop */	2✔
405	}	2✔
406		2✔
407	// run executable code which received from remote and send back the result	2✔
408	private static handleDebugger(	2✔
409	{ source }: SpyBase.InteractiveEvent<string>,	2✔
410	reply: (data: any) => void,	2✔
411	) {	2✔
412	const { type, data } = source;	2✔
413	if (type === DEBUG_MESSAGE_TYPE.DEBUG) {	2✔
414	const originMsg = makeMessage(DEBUG_MESSAGE_TYPE.CONSOLE, {	2✔
415	logType: 'debug-origin',	2✔
416	logs: [	2✔
417	{	2✔
418	id: getRandomId(),	2✔
419	type: 'debug-origin',	2✔
420	value: data,	2✔
421	},	2✔
422	],	2✔
423	});	2✔
424	reply(originMsg);	2✔
425	try {	2✔
426	// eslint-disable-next-line no-new-func, @typescript-eslint/no-implied-eval	2✔
427	const result = new Function(`return ${data}`)();	2✔
428	const evalMsg = makeMessage(DEBUG_MESSAGE_TYPE.CONSOLE, {	2✔
429	logType: 'debug-eval',	2✔
430	logs: [atom.transformToAtom(result)],	2✔
431	});	2✔
432	reply(evalMsg);	2✔
433	} catch (err) {	2✔
434	const errMsg = makeMessage(DEBUG_MESSAGE_TYPE.CONSOLE, {	2✔
435	logType: 'error',	2✔
436	logs: [	2✔
437	{	2✔
438	type: 'error',	2✔
439	value: (err as Error).stack,	2✔
440	},	2✔
441	],	2✔
442	});	2✔
443	reply(errMsg);	2✔
444	}	2✔
445	}	2✔
446	}	2✔
447		2✔
448	private static handleResolveAtom(	2✔
449	{ source }: SpyBase.InteractiveEvent<string>,	2✔
450	reply: (data: any) => void,	2✔
451	) {	2✔
452	const { type, data } = source;	2✔
453	if (type === DEBUG_MESSAGE_TYPE.ATOM_DETAIL) {	2✔
454	const atomData = atom.get(data) \|\| {};	2✔
455	const msg = makeMessage(`atom-detail-${data}`, atomData, false);	2✔
456	reply(msg);	2✔
457	}	2✔
458	}	2✔
459		2✔
460	private static handleAtomPropertyGetter(	2✔
461	{ source }: SpyBase.InteractiveEvent<GetterMember>,	2✔
462	reply: (data: any) => void,	2✔
463	) {	2✔
464	const { type, data } = source;	2✔
465	if (type === DEBUG_MESSAGE_TYPE.ATOM_GETTER) {	2✔
466	const { id, parentId, key, instanceId } = data;	2✔
467	const instance = atom.getOrigin(instanceId);	2✔
468	const current = atom.getOrigin(parentId);	2✔
469	let value = {};	2✔
470	/* c8 ignore start */	2✔
471	if (instance && current) {	2✔
472	value = Object.getOwnPropertyDescriptor(current, key)?.get?.call(	2✔
473	instance,	2✔
474	);	2✔
475	} else {	2✔
476	value = new Error('Getter computed failed');	2✔
477	}	2✔
478	/* c8 ignore stop */	2✔
479	const msg = makeMessage(`atom-getter-${id}`, atom.transformToAtom(value));	2✔
480	reply(msg);	2✔
481	}	2✔
482	}	2✔
483		2✔
484	private send(msg: SpySocket.ClientEvent, noCache: boolean = false) {	2✔
485	if (this.connectionStatus) {	1,964✔
486	/* c8 ignore start */	2✔
487	try {	2✔
488	const pkMsg = msg as PackedEvent;	2✔
489	pkMsg.createdAt = Date.now();	2✔
490	pkMsg.requestId = getRandomId();	2✔
491	const dataString = stringifyData(pkMsg);	2✔
492	this.socketWrapper?.send(dataString);	2✔
493	} catch (e) {	2✔
494	throw Error(`Incompatible: ${(e as Error).message}`);	2✔
495	}	2✔
496	/* c8 ignore stop */	2✔
497	}	8✔
498	if (!noCache) {	1,964✔
499	if (	262✔
500	[SERVER_MESSAGE_TYPE.MESSAGE, SERVER_MESSAGE_TYPE.PING].indexOf(	262✔
501	msg.type,	262✔
502	) > -1	262✔
503	) {	262✔
504	return;	10✔
505	}	10✔
506	this.messages.push(	252✔
507	msg as Exclude<SpySocket.ClientEvent, SpySocket.PingEvent>,	252✔
508	);	252✔
509	}	252✔
510	}	1,964✔
511	}	2✔

HuolalaTech / page-spy / 7707910534

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous