@cloudbase/realtime 1.2.3-alpha.0 → 1.8.2

package/src/websocket-client.ts

@@ -1,8 +1,12 @@
-import { VirtualWebSocketClient } from './virtual-websocket-client'
-import { genRequestId } from './message'
+/* eslint-disable no-plusplus */
+/* eslint-disable @typescript-eslint/consistent-type-assertions */
+/* eslint-disable new-cap */
+/* eslint-disable @typescript-eslint/no-misused-promises */
+import { VirtualWebSocketClient } from './virtual-websocket-client';
+import { genRequestId } from './message';
 import {
   IDatabaseServiceContext,
-} from '@cloudbase/types/database'
+} from '@cloudbase/types/database';
 import {
   IWatchOptions,
   DBRealtimeListener,
@@ -11,17 +15,17 @@ import {
   IRequestMessagePingMsg,
   IRequestMessageLoginMsg,
   IResponseMessageLoginResMsg,
-  IRequestMessageLoginData
-} from '@cloudbase/types/realtime'
+  IRequestMessageLoginData,
+} from '@cloudbase/types/realtime';
 import {
   CLOSE_EVENT_CODE,
   CLOSE_EVENT_CODE_INFO,
-  getWSCloseError
-} from './ws-event'
+  getWSCloseError,
+} from './ws-event';
 
-import { ERR_CODE, TimeoutError, RealtimeErrorMessageError,CloudSDKError } from './error'
-import { getWsClass, getRuntime } from './common'
-import { sleep } from './utils'
+import { ERR_CODE, TimeoutError, RealtimeErrorMessageError, CloudSDKError } from './error';
+import { getWsClass, getRuntime } from './common';
+import { sleep } from './utils';
 
 export interface IRealtimeWebSocketClientConstructorOptions {
   maxReconnect?: number
@@ -85,215 +89,203 @@ const WS_READY_STATE = {
   CONNECTING: 0,
   OPEN: 1,
   CLOSING: 2,
-  CLOSED: 3
-}
-
-const MAX_RTT_OBSERVED = 3
-const DEFAULT_EXPECTED_EVENT_WAIT_TIME = 5000
-const DEFAULT_UNTRUSTED_RTT_THRESHOLD = 10000
-const DEFAULT_MAX_RECONNECT = 5
-const DEFAULT_WS_RECONNECT_INTERVAL = 10000
+  CLOSED: 3,
+};
+
+const MAX_RTT_OBSERVED = 3;
+const DEFAULT_EXPECTED_EVENT_WAIT_TIME = 5000;
+const DEFAULT_UNTRUSTED_RTT_THRESHOLD = 10000;
+const DEFAULT_MAX_RECONNECT = 5;
+const DEFAULT_WS_RECONNECT_INTERVAL = 10000;
 // const DEFAULT_WS_RECONNECT_MAX_VALID_INTERVAL = 3 * 60 * 1000
-const DEFAULT_PING_FAIL_TOLERANCE = 2
-const DEFAULT_PONG_MISS_TOLERANCE = 2
-const DEFAULT_LOGIN_TIMEOUT = 5000
+const DEFAULT_PING_FAIL_TOLERANCE = 2;
+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 _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 _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 _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 _wsInitPromise?: Promise<void>;
+  private _wsReadySubsribers: IResolveReject[] = [];
   private _wsResponseWait: Map<
-    string /* requestId */,
-    IResponseWaitSpec
-  > = new Map()
-  private _rttObserved: number[] = []
-  private _reconnectState: boolean
+  string /* requestId */,
+  IResponseWaitSpec
+  > = new Map();
+  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._maxReconnect = options.maxReconnect || DEFAULT_MAX_RECONNECT;
     // this._availableRetries = this._maxReconnect
