@cloudbase/database 1.4.1 → 1.4.2

package/dist/esm/query.js

@@ -1,244 +0,0 @@
-import { QueryType } from './constant';
-import { Db } from './index';
-import { Validate } from './validate';
-import { Util } from './util';
-import { QuerySerializer } from './serializer/query';
-import { UpdateSerializer } from './serializer/update';
-import { RealtimeWebSocketClient } from './realtime/websocket-client';
-import { ErrorCode } from './constant';
-import { getReqOpts, stringifyByEJSON, processReturn } from './utils/utils';
-import { ERRORS } from './const/code';
-import { EJSON } from 'bson';
-export class Query {
-    constructor(db, coll, fieldFilters, apiOptions, transactionId) {
-        this.watch = (options) => {
-            if (!Db.ws) {
-                Db.ws = new RealtimeWebSocketClient({
-                    context: {
-                        appConfig: {
-                            docSizeLimit: 1000,
-                            realtimePingInterval: 10000,
-                            realtimePongWaitTimeout: 5000,
-                            request: this._request
-                        }
-                    }
-                });
-            }
-            const { limit, order } = this._apiOptions;
-            return Db.ws.watch(Object.assign(Object.assign({}, options), { envId: this._db.config.env, collectionName: this._coll, query: JSON.stringify(this._fieldFilters), limit, orderBy: order
-                    ? order.reduce((acc, cur) => {
-                        acc[cur.field] = cur.direction;
-                        return acc;
-                    }, {})
-                    : undefined }));
-        };
-        this._db = db;
-        this._coll = coll;
-        this._fieldFilters = fieldFilters;
-        this._apiOptions = apiOptions || {};
-        this._request = new Db.reqClass(this._db.config);
-        this._transactionId = transactionId;
-    }
-    async get() {
-        const order = this._apiOptions.order;
-        let param = {
-            collectionName: this._coll,
-            queryType: QueryType.WHERE,
-            transactionId: this._transactionId
-        };
-        if (this._fieldFilters) {
-            param.query = this._fieldFilters;
-        }
-        if (order) {
-            param.order = stringifyByEJSON(order);
-        }
-        const offset = this._apiOptions.offset;
-        if (offset) {
-            param.offset = offset;
-        }
-        const limit = this._apiOptions.limit;
-        if (limit) {
-            param.limit = limit < 1000 ? limit : 1000;
-        }
-        else {
-            param.limit = 100;
-        }
-        const projection = this._apiOptions.projection;
-        if (projection) {
-            param.projection = stringifyByEJSON(projection);
-        }
-        const res = await this._request.send('database.getDocument', param, getReqOpts(this._apiOptions));
-        if (res.code) {
-            return res;
-        }
-        const list = res.data.list.map(item => EJSON.parse(item));
-        const documents = Util.formatResDocumentData(list);
-        const result = {
-            data: documents,
-            requestId: res.requestId
-        };
-        if (res.limit)
-            result.limit = res.limit;
-        if (res.offset)
-            result.offset = res.offset;
-        return result;
-    }
-    async count() {
-        let param = {
-            collectionName: this._coll,
-            queryType: QueryType.WHERE
-        };
-        if (this._fieldFilters) {
-            param.query = this._fieldFilters;
-        }
-        const res = await this._request.send('database.calculateDocument', param, getReqOpts(this._apiOptions));
-        if (res.code) {
-            return res;
-        }
-        return {
-            requestId: res.requestId,
-            total: res.data.total
-        };
-    }
-    where(query) {
-        if (Object.prototype.toString.call(query).slice(8, -1) !== 'Object') {
-            throw Error(ErrorCode.QueryParamTypeError);
-        }
-        const keys = Object.keys(query);
-        const checkFlag = keys.some(item => {
-            return query[item] !== undefined;
-        });
-        if (keys.length && !checkFlag) {
-            throw Error(ErrorCode.QueryParamValueError);
-        }
-        return new Query(this._db, this._coll, QuerySerializer.encodeEJSON(query, this._apiOptions.raw || false), this._apiOptions, this._transactionId);
-    }
-    options(apiOptions) {
-        Validate.isValidOptions(apiOptions);
-        return new Query(this._db, this._coll, this._fieldFilters, apiOptions, this._transactionId);
-    }
-    orderBy(fieldPath, directionStr) {
-        Validate.isFieldPath(fieldPath);
-        Validate.isFieldOrder(directionStr);
-        const newOrder = {
-            [fieldPath]: directionStr === 'desc' ? -1 : 1
-        };
-        const order = this._apiOptions.order || {};
-        const newApiOption = Object.assign({}, this._apiOptions, {
-            order: Object.assign({}, order, newOrder)
-        });
-        return new Query(this._db, this._coll, this._fieldFilters, newApiOption, this._transactionId);
-    }
-    limit(limit) {
-        Validate.isInteger('limit', limit);
-        let newApiOption = Object.assign({}, this._apiOptions);
-        newApiOption.limit = limit;
-        return new Query(this._db, this._coll, this._fieldFilters, newApiOption, this._transactionId);
-    }
-    skip(offset) {
-        Validate.isInteger('offset', offset);
-        let newApiOption = Object.assign({}, this._apiOptions);
-        newApiOption.offset = offset;
-        return new Query(this._db, this._coll, this._fieldFilters, newApiOption, this._transactionId);
-    }
-    async update(data) {
-        if (!data || typeof data !== 'object') {
-            return processReturn(this._db.config.throwOnCode, Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: '参数必需是非空对象' }));
-        }
-        if (data.hasOwnProperty('_id')) {
-            return processReturn(this._db.config.throwOnCode, Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: '不能更新_id的值' }));
-        }
-        let { multiple } = this._apiOptions;
-        const multi = multiple === undefined ? true : multiple;
-        let param = {
-            collectionName: this._coll,
-            queryType: QueryType.WHERE,
-            multi,
-            merge: true,
-            upsert: false,
-            data: UpdateSerializer.encodeEJSON(data, this._apiOptions.raw || false)
-        };
-        if (this._fieldFilters) {
-            param.query = this._fieldFilters;
-        }
-        const res = await this._request.send('database.modifyDocument', param, getReqOpts(this._apiOptions));
-        if (res.code) {
-            return res;
-        }
-        return {
-            requestId: res.requestId,
-            updated: res.data.updated,
-            upsertId: res.data.upsert_id
-        };
-    }
-    field(projection) {
-        let transformProjection = {};
-        for (let k in projection) {
-            if (typeof projection[k] === 'boolean') {
-                transformProjection[k] = projection[k] === true ? 1 : 0;
-            }
-            if (typeof projection[k] === 'number') {
-                transformProjection[k] = projection[k] > 0 ? 1 : 0;
-            }
-            if (typeof projection[k] === 'object') {
-                transformProjection[k] = projection[k];
-            }
-        }
-        let newApiOption = Object.assign({}, this._apiOptions);
-        newApiOption.projection = transformProjection;
-        return new Query(this._db, this._coll, this._fieldFilters, newApiOption, this._transactionId);
-    }
-    async remove() {
-        const { offset, limit, projection, order } = this._apiOptions;
-        if (offset !== undefined ||
-            limit !== undefined ||
-            projection !== undefined ||
-            order !== undefined) {
-            console.warn('`offset`, `limit`, `projection`, `orderBy` are not supported in remove() operation');
-        }
-        let { multiple } = this._apiOptions;
-        const multi = multiple === undefined ? true : multiple;
-        const param = {
-            collectionName: this._coll,
-            query: this._fieldFilters,
-            queryType: QueryType.WHERE,
-            multi
-        };
-        const res = await this._request.send('database.removeDocument', param, getReqOpts(this._apiOptions));
-        if (res.code) {
-            return res;
-        }
-        return {
-            requestId: res.requestId,
-            deleted: res.data.deleted
-        };
-    }
-    async updateAndReturn(data) {
-        if (!data || typeof data !== 'object') {
-            return processReturn(this._db.config.throwOnCode, Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: '参数必需是非空对象' }));
-        }
-        if (data.hasOwnProperty('_id')) {
-            return processReturn(this._db.config.throwOnCode, Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: '不能更新_id的值' }));
-        }
-        let param = {
-            collectionName: this._coll,
-            queryType: QueryType.WHERE,
-            data: UpdateSerializer.encodeEJSON(data, false)
-        };
-        if (this._transactionId) {
-            param.transactionId = this._transactionId;
-        }
-        if (this._fieldFilters) {
-            param.query = this._fieldFilters;
-        }
-        const res = await this._request.send('database.modifyAndReturnDoc', param, getReqOpts(this._apiOptions));
-        if (res.code) {
-            return res;
-        }
-        return {
-            requestId: res.requestId,
-            updated: res.data.updated,
-            doc: res.data.doc && EJSON.parse(res.data.doc)
-        };
-    }
-}

