@cloudbase/database 0.9.19 → 0.9.20

package/dist/esm/realtime/websocket-client.d.ts

@@ -1,78 +0,0 @@
-import { VirtualWebSocketClient } from './virtual-websocket-client';
-import { IDatabaseServiceContext, IWatchOptions, DBRealtimeListener } from '../typings/index';
-import { IRequestMessage } from '../typings/realtime';
-import { CLOSE_EVENT_CODE } from './ws-event';
-export interface IRealtimeWebSocketClientConstructorOptions {
-    maxReconnect?: number;
-    reconnectInterval?: number;
-    context: IDatabaseServiceContext;
-}
-export interface ISignature {
-    envId: string;
-    secretVersion: number;
-    signStr: string;
-    wsUrl: string;
-    expireTS: number;
-}
-export interface ILoginInfo {
-    loggedIn: boolean;
-    loggingInPromise?: Promise<ILoginResult>;
-    loginStartTS?: number;
-    loginResult?: ILoginResult;
-}
-export interface ILoginResult {
-    envId: string;
-}
-export interface IWSSendOptions {
-    msg: IRequestMessage;
-    waitResponse?: boolean;
-    skipOnMessage?: boolean;
-    timeout?: number;
-}
-export interface IWSWatchOptions extends IWatchOptions {
-    envId?: string;
-    collectionName: string;
-    query: string;
-    limit?: number;
-    orderBy?: Record<string, string>;
-}
-export declare class RealtimeWebSocketClient {
-    private _virtualWSClient;
-    private _queryIdClientMap;
-    private _watchIdClientMap;
-    private _maxReconnect;
-    private _reconnectInterval;
-    private _context;
-    private _ws?;
-    private _lastPingSendTS?;
-    private _pingFailed;
-    private _pongMissed;
-    private _pingTimeoutId?;
-    private _pongTimeoutId?;
-    private _logins;
-    private _wsInitPromise?;
-    private _wsReadySubsribers;
-    private _wsResponseWait;
-    private _rttObserved;
-    private _reconnectState;
-    private _wsSign;
-    constructor(options: IRealtimeWebSocketClientConstructorOptions);
-    private initWebSocketConnection;
-    private initWebSocketEvent;
-    private isWSConnected;
-    private onceWSConnected;
-    private webLogin;
-    private getWsSign;
-    private getWaitExpectedTimeoutLength;
-    private heartbeat;
-    clearHeartbeat(): void;
-    private ping;
-    send: <T = any>(opts: IWSSendOptions) => Promise<T>;
-    close(code: CLOSE_EVENT_CODE): void;
-    closeAllClients: (error: any) => void;
-    pauseClients: (clients?: Set<VirtualWebSocketClient>) => void;
-    resumeClients: (clients?: Set<VirtualWebSocketClient>) => void;
-    private onWatchStart;
-    private onWatchClose;
-    watch(options: IWSWatchOptions): DBRealtimeListener;
-}

package/dist/esm/realtime/websocket-client.js