-    this._reconnectInterval =
-      options.reconnectInterval || DEFAULT_WS_RECONNECT_INTERVAL
-    this._context = options.context
+    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) => {
-      let timeoutId: number
-      let _hasResolved = false
-      let _hasRejected = false
-
-      const resolve: typeof _resolve = (
-        value?: T | PromiseLike<T> | undefined
-      ) => {
-        _hasResolved = true
-        timeoutId && clearTimeout(timeoutId)
-        _resolve(value)
-      }
-
-      const reject: typeof _reject = (error: any) => {
-        _hasRejected = true
-        timeoutId && clearTimeout(timeoutId)
-        _reject(error)
-      }
-
-      if (opts.timeout) {
-        // @ts-ignore
-        timeoutId = setTimeout(async () => {
+  send = async <T = any>(opts: IWSSendOptions): Promise<T> => new Promise<T>(async (_resolve, _reject) => {
+    let timeoutId: number;
+    let _hasResolved = false;
+    let _hasRejected = false;
+
+    const resolve: typeof _resolve = (value?: T | PromiseLike<T> | undefined) => {
+      _hasResolved = true;
+      timeoutId && clearTimeout(timeoutId);
+      _resolve(value);
+    };
+
+    const reject: typeof _reject = (error: any) => {
+      _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) {
-            // 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'))
-            }
+            reject(new TimeoutError('wsclient.send timedout'));
           }
-        }, opts.timeout)
-      }
+        }
+      }, 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
-        // )
-        // }
+    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) {
-          await this._wsInitPromise
-        }
+      if (!this._ws) {
+        reject(new Error('invalid state: ws connection not exists, can not send message'));
+        return;
+      }
 
