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

package/src/virtual-websocket-client.ts

@@ -12,31 +12,29 @@ import {
   IRequestMsgType,
   IResponseMessageNextEventMsg,
   IRequestMessageCheckLastMsg,
-  IWatchOptions
+  IWatchOptions,
 } from '@cloudbase/types/realtime'
-import { 
-  ISingleDBEvent
+import {
+  ISingleDBEvent,
 } from '@cloudbase/types/database'
-// import Reporter from "./externals/public-lib/reporter"
 import { RealtimeListener } from './listener'
 import { Snapshot } from './snapshot'
 import { IWSSendOptions, ILoginResult } from './websocket-client'
-import { 
+import {
   ERR_CODE,
   CloudSDKError,
   isTimeoutError,
   CancelledError,
   isCancelledError,
-  isRealtimeErrorMessageError, 
-  RealtimeErrorMessageError, 
-  TimeoutError 
+  isRealtimeErrorMessageError,
+  RealtimeErrorMessageError,
+  TimeoutError,
 } from './error'
 import { sleep } from './utils'
 
 // =============== Realtime Virtual WebSocket Client (Internal) ====================
 
 interface IVirtualWebSocketClientConstructorOptions extends IWatchOptions {
-  // ws: RealtimeWebSocketClient
   envId?: string
   collectionName: string
   query: string
@@ -71,11 +69,9 @@ interface IHandleWatchEstablishmentErrorOptions {
   operationName: 'INIT_WATCH' | 'REBUILD_WATCH'
   resolve: (value?: PromiseLike<void> | undefined) => void
   reject: (e: any) => void
-  // retry: (refreshLogin?: boolean) => void
-  // abortWatch: (e: any) => void
 }
 
-enum WATCH_STATUS {
+enum WatchStatus {
   LOGGINGIN = 'LOGGINGIN',
   INITING = 'INITING',
   REBUILDING = 'REBUILDING',
@@ -119,17 +115,17 @@ export class VirtualWebSocketClient {
   ) => void
   private debug?: boolean
 
-  private watchStatus: WATCH_STATUS = WATCH_STATUS.INITING
-  private _availableRetries: Partial<Record<IRequestMsgType, number>>
-  private _ackTimeoutId?: number
-  private _initWatchPromise?: Promise<void>
-  private _rebuildWatchPromise?: Promise<void>
+  private watchStatus: WatchStatus = WatchStatus.INITING
+  private availableRetries: Partial<Record<IRequestMsgType, number>>
+  private ackTimeoutId?: number
+  private initWatchPromise?: Promise<void>
+  private rebuildWatchPromise?: Promise<void>
 
   // obtained
   private sessionInfo?: IWatchSessionInfo
 
   // internal
-  private _waitExpectedTimeoutId?: number
+  private waitExpectedTimeoutId?: number
 
   constructor(options: IVirtualWebSocketClientConstructorOptions) {
     this.watchId = `watchid_${+new Date()}_${Math.random()}`
@@ -147,18 +143,20 @@ export class VirtualWebSocketClient {
     this.onWatchClose = options.onWatchClose
     this.debug = options.debug
 
-    this._availableRetries = {
+    this.availableRetries = {
       INIT_WATCH: DEFAULT_MAX_AUTO_RETRY_ON_ERROR,
       REBUILD_WATCH: DEFAULT_MAX_AUTO_RETRY_ON_ERROR,
-      CHECK_LAST: DEFAULT_MAX_SEND_ACK_AUTO_RETRY_ON_ERROR
+      CHECK_LAST: DEFAULT_MAX_SEND_ACK_AUTO_RETRY_ON_ERROR,
     }
 
     this.listener = new RealtimeListener({
-      close: this.closeWatch,
+      close: void (() => {
+        this.closeWatch()
+      }),
       onChange: options.onChange,
       onError: options.onError,
       debug: this.debug,
-      virtualClient: this
+      virtualClient: this,
     })
 
     this.initWatch()
@@ -167,39 +165,31 @@ export class VirtualWebSocketClient {
   onMessage(msg: IResponseMessage) {
     // watchStatus sanity check
     switch (this.watchStatus) {
-      case WATCH_STATUS.PAUSED: {
+      case WatchStatus.PAUSED: {
         // ignore all but error message
         if (msg.msgType !== 'ERROR') {
           return
         }
         break
       }
-      case WATCH_STATUS.LOGGINGIN:
-      case WATCH_STATUS.INITING:
-      case WATCH_STATUS.REBUILDING: {
-        console.warn(
-          `[realtime listener] internal non-fatal error: unexpected message received while ${this.watchStatus}`
-        )
+      case WatchStatus.LOGGINGIN:
+      case WatchStatus.INITING:
+      case WatchStatus.REBUILDING: {
+        console.warn(`[realtime listener] internal non-fatal error: unexpected message received while ${this.watchStatus}`)
         return
       }
-      case WATCH_STATUS.CLOSED: {
-        console.warn(
-          '[realtime listener] internal non-fatal error: unexpected message received when the watch has closed'
-        )
+      case WatchStatus.CLOSED: {
+        console.warn('[realtime listener] internal non-fatal error: unexpected message received when the watch has closed')
         return
       }
-      case WATCH_STATUS.ERRORED: {
-        console.warn(
-          '[realtime listener] internal non-fatal error: unexpected message received when the watch has ended with error'
-        )
+      case WatchStatus.ERRORED: {
+        console.warn('[realtime listener] internal non-fatal error: unexpected message received when the watch has ended with error')
         return
       }
     }
 
     if (!this.sessionInfo) {
-      console.warn(
-        '[realtime listener] internal non-fatal error: sessionInfo not found while message is received.'
-      )
+      console.warn('[realtime listener] internal non-fatal error: sessionInfo not found while message is received.')
       return
     }
 
@@ -227,105 +217,75 @@ export class VirtualWebSocketClient {
           this.sessionInfo.expectEventId = msg.msgData.currEvent
           this.clearWaitExpectedEvent()
           // @ts-ignore
-          this._waitExpectedTimeoutId = setTimeout(() => {
+          this.waitExpectedTimeoutId = setTimeout(() => {
             // must rebuild watch
             this.rebuildWatch()
           }, this.getWaitExpectedTimeoutLength())
 
-          // if (process.env.DEBUG) {
-          console.log(
-            `[realtime] waitExpectedTimeoutLength ${this.getWaitExpectedTimeoutLength()}`
-          )
-          // }
+          console.log(`[realtime] waitExpectedTimeoutLength ${this.getWaitExpectedTimeoutLength()}`)
         }
         break
       }
       case 'ERROR': {
         // receive server error
-        this.closeWithError(
-          new CloudSDKError({
-            errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_SERVER_ERROR_MSG as string,
-            errMsg: `${msg.msgData.code} - ${msg.msgData.message}`
-          })
-        )
+        this.closeWithError(new CloudSDKError({
+          errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_SERVER_ERROR_MSG as string,
+          errMsg: `${msg.msgData.code} - ${msg.msgData.message}`,
+        }))
         break
       }
       default: {
-        // if (process.env.DEBUG) {
         console.warn(
           `[realtime listener] virtual client receive unexpected msg ${msg.msgType}: `,
           msg
         )
-        // }
         break
       }
     }
   }
 
   closeWithError(error: any) {
-    this.watchStatus = WATCH_STATUS.ERRORED
+    this.watchStatus = WatchStatus.ERRORED
     this.clearACKSchedule()
     this.listener.onError(error)
-    // Reporter.surroundThirdByTryCatch(() => this.listener.onError(error))
     this.onWatchClose(
       this,
-      (this.sessionInfo && this.sessionInfo.queryID) || ''
+      (this.sessionInfo?.queryID) || ''
     )
 
-    // if (process.env.DEBUG) {
-    console.log(
-      `[realtime] client closed (${this.collectionName} ${this.query}) (watchId ${this.watchId})`
-    )
-    // }
+    console.log(`[realtime] client closed (${this.collectionName} ${this.query}) (watchId ${this.watchId})`)
   }
 
   pause() {
-    this.watchStatus = WATCH_STATUS.PAUSED
-    // if (process.env.DEBUG) {
-    console.log(
-      `[realtime] client paused (${this.collectionName} ${this.query}) (watchId ${this.watchId})`
-    )
-    // }
+    this.watchStatus = WatchStatus.PAUSED
+    console.log(`[realtime] client paused (${this.collectionName} ${this.query}) (watchId ${this.watchId})`)
   }
 
-  // resume() {
-  //   return this.sessionInfo ? this.rebuildWatch() : this.initWatch()
-  // }
 
   async resume(): Promise<void> {
-    this.watchStatus = WATCH_STATUS.RESUMING
+    this.watchStatus = WatchStatus.RESUMING
 
-    // if (process.env.DEBUG) {
-    console.log(
-      `[realtime] client resuming with ${
-        this.sessionInfo ? 'REBUILD_WATCH' : 'INIT_WATCH'
-      } (${this.collectionName} ${this.query}) (${this.watchId})`
-    )
-    // }
+    console.log(`[realtime] client resuming with ${
+      this.sessionInfo ? 'REBUILD_WATCH' : 'INIT_WATCH'
+    } (${this.collectionName} ${this.query}) (${this.watchId})`)
 
     try {
       await (this.sessionInfo ? this.rebuildWatch() : this.initWatch())
 
-      // if (process.env.DEBUG) {
-      console.log(
-        `[realtime] client successfully resumed (${this.collectionName} ${this.query}) (${this.watchId})`
-      )
-      // }
+      console.log(`[realtime] client successfully resumed (${this.collectionName} ${this.query}) (${this.watchId})`)
     } catch (e) {
-      // if (process.env.DEBUG) {
       console.error(
         `[realtime] client resume failed (${this.collectionName} ${this.query}) (${this.watchId})`,
         e
       )
-      // }
     }
   }
 
-  private _login = async (
+  private wsLogin = async (
     envId?: string,
     refresh?: boolean
   ): Promise<ILoginResult> => {
-    this.watchStatus = WATCH_STATUS.LOGGINGIN
+    this.watchStatus = WatchStatus.LOGGINGIN
     const loginResult = await this.login(envId, refresh)
     if (!this.envId) {
       this.envId = loginResult.envId
@@ -334,32 +294,25 @@ export class VirtualWebSocketClient {
   }
 
   private initWatch = async (forceRefreshLogin?: boolean): Promise<void> => {
-    if (this._initWatchPromise) {
-      return this._initWatchPromise
+    if (this.initWatchPromise !== null && this.initWatchPromise !== undefined) {
+      return this.initWatchPromise
     }
 
-    this._initWatchPromise = new Promise<void>(
-      async (resolve, reject): Promise<void> => {
+    this.initWatchPromise = new Promise<void>((resolve, reject) => {
+      void (async () => {
         try {
-          if (this.watchStatus === WATCH_STATUS.PAUSED) {
-            // if (process.env.DEBUG) {
+          if (this.watchStatus === WatchStatus.PAUSED) {
             console.log('[realtime] initWatch cancelled on pause')
-            // }
             return resolve()
           }
 
-          const { envId } = await this._login(this.envId, forceRefreshLogin)
-
-          // if (!this.sessionInfo) {
-          //   throw new Error(`can not rebuildWatch without a successful initWatch (lack of sessionInfo)`)
-          // }
-
-          if ((this.watchStatus as WATCH_STATUS) === WATCH_STATUS.PAUSED) {
+          const { envId } = await this.wsLogin(this.envId, forceRefreshLogin)
+          if ((this.watchStatus as WatchStatus) === WatchStatus.PAUSED) {
             console.log('[realtime] initWatch cancelled on pause')
             return resolve()
           }
 
-          this.watchStatus = WATCH_STATUS.INITING
+          this.watchStatus = WatchStatus.INITING
 
           const initWatchMsg: IRequestMessageInitWatchMsg = {
             watchId: this.watchId,
@@ -370,15 +323,15 @@ export class VirtualWebSocketClient {
               collName: this.collectionName,
               query: this.query,
               limit: this.limit,
-              orderBy: this.orderBy
-            }
+              orderBy: this.orderBy,
+            },
           }
 
           const initEventMsg = await this.send<IResponseMessageInitEventMsg>({
             msg: initWatchMsg,
             waitResponse: true,
             skipOnMessage: true,
-            timeout: DEFAULT_INIT_WATCH_TIMEOUT
+            timeout: DEFAULT_INIT_WATCH_TIMEOUT,
           })
 
           const { events, currEvent } = initEventMsg.msgData
@@ -386,7 +339,7 @@ export class VirtualWebSocketClient {
           this.sessionInfo = {
             queryID: initEventMsg.msgData.queryID,
             currentEventId: currEvent - 1,
-            currentDocs: []
+            currentDocs: [],
           }
 
           // FIX: in initEvent message, all events have id 0, which is inconsistent with currEvent
@@ -401,67 +354,60 @@ export class VirtualWebSocketClient {
               id: currEvent,
               docChanges: [],
               docs: [],
-              type: 'init'
+              type: 'init',
             })
             this.listener.onChange(snapshot)
             this.scheduleSendACK()
           }
           this.onWatchStart(this, this.sessionInfo.queryID)
-          this.watchStatus = WATCH_STATUS.ACTIVE
-          this._availableRetries.INIT_WATCH = DEFAULT_MAX_AUTO_RETRY_ON_ERROR
+          this.watchStatus = WatchStatus.ACTIVE
+          this.availableRetries.INIT_WATCH = DEFAULT_MAX_AUTO_RETRY_ON_ERROR
           resolve()
         } catch (e) {
           this.handleWatchEstablishmentError(e, {
             operationName: 'INIT_WATCH',
             resolve,
-            reject
+            reject,
           })
         }
-      }
-    )
+      })()
+    })
 
     let success = false
 
     try {
-      await this._initWatchPromise
+      await this.initWatchPromise
       success = true
     } finally {
-      this._initWatchPromise = undefined
+      this.initWatchPromise = undefined
     }
-
-    // if (process.env.DEBUG) {
     console.log(`[realtime] initWatch ${success ? 'success' : 'fail'}`)
-    // }
   }
 
   private rebuildWatch = async (forceRefreshLogin?: boolean): Promise<void> => {
-    if (this._rebuildWatchPromise) {
-      return this._rebuildWatchPromise
+    if (this.rebuildWatchPromise !== null && this.rebuildWatchPromise !== undefined) {
+      return this.rebuildWatchPromise
     }
 
-    this._rebuildWatchPromise = new Promise<void>(
-      async (resolve, reject): Promise<void> => {
+    this.rebuildWatchPromise = new Promise<void>((resolve, reject) => {
+      void (async () => {
         try {
-          if (this.watchStatus === WATCH_STATUS.PAUSED) {
-            // if (process.env.DEBUG) {
+          if (this.watchStatus === WatchStatus.PAUSED) {
             console.log('[realtime] rebuildWatch cancelled on pause')
-            // }
             return resolve()
           }
-          const { envId } = await this._login(this.envId, forceRefreshLogin)
+          const { envId } = await this.wsLogin(this.envId, forceRefreshLogin)
 
           if (!this.sessionInfo) {
-            throw new Error(
-              'can not rebuildWatch without a successful initWatch (lack of sessionInfo)'
-            )
+            throw new Error('can not rebuildWatch without a successful initWatch (lack of sessionInfo)')
           }
 
-          if ((this.watchStatus as WATCH_STATUS) === WATCH_STATUS.PAUSED) {
+          if ((this.watchStatus as WatchStatus) === WatchStatus.PAUSED) {
             console.log('[realtime] rebuildWatch cancelled on pause')
             return resolve()
           }
 
-          this.watchStatus = WATCH_STATUS.REBUILDING
+          this.watchStatus = WatchStatus.REBUILDING
 
           const rebuildWatchMsg: IRequestMessageRebuildWatchMsg = {
             watchId: this.watchId,
@@ -471,44 +417,42 @@ export class VirtualWebSocketClient {
               envId,
               collName: this.collectionName,
               queryID: this.sessionInfo.queryID,
-              eventID: this.sessionInfo.currentEventId
-            }
+              eventID: this.sessionInfo.currentEventId,
+            },
           }
 
           const nextEventMsg = await this.send<IResponseMessageNextEventMsg>({
             msg: rebuildWatchMsg,
             waitResponse: true,
             skipOnMessage: false,
-            timeout: DEFAULT_REBUILD_WATCH_TIMEOUT
+            timeout: DEFAULT_REBUILD_WATCH_TIMEOUT,
           })
 
           this.handleServerEvents(nextEventMsg)
 
-          this.watchStatus = WATCH_STATUS.ACTIVE
-          this._availableRetries.REBUILD_WATCH = DEFAULT_MAX_AUTO_RETRY_ON_ERROR
+          this.watchStatus = WatchStatus.ACTIVE
+          this.availableRetries.REBUILD_WATCH = DEFAULT_MAX_AUTO_RETRY_ON_ERROR
           resolve()
         } catch (e) {
           this.handleWatchEstablishmentError(e, {
             operationName: 'REBUILD_WATCH',
             resolve,
-            reject
+            reject,
           })
         }
-      }
-    )
+      })()
+    })
 
     let success = false
 
     try {
-      await this._rebuildWatchPromise
+      await this.rebuildWatchPromise
       success = true
     } finally {
-      this._rebuildWatchPromise = undefined
+      this.rebuildWatchPromise = undefined
     }
 
-    // if (process.env.DEBUG) {
     console.log(`[realtime] rebuildWatch ${success ? 'success' : 'fail'}`)
-    // }
   }
 
   private handleWatchEstablishmentError = async (
@@ -519,24 +463,22 @@ export class VirtualWebSocketClient {
 
     const abortWatch = () => {
       // mock temp comment
-      this.closeWithError(
-        new CloudSDKError({
-          errCode: isInitWatch
-            ? (ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_INIT_WATCH_FAIL as string)
-            : (ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_REBUILD_WATCH_FAIL as string),
-          errMsg: e
-        })
-      )
+      this.closeWithError(new CloudSDKError({
+        errCode: isInitWatch
+          ? (ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_INIT_WATCH_FAIL as string)
+          : (ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_REBUILD_WATCH_FAIL as string),
+        errMsg: e,
+      }))
       options.reject(e)
     }
 
     const retry = (refreshLogin?: boolean) => {
       if (this.useRetryTicket(options.operationName)) {
         if (isInitWatch) {
-          this._initWatchPromise = undefined
+          this.initWatchPromise = undefined
           options.resolve(this.initWatch(refreshLogin))
         } else {
-          this._rebuildWatchPromise = undefined
+          this.rebuildWatchPromise = undefined
           options.resolve(this.rebuildWatch(refreshLogin))
         }
       } else {
@@ -549,71 +491,67 @@ export class VirtualWebSocketClient {
       onTimeoutError: () => retry(false),
       onNotRetryableError: abortWatch,
       onCancelledError: options.reject,
-      onUnknownError: async () => {
-        try {
-          const onWSDisconnected = async () => {
-            this.pause()
-            await this.onceWSConnected()
-            retry(true)
-          }
+      onUnknownError: () => {
+        (async () => {
+          try {
+            const onWSDisconnected = async () => {
+              this.pause()
+              await this.onceWSConnected()
+              retry(true)
+            }
 
-          if (!this.isWSConnected()) {
-            await onWSDisconnected()
-          } else {
-            await sleep(DEFAULT_WAIT_TIME_ON_UNKNOWN_ERROR)
-            if (this.watchStatus === WATCH_STATUS.PAUSED) {
-              // cancel
-              options.reject(
-                new CancelledError(
-                  `${options.operationName} cancelled due to pause after unknownError`
-                )
-              )
-            } else if (!this.isWSConnected()) {
+            if (!this.isWSConnected()) {
               await onWSDisconnected()
             } else {
-              retry(false)
+              await sleep(DEFAULT_WAIT_TIME_ON_UNKNOWN_ERROR)
+              if (this.watchStatus === WatchStatus.PAUSED) {
+                // cancel
+                options.reject(new CancelledError(`${options.operationName} cancelled due to pause after unknownError`))
+              } else if (!this.isWSConnected()) {
+                await onWSDisconnected()
+              } else {
+                retry(false)
+              }
             }
+          } catch (e) {
+            // unexpected error while handling error, in order to provide maximum effort on SEAMINGLESS FAULT TOLERANCE, just retry
+            retry(true)
           }
-        } catch (e) {
-          // unexpected error while handling error, in order to provide maximum effort on SEAMINGLESS FAULT TOLERANCE, just retry
-          retry(true)
-        }
-      }
+        })()
+      },
     })
   }
 
   private closeWatch = async () => {
     const queryId = this.sessionInfo ? this.sessionInfo.queryID : ''
 
-    if (this.watchStatus !== WATCH_STATUS.ACTIVE) {
-      this.watchStatus = WATCH_STATUS.CLOSED
+    if (this.watchStatus !== WatchStatus.ACTIVE) {
+      this.watchStatus = WatchStatus.CLOSED
       this.onWatchClose(this, queryId)
       return
     }
 
     try {
-      this.watchStatus = WATCH_STATUS.CLOSING
+      this.watchStatus = WatchStatus.CLOSING
 
       const closeWatchMsg: IRequestMessageCloseWatchMsg = {
         watchId: this.watchId,
         requestId: genRequestId(),
         msgType: 'CLOSE_WATCH',
-        msgData: null
+        msgData: null,
       }
 
       await this.send({
-        msg: closeWatchMsg
+        msg: closeWatchMsg,
       })
 
       this.sessionInfo = undefined
-      this.watchStatus = WATCH_STATUS.CLOSED
+      this.watchStatus = WatchStatus.CLOSED
     } catch (e) {
-      this.closeWithError(
-        new CloudSDKError({
-          errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_CLOSE_WATCH_FAIL as string,
-          errMsg: e
-        })
-      )
+      this.closeWithError(new CloudSDKError({
+        errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_CLOSE_WATCH_FAIL as string,
+        errMsg: e,
+      }))
     } finally {
       this.onWatchClose(this, queryId)
     }
@@ -624,8 +562,8 @@ export class VirtualWebSocketClient {
 
     // TODO: should we check status after timeout
     // @ts-ignore
-    this._ackTimeoutId = setTimeout(() => {
-      if (this._waitExpectedTimeoutId) {
+    this.ackTimeoutId = setTimeout(() => {
+      if (this.waitExpectedTimeoutId) {
         this.scheduleSendACK()
       } else {
         this.sendACK()
@@ -634,22 +572,20 @@ export class VirtualWebSocketClient {
   }
 
   private clearACKSchedule = () => {
-    if (this._ackTimeoutId) {
-      clearTimeout(this._ackTimeoutId)
+    if (this.ackTimeoutId) {
+      clearTimeout(this.ackTimeoutId)
     }
   }
 
   private sendACK = async (): Promise<void> => {
     try {
-      if (this.watchStatus !== WATCH_STATUS.ACTIVE) {
+      if (this.watchStatus !== WatchStatus.ACTIVE) {
         this.scheduleSendACK()
         return
       }
 
       if (!this.sessionInfo) {
-        console.warn(
-          '[realtime listener] can not send ack without a successful initWatch (lack of sessionInfo)'
-        )
+        console.warn('[realtime listener] can not send ack without a successful initWatch (lack of sessionInfo)')
         return
       }
 
@@ -659,12 +595,12 @@ export class VirtualWebSocketClient {
         msgType: 'CHECK_LAST',
         msgData: {
           queryID: this.sessionInfo.queryID,
-          eventID: this.sessionInfo.currentEventId
-        }
+          eventID: this.sessionInfo.currentEventId,
+        },
       }
 
       await this.send({
-        msg: ackMsg
+        msg: ackMsg,
       })
 
       this.scheduleSendACK()
@@ -687,12 +623,10 @@ export class VirtualWebSocketClient {
           case 'INVALIID_ENV':
           case 'COLLECTION_PERMISSION_DENIED': {
             // must throw
-            this.closeWithError(
-              new CloudSDKError({
-                errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_CHECK_LAST_FAIL as string,
-                errMsg: msg.msgData.code
-              })
-            )
+            this.closeWithError(new CloudSDKError({
+              errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_CHECK_LAST_FAIL as string,
+              errMsg: msg.msgData.code,
+            }))
             return
           }
           default: {
@@ -703,18 +637,16 @@ export class VirtualWebSocketClient {
 
       // maybe retryable
       if (
-        this._availableRetries.CHECK_LAST &&
-        this._availableRetries.CHECK_LAST > 0
+        this.availableRetries.CHECK_LAST
+        && this.availableRetries.CHECK_LAST > 0
       ) {
-        this._availableRetries.CHECK_LAST--
+        this.availableRetries.CHECK_LAST -= 1
         this.scheduleSendACK()
       } else {
-        this.closeWithError(
-          new CloudSDKError({
-            errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_CHECK_LAST_FAIL as string,
-            errMsg: e
-          })
-        )
+        this.closeWithError(new CloudSDKError({
+          errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_CHECK_LAST_FAIL as string,
+          errMsg: e,
+        }))
       }
     }
   }
@@ -764,55 +696,33 @@ export class VirtualWebSocketClient {
   // credit a retry chance from availableRetries
   private useRetryTicket(operationName: IRequestMsgType): boolean {
     if (
-      this._availableRetries[operationName] &&
-      this._availableRetries[operationName]! > 0
+      this.availableRetries[operationName]
+      && this.availableRetries[operationName]! > 0
     ) {
-      this._availableRetries[operationName]!--
-
-      // if (process.env.DEBUG) {
-      console.log(
-        `[realtime] ${operationName} use a retry ticket, now only ${this._availableRetries[operationName]} retry left`
-      )
-      // }
+      this.availableRetries[operationName]! -= 1
+      console.log(`[realtime] ${operationName} use a retry ticket, now only ${this.availableRetries[operationName]} retry left`)
 
       return true
     }
     return false
   }
 
-  private async handleServerEvents(
-    msg: IResponseMessageInitEventMsg | IResponseMessageNextEventMsg
-  ) {
+  private async handleServerEvents(msg: IResponseMessageInitEventMsg | IResponseMessageNextEventMsg) {
     try {
       this.scheduleSendACK()
-      await this._handleServerEvents(msg)
-      this._postHandleServerEventsValidityCheck(msg)
+      await this.handleServerEventsInternel(msg)
+      this.postHandleServerEventsValidityCheck(msg)
     } catch (e) {
-      // if (process.env.DEBUG) {
       // TODO: report
       console.error(
         '[realtime listener] internal non-fatal error: handle server events failed with error: ',
         e
       )
-
-      // writeToFile(
-      //   "wserror.txt",
-      //   `[realtime listener] internal non-fatal error: handle server events failed with error:  ${JSON.stringify(
-      //     Object.assign({}, e, {
-      //       requestId: msg.requestId,
-      //       watchId: msg.watchId
-      //     })
-      //   )} \n`
-      // )
-      // }
-
       throw e
     }
   }
 
-  private async _handleServerEvents(
-    msg: IResponseMessageInitEventMsg | IResponseMessageNextEventMsg
-  ) {
+  private async handleServerEventsInternel(msg: IResponseMessageInitEventMsg | IResponseMessageNextEventMsg) {
     const { requestId } = msg
 
     const { events } = msg.msgData
@@ -822,18 +732,16 @@ export class VirtualWebSocketClient {
       return
     }
 
-    const sessionInfo = this.sessionInfo
+    const { sessionInfo } = this
 
     let allChangeEvents: ISingleDBEvent[]
     try {
       allChangeEvents = events.map(getPublicEvent)
     } catch (e) {
-      this.closeWithError(
-        new CloudSDKError({
-          errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_RECEIVE_INVALID_SERVER_DATA as string,
-          errMsg: e
-        })
-      )
+      this.closeWithError(new CloudSDKError({
+        errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_RECEIVE_INVALID_SERVER_DATA as string,
+        errMsg: e,
+      }))
       return
     }
 
@@ -848,28 +756,11 @@ export class VirtualWebSocketClient {
           // duplicate event, dropable
           // TODO: report
           // if (process.env.DEBUG) {
-          console.warn(
-            `[realtime] duplicate event received, cur ${sessionInfo.currentEventId} but got ${change.id}`
-          )
+          console.warn(`[realtime] duplicate event received, cur ${sessionInfo.currentEventId} but got ${change.id}`)
           // }
         } else {
           // allChangeEvents should be in ascending order according to eventId, this should never happens, must report a non-fatal error
-          console.error(
-            `[realtime listener] server non-fatal error: events out of order (the latter event's id is smaller than that of the former) (requestId ${requestId})`
-          )
-
-          // writeToFile(
-          //   "wserror.txt",
-          //   `[realtime listener] server non-fatal error: events out of order (the latter event's id is smaller than that of the former)  ${JSON.stringify(
-          //     Object.assign(
-          //       {},
-          //       {
-          //         requestId: msg.requestId,
-          //         watchId: msg.watchId
-          //       }
-          //     )
-          //   )} \n`
-          // )
+          console.error(`[realtime listener] server non-fatal error: events out of order (the latter event's id is smaller than that of the former) (requestId ${requestId})`)
         }
         continue
       } else if (sessionInfo.currentEventId === change.id - 1) {
@@ -891,9 +782,9 @@ export class VirtualWebSocketClient {
                     const doc = cloneDeep(localDoc)
 
                     if (change.updatedFields) {
-                      for (const fieldPath in change.updatedFields) {
+                      Object.keys(change.updatedFields).forEach((fieldPath) => {
                         set(doc, fieldPath, change.updatedFields[fieldPath])
-                      }
+                      })
                     }
 
                     if (change.removedFields) {
@@ -905,22 +796,7 @@ export class VirtualWebSocketClient {
                     change.doc = doc
                   } else {
                     // TODO report
-                    console.error(
-                      '[realtime listener] internal non-fatal server error: unexpected update dataType event where no doc is associated.'
-                    )
-
-                    // writeToFile(
-                    //   "wserror.txt",
-                    //   `[realtime listener] internal non-fatal server error: unexpected update dataType event where no doc is associated.  ${JSON.stringify(
-                    //     Object.assign(
-                    //       {},
-                    //       {
-                    //         requestId: msg.requestId,
-                    //         watchId: msg.watchId
-                    //       }
-                    //     )
-                    //   )} \n`
-                    // )
+                    console.error('[realtime listener] internal non-fatal server error: unexpected update dataType event where no doc is associated.')
                   }
                   break
                 }
@@ -928,7 +804,7 @@ export class VirtualWebSocketClient {
                   // doc is provided by server, this should never occur
                   const err = new CloudSDKError({
                     errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_UNEXPECTED_FATAL_ERROR as string,
-                    errMsg: `HandleServerEvents: full doc is not provided with dataType="update" and queueType="enqueue" (requestId ${msg.requestId})`
+                    errMsg: `HandleServerEvents: full doc is not provided with dataType="update" and queueType="enqueue" (requestId ${msg.requestId})`,
                   })
                   this.closeWithError(err)
                   throw err
@@ -946,7 +822,7 @@ export class VirtualWebSocketClient {
               // doc is provided by server, this should never occur
               const err = new CloudSDKError({
                 errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_UNEXPECTED_FATAL_ERROR as string,
-                errMsg: `HandleServerEvents: full doc is not provided with dataType="replace" (requestId ${msg.requestId})`
+                errMsg: `HandleServerEvents: full doc is not provided with dataType="replace" (requestId ${msg.requestId})`,
               })
               this.closeWithError(err)
               throw err
@@ -959,36 +835,19 @@ export class VirtualWebSocketClient {
               change.doc = doc
             } else {
               // TODO report
-              console.error(
-                '[realtime listener] internal non-fatal server error: unexpected remove event where no doc is associated.'
-              )
-
-              // writeToFile(
-              //   "wserror.txt",
-              //   `[realtime listener] internal non-fatal server error: unexpected remove event where no doc is associated. ${JSON.stringify(
-              //     Object.assign(
-              //       {},
-              //       {
-              //         requestId: msg.requestId,
-              //         watchId: msg.watchId
-              //       }
-              //     )
-              //   )} \n`
-              // )
+              console.error('[realtime listener] internal non-fatal server error: unexpected remove event where no doc is associated.')
             }
             break
           }
           case 'limit': {
             if (!change.doc) {
-              switch(change.queueType) {
+              switch (change.queueType) {
                 case 'dequeue': {
                   const doc = docs.find(doc => doc._id === change.docId)
                   if (doc) {
                     change.doc = doc
                   } else {
-                    console.error(
-                      '[realtime listener] internal non-fatal server error: unexpected limit dataType event where no doc is associated.'
-                    )
+                    console.error('[realtime listener] internal non-fatal server error: unexpected limit dataType event where no doc is associated.')
                   }
                   break
                 }
@@ -996,7 +855,7 @@ export class VirtualWebSocketClient {
                   // doc is provided by server, this should never occur
                   const err = new CloudSDKError({
                     errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_UNEXPECTED_FATAL_ERROR as string,
-                    errMsg: `HandleServerEvents: full doc is not provided with dataType="limit" and queueType="enqueue" (requestId ${msg.requestId})`
+                    errMsg: `HandleServerEvents: full doc is not provided with dataType="limit" and queueType="enqueue" (requestId ${msg.requestId})`,
                   })
                   this.closeWithError(err)
                   throw err
@@ -1030,61 +889,25 @@ export class VirtualWebSocketClient {
               docs.splice(ind, 1)
             } else {
               // TODO report
-              console.error(
-                '[realtime listener] internal non-fatal server error: unexpected dequeue event where no doc is associated.'
-              )
-
-              // writeToFile(
-              //   "wserror.txt",
-              //   `[realtime listener] internal non-fatal server error: unexpected dequeue event where no doc is associated. ${JSON.stringify(
-              //     Object.assign(
-              //       {},
-              //       {
-              //         requestId: msg.requestId,
-              //         watchId: msg.watchId
-              //       }
-              //     )
-              //   )} \n`
-              // )
+              console.error('[realtime listener] internal non-fatal server error: unexpected dequeue event where no doc is associated.')
             }
             break
           }
           case 'update': {
-            // writeToFile(
-            //   "wserror.txt",
-            //   `[realtime listener] docs ${JSON.stringify(
-            //     docs
-            //   )} change doc ${JSON.stringify(change)} \n`
-            // )
             const ind = docs.findIndex(doc => doc._id === change.docId)
             if (ind > -1) {
               docs[ind] = change.doc
             } else {
               // TODO report
-              console.error(
-                '[realtime listener] internal non-fatal server error: unexpected queueType update event where no doc is associated.'
-              )
-
-              // writeToFile(
-              //   "wserror.txt",
-              //   `[realtime listener] internal non-fatal server error: unexpected queueType update event where no doc is associated. ${JSON.stringify(
-              //     Object.assign(
-              //       {},
-              //       {
-              //         requestId: msg.requestId,
-              //         watchId: msg.watchId
-              //       }
-              //     )
-              //   )} \n`
-              // )
+              console.error('[realtime listener] internal non-fatal server error: unexpected queueType update event where no doc is associated.')
             }
             break
           }
         }
 
         if (
-          i === len - 1 ||
-          (allChangeEvents[i + 1] && allChangeEvents[i + 1].id !== change.id)
+          i === len - 1
+          || (allChangeEvents[i + 1] && allChangeEvents[i + 1].id !== change.id)
         ) {
           // a shallow slice creates a shallow snapshot
           const docsSnapshot = [...docs]
@@ -1102,20 +925,16 @@ export class VirtualWebSocketClient {
             id: change.id,
             docChanges,
             docs: docsSnapshot,
-            msgType
+            msgType,
           })
 
-          // Reporter.surroundThirdByTryCatch(() =>
           this.listener.onChange(snapshot)
-          // )()
         }
       } else {
         // out-of-order event
         // if (process.env.DEBUG) {
         // TODO: report
-        console.warn(
-          `[realtime listener] event received is out of order, cur ${this.sessionInfo.currentEventId} but got ${change.id}`
-        )
+        console.warn(`[realtime listener] event received is out of order, cur ${this.sessionInfo.currentEventId} but got ${change.id}`)
         // }
         // rebuild watch
         await this.rebuildWatch()
@@ -1124,48 +943,29 @@ export class VirtualWebSocketClient {
     }
   }
 
-  private _postHandleServerEventsValidityCheck(
-    msg: IResponseMessageInitEventMsg | IResponseMessageNextEventMsg
-  ) {
+  private postHandleServerEventsValidityCheck(msg: IResponseMessageInitEventMsg | IResponseMessageNextEventMsg) {
     if (!this.sessionInfo) {
-      console.error(
-        '[realtime listener] internal non-fatal error: sessionInfo lost after server event handling, this should never occur'
-      )
-
-      // writeToFile(
-      //   "wserror.txt",
-      //   `[realtime listener] internal non-fatal error: sessionInfo lost after server event handling, this should never occur ${JSON.stringify(
-      //     Object.assign(
-      //       {},
-      //       {
-      //         requestId: msg.requestId,
-      //         watchId: msg.watchId
-      //       }
-      //     )
-      //   )} \n`
-      // )
+      console.error('[realtime listener] internal non-fatal error: sessionInfo lost after server event handling, this should never occur')
       return
     }
 
     if (
-      this.sessionInfo.expectEventId &&
-      this.sessionInfo.currentEventId >= this.sessionInfo.expectEventId
+      this.sessionInfo.expectEventId
+      && this.sessionInfo.currentEventId >= this.sessionInfo.expectEventId
     ) {
       this.clearWaitExpectedEvent()
     }
 
     if (this.sessionInfo.currentEventId < msg.msgData.currEvent) {
-      console.warn(
-        '[realtime listener] internal non-fatal error: client eventId does not match with server event id after server event handling'
-      )
+      console.warn('[realtime listener] internal non-fatal error: client eventId does not match with server event id after server event handling')
       return
     }
   }
 
   private clearWaitExpectedEvent() {
-    if (this._waitExpectedTimeoutId) {
-      clearTimeout(this._waitExpectedTimeoutId)
-      this._waitExpectedTimeoutId = undefined
+    if (this.waitExpectedTimeoutId) {
+      clearTimeout(this.waitExpectedTimeoutId)
+      this.waitExpectedTimeoutId = undefined
     }
   }
 }
@@ -1176,7 +976,7 @@ function getPublicEvent(event: IDBEvent): ISingleDBEvent {
     dataType: event.DataType,
     queueType: event.QueueType,
     docId: event.DocID,
-    doc: event.Doc && event.Doc !== '{}' ? JSON.parse(event.Doc) : undefined
+    doc: event.Doc && event.Doc !== '{}' ? JSON.parse(event.Doc) : undefined,
   }
 
   if (event.DataType === 'update') {