package/dist/esm/realtime/error.d.ts

@@ -1,7 +0,0 @@
-import { IResponseMessageErrorMsg } from '../typings/realtime';
-export declare class RealtimeErrorMessageError extends Error {
-    isRealtimeErrorMessageError: boolean;
-    payload: IResponseMessageErrorMsg;
-    constructor(serverErrorMsg: IResponseMessageErrorMsg);
-}
-export declare const isRealtimeErrorMessageError: (e: any) => e is RealtimeErrorMessageError;

package/dist/esm/realtime/error.js

@@ -1,8 +0,0 @@
-export class RealtimeErrorMessageError extends Error {
-    constructor(serverErrorMsg) {
-        super(`Watch Error ${JSON.stringify(serverErrorMsg.msgData)} (requestid: ${serverErrorMsg.requestId})`);
-        this.isRealtimeErrorMessageError = true;
-        this.payload = serverErrorMsg;
-    }
-}
-export const isRealtimeErrorMessageError = (e) => e && e.isRealtimeErrorMessageError;

package/dist/esm/realtime/listener.d.ts

@@ -1,14 +0,0 @@
-import { VirtualWebSocketClient } from './virtual-websocket-client';
-import { IRealtimeListenerConstructorOptions, DBRealtimeListener } from '../typings/index';
-interface IRealtimeListenerOptions extends IRealtimeListenerConstructorOptions {
-    close: () => void;
-    debug?: boolean;
-    virtualClient?: VirtualWebSocketClient;
-}
-export declare class RealtimeListener implements DBRealtimeListener {
-    close: () => void;
-    onChange: (res: any) => void;
-    onError: (error: any) => void;
-    constructor(options: IRealtimeListenerOptions);
-}
-export {};