-        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`));
+        return;
+      }
 
-        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, {
+          resolve,
+          reject,
+          skipOnMessage: opts.skipOnMessage,
+        } as IResponseWaitSpec);
+      }
 
-        if (opts.waitResponse) {
-          this._wsResponseWait.set(opts.msg.requestId, {
-            resolve,
-            reject,
-            skipOnMessage: opts.skipOnMessage
-          } as IResponseWaitSpec)
+      // console.log('send msg:', opts.msg)
+      try {
+        await this._ws.send(JSON.stringify(opts.msg));
+        if (!opts.waitResponse) {
+          resolve(undefined);
         }
-
-        // console.log('send msg:', opts.msg)
-        try {
-          await this._ws.send(JSON.stringify(opts.msg))
-          if (!opts.waitResponse) {
-            resolve()
-          }
-        } catch (err) {
-          if (err) {
-            reject(err)
-            if (opts.waitResponse) {
-              this._wsResponseWait.delete(opts.msg.requestId)
-            }
+      } catch (err) {
+        if (err) {
+          reject(err);
+          if (opts.waitResponse) {
+            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)
       }
-    })
+      // 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) {
-    this.clearHeartbeat()
+    this.clearHeartbeat();
 
     if (this._ws) {
-      this._ws.close(code, CLOSE_EVENT_CODE_INFO[code].name)
-      this._ws = undefined
+      this._ws.close(code, CLOSE_EVENT_CODE_INFO[code].name);
+      this._ws = undefined;
     }
   }
 
   closeAllClients = (error: any) => {
-    this._virtualWSClient.forEach(client => {
-      client.closeWithError(error)
-    })
-  }
+    this._virtualWSClient.forEach((client) => {
+      client.closeWithError(error);
+    });
+  };
 
   pauseClients = (clients?: Set<VirtualWebSocketClient>) => {
-    ;(clients || this._virtualWSClient).forEach(client => {
-      client.pause()
-    })
-  }
+    (clients || this._virtualWSClient).forEach((client) => {
+      client.pause();
+    });
+  };
 
   resumeClients = (clients?: Set<VirtualWebSocketClient>) => {
-    ;(clients || this._virtualWSClient).forEach(client => {
-      client.resume()
-    })
-  }
+    (clients || this._virtualWSClient).forEach((client) => {
+      client.resume();
+    });
+  };
 
   watch(options: IWSWatchOptions): DBRealtimeListener {
     if (!this._ws && !this._wsInitPromise) {
-      this.initWebSocketConnection(false)
+      this.initWebSocketConnection(false);
     }
 
     const virtualClient = new VirtualWebSocketClient({
@@ -305,11 +297,11 @@ export class RealtimeWebSocketClient {
       getWaitExpectedTimeoutLength: this.getWaitExpectedTimeoutLength,
       onWatchStart: this.onWatchStart,
       onWatchClose: this.onWatchClose,
-      debug: true
-    })
-    this._virtualWSClient.add(virtualClient)
-    this._watchIdClientMap.set(virtualClient.watchId, virtualClient)
-    return virtualClient.listener
+      debug: true,
+    });
+    this._virtualWSClient.add(virtualClient);
+    this._watchIdClientMap.set(virtualClient.watchId, virtualClient);
+    return virtualClient.listener;
   }
 
   private initWebSocketConnection = async (
@@ -318,16 +310,16 @@ export class RealtimeWebSocketClient {
   ): Promise<void> => {
     // 当前处于正在重连中的状态
     if (reconnect && this._reconnectState) {
-      return // 忽略
+      return; // 忽略
     }
 
     if (reconnect) {
-      this._reconnectState = true // 重连状态开始
+      this._reconnectState = true; // 重连状态开始
     }
 
     if (this._wsInitPromise) {
       // there already exists a websocket initiation, just wait for it
-      return this._wsInitPromise
+      return this._wsInitPromise;
     }
 
     // if (process.env.DEBUG) {
@@ -337,10 +329,10 @@ export class RealtimeWebSocketClient {
     // }
 
     if (reconnect) {
-      this.pauseClients()
+      this.pauseClients();
     }
 
-    this.close(CLOSE_EVENT_CODE.ReconnectWebSocket)
+    this.close(CLOSE_EVENT_CODE.ReconnectWebSocket);
 
     this._wsInitPromise = new Promise<void>(async (resolve, reject) => {
       try {
@@ -358,14 +350,14 @@ export class RealtimeWebSocketClient {
         // }
 
         // const signature = await this.getSignature()
-        const wsSign = await this.getWsSign()
+        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 => {
+        await new Promise((success) => {
           // this._ws = getSDK(this._context.identifiers)
           //   ._socketSkipCheckDomainFactory()
           //   .connectSocket({
@@ -379,12 +371,12 @@ export class RealtimeWebSocketClient {
 
           const url = wsSign.wsUrl || 'wss://tcb-ws.tencentcloudapi.com';
           const wsClass = getWsClass();
-          this._ws = wsClass ? new wsClass(url) : new WebSocket(url)
-          success()
-        })
+          this._ws = wsClass ? new wsClass(url) : new WebSocket(url);
+          success(undefined);
+        });
 
-        if(this._ws.connect){
-          await this._ws.connect()
+        if (this._ws.connect) {
+          await this._ws.connect();
         }
 
         // if (process.env.DEBUG) {
@@ -393,23 +385,23 @@ export class RealtimeWebSocketClient {
         // )
         // }
 
-        await this.initWebSocketEvent()
-        resolve()
+        await this.initWebSocketEvent();
+        resolve();
 
         if (reconnect) {
-          this.resumeClients()
-          this._reconnectState = false // 重连状态结束
+          this.resumeClients();
+          this._reconnectState = false; // 重连状态结束
         }
       } catch (e) {
         // if (process.env.DEBUG) {
-        console.error('[realtime] initWebSocketConnection connect fail', e)
+        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
+          const isConnected = true;
 
           // if (process.env.DEBUG) {
           // console.log(
@@ -430,7 +422,7 @@ export class RealtimeWebSocketClient {
           // console.log('[realtime] initWebSocketConnection network online')
           // }
 
-          this._wsInitPromise = undefined
+          this._wsInitPromise = undefined;
 
           if (isConnected) {
             // if (process.env.DEBUG) {
@@ -438,39 +430,37 @@ export class RealtimeWebSocketClient {
             //   `[realtime] initWebSocketConnection sleep ${this._reconnectInterval}ms`
             // )
             // }
-            await sleep(this._reconnectInterval)
+            await sleep(this._reconnectInterval);
             if (reconnect) {
-              this._reconnectState = false // 重连异常也算重连状态结束
+              this._reconnectState = false; // 重连异常也算重连状态结束
             }
           }
 
-          resolve(this.initWebSocketConnection(reconnect, availableRetries - 1))
+          resolve(this.initWebSocketConnection(reconnect, availableRetries - 1));
         } else {
-          reject(e)
+          reject(e);
 
           if (reconnect) {
-            this.closeAllClients(
-              new CloudSDKError({
-                errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_RECONNECT_WATCH_FAIL as string,
-                errMsg: e
-              })
-            )
+            this.closeAllClients(new CloudSDKError({
+              errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_RECONNECT_WATCH_FAIL as string,
+              errMsg: e,
+            }));
           }
         }
       }
-    })
+    });
 
     // let success = false
 
     try {
-      await this._wsInitPromise
+      await this._wsInitPromise;
       // success = true
-      this._wsReadySubsribers.forEach(({ resolve }) => resolve())
+      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) {
@@ -478,264 +468,255 @@ export class RealtimeWebSocketClient {
     //   `[realtime] initWebSocketConnection ${success ? 'success' : 'fail'}`
     // )
     // }
-  }
-
-  private initWebSocketEvent = () =>
-    new Promise<void>((resolve, reject) => {
-      if (!this._ws) {
-        throw new Error('can not initWebSocketEvent, ws not exists')
-      }
-
-      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()
+  private initWebSocketEvent = () => new Promise<void>((resolve, reject) => {
+    if (!this._ws) {
+      throw new Error('can not initWebSocketEvent, ws not exists');
+    }
 
-        // error写进file
+    let wsOpened = false;
 
-        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`
-          // )
+    this._ws.onopen = (event) => {
+      // this._ws.onOpen(() => {
+      // this._ws.on("open", () => {
+      // this._context.debug &&
+      console.warn('[realtime] ws event: open', event);
+      wsOpened = true;
+      resolve();
+    };
 
