@cloudbase/realtime 2.0.3-alpha.0 → 2.5.0-beta.0

package/src/websocket-client.ts

@@ -11,15 +11,15 @@ import {
   IRequestMessagePingMsg,
   IRequestMessageLoginMsg,
   IResponseMessageLoginResMsg,
-  IRequestMessageLoginData
+  IRequestMessageLoginData,
 } from '@cloudbase/types/realtime'
 import {
-  CLOSE_EVENT_CODE,
+  CloseEventCode,
   CLOSE_EVENT_CODE_INFO,
-  getWSCloseError
+  getWSCloseError,
 } from './ws-event'
 
-import { ERR_CODE, TimeoutError, RealtimeErrorMessageError,CloudSDKError } from './error'
+import { ERR_CODE, TimeoutError, RealtimeErrorMessageError, CloudSDKError } from './error'
 import { getWsClass, getRuntime } from './common'
 import { sleep } from './utils'
 
@@ -85,7 +85,7 @@ const WS_READY_STATE = {
   CONNECTING: 0,
   OPEN: 1,
   CLOSING: 2,
-  CLOSED: 3
+  CLOSED: 3,
 }
 
 const MAX_RTT_OBSERVED = 3
@@ -99,200 +99,149 @@ const DEFAULT_PONG_MISS_TOLERANCE = 2
 const DEFAULT_LOGIN_TIMEOUT = 5000
 
 export class RealtimeWebSocketClient {
-  private _virtualWSClient: Set<VirtualWebSocketClient> = new Set()
+  private virtualWSClient: Set<VirtualWebSocketClient> = new Set()
   // after listener initWatch, the listener has the queryID and can store it here
-  private _queryIdClientMap: Map<string, VirtualWebSocketClient> = new Map()
-  private _watchIdClientMap: Map<string, VirtualWebSocketClient> = new Map()
-  private _maxReconnect: number
-  // private _availableRetries: number
-  private _reconnectInterval: number
-  private _context: IDatabaseServiceContext
-  // private _ws?: WXNS.Socket.ISocketTask
-  private _ws?: any
-  private _lastPingSendTS?: number
-  private _pingFailed = 0
-  private _pongMissed = 0
-  private _pingTimeoutId?: number
-  private _pongTimeoutId?: number
-  private _logins: Map<string /* envId */, ILoginInfo> = new Map()
-  // private _loginInfo: ILoginInfo
-  // private _signatures: Map<string /* envId */, ISignature> = new Map()
-  private _wsInitPromise?: Promise<void>
-  private _wsReadySubsribers: IResolveReject[] = []
-  private _wsResponseWait: Map<
-    string /* requestId */,
-    IResponseWaitSpec
+  private queryIdClientMap: Map<string, VirtualWebSocketClient> = new Map()
+  private watchIdClientMap: Map<string, VirtualWebSocketClient> = new Map()
+  private maxReconnect: number
+  private reconnectInterval: number
+  private context: IDatabaseServiceContext
+  private ws?: any
+  private lastPingSendTS?: number
+  private pingFailed = 0
+  private pongMissed = 0
+  private pingTimeoutId?: number
+  private pongTimeoutId?: number
+  private logins: Map<string /* envId */, ILoginInfo> = new Map()
+  private wsInitPromise?: Promise<void>
+  private wsReadySubsribers: IResolveReject[] = []
+  private wsResponseWait: Map<
+  string /* requestId */,
+  IResponseWaitSpec
   > = new Map()
-  private _rttObserved: number[] = []
-  private _reconnectState: boolean
+  private rttObserved: number[] = []
+  private reconnectState: boolean
   // obtained from the first getSignature with no envId provided
-  // private _defaultEnvId?: string
-  private _wsSign: IWsSign
+  private wsSign: IWsSign
 
   constructor(options: IRealtimeWebSocketClientConstructorOptions) {
-    this._maxReconnect = options.maxReconnect || DEFAULT_MAX_RECONNECT
-    // this._availableRetries = this._maxReconnect
-    this._reconnectInterval =
-      options.reconnectInterval || DEFAULT_WS_RECONNECT_INTERVAL
-    this._context = options.context
+    this.maxReconnect = options.maxReconnect || DEFAULT_MAX_RECONNECT
+    this.reconnectInterval = options.reconnectInterval || DEFAULT_WS_RECONNECT_INTERVAL
+    this.context = options.context
   }
 
   clearHeartbeat() {
-    this._pingTimeoutId && clearTimeout(this._pingTimeoutId)
-    this._pongTimeoutId && clearTimeout(this._pongTimeoutId)
+    this.pingTimeoutId && clearTimeout(this.pingTimeoutId)
+    this.pongTimeoutId && clearTimeout(this.pongTimeoutId)
   }
 
-  send = async <T = any>(opts: IWSSendOptions): Promise<T> =>
-    new Promise<T>(async (_resolve, _reject) => {
+  send = async <T = any>(opts: IWSSendOptions): Promise<T> => new Promise<T>((_resolve, _reject) => {
+    void (async () => {
       let timeoutId: number
-      let _hasResolved = false
-      let _hasRejected = false
+      let hasResolved = false
+      let hasRejected = false
 
-      const resolve: typeof _resolve = (
-        value?: T | PromiseLike<T> | undefined
-      ) => {
-        _hasResolved = true
+      const resolve: typeof _resolve = (value?: T | PromiseLike<T> | undefined) => {
+        hasResolved = true
         timeoutId && clearTimeout(timeoutId)
         _resolve(value)
       }
 
       const reject: typeof _reject = (error: any) => {
-        _hasRejected = true
+        hasRejected = true
         timeoutId && clearTimeout(timeoutId)
         _reject(error)
       }
 
       if (opts.timeout) {
         // @ts-ignore
-        timeoutId = setTimeout(async () => {
-          if (!_hasResolved || !_hasRejected) {
-            // wait another immediate timeout to allow the success/fail callback to be invoked if ws has already got the result,
-            // this is because the timer is registered before ws.send
-            await sleep(0)
-            if (!_hasResolved || !_hasRejected) {
-              reject(new TimeoutError('wsclient.send timedout'))
+        timeoutId = setTimeout(() => {
+          (async () => {
+            if (!hasResolved || !hasRejected) {
+              // wait another immediate timeout to allow the success/fail callback to be invoked if ws has already got the result,
+              // this is because the timer is registered before ws.send
+              await sleep(0)
+              if (!hasResolved || !hasRejected) {
+                reject(new TimeoutError('wsclient.send timedout'))
+              }
             }
-          }
+          })()
         }, opts.timeout)
       }
 
       try {
-        // if (this._context.debug) {
-        // console.log(`[realtime] ws send (${new Date()}): `, opts)
-        // console.log(
-        //   `[realtime] ws send ${
-        //     opts.msg.msgType
-        //   } (${new Date().toLocaleString()}): `,
-        //   opts
-        // )
-        // }
-
-        if (this._wsInitPromise) {
-          await this._wsInitPromise
+        if (this.wsInitPromise !== undefined || this.wsInitPromise !== null) {
+          await this.wsInitPromise
         }
 
-        if (!this._ws) {
-          reject(
-            new Error(
-              'invalid state: ws connection not exists, can not send message'
-            )
-          )
+        if (!this.ws) {
+          reject(new Error('invalid state: ws connection not exists, can not send message'))
           return
         }
 
-        if (this._ws.readyState !== WS_READY_STATE.OPEN) {
-          reject(
-            new Error(
-              `ws readyState invalid: ${this._ws.readyState}, can not send message`
-            )
-          )
+        if (this.ws.readyState !== WS_READY_STATE.OPEN) {
+          reject(new Error(`ws readyState invalid: ${this.ws.readyState}, can not send message`))
           return
         }
 
         if (opts.waitResponse) {
-          this._wsResponseWait.set(opts.msg.requestId, {
+          const respWaitSpec: IResponseWaitSpec = {
             resolve,
             reject,
-            skipOnMessage: opts.skipOnMessage
-          } as IResponseWaitSpec)
+            skipOnMessage: opts.skipOnMessage,
+          }
+          this.wsResponseWait.set(opts.msg.requestId, respWaitSpec)
         }
 
         // console.log('send msg:', opts.msg)
         try {
-          await this._ws.send(JSON.stringify(opts.msg))
+          await this.ws.send(JSON.stringify(opts.msg))
           if (!opts.waitResponse) {
-            resolve()
+            resolve(void 0)
           }
         } catch (err) {
           if (err) {
             reject(err)
             if (opts.waitResponse) {
-              this._wsResponseWait.delete(opts.msg.requestId)
+              this.wsResponseWait.delete(opts.msg.requestId)
             }
           }
         }
-        // this._ws.send(JSON.stringify(opts.msg), err => {
-        //   if (err) {
-        //     reject(err)
-        //     if (opts.waitResponse) {
-        //       this._wsResponseWait.delete(opts.msg.requestId)
-        //     }
-        //     return
-        //   }
-
-        //   if (!opts.waitResponse) {
-        //     resolve()
-        //   }
-        // })
-
-        // this._ws.send({
-        //   data: JSON.stringify(opts.msg),
-        //   success: res => {
-        //     if (!opts.waitResponse) {
-        //       resolve(res)
-        //     }
-        //   },
-        //   fail: e => {
-        //     reject(e)
-        //     if (opts.waitResponse) {
-        //       this._wsResponseWait.delete(opts.msg.requestId)
-        //     }
-        //   }
-        // })
       } catch (e) {
         reject(e)
       }
-    })
+    })()
+  })
 
-  close(code: CLOSE_EVENT_CODE) {
+  close(code: CloseEventCode) {
     this.clearHeartbeat()
 
-    if (this._ws) {
-      this._ws.close(code, CLOSE_EVENT_CODE_INFO[code].name)
-      this._ws = undefined
+    if (this.ws) {
+      this.ws.close(code, CLOSE_EVENT_CODE_INFO[code].name)
+      this.ws = undefined
     }
   }
 
   closeAllClients = (error: any) => {
-    this._virtualWSClient.forEach(client => {
+    this.virtualWSClient.forEach((client) => {
       client.closeWithError(error)
     })
   }
 
   pauseClients = (clients?: Set<VirtualWebSocketClient>) => {
-    ;(clients || this._virtualWSClient).forEach(client => {
+    (clients || this.virtualWSClient).forEach((client) => {
       client.pause()
     })
   }
 
   resumeClients = (clients?: Set<VirtualWebSocketClient>) => {
-    ;(clients || this._virtualWSClient).forEach(client => {
+    (clients || this.virtualWSClient).forEach((client) => {
       client.resume()
     })
   }
 
   watch(options: IWSWatchOptions): DBRealtimeListener {
-    if (!this._ws && !this._wsInitPromise) {
+    if (!this.ws && (this.wsInitPromise === undefined || this.wsInitPromise === null)) {
       this.initWebSocketConnection(false)
     }
 
@@ -305,434 +254,298 @@ export class RealtimeWebSocketClient {
       getWaitExpectedTimeoutLength: this.getWaitExpectedTimeoutLength,
       onWatchStart: this.onWatchStart,
       onWatchClose: this.onWatchClose,
-      debug: true
+      debug: true,
     })
-    this._virtualWSClient.add(virtualClient)
-    this._watchIdClientMap.set(virtualClient.watchId, virtualClient)
+    this.virtualWSClient.add(virtualClient)
+    this.watchIdClientMap.set(virtualClient.watchId, virtualClient)
     return virtualClient.listener
   }
 
   private initWebSocketConnection = async (
     reconnect: boolean,
-    availableRetries: number = this._maxReconnect
+    availableRetries: number = this.maxReconnect
   ): Promise<void> => {
     // 当前处于正在重连中的状态
-    if (reconnect && this._reconnectState) {
+    if (reconnect && this.reconnectState) {
       return // 忽略
     }
 
     if (reconnect) {
-      this._reconnectState = true // 重连状态开始
+      this.reconnectState = true // 重连状态开始
     }
 
-    if (this._wsInitPromise) {
+    if (this.wsInitPromise !== undefined && this.wsInitPromise !== null) {
       // there already exists a websocket initiation, just wait for it
-      return this._wsInitPromise
+      return this.wsInitPromise
     }
 
-    // if (process.env.DEBUG) {
-    // console.log(
-    //   `[realtime] initWebSocketConnection reconnect ${reconnect} availableRetries ${availableRetries}`
-    // )
-    // }
-
     if (reconnect) {
       this.pauseClients()
     }
 
-    this.close(CLOSE_EVENT_CODE.ReconnectWebSocket)
+    this.close(CloseEventCode.ReconnectWebSocket)
 
-    this._wsInitPromise = new Promise<void>(async (resolve, reject) => {
-      try {
-        // if (process.env.DEBUG) {
-        // console.log(
-        //   '[realtime] initWebSocketConnection start throwErrorIfNetworkOffline'
-        // )
-        // }
-
-        // 暂不检查网络态
-        // await throwErrorIfNetworkOffline()
-
-        // if (process.env.DEBUG) {
-        // console.log('[realtime] initWebSocketConnection start getSignature')
-        // }
-
-        // const signature = await this.getSignature()
-        const wsSign = await this.getWsSign()
-
-        // if (process.env.DEBUG) {
-        // console.log('[realtime] initWebSocketConnection getSignature success')
-        // console.log('[realtime] initWebSocketConnection start connectSocket')
-        // }
-
-        await new Promise(success => {
-          // this._ws = getSDK(this._context.identifiers)
-          //   ._socketSkipCheckDomainFactory()
-          //   .connectSocket({
-          //     url: signature.wsUrl,
-          //     header: {
-          //       "content-type": "application/json"
-          //     },
-          //     success: () => success(),
-          //     fail
-          //   })
-
-          const url = wsSign.wsUrl || 'wss://tcb-ws.tencentcloudapi.com';
-          const wsClass = getWsClass();
-          this._ws = wsClass ? new wsClass(url) : new WebSocket(url)
-          success()
-        })
+    this.wsInitPromise = new Promise<void>((resolve, reject) => {
+      (async () => {
+        try {
+          const wsSign = await this.getWsSign()
+
+          await new Promise((success) => {
+            const url = wsSign.wsUrl || 'wss://tcb-ws.tencentcloudapi.com'
+            const wsClass = getWsClass()
+            /* eslint-disable-next-line */
+            this.ws = wsClass ? new wsClass(url) : new WebSocket(url)
+            success(void 0)
+          })
 
-        if(this._ws.connect){
-          await this._ws.connect()
-        }
+          if (this.ws.connect) {
+            await this.ws.connect()
+          }
+
+          await this.initWebSocketEvent()
+          resolve()
+
+          if (reconnect) {
+            this.resumeClients()
+            this.reconnectState = false // 重连状态结束
+          }
+        } catch (e) {
+          console.error('[realtime] initWebSocketConnection connect fail', e)
 
-        // if (process.env.DEBUG) {
-        // console.log(
-        //   '[realtime] initWebSocketConnection connectSocket successfully fired'
-        // )
-        // }
+          if (availableRetries > 0) {
+            // this is an optimization, in case of network offline, we don't need to stubbornly sleep for sometime,
+            // we only need to wait for the network to be back online, this ensures minimum downtime
+            // const { isConnected } = await getNetworkStatus()
+            const isConnected = true
 
-        await this.initWebSocketEvent()
-        resolve()
+            this.wsInitPromise = undefined
 
-        if (reconnect) {
-          this.resumeClients()
-          this._reconnectState = false // 重连状态结束
-        }
-      } catch (e) {
-        // if (process.env.DEBUG) {
-        console.error('[realtime] initWebSocketConnection connect fail', e)
-        // }
-
-        if (availableRetries > 0) {
-          // this is an optimization, in case of network offline, we don't need to stubbornly sleep for sometime,
-          // we only need to wait for the network to be back online, this ensures minimum downtime
-          // const { isConnected } = await getNetworkStatus()
-          const isConnected = true
-
-          // if (process.env.DEBUG) {
-          // console.log(
-          //   '[realtime] initWebSocketConnection waiting for network online'
-          // )
-          // }
-
-          // auto wait until network online, cause' it would be meaningless to reconnect while network is offline
-
-          // await onceNetworkOnline()
-
-          // COMPATIBILITY: wait for ide state update
-          // if (isDevTools()) {
-          //   await sleep(0)
-          // }
-
-          // if (process.env.DEBUG) {
-          // console.log('[realtime] initWebSocketConnection network online')
-          // }
-
-          this._wsInitPromise = undefined
-
-          if (isConnected) {
-            // if (process.env.DEBUG) {
-            // console.log(
-            //   `[realtime] initWebSocketConnection sleep ${this._reconnectInterval}ms`
-            // )
-            // }
-            await sleep(this._reconnectInterval)
-            if (reconnect) {
-              this._reconnectState = false // 重连异常也算重连状态结束
+            if (isConnected) {
+              await sleep(this.reconnectInterval)
+              if (reconnect) {
+                this.reconnectState = false // 重连异常也算重连状态结束
+              }
             }
-          }
 
-          resolve(this.initWebSocketConnection(reconnect, availableRetries - 1))
-        } else {
-          reject(e)
+            resolve(this.initWebSocketConnection(reconnect, availableRetries - 1))
+          } else {
+            reject(e)
 
-          if (reconnect) {
-            this.closeAllClients(
-              new CloudSDKError({
+            if (reconnect) {
+              this.closeAllClients(new CloudSDKError({
                 errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_RECONNECT_WATCH_FAIL as string,
-                errMsg: e
-              })
-            )
+                errMsg: e,
+              }))
+            }
           }
         }
-      }
+      })()
     })
 
-    // let success = false
-
     try {
-      await this._wsInitPromise
-      // success = true
-      this._wsReadySubsribers.forEach(({ resolve }) => resolve())
+      await this.wsInitPromise
+      this.wsReadySubsribers.forEach(({ resolve }) => resolve())
     } catch (e) {
-      this._wsReadySubsribers.forEach(({ reject }) => reject())
+      this.wsReadySubsribers.forEach(({ reject }) => reject())
     } finally {
-      this._wsInitPromise = undefined
-      this._wsReadySubsribers = []
+      this.wsInitPromise = undefined
+      this.wsReadySubsribers = []
     }
-
-    // if (process.env.DEBUG) {
-    // console.log(
-    //   `[realtime] initWebSocketConnection ${success ? 'success' : 'fail'}`
-    // )
-    // }
   }
 
-  private initWebSocketEvent = () =>
-    new Promise<void>((resolve, reject) => {
-      if (!this._ws) {
-        throw new Error('can not initWebSocketEvent, ws not exists')
-      }
+  private initWebSocketEvent = () => new Promise<void>((resolve, reject) => {
+    if (!this.ws) {
+      throw new Error('can not initWebSocketEvent, ws not exists')
+    }
 
-      let wsOpened = false
+    let wsOpened = false
 
-      this._ws.onopen = event => {
-        // this._ws.onOpen(() => {
-        // this._ws.on("open", () => {
-        // this._context.debug &&
-        console.warn('[realtime] ws event: open', event)
-        wsOpened = true
-        resolve()
-      }
-
-      this._ws.onerror = event => {
-        // this._ws.on("error", error => {
-        // this._ws.onError(error => {
-        // all logins are invalid after disconnection
-        this._logins = new Map()
-
-        // error写进file
-
-        if (!wsOpened) {
-          // this._context.debug &&
-          console.error('[realtime] ws open failed with ws event: error', event)
-          // writeToFile(
-          //   "wserror.txt",
-          //   `${
-          //     this.specialNumber
-          //   } [realtime] ws open failed with ws event: error ${error} \n`
-          // )
-
-          reject(event)
-        } else {
-          // this._context.debug &&
-          console.error('[realtime] ws event: error', event)
-
-          // writeToFile(
-          //   "wserror.txt",
-          //   `${this.specialNumber} [realtime] ws event: error ${error} \n`
-          // )
-
-          this.clearHeartbeat()
-          this._virtualWSClient.forEach(client =>
-            client.closeWithError(
-              new CloudSDKError({
-                errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_WEBSOCKET_CONNECTION_ERROR as string,
-                errMsg: event
-              })
-            )
-          )
-        }
-      }
+    this.ws.onopen = (event) => {
+      console.warn('[realtime] ws event: open', event)
+      wsOpened = true
+      resolve()
+    }
 
-      // TODO: reconnect
-      this._ws.onclose = closeEvent => {
-        // this._ws.on("close", (closeEvent, closereason) => {
-        // this._ws.onClose(closeEvent => {
-        // if (process.env.DEBUG) {
-        console.warn('[realtime] ws event: close', closeEvent)
-        // }
+    this.ws.onerror = (event) => {
+      // all logins are invalid after disconnection
+      this.logins = new Map()
 
-        // writeToFile(
-        //   "wsclose.txt",
-        //   `${
-        //     this.specialNumber
-        //   } [realtime] ws event: close ${closeEvent} ${closereason} \n`
-        // )
+      // error写进file
 
-        // all logins are invalid after disconnection
-        this._logins = new Map()
+      if (!wsOpened) {
+        console.error('[realtime] ws open failed with ws event: error', event)
+        reject(event)
+      } else {
+        console.error('[realtime] ws event: error', event)
 
         this.clearHeartbeat()
-        switch (closeEvent.code) {
-          case CLOSE_EVENT_CODE.ReconnectWebSocket: {
-            // just ignore
-            break
-          }
-          case CLOSE_EVENT_CODE.NoRealtimeListeners: {
-            // quit
-            break
-          }
-          case CLOSE_EVENT_CODE.HeartbeatPingError:
-          case CLOSE_EVENT_CODE.HeartbeatPongTimeoutError:
-          case CLOSE_EVENT_CODE.NormalClosure:
-          case CLOSE_EVENT_CODE.AbnormalClosure: {
-            // Normal Closure and Abnormal Closure:
-            //   expected closure, most likely dispatched by wechat client,
-            //   since this is the status code dispatched in case of network failure,
-            //   we should retry
-
-            if (this._maxReconnect > 0) {
-              // if (this._availableRetries > 0) {
-              this.initWebSocketConnection(true, this._maxReconnect)
-            } else {
-              this.closeAllClients(getWSCloseError(closeEvent.code))
-            }
-            break
-          }
-          case CLOSE_EVENT_CODE.NoAuthentication: {
-            this.closeAllClients(
-              getWSCloseError(closeEvent.code, closeEvent.reason)
-            )
-            break
+        this.virtualWSClient.forEach(client => client.closeWithError(new CloudSDKError({
+          errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_WEBSOCKET_CONNECTION_ERROR as string,
+          errMsg: event,
+        })))
+      }
+    }
+
+    // TODO: reconnect
+    this.ws.onclose = (closeEvent) => {
+      console.warn('[realtime] ws event: close', closeEvent)
+      // all logins are invalid after disconnection
+      this.logins = new Map()
+
+      this.clearHeartbeat()
+      switch (closeEvent.code) {
+        case CloseEventCode.ReconnectWebSocket: {
+          // just ignore
+          break
+        }
+        case CloseEventCode.NoRealtimeListeners: {
+          // quit
+          break
+        }
+        case CloseEventCode.HeartbeatPingError:
+        case CloseEventCode.HeartbeatPongTimeoutError:
+        case CloseEventCode.NormalClosure:
+        case CloseEventCode.AbnormalClosure: {
+          // Normal Closure and Abnormal Closure:
+          //   expected closure, most likely dispatched by wechat client,
+          //   since this is the status code dispatched in case of network failure,
+          //   we should retry
+
+          if (this.maxReconnect > 0) {
+            this.initWebSocketConnection(true, this.maxReconnect)
+          } else {
+            this.closeAllClients(getWSCloseError(closeEvent.code))
           }
-          default: {
-            // we should retry by default
-            if (this._maxReconnect > 0) {
-              // if (this._availableRetries > 0) {
-              this.initWebSocketConnection(true, this._maxReconnect)
-            } else {
-              this.closeAllClients(getWSCloseError(closeEvent.code))
-            }
-            // console.warn(`[realtime] unrecognize ws close event`, closeEvent)
-            // this.closeAllClients(getWSCloseError(closeEvent.code))
+          break
+        }
+        case CloseEventCode.NoAuthentication: {
+          this.closeAllClients(getWSCloseError(closeEvent.code, closeEvent.reason))
+          break
+        }
+        default: {
+          // we should retry by default
+          if (this.maxReconnect > 0) {
+            this.initWebSocketConnection(true, this.maxReconnect)
+          } else {
+            this.closeAllClients(getWSCloseError(closeEvent.code))
           }
         }
       }
+    }
 
-      this._ws.onmessage = res => {
-        // this._ws.on("message", res => {
-        // this._ws.onMessage(res => {
-        // const rawMsg = res.data
-        const rawMsg = res.data
-
-        // reset & restart heartbeat
-        this.heartbeat()
+    this.ws.onmessage = (res) => {
+      const rawMsg = res.data
 
-        let msg: IResponseMessage
+      // reset & restart heartbeat
+      this.heartbeat()
 
-        try {
-          msg = JSON.parse(rawMsg as string)
-        } catch (e) {
-          throw new Error(`[realtime] onMessage parse res.data error: ${e}`)
-        }
+      let msg: IResponseMessage
 
-        // console.log(
-        //   `[realtime] onMessage ${
-        //     msg.msgType
-        //   } (${new Date().toLocaleString()})`,
-        //   msg
-        // )
-
-        if (msg.msgType === 'ERROR') {
-          // 找到当前监听，并将error返回
-          let virtualWatch = null
-          this._virtualWSClient.forEach(item => {
-            if (item.watchId === msg.watchId) {
-              virtualWatch = item
-            }
-          })
+      try {
+        msg = JSON.parse(rawMsg as string)
+      } catch (e) {
+        throw new Error(`[realtime] onMessage parse res.data error: ${e}`)
+      }
 
-          if (virtualWatch) {
-            virtualWatch.listener.onError(msg)
+      if (msg.msgType === 'ERROR') {
+        // 找到当前监听，并将error返回
+        let virtualWatch = null
+        this.virtualWSClient.forEach((item) => {
+          if (item.watchId === msg.watchId) {
+            virtualWatch = item
           }
+        })
+
+        if (virtualWatch) {
+          virtualWatch.listener.onError(msg)
         }
+      }
 
-        const responseWaitSpec = this._wsResponseWait.get(msg.requestId)
-        if (responseWaitSpec) {
-          try {
-            if (msg.msgType === 'ERROR') {
-              responseWaitSpec.reject(new RealtimeErrorMessageError(msg))
-            } else {
-              responseWaitSpec.resolve(msg)
-            }
-          } catch (e) {
-            // this._context.debug &&
-            console.error(
-              'ws onMessage responseWaitSpec.resolve(msg) errored:',
-              e
-            )
-          } finally {
-            this._wsResponseWait.delete(msg.requestId)
+      const responseWaitSpec = this.wsResponseWait.get(msg.requestId)
+      if (responseWaitSpec) {
+        try {
+          if (msg.msgType === 'ERROR') {
+            responseWaitSpec.reject(new RealtimeErrorMessageError(msg))
+          } else {
+            responseWaitSpec.resolve(msg)
           }
-          if (responseWaitSpec.skipOnMessage) {
+        } catch (e) {
+          console.error(
+            'ws onMessage responseWaitSpec.resolve(msg) errored:',
+            e
+          )
+        } finally {
+          this.wsResponseWait.delete(msg.requestId)
+        }
+        if (responseWaitSpec.skipOnMessage) {
+          return
+        }
+      }
+
+      if (msg.msgType === 'PONG') {
+        if (this.lastPingSendTS) {
+          const rtt = Date.now() - this.lastPingSendTS
+          if (rtt > DEFAULT_UNTRUSTED_RTT_THRESHOLD) {
+            console.warn(`[realtime] untrusted rtt observed: ${rtt}`)
             return
           }
+          if (this.rttObserved.length >= MAX_RTT_OBSERVED) {
+            this.rttObserved.splice(
+              0,
+              this.rttObserved.length - MAX_RTT_OBSERVED + 1
+            )
+          }
+          this.rttObserved.push(rtt)
         }
+        return
+      }
 
-        if (msg.msgType === 'PONG') {
-          if (this._lastPingSendTS) {
-            const rtt = Date.now() - this._lastPingSendTS
-            if (rtt > DEFAULT_UNTRUSTED_RTT_THRESHOLD) {
-              // this._context.debug &&
-              console.warn(`[realtime] untrusted rtt observed: ${rtt}`)
-              return
-            }
-            if (this._rttObserved.length >= MAX_RTT_OBSERVED) {
-              this._rttObserved.splice(
-                0,
-                this._rttObserved.length - MAX_RTT_OBSERVED + 1
-              )
+      let client = msg.watchId && this.watchIdClientMap.get(msg.watchId)
+      if (client) {
+        client.onMessage(msg)
+      } else {
+        console.error(
+          `[realtime] no realtime listener found responsible for watchId ${msg.watchId}: `,
+          msg
+        )
+        switch (msg.msgType) {
+          case 'INIT_EVENT':
+          case 'NEXT_EVENT':
+          case 'CHECK_EVENT': {
+            client = this.queryIdClientMap.get(msg.msgData.queryID)
+            if (client) {
+              client.onMessage(msg)
             }
-            this._rttObserved.push(rtt)
+            break
           }
-          return
-        }
-
-        let client = msg.watchId && this._watchIdClientMap.get(msg.watchId)
-        if (client) {
-          client.onMessage(msg)
-        } else {
-          // TODO, this is a temporary fix done for server
-          // if (process.env.DEBUG) {
-          console.error(
-            `[realtime] no realtime listener found responsible for watchId ${msg.watchId}: `,
-            msg
-          )
-          // }
-          switch (msg.msgType) {
-            case 'INIT_EVENT':
-            case 'NEXT_EVENT':
-            case 'CHECK_EVENT': {
-              client = this._queryIdClientMap.get(msg.msgData.queryID)
-              if (client) {
-                client.onMessage(msg)
-              }
+          default: {
+            for (const [, client] of Array.from(this.watchIdClientMap.entries())) {
+              client.onMessage(msg)
               break
             }
-            default: {
-              for (const [,client] of Array.from(this._watchIdClientMap.entries())) {
-                // console.log('watchid*****', watchId)
-                client.onMessage(msg)
-                break
-              }
-            }
           }
         }
       }
+    }
 
-      this.heartbeat()
-    })
+    this.heartbeat()
+  })
 
-  private isWSConnected = (): boolean => {
-    return Boolean(this._ws && this._ws.readyState === WS_READY_STATE.OPEN)
-  }
+  private isWSConnected = (): boolean => Boolean(this.ws && this.ws.readyState === WS_READY_STATE.OPEN)
 
   private onceWSConnected = async (): Promise<void> => {
     if (this.isWSConnected()) {
       return
     }
 
-    if (this._wsInitPromise) {
-      return this._wsInitPromise
+    if (this.wsInitPromise !== null && this.wsInitPromise !== undefined) {
+      return this.wsInitPromise
     }
 
     return new Promise<void>((resolve, reject) => {
-      this._wsReadySubsribers.push({
+      this.wsReadySubsribers.push({
         resolve,
-        reject
+        reject,
       })
     })
   }
@@ -742,82 +555,69 @@ export class RealtimeWebSocketClient {
     refresh?: boolean
   ): Promise<any> => {
     if (!refresh) {
-      // let loginInfo = this._loginInfo
       if (envId) {
-        const loginInfo = this._logins.get(envId)
+        const loginInfo = this.logins.get(envId)
         if (loginInfo) {
           if (loginInfo.loggedIn && loginInfo.loginResult) {
-            // if (process.env.DEBUG) {
-            // console.log('[realtime] login: already logged in')
-            // }
             return loginInfo.loginResult
-          } else if (loginInfo.loggingInPromise) {
+          } if (loginInfo.loggingInPromise !== null && loginInfo.loggingInPromise !== undefined) {
             return loginInfo.loggingInPromise
           }
         }
       } else {
-        const emptyEnvLoginInfo = this._logins.get('')
-        if (emptyEnvLoginInfo?.loggingInPromise) {
+        const emptyEnvLoginInfo = this.logins.get('')
+        if (emptyEnvLoginInfo?.loggingInPromise !== null && emptyEnvLoginInfo?.loggingInPromise !== undefined) {
           return emptyEnvLoginInfo.loggingInPromise
         }
       }
     }
-    // console.log('[realtime] login: logging in')
 
-    const promise = new Promise<ILoginResult>(async (resolve, reject) => {
-      try {
-        // const signature = await this.getSignature(envId, refresh)
-
-        const wsSign = await this.getWsSign()
-
-        // const wxVersion = getWXVersion()
-        const msgData: IRequestMessageLoginData = {
-          envId: wsSign.envId || '',
-          accessToken: '', // 已废弃字段
-          // signStr: signature.signStr,
-          // secretVersion: signature.secretVersion,
-          referrer: 'web',
-          sdkVersion: '',
-          dataVersion: ''
-        }
-        const loginMsg: IRequestMessageLoginMsg = {
-          watchId: undefined,
-          requestId: genRequestId(),
-          msgType: 'LOGIN',
-          msgData,
-          exMsgData: {
-            runtime: getRuntime(),
-            signStr: wsSign.signStr,
-            secretVersion: wsSign.secretVersion
+    const promise = new Promise<ILoginResult>((resolve, reject) => {
+      (async () => {
+        try {
+          const wsSign = await this.getWsSign()
+
+          const msgData: IRequestMessageLoginData = {
+            envId: wsSign.envId || '',
+            accessToken: '', // 已废弃字段
+            referrer: 'web',
+            sdkVersion: '',
+            dataVersion: '',
           }
-        }
-        const loginResMsg = await this.send<IResponseMessageLoginResMsg>({
-          msg: loginMsg,
-          waitResponse: true,
-          skipOnMessage: true,
-          timeout: DEFAULT_LOGIN_TIMEOUT
-        })
-
-        if (!loginResMsg.msgData.code) {
-          // login success
-          resolve({
-            envId: wsSign.envId
+          const loginMsg: IRequestMessageLoginMsg = {
+            watchId: undefined,
+            requestId: genRequestId(),
+            msgType: 'LOGIN',
+            msgData,
+            exMsgData: {
+              runtime: getRuntime(),
+              signStr: wsSign.signStr,
+              secretVersion: wsSign.secretVersion,
+            },
+          }
+          const loginResMsg = await this.send<IResponseMessageLoginResMsg>({
+            msg: loginMsg,
+            waitResponse: true,
+            skipOnMessage: true,
+            timeout: DEFAULT_LOGIN_TIMEOUT,
           })
-        } else {
-          // login failed
-          reject(
-            new Error(
-              `${loginResMsg.msgData.code} ${loginResMsg.msgData.message}`
-            )
-          )
+
+          if (!loginResMsg.msgData.code) {
+            // login success
+            resolve({
+              envId: wsSign.envId,
+            })
+          } else {
+            // login failed
+            reject(new Error(`${loginResMsg.msgData.code} ${loginResMsg.msgData.message}`))
+          }
+        } catch (e) {
+          reject(e)
         }
-      } catch (e) {
-        reject(e)
-      }
+      })()
     })
 
-    // let loginInfo = this._loginInfo
-    let loginInfo = envId && this._logins.get(envId)
+    let loginInfo = envId && this.logins.get(envId)
 
     const loginStartTS = Date.now()
 
@@ -829,48 +629,31 @@ export class RealtimeWebSocketClient {
       loginInfo = {
         loggedIn: false,
         loggingInPromise: promise,
-        loginStartTS
+        loginStartTS,
       }
-      // this._loginInfo = loginInfo
-      this._logins.set(envId || '', loginInfo)
+      this.logins.set(envId || '', loginInfo)
     }
 
-    // try {
-    //   const loginResult = await promise
-    //   loginInfo.loggedIn = true
-    //   loginInfo.loggingInPromise = undefined
-    //   loginInfo.loginStartTS = undefined
-    //   loginInfo.loginResult = loginResult
-    //   return loginResult
-    // } catch (e) {
-    //   loginInfo.loggedIn = false
-    //   loginInfo.loggingInPromise = undefined
-    //   loginInfo.loginStartTS = undefined
-    //   loginInfo.loginResult = undefined
-    //   throw e
-    // }
-
     try {
       const loginResult = await promise
-      const curLoginInfo = envId && this._logins.get(envId)
+      const curLoginInfo = envId && this.logins.get(envId)
       if (
-        curLoginInfo &&
-        curLoginInfo === loginInfo &&
-        curLoginInfo.loginStartTS === loginStartTS
+        curLoginInfo
+        && curLoginInfo === loginInfo
+        && curLoginInfo.loginStartTS === loginStartTS
       ) {
         loginInfo.loggedIn = true
         loginInfo.loggingInPromise = undefined
         loginInfo.loginStartTS = undefined
         loginInfo.loginResult = loginResult
         return loginResult
-      } else if (curLoginInfo) {
+      } if (curLoginInfo) {
         if (curLoginInfo.loggedIn && curLoginInfo.loginResult) {
           return curLoginInfo.loginResult
-        } else if (curLoginInfo.loggingInPromise) {
+        } if (curLoginInfo.loggingInPromise !== null && curLoginInfo.loggingInPromise !== undefined) {
           return curLoginInfo.loggingInPromise
-        } else {
-          throw new Error('ws unexpected login info')
         }
+        throw new Error('ws unexpected login info')
       } else {
         throw new Error('ws login info reset')
       }
@@ -884,79 +667,82 @@ export class RealtimeWebSocketClient {
   }
 
   private getWsSign = async (): Promise<IWsSign> => {
-    if (this._wsSign && this._wsSign.expiredTs > Date.now()) {
-      return this._wsSign
+    if (this.wsSign && this.wsSign.expiredTs > Date.now()) {
+      return this.wsSign
     }
     const expiredTs = Date.now() + 60000
-    const res = await this._context.appConfig.request.send('auth.wsWebSign', {runtime: getRuntime()})
+    const res = await this.context.appConfig.request.send('auth.wsWebSign', { runtime: getRuntime() })
 
     if (res.code) {
       throw new Error(`[tcb-js-sdk] 获取实时数据推送登录票据失败: ${res.code}`)
     }
 
     if (res.data) {
-      const {signStr, wsUrl, secretVersion, envId} = res.data
+      const { signStr, wsUrl, secretVersion, envId } = res.data
       return {
         signStr,
         wsUrl,
         secretVersion,
         envId,
-        expiredTs
+        expiredTs,
       }
-    } else {
-      throw new Error('[tcb-js-sdk] 获取实时数据推送登录票据失败')
     }
+    throw new Error('[tcb-js-sdk] 获取实时数据推送登录票据失败')
   }
 
   private getWaitExpectedTimeoutLength = () => {
-    if (!this._rttObserved.length) {
+    if (!this.rttObserved.length) {
       return DEFAULT_EXPECTED_EVENT_WAIT_TIME
     }
 
     // 1.5 * RTT
     return (
-      (this._rttObserved.reduce((acc, cur) => acc + cur) /
-        this._rttObserved.length) *
-      1.5
+      (this.rttObserved.reduce((acc, cur) => acc + cur)
+        / this.rttObserved.length)
+      * 1.5
     )
   }
 
   private heartbeat(immediate?: boolean) {
     this.clearHeartbeat()
     // @ts-ignore
-    this._pingTimeoutId = setTimeout(
-      async () => {
-        try {
-          if (!this._ws || this._ws.readyState !== WS_READY_STATE.OPEN) {
-            // no need to ping
-            return
-          }
+    this.pingTimeoutId = setTimeout(
+      () => {
+        (
+          async () => {
+            try {
+              if (!this.ws || this.ws.readyState !== WS_READY_STATE.OPEN) {
+                // no need to ping
+                return
+              }
 
-          this._lastPingSendTS = Date.now()
-          await this.ping()
-          this._pingFailed = 0
-
-          // @ts-ignore
-          this._pongTimeoutId = setTimeout(() => {
-            console.error('pong timed out')
-            if (this._pongMissed < DEFAULT_PONG_MISS_TOLERANCE) {
-              this._pongMissed++
-              this.heartbeat(true)
-            } else {
-              // logical perceived connection lost, even though websocket did not receive error or close event
-              this.initWebSocketConnection(true)
+              this.lastPingSendTS = Date.now()
+              await this.ping()
+              this.pingFailed = 0
+
+              // @ts-ignore
+              this.pongTimeoutId = setTimeout(() => {
+                console.error('pong timed out')
+                if (this.pongMissed < DEFAULT_PONG_MISS_TOLERANCE) {
+                  this.pongMissed += 1
+                  this.heartbeat(true)
+                } else {
+                  // logical perceived connection lost, even though websocket did not receive error or close event
+                  this.initWebSocketConnection(true)
+                }
+              }, this.context.appConfig.realtimePongWaitTimeout)
+            } catch (e) {
+              if (this.pingFailed < DEFAULT_PING_FAIL_TOLERANCE) {
+                this.pingFailed += 1
+                this.heartbeat()
+              } else {
+                this.close(CloseEventCode.HeartbeatPingError)
+              }
             }
-          }, this._context.appConfig.realtimePongWaitTimeout)
-        } catch (e) {
-          if (this._pingFailed < DEFAULT_PING_FAIL_TOLERANCE) {
-            this._pingFailed++
-            this.heartbeat()
-          } else {
-            this.close(CLOSE_EVENT_CODE.HeartbeatPingError)
           }
-        }
+        )()
       },
-      immediate ? 0 : this._context.appConfig.realtimePingInterval
+      immediate ? 0 : this.context.appConfig.realtimePingInterval
     )
   }
 
@@ -965,28 +751,27 @@ export class RealtimeWebSocketClient {
       watchId: undefined,
       requestId: genRequestId(),
       msgType: 'PING',
-      msgData: null
+      msgData: null,
     }
     await this.send({
-      msg
+      msg,
     })
-    // console.log('ping sent')
   }
 
   private onWatchStart = (client: VirtualWebSocketClient, queryID: string) => {
-    this._queryIdClientMap.set(queryID, client)
+    this.queryIdClientMap.set(queryID, client)
   }
 
   private onWatchClose = (client: VirtualWebSocketClient, queryID: string) => {
     if (queryID) {
-      this._queryIdClientMap.delete(queryID)
+      this.queryIdClientMap.delete(queryID)
     }
-    this._watchIdClientMap.delete(client.watchId)
-    this._virtualWSClient.delete(client)
+    this.watchIdClientMap.delete(client.watchId)
+    this.virtualWSClient.delete(client)
 
-    if (!this._virtualWSClient.size) {
+    if (!this.virtualWSClient.size) {
       // no more existing watch, we should release the websocket connection
-      this.close(CLOSE_EVENT_CODE.NoRealtimeListeners)
+      this.close(CloseEventCode.NoRealtimeListeners)
     }
   }
 }