package/dist/esm/realtime/listener.js

@@ -1,14 +0,0 @@
-export class RealtimeListener {
-    constructor(options) {
-        this.close = options.close;
-        this.onChange = options.onChange;
-        this.onError = options.onError;
-        if (options.debug) {
-            Object.defineProperty(this, 'virtualClient', {
-                get: () => {
-                    return options.virtualClient;
-                }
-            });
-        }
-    }
-}

package/dist/esm/realtime/message.d.ts

@@ -1,3 +0,0 @@
-import { IResponseMessage, IResponseMessageInitEventMsg } from '../typings/realtime';
-export declare function genRequestId(prefix?: string): string;
-export declare function isInitEventMessage(msg: IResponseMessage): msg is IResponseMessageInitEventMsg;

package/dist/esm/realtime/message.js

@@ -1,6 +0,0 @@
-export function genRequestId(prefix = '') {
-    return `${prefix ? `${prefix}_` : ''}${+new Date()}_${Math.random()}`;
-}
-export function isInitEventMessage(msg) {
-    return msg.msgType === 'INIT_EVENT';
-}

package/dist/esm/realtime/snapshot.d.ts

@@ -1,16 +0,0 @@
-import { ISingleDBEvent, SnapshotType, ISnapshot } from '../typings/index';
-interface ISnapshotConstructorOptions {
-    id: number;
-    docChanges: ISingleDBEvent[];
-    docs: Record<string, any>[];
-    type?: SnapshotType;
-    msgType?: String;
-}
-export declare class Snapshot implements ISnapshot {
-    id: number;
-    docChanges: ISingleDBEvent[];
-    docs: Record<string, any>[];
-    type?: 'init';
-    constructor(options: ISnapshotConstructorOptions);
-}
-export {};