-          reject(event)
-        } else {
-          // this._context.debug &&
-          console.error('[realtime] ws event: error', event)
+    this._ws.onerror = (event) => {
+      // this._ws.on("error", error => {
+      // this._ws.onError(error => {
+      // all logins are invalid after disconnection
+      this._logins = new Map();
 
-          // 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
-              })
-            )
-          )
-        }
-      }
-
-      // 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)
-        // }
+      // error写进file
 
+      if (!wsOpened) {
+        // this._context.debug &&
+        console.error('[realtime] ws open failed with ws event: error', event);
         // writeToFile(
-        //   "wsclose.txt",
+        //   "wserror.txt",
         //   `${
         //     this.specialNumber
-        //   } [realtime] ws event: close ${closeEvent} ${closereason} \n`
+        //   } [realtime] ws open failed with ws event: error ${error} \n`
         // )
 
-        // all logins are invalid after disconnection
-        this._logins = new Map()
+        reject(event);
+      } else {
+        // this._context.debug &&
+        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
+        // 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,
+        })));
+      }
+    };
+
+    // 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);
+      // }
+
+      // writeToFile(
+      //   "wsclose.txt",
+      //   `${
+      //     this.specialNumber
+      //   } [realtime] ws event: close ${closeEvent} ${closereason} \n`
+      // )
+
+      // all logins are invalid after disconnection
+      this._logins = new Map();
+
+      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));
           }
-          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 CLOSE_EVENT_CODE.NoAuthentication: {
+          this.closeAllClients(getWSCloseError(closeEvent.code, closeEvent.reason));
+          break;
+        }
+        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))
         }
       }
+    };
 
-      this._ws.onmessage = res => {
-        // this._ws.on("message", res => {
-        // this._ws.onMessage(res => {
-        // const rawMsg = res.data
-        const rawMsg = res.data
+    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()
+      // reset & restart heartbeat
+      this.heartbeat();
 
-        let msg: IResponseMessage
+      let msg: IResponseMessage;
 
-        try {
-          msg = JSON.parse(rawMsg as string)
-        } catch (e) {
-          throw new Error(`[realtime] onMessage parse res.data error: ${e}`)
-        }
+      try {
+        msg = JSON.parse(rawMsg as string);
+      } catch (e) {
+        throw new Error(`[realtime] onMessage parse res.data error: ${e}`);
+      }
 
-        // console.log(
-        //   `[realtime] onMessage ${
-        //     msg.msgType
-        //   } (${new Date().toLocaleString()})`,
-        //   msg
-        // )
+      // 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;
+          }
+        });
 
-        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);
+        }
+      }
 
-          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);
+        }
+        if (responseWaitSpec.skipOnMessage) {
+          return;
         }
+      }
 