@@ -1,564 +0,0 @@
-import { VirtualWebSocketClient } from './virtual-websocket-client';
-import { sleep } from '../utils/utils';
-import { genRequestId } from './message';
-import { CLOSE_EVENT_CODE, CLOSE_EVENT_CODE_INFO, getWSCloseError } from './ws-event';
-import { CloudSDKError, TimeoutError } from '../utils/error';
-import { RealtimeErrorMessageError } from './error';
-import { ERR_CODE } from '../config/error.config';
-import { Db } from '../';
-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;
-const DEFAULT_PING_FAIL_TOLERANCE = 2;
-const DEFAULT_PONG_MISS_TOLERANCE = 2;
-const DEFAULT_LOGIN_TIMEOUT = 5000;
-export class RealtimeWebSocketClient {
-    constructor(options) {
-        this._virtualWSClient = new Set();
-        this._queryIdClientMap = new Map();
-        this._watchIdClientMap = new Map();
-        this._pingFailed = 0;
-        this._pongMissed = 0;
-        this._logins = new Map();
-        this._wsReadySubsribers = [];
-        this._wsResponseWait = new Map();
-        this._rttObserved = [];
-        this.initWebSocketConnection = async (reconnect, availableRetries = this._maxReconnect) => {
-            if (reconnect && this._reconnectState) {
-                return;
-            }
-            if (reconnect) {
-                this._reconnectState = true;
-            }
-            if (this._wsInitPromise) {
-                return this._wsInitPromise;
-            }
-            if (reconnect) {
-                this.pauseClients();
-            }
-            this.close(CLOSE_EVENT_CODE.ReconnectWebSocket);
-            this._wsInitPromise = new Promise(async (resolve, reject) => {
-                try {
-                    const wsSign = await this.getWsSign();
-                    await new Promise(success => {
-                        const url = wsSign.wsUrl || 'wss://tcb-ws.tencentcloudapi.com';
-                        this._ws = Db.wsClass ? new Db.wsClass(url) : new WebSocket(url);
-                        success();
-                    });
-                    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 (availableRetries > 0) {
-                        const isConnected = true;
-                        this._wsInitPromise = undefined;
-                        if (isConnected) {
-                            await sleep(this._reconnectInterval);
-                            if (reconnect) {
-                                this._reconnectState = false;
-                            }
-                        }
-                        resolve(this.initWebSocketConnection(reconnect, availableRetries - 1));
-                    }
-                    else {
-                        reject(e);
-                        if (reconnect) {
-                            this.closeAllClients(new CloudSDKError({
-                                errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_RECONNECT_WATCH_FAIL,
-                                errMsg: e
-                            }));
-                        }
-                    }
-                }
-            });
-            try {
-                await this._wsInitPromise;
-                this._wsReadySubsribers.forEach(({ resolve }) => resolve());
-            }
-            catch (e) {
-                this._wsReadySubsribers.forEach(({ reject }) => reject());
-            }
-            finally {
-                this._wsInitPromise = undefined;
-                this._wsReadySubsribers = [];
-            }
-        };
-        this.initWebSocketEvent = () => new Promise((resolve, reject) => {
-            if (!this._ws) {
-                throw new Error('can not initWebSocketEvent, ws not exists');
-            }
-            let wsOpened = false;
-            this._ws.onopen = event => {
-                console.warn('[realtime] ws event: open', event);
-                wsOpened = true;
-                resolve();
-            };
-            this._ws.onerror = event => {
-                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();
-                    this._virtualWSClient.forEach(client => client.closeWithError(new CloudSDKError({
-                        errCode: ERR_CODE.SDK_DATABASE_REALTIME_LISTENER_WEBSOCKET_CONNECTION_ERROR,
-                        errMsg: event
-                    })));
-                }
-            };
-            this._ws.onclose = closeEvent => {
-                console.warn('[realtime] ws event: close', closeEvent);
-                this._logins = new Map();
-                this.clearHeartbeat();
-                switch (closeEvent.code) {
-                    case CLOSE_EVENT_CODE.ReconnectWebSocket: {
-                        break;
-                    }
-                    case CLOSE_EVENT_CODE.NoRealtimeListeners: {
-                        break;
-                    }
-                    case CLOSE_EVENT_CODE.HeartbeatPingError:
-                    case CLOSE_EVENT_CODE.HeartbeatPongTimeoutError:
-                    case CLOSE_EVENT_CODE.NormalClosure:
-                    case CLOSE_EVENT_CODE.AbnormalClosure: {
-                        if (this._maxReconnect > 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;
-                    }
-                    default: {
-                        if (this._maxReconnect > 0) {
-                            this.initWebSocketConnection(true, this._maxReconnect);
-                        }
-                        else {
-                            this.closeAllClients(getWSCloseError(closeEvent.code));
-                        }
-                    }
-                }
-            };
-            this._ws.onmessage = res => {
-                const rawMsg = res.data;
-                this.heartbeat();
-                let msg;
-                try {
-                    msg = JSON.parse(rawMsg);
-                }
-                catch (e) {
-                    throw new Error(`[realtime] onMessage parse res.data error: ${e}`);
-                }
-                if (msg.msgType === '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) {
-                        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;
-                }
-                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);
-                            }
-                            break;
-                        }
-                        default: {
-                            for (const [, client] of this._watchIdClientMap) {
-                                client.onMessage(msg);
-                                break;
-                            }
-                        }
-                    }
-                }
-            };
-            this.heartbeat();
-        });
-        this.isWSConnected = () => {
-            return Boolean(this._ws && this._ws.readyState === WS_READY_STATE.OPEN);
-        };
-        this.onceWSConnected = async () => {
-            if (this.isWSConnected()) {
-                return;
-            }
-            if (this._wsInitPromise) {
-                return this._wsInitPromise;
-            }
-            return new Promise((resolve, reject) => {
-                this._wsReadySubsribers.push({
-                    resolve,
-                    reject
-                });
-            });
-        };
-        this.webLogin = async (envId, refresh) => {
-            if (!refresh) {
-                if (envId) {
-                    const loginInfo = this._logins.get(envId);
-                    if (loginInfo) {
-                        if (loginInfo.loggedIn && loginInfo.loginResult) {
-                            return loginInfo.loginResult;
-                        }
-                        else if (loginInfo.loggingInPromise) {
-                            return loginInfo.loggingInPromise;
-                        }
-                    }
-                }
-                else {
-                    const emptyEnvLoginInfo = this._logins.get('');
-                    if (emptyEnvLoginInfo && emptyEnvLoginInfo.loggingInPromise) {
-                        return emptyEnvLoginInfo.loggingInPromise;
-                    }
-                }
-            }
-            const promise = new Promise(async (resolve, reject) => {
-                try {
-                    const wsSign = await this.getWsSign();
-                    const msgData = {
-                        envId: wsSign.envId || '',
-                        accessToken: '',
-                        referrer: 'web',
-                        sdkVersion: '',
-                        dataVersion: Db.dataVersion || ''
-                    };
-                    const loginMsg = {
-                        watchId: undefined,
-                        requestId: genRequestId(),
-                        msgType: 'LOGIN',
-                        msgData,
-                        exMsgData: {
-                            runtime: Db.runtime,
-                            signStr: wsSign.signStr,
-                            secretVersion: wsSign.secretVersion
-                        }
-                    };
-                    const loginResMsg = await this.send({
-                        msg: loginMsg,
-                        waitResponse: true,
-                        skipOnMessage: true,
-                        timeout: DEFAULT_LOGIN_TIMEOUT
-                    });
-                    if (!loginResMsg.msgData.code) {
-                        resolve({
-                            envId: wsSign.envId
-                        });
-                    }
-                    else {
-                        reject(new Error(`${loginResMsg.msgData.code} ${loginResMsg.msgData.message}`));
-                    }
-                }
-                catch (e) {
-                    reject(e);
-                }
-            });
-            let loginInfo = envId && this._logins.get(envId);
-            const loginStartTS = Date.now();
-            if (loginInfo) {
-                loginInfo.loggedIn = false;
-                loginInfo.loggingInPromise = promise;
-                loginInfo.loginStartTS = loginStartTS;
-            }
-            else {
-                loginInfo = {
-                    loggedIn: false,
-                    loggingInPromise: promise,
-                    loginStartTS
-                };
-                this._logins.set(envId || '', loginInfo);
-            }
-            try {
-                const loginResult = await promise;
-                const curLoginInfo = envId && this._logins.get(envId);
-                if (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.loggedIn && curLoginInfo.loginResult) {
-                        return curLoginInfo.loginResult;
-                    }
-                    else if (curLoginInfo.loggingInPromise) {
-                        return curLoginInfo.loggingInPromise;
-                    }
-                    else {
-                        throw new Error('ws unexpected login info');
-                    }
-                }
-                else {
-                    throw new Error('ws login info reset');
-                }
-            }
-            catch (e) {
-                loginInfo.loggedIn = false;
-                loginInfo.loggingInPromise = undefined;
-                loginInfo.loginStartTS = undefined;
-                loginInfo.loginResult = undefined;
-                throw e;
-            }
-        };
-        this.getWsSign = async () => {
-            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: Db.runtime });
-            if (res.code) {
-                throw new Error(`[tcb-js-sdk] 获取实时数据推送登录票据失败: ${res.code}`);
-            }
-            if (res.data) {
-                const { signStr, wsUrl, secretVersion, envId } = res.data;
-                return {
-                    signStr,
-                    wsUrl,
-                    secretVersion,
-                    envId,
-                    expiredTs
-                };
-            }
-            else {
-                throw new Error('[tcb-js-sdk] 获取实时数据推送登录票据失败');
-            }
-        };
-        this.getWaitExpectedTimeoutLength = () => {
-            if (!this._rttObserved.length) {
-                return DEFAULT_EXPECTED_EVENT_WAIT_TIME;
-            }
-            return ((this._rttObserved.reduce((acc, cur) => acc + cur) /
-                this._rttObserved.length) *
-                1.5);
-        };
-        this.ping = async () => {
-            const msg = {
-                watchId: undefined,
-                requestId: genRequestId(),
-                msgType: 'PING',
-                msgData: null
-            };
-            await this.send({
-                msg
-            });
-        };
-        this.send = async (opts) => new Promise(async (_resolve, _reject) => {
-            let timeoutId;
-            let _hasResolved = false;
-            let _hasRejected = false;
-            const resolve = (value) => {
-                _hasResolved = true;
-                timeoutId && clearTimeout(timeoutId);
-                _resolve(value);
-            };
-            const reject = (error) => {
-                _hasRejected = true;
-                timeoutId && clearTimeout(timeoutId);
-                _reject(error);
-            };
-            if (opts.timeout) {
-                timeoutId = setTimeout(async () => {
-                    if (!_hasResolved || !_hasRejected) {
-                        await sleep(0);
-                        if (!_hasResolved || !_hasRejected) {
-                            reject(new TimeoutError('wsclient.send timedout'));
-                        }
-                    }
-                }, opts.timeout);
-            }
-            try {
-                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.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
-                    });
-                }
-                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 (e) {
-                reject(e);
-            }
-        });
-        this.closeAllClients = (error) => {
-            this._virtualWSClient.forEach(client => {
-                client.closeWithError(error);
-            });
-        };
-        this.pauseClients = (clients) => {
-            ;
-            (clients || this._virtualWSClient).forEach(client => {
-                client.pause();
-            });
-        };
-        this.resumeClients = (clients) => {
-            ;
-            (clients || this._virtualWSClient).forEach(client => {
-                client.resume();
-            });
-        };
-        this.onWatchStart = (client, queryID) => {
-            this._queryIdClientMap.set(queryID, client);
-        };
-        this.onWatchClose = (client, queryID) => {
-            if (queryID) {
-                this._queryIdClientMap.delete(queryID);
-            }
-            this._watchIdClientMap.delete(client.watchId);
-            this._virtualWSClient.delete(client);
-            if (!this._virtualWSClient.size) {
-                this.close(CLOSE_EVENT_CODE.NoRealtimeListeners);
-            }
-        };
-        this._maxReconnect = options.maxReconnect || DEFAULT_MAX_RECONNECT;
-        this._reconnectInterval =
-            options.reconnectInterval || DEFAULT_WS_RECONNECT_INTERVAL;
-        this._context = options.context;
-    }
-    heartbeat(immediate) {
-        this.clearHeartbeat();
-        this._pingTimeoutId = setTimeout(async () => {
-            try {
-                if (!this._ws || this._ws.readyState !== WS_READY_STATE.OPEN) {
-                    return;
-                }
-                this._lastPingSendTS = Date.now();
-                await this.ping();
-                this._pingFailed = 0;
-                this._pongTimeoutId = setTimeout(() => {
-                    console.error('pong timed out');
-                    if (this._pongMissed < DEFAULT_PONG_MISS_TOLERANCE) {
-                        this._pongMissed++;
-                        this.heartbeat(true);
-                    }
-                    else {
-                        this.initWebSocketConnection(true);
-                    }
-                }, 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);
-    }
-    clearHeartbeat() {
-        this._pingTimeoutId && clearTimeout(this._pingTimeoutId);
-        this._pongTimeoutId && clearTimeout(this._pongTimeoutId);
-    }
-    close(code) {
-        this.clearHeartbeat();
-        if (this._ws) {
-            this._ws.close(code, CLOSE_EVENT_CODE_INFO[code].name);
-            this._ws = undefined;
-        }
-    }
-    watch(options) {
-        if (!this._ws && !this._wsInitPromise) {
-            this.initWebSocketConnection(false);
-        }
-        const virtualClient = new VirtualWebSocketClient(Object.assign(Object.assign({}, options), { send: this.send, login: this.webLogin, isWSConnected: this.isWSConnected, onceWSConnected: this.onceWSConnected, getWaitExpectedTimeoutLength: this.getWaitExpectedTimeoutLength, onWatchStart: this.onWatchStart, onWatchClose: this.onWatchClose, debug: true }));
-        this._virtualWSClient.add(virtualClient);
-        this._watchIdClientMap.set(virtualClient.watchId, virtualClient);
-        return virtualClient.listener;
-    }
-}