package/dist/esm/realtime/snapshot.js

@@ -1,39 +0,0 @@
-export class Snapshot {
-    constructor(options) {
-        const { id, docChanges, docs, msgType, type } = options;
-        let cachedDocChanges;
-        let cachedDocs;
-        Object.defineProperties(this, {
-            id: {
-                get: () => id,
-                enumerable: true
-            },
-            docChanges: {
-                get: () => {
-                    if (!cachedDocChanges) {
-                        cachedDocChanges = JSON.parse(JSON.stringify(docChanges));
-                    }
-                    return cachedDocChanges;
-                },
-                enumerable: true
-            },
-            docs: {
-                get: () => {
-                    if (!cachedDocs) {
-                        cachedDocs = JSON.parse(JSON.stringify(docs));
-                    }
-                    return cachedDocs;
-                },
-                enumerable: true
-            },
-            msgType: {
-                get: () => msgType,
-                enumerable: true
-            },
-            type: {
-                get: () => type,
-                enumerable: true
-            }
-        });
-    }
-}

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

@@ -1,63 +0,0 @@
-import { IResponseMessage } from '../typings/realtime';
-import { RealtimeListener } from './listener';
-import { IWSSendOptions } from './websocket-client';
-import { IWatchOptions } from '../typings/index';
-interface IVirtualWebSocketClientConstructorOptions extends IWatchOptions {
-    envId?: string;
-    collectionName: string;
-    query: string;
-    limit?: number;
-    orderBy?: Record<string, string>;
-    send: <T = any>(opts: IWSSendOptions) => Promise<T>;
-    login: (envId?: string, refresh?: boolean) => Promise<any>;
-    isWSConnected: () => boolean;
-    onceWSConnected: () => Promise<void>;
-    getWaitExpectedTimeoutLength: () => number;
-    onWatchStart: (client: VirtualWebSocketClient, queryID: string) => void;
-    onWatchClose: (client: VirtualWebSocketClient, queryID: string) => void;
-    debug?: boolean;
-}
-export declare class VirtualWebSocketClient {
-    watchId: string;
-    private envId?;
-    private collectionName;
-    private query;
-    private limit;
-    private orderBy;
-    private send;
-    private login;
-    private isWSConnected;
-    private onceWSConnected;
-    private getWaitExpectedTimeoutLength;
-    private onWatchStart;
-    private onWatchClose;
-    private debug?;
-    listener: RealtimeListener;
-    private watchStatus;
-    private _availableRetries;
-    private _ackTimeoutId?;
-    private _initWatchPromise?;
-    private _rebuildWatchPromise?;
-    private sessionInfo?;
-    private _waitExpectedTimeoutId?;
-    constructor(options: IVirtualWebSocketClientConstructorOptions);
-    private _login;
-    private initWatch;
-    private rebuildWatch;
-    private handleWatchEstablishmentError;
-    private closeWatch;
-    private scheduleSendACK;
-    private clearACKSchedule;
-    private sendACK;
-    private handleCommonError;
-    private useRetryTicket;
-    private handleServerEvents;
-    private _handleServerEvents;
-    private _postHandleServerEventsValidityCheck;
-    private clearWaitExpectedEvent;
-    onMessage(msg: IResponseMessage): void;
-    closeWithError(error: any): void;
-    pause(): void;
-    resume(): Promise<void>;
-}
-export {};