-        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) {
+      if (msg.msgType === 'PONG') {
+        if (this._lastPingSendTS) {
+          const rtt = Date.now() - this._lastPingSendTS;
+          if (rtt > DEFAULT_UNTRUSTED_RTT_THRESHOLD) {
             // this._context.debug &&
-            console.error(
-              'ws onMessage responseWaitSpec.resolve(msg) errored:',
-              e
-            )
-          } finally {
-            this._wsResponseWait.delete(msg.requestId)
+            console.warn(`[realtime] untrusted rtt observed: ${rtt}`);
+            return;
           }
-          if (responseWaitSpec.skipOnMessage) {
-            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 {
+        // 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);
             }
-            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)
-              }
-              break
-            }
-            default: {
-              for (const [,client] of Array.from(this._watchIdClientMap.entries())) {
-                // console.log('watchid*****', watchId)
-                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
+      return;
     }
 
     if (this._wsInitPromise) {
-      return this._wsInitPromise
+      return this._wsInitPromise;
     }
 
     return new Promise<void>((resolve, reject) => {
       this._wsReadySubsribers.push({
         resolve,
-        reject
-      })
-    })
-  }
+        reject,
+      });
+    });
+  };
 
   private webLogin = async (
     envId?: string,
@@ -744,21 +725,21 @@ export class RealtimeWebSocketClient {
     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) {
-            return loginInfo.loggingInPromise
+            return loginInfo.loginResult;
+          } if (loginInfo.loggingInPromise) {
+            return loginInfo.loggingInPromise;
           }
         }
       } else {
-        const emptyEnvLoginInfo = this._logins.get('')
+        const emptyEnvLoginInfo = this._logins.get('');
         if (emptyEnvLoginInfo?.loggingInPromise) {
-          return emptyEnvLoginInfo.loggingInPromise
+          return emptyEnvLoginInfo.loggingInPromise;
         }
       }
     }
@@ -768,7 +749,7 @@ export class RealtimeWebSocketClient {
       try {
         // const signature = await this.getSignature(envId, refresh)
 
-        const wsSign = await this.getWsSign()
+        const wsSign = await this.getWsSign();
 
         // const wxVersion = getWXVersion()
         const msgData: IRequestMessageLoginData = {
@@ -778,8 +759,8 @@ export class RealtimeWebSocketClient {
           // secretVersion: signature.secretVersion,
           referrer: 'web',
           sdkVersion: '',
-          dataVersion: ''
-        }
+          dataVersion: '',
+        };
         const loginMsg: IRequestMessageLoginMsg = {
           watchId: undefined,
           requestId: genRequestId(),
@@ -788,51 +769,47 @@ export class RealtimeWebSocketClient {
           exMsgData: {
             runtime: getRuntime(),
             signStr: wsSign.signStr,
-            secretVersion: wsSign.secretVersion
-          }
-        }
+            secretVersion: wsSign.secretVersion,
+          },
+        };
         const loginResMsg = await this.send<IResponseMessageLoginResMsg>({
           msg: loginMsg,
           waitResponse: true,
           skipOnMessage: true,
-          timeout: DEFAULT_LOGIN_TIMEOUT
-        })
+          timeout: DEFAULT_LOGIN_TIMEOUT,
+        });
 
         if (!loginResMsg.msgData.code) {
           // login success
           resolve({
-            envId: wsSign.envId
-          })
+            envId: wsSign.envId,
+          });
         } else {
           // login failed
-          reject(
-            new Error(
-              `${loginResMsg.msgData.code} ${loginResMsg.msgData.message}`
-            )
-          )
+          reject(new Error(`${loginResMsg.msgData.code} ${loginResMsg.msgData.message}`));
         }
       } catch (e) {
-        reject(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()
+    const loginStartTS = Date.now();
 
     if (loginInfo) {
-      loginInfo.loggedIn = false
-      loginInfo.loggingInPromise = promise
-      loginInfo.loginStartTS = loginStartTS
+      loginInfo.loggedIn = false;
+      loginInfo.loggingInPromise = promise;
+      loginInfo.loginStartTS = loginStartTS;
     } else {
       loginInfo = {
         loggedIn: false,
         loggingInPromise: promise,
-        loginStartTS
-      }
+        loginStartTS,
+      };
       // this._loginInfo = loginInfo
-      this._logins.set(envId || '', loginInfo)
+      this._logins.set(envId || '', loginInfo);
     }
 
     // try {
@@ -851,113 +828,111 @@ export class RealtimeWebSocketClient {
     // }
 
     try {
-      const loginResult = await promise
-      const curLoginInfo = envId && this._logins.get(envId)
+      const loginResult = await promise;
+      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) {
+        loginInfo.loggedIn = true;
+        loginInfo.loggingInPromise = undefined;
+        loginInfo.loginStartTS = undefined;
+        loginInfo.loginResult = loginResult;
+        return loginResult;
+      } if (curLoginInfo) {
         if (curLoginInfo.loggedIn && curLoginInfo.loginResult) {
-          return curLoginInfo.loginResult
-        } else if (curLoginInfo.loggingInPromise) {
-          return curLoginInfo.loggingInPromise
-        } else {
-          throw new Error('ws unexpected login info')
+          return curLoginInfo.loginResult;
+        } if (curLoginInfo.loggingInPromise) {
+          return curLoginInfo.loggingInPromise;
         }
+        throw new Error('ws unexpected login info');
       } else {
-        throw new Error('ws login info reset')
+        throw new Error('ws login info reset');
       }
     } catch (e) {
-      loginInfo.loggedIn = false
-      loginInfo.loggingInPromise = undefined
-      loginInfo.loginStartTS = undefined
-      loginInfo.loginResult = undefined
-      throw e
+      loginInfo.loggedIn = false;
+      loginInfo.loggingInPromise = undefined;
+      loginInfo.loginStartTS = undefined;
+      loginInfo.loginResult = undefined;
+      throw e;
     }
-  }
+  };
 
   private getWsSign = async (): Promise<IWsSign> => {
     if (this._wsSign && this._wsSign.expiredTs > Date.now()) {
-      return this._wsSign
+      return this._wsSign;
     }
-    const expiredTs = Date.now() + 60000
-    const res = await this._context.appConfig.request.send('auth.wsWebSign', {runtime: getRuntime()})
+    const expiredTs = Date.now() + 60000;
+    const res = await this._context.appConfig.request.send('auth.wsWebSign', { runtime: getRuntime() });
 
     if (res.code) {
-      throw new Error(`[tcb-js-sdk] 获取实时数据推送登录票据失败: ${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
-      }
-    } else {
-      throw new Error('[tcb-js-sdk] 获取实时数据推送登录票据失败')
+        expiredTs,
+      };
     }
-  }
+    throw new Error('[tcb-js-sdk] 获取实时数据推送登录票据失败');
+  };
 
   private getWaitExpectedTimeoutLength = () => {
     if (!this._rttObserved.length) {
-      return DEFAULT_EXPECTED_EVENT_WAIT_TIME
+      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()
+    this.clearHeartbeat();
     // @ts-ignore
     this._pingTimeoutId = setTimeout(
       async () => {
         try {
           if (!this._ws || this._ws.readyState !== WS_READY_STATE.OPEN) {
             // no need to ping
-            return
+            return;
           }
 
-          this._lastPingSendTS = Date.now()
-          await this.ping()
-          this._pingFailed = 0
+          this._lastPingSendTS = Date.now();
+          await this.ping();
+          this._pingFailed = 0;
 
           // @ts-ignore
           this._pongTimeoutId = setTimeout(() => {
-            console.error('pong timed out')
+            console.error('pong timed out');
             if (this._pongMissed < DEFAULT_PONG_MISS_TOLERANCE) {
-              this._pongMissed++
-              this.heartbeat(true)
+              this._pongMissed++;
+              this.heartbeat(true);
             } else {
               // logical perceived connection lost, even though websocket did not receive error or close event
-              this.initWebSocketConnection(true)
+              this.initWebSocketConnection(true);
             }
-          }, this._context.appConfig.realtimePongWaitTimeout)
+          }, this._context.appConfig.realtimePongWaitTimeout);
         } catch (e) {
           if (this._pingFailed < DEFAULT_PING_FAIL_TOLERANCE) {
-            this._pingFailed++
-            this.heartbeat()
+            this._pingFailed++;
+            this.heartbeat();
           } else {
-            this.close(CLOSE_EVENT_CODE.HeartbeatPingError)
+            this.close(CLOSE_EVENT_CODE.HeartbeatPingError);
           }
         }
       },
       immediate ? 0 : this._context.appConfig.realtimePingInterval
-    )
+    );
   }
 
   private ping = async () => {
@@ -965,28 +940,28 @@ 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) {
       // no more existing watch, we should release the websocket connection
-      this.close(CLOSE_EVENT_CODE.NoRealtimeListeners)
+      this.close(CLOSE_EVENT_CODE.NoRealtimeListeners);
     }
-  }
+  };
 }