@cloudbase/database 1.4.2 → 1.4.3-alpha.0

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

@@ -0,0 +1,219 @@
+import { DataType, QueueType } from './index';
+export declare type IRequestMsgType = 'LOGIN' | 'INIT_WATCH' | 'REBUILD_WATCH' | 'CHECK_LAST' | 'CLOSE_WATCH' | 'PING';
+export declare type IResponseMsgType = 'LOGIN_RES' | 'INIT_EVENT' | 'NEXT_EVENT' | 'CHECK_EVENT' | 'PONG' | 'ERROR';
+export interface IRequestMessageBase<W extends boolean = true> {
+    watchId: W extends true ? string : undefined;
+    requestId: string;
+    msgType: IRequestMsgType;
+    msgData: IRequestMessageMsgData;
+}
+export declare type IRequestMessageMsgData = IRequestMessageInitWatchData | IRequestMessageLoginData | IRequestMessageRebuildWatchData | IRequestMessageCheckLastData | IRequestMessageCloseWatchData | IRequestMessagePingData;
+export declare type IRequestMessage = IRequestMessageInitWatchMsg | IRequestMessageLoginMsg | IRequestMessageRebuildWatchMsg | IRequestMessageCheckLastMsg | IRequestMessageCloseWatchMsg | IRequestMessagePingMsg;
+export interface IRequestMessageLoginData {
+    envId: string;
+    accessToken: string;
+    referrer: 'web';
+    sdkVersion: string;
+    dataVersion: string;
+}
+export interface IRequestExtraMessageLoginData {
+    runtime: string;
+    signStr: string;
+    secretVersion: string;
+}
+export interface IRequestMessageLoginMsg extends IRequestMessageBase<false> {
+    msgType: 'LOGIN';
+    msgData: IRequestMessageLoginData;
+    exMsgData?: IRequestExtraMessageLoginData;
+}
+export interface IRequestMessageInitWatchData {
+    envId: string;
+    collName: string;
+    query: string;
+    limit?: number;
+    orderBy?: Record<string, string>;
+}
+export interface IRequestMessageInitWatchMsg extends IRequestMessageBase {
+    msgType: 'INIT_WATCH';
+    msgData: IRequestMessageInitWatchData;
+}
+export interface IRequestMessageRebuildWatchData {
+    envId: string;
+    collName: string;
+    queryID: string;
+    eventID: number;
+}
+export interface IRequestMessageRebuildWatchMsg extends IRequestMessageBase {
+    msgType: 'REBUILD_WATCH';
+    msgData: IRequestMessageRebuildWatchData;
+}
+export interface IRequestMessageCheckLastData {
+    queryID: string;
+    eventID: number;
+}
+export interface IRequestMessageCheckLastMsg extends IRequestMessageBase {
+    msgType: 'CHECK_LAST';
+    msgData: IRequestMessageCheckLastData;
+}
+export declare type IRequestMessageCloseWatchData = null;
+export interface IRequestMessageCloseWatchMsg extends IRequestMessageBase {
+    msgType: 'CLOSE_WATCH';
+    msgData: IRequestMessageCloseWatchData;
+}
+export declare type IRequestMessagePingData = null;
+export interface IRequestMessagePingMsg extends IRequestMessageBase<false> {
+    msgType: 'PING';
+    msgData: IRequestMessagePingData;
+}
+export interface IResponseMessageBase<W extends boolean = true> {
+    watchId: W extends true ? string : undefined;
+    requestId: string;
+    msgType: IResponseMsgType;
+    msgData: IResponseMessageMsgData;
+}
+export declare type IResponseMessageMsgData = IResponseMessageLoginResData | IResponseMessageInitEventData | IResponseMessageNextEventData | IResponseMessageCheckEventData | IResponseMessagePongData | IResponseMessageErrorData;
+export declare type IResponseMessage = IResponseMessageLoginResMsg | IResponseMessageInitEventMsg | IResponseMessageNextEventMsg | IResponseMessageCheckEventMsg | IResponseMessagePongMsg | IResponseMessageErrorMsg;
+export declare type IResponseMessageLoginResData = {
+    envId: string;
+} & Partial<IResponseMessageErrorData>;
+export interface IResponseMessageLoginResMsg extends IResponseMessageBase<false> {
+    msgType: 'LOGIN_RES';
+    msgData: IResponseMessageLoginResData;
+}
+export interface IResponseMessageInitEventData {
+    queryID: string;
+    currEvent: number;
+    events: IDBEvent[];
+}
+export interface IResponseMessageInitEventMsg extends IResponseMessageBase {
+    msgType: 'INIT_EVENT';
+    msgData: IResponseMessageInitEventData;
+}
+export interface IResponseMessageNextEventData {
+    queryID: string;
+    currEvent: number;
+    events: IDBEvent[];
+}
+export interface IResponseMessageNextEventMsg extends IResponseMessageBase {
+    msgType: 'NEXT_EVENT';
+    msgData: IResponseMessageNextEventData;
+}
+export interface IResponseMessageCheckEventData {
+    queryID: string;
+    currEvent: number;
+}
+export interface IResponseMessageCheckEventMsg extends IResponseMessageBase {
+    msgType: 'CHECK_EVENT';
+    msgData: IResponseMessageCheckEventData;
+}
+export declare type IResponseMessagePongData = null;
+export interface IResponseMessagePongMsg extends IResponseMessageBase {
+    msgType: 'PONG';
+    msgData: IResponseMessagePongData;
+}
+export declare type IResponseMessageErrorData = {
+    message: string;
+} & ({
+    code: 'SYS_ERR';
+} | {
+    code: 'CHECK_LOGIN_FAILED';
+} | {
+    code: 'SIGN_INVALID_ERROR';
+} | {
+    code: 'SIGN_EXPIRED_ERROR';
+} | {
+    code: 'INVALIID_ENV';
+} | {
+    code: 'SIGN_PARAM_INVALID';
+} | {
+    code: 'COLLECTION_PERMISSION_DENIED';
+} | {
+    code: 'QUERYID_INVALID_ERROR';
+});
+export interface IResponseMessageErrorMsg extends IResponseMessageBase {
+    msgType: 'ERROR';
+    msgData: IResponseMessageErrorData;
+}
+export declare type IDBEvent = IDBInitEvent | IDBNextEvent;
+export interface IDBEventBase {
+    ID: number;
+    DataType: DataType;
+    QueueType: QueueType;
+    DocID: string;
+    Doc: string;
+}
+export interface IDBInitEvent extends IDBEventBase {
+    DataType: 'init';
+    QueueType: 'init';
+    UpdatedFields?: any;
+    removedFields?: any;
+}
+export declare type IDBNextEvent = IDBNextEventDataUpdate | IDBNextEventDataReplace | IDBNextEventDataAdd | IDBNextEventDataRemove | IDBNextEventDataLimit;
+export declare type IDBNextEventDataUpdate = IDBNextEventDataUpdateQueueUpdate | IDBNextEventDataUpdateQueueEnqueue | IDBNextEventDataUpdateQueueDequeue;
+export declare type IDBNextEventDataReplace = IDBNextEventDataReplaceQueueUpdate | IDBNextEventDataReplaceQueueEnqueue | IDBNextEventDataReplaceQueueDequeue;
+export declare type IDBNextEventDataLimit = IDBNextEventDataLimitQueueEnqueue | IDBNextEventDataLimitQueueDequeue;
+export interface IDBNextEventDataUpdateQueueUpdate extends IDBEventBase {
+    DataType: 'update';
+    QueueType: 'update';
+    Doc: '';
+    UpdatedFields: string;
+    RemovedFields: string;
+}
+export interface IDBNextEventDataUpdateQueueEnqueue extends IDBEventBase {
+    DataType: 'update';
+    QueueType: 'enqueue';
+    Doc: string;
+    UpdatedFields: string;
+    RemovedFields: string;
+}
+export interface IDBNextEventDataUpdateQueueDequeue extends IDBEventBase {
+    DataType: 'update';
+    QueueType: 'dequeue';
+    Doc: '';
+    UpdatedFields: string;
+    RemovedFields: string;
+}
+export interface IDBNextEventDataReplaceQueueUpdate extends IDBEventBase {
+    DataType: 'replace';
+    QueueType: 'update';
+    Doc: string;
+    UpdatedFields: '';
+    RemovedFields: '';
+}
+export interface IDBNextEventDataReplaceQueueEnqueue extends IDBEventBase {
+    DataType: 'replace';
+    QueueType: 'enqueue';
+    Doc: string;
+    UpdatedFields: '';
+    RemovedFields: '';
+}
+export interface IDBNextEventDataReplaceQueueDequeue extends IDBEventBase {
+    DataType: 'replace';
+    QueueType: 'dequeue';
+    Doc: string;
+    UpdatedFields: '';
+    RemovedFields: '';
+}
+export interface IDBNextEventDataAdd extends IDBEventBase {
+    DataType: 'add';
+    QueueType: 'enqueue';
+}
+export interface IDBNextEventDataRemove extends IDBEventBase {
+    DataType: 'remove';
+    QueueType: 'dequeue';
+    Doc: '';
+}
+export interface IDBNextEventDataLimitQueueEnqueue extends IDBEventBase {
+    DataType: 'limit';
+    QueueType: 'enqueue';
+    Doc: string;
+    UpdatedFields: '';
+    RemovedFields: '';
+}
+export interface IDBNextEventDataLimitQueueDequeue extends IDBEventBase {
+    DataType: 'limit';
+    QueueType: 'dequeue';
+    Doc: '';
+    UpdatedFields: '';
+    RemovedFields: '';
+}

package/dist/esm/util.d.ts

@@ -0,0 +1,9 @@
+interface DocumentModel {
+    _id: string;
+}
+export declare class Util {
+    static formatResDocumentData: (documents: DocumentModel[]) => {}[];
+    static whichType: (obj: any) => String;
+    static generateDocId: () => string;
+}
+export {};

package/dist/esm/util.js

@@ -0,0 +1,98 @@
+import { FieldType } from './constant';
+import { Point, LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon } from './geo/index';
+export class Util {
+}
+Util.formatResDocumentData = (documents) => {
+    return documents.map(document => {
+        return Util.formatField(document);
+    });
+};
+Util.formatField = document => {
+    const keys = Object.keys(document);
+    let protoField = {};
+    if (Array.isArray(document)) {
+        protoField = [];
+    }
+    keys.forEach(key => {
+        const item = document[key];
+        const type = Util.whichType(item);
+        let realValue;
+        switch (type) {
+            case FieldType.GeoPoint:
+                realValue = new Point(item.coordinates[0], item.coordinates[1]);
+                break;
+            case FieldType.GeoLineString:
+                realValue = new LineString(item.coordinates.map(point => new Point(point[0], point[1])));
+                break;
+            case FieldType.GeoPolygon:
+                realValue = new Polygon(item.coordinates.map(line => new LineString(line.map(([lng, lat]) => new Point(lng, lat)))));
+                break;
+            case FieldType.GeoMultiPoint:
+                realValue = new MultiPoint(item.coordinates.map(point => new Point(point[0], point[1])));
+                break;
+            case FieldType.GeoMultiLineString:
+                realValue = new MultiLineString(item.coordinates.map(line => new LineString(line.map(([lng, lat]) => new Point(lng, lat)))));
+                break;
+            case FieldType.GeoMultiPolygon:
+                realValue = new MultiPolygon(item.coordinates.map(polygon => new Polygon(polygon.map(line => new LineString(line.map(([lng, lat]) => new Point(lng, lat)))))));
+                break;
+            case FieldType.Date:
+                realValue = item;
+                break;
+            case FieldType.Object:
+            case FieldType.Array:
+                realValue = Util.formatField(item);
+                break;
+            case FieldType.ServerDate:
+                realValue = new Date(item.$date);
+                break;
+            default:
+                realValue = item;
+        }
+        if (Array.isArray(protoField)) {
+            protoField.push(realValue);
+        }
+        else {
+            protoField[key] = realValue;
+        }
+    });
+    return protoField;
+};
+Util.whichType = (obj) => {
+    let type = Object.prototype.toString.call(obj).slice(8, -1);
+    if (type === FieldType.Date) {
+        return FieldType.Date;
+    }
+    if (type === FieldType.Object) {
+        if (obj.$date) {
+            type = FieldType.ServerDate;
+        }
+        else if (Point.validate(obj)) {
+            type = FieldType.GeoPoint;
+        }
+        else if (LineString.validate(obj)) {
+            type = FieldType.GeoLineString;
+        }
+        else if (Polygon.validate(obj)) {
+            type = FieldType.GeoPolygon;
+        }
+        else if (MultiPoint.validate(obj)) {
+            type = FieldType.GeoMultiPoint;
+        }
+        else if (MultiLineString.validate(obj)) {
+            type = FieldType.GeoMultiLineString;
+        }
+        else if (MultiPolygon.validate(obj)) {
+            type = FieldType.GeoMultiPolygon;
+        }
+    }
+    return type;
+};
+Util.generateDocId = () => {
+    let chars = 'ABCDEFabcdef0123456789';
+    let autoId = '';
+    for (let i = 0; i < 24; i++) {
+        autoId += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return autoId;
+};

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

@@ -0,0 +1,37 @@
+export interface ICloudSDKError extends Error {
+    errCode: number;
+    errMsg: string;
+}
+export declare class CloudSDKError extends Error {
+    errCode: string;
+    errMsg: string;
+    requestID?: string;
+    constructor(options: IErrorConstructorOptions);
+    message: string;
+}
+interface IErrorConstructorOptions {
+    errCode?: string;
+    errMsg: string;
+}
+export declare function isSDKError(error: any): error is CloudSDKError;
+export interface IGenericError<T extends string, P = any> extends Error {
+    type: T;
+    payload: P;
+    generic: boolean;
+}
+export declare const isGenericError: <T extends string, P>(e: any) => e is IGenericError<T, P>;
+export declare class TimeoutError extends Error implements IGenericError<'timeout', null> {
+    type: "timeout";
+    payload: any;
+    generic: boolean;
+    constructor(message: string);
+}
+export declare const isTimeoutError: (e: any) => e is TimeoutError;
+export declare class CancelledError extends Error implements IGenericError<'cancelled', null> {
+    type: "cancelled";
+    payload: any;
+    generic: boolean;
+    constructor(message: string);
+}
+export declare const isCancelledError: (e: any) => e is CancelledError;
+export {};

package/dist/esm/utils/error.js

@@ -0,0 +1,49 @@
+import { isString } from './type';
+import { ERR_CODE } from '../config/error.config';
+export class CloudSDKError extends Error {
+    constructor(options) {
+        super(options.errMsg);
+        this.errCode = 'UNKNOWN_ERROR';
+        Object.defineProperties(this, {
+            message: {
+                get() {
+                    return (`errCode: ${this.errCode} ${ERR_CODE[this.errCode] ||
+                        ''} | errMsg: ` + this.errMsg);
+                },
+                set(msg) {
+                    this.errMsg = msg;
+                }
+            }
+        });
+        this.errCode = options.errCode || 'UNKNOWN_ERROR';
+        this.errMsg = options.errMsg;
+    }
+    get message() {
+        return `errCode: ${this.errCode} | errMsg: ` + this.errMsg;
+    }
+    set message(msg) {
+        this.errMsg = msg;
+    }
+}
+export function isSDKError(error) {
+    return (error && error instanceof Error && isString(error.errMsg));
+}
+export const isGenericError = (e) => e.generic;
+export class TimeoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.type = 'timeout';
+        this.payload = null;
+        this.generic = true;
+    }
+}
+export const isTimeoutError = (e) => e.type === 'timeout';
+export class CancelledError extends Error {
+    constructor(message) {
+        super(message);
+        this.type = 'cancelled';
+        this.payload = null;
+        this.generic = true;
+    }
+}
+export const isCancelledError = (e) => e.type === 'cancelled';

package/dist/esm/utils/symbol.d.ts

@@ -0,0 +1,8 @@
+declare class HiddenSymbol {
+    constructor(target: any);
+}
+export declare class InternalSymbol extends HiddenSymbol {
+    constructor(target: any, __mark__: any);
+    static for(target: any): InternalSymbol;
+}
+export default InternalSymbol;

package/dist/esm/utils/symbol.js

@@ -0,0 +1,36 @@
+const _symbols = [];
+const __internalMark__ = {};
+class HiddenSymbol {
+    constructor(target) {
+        Object.defineProperties(this, {
+            target: {
+                enumerable: false,
+                writable: false,
+                configurable: false,
+                value: target,
+            },
+        });
+    }
+}
+export class InternalSymbol extends HiddenSymbol {
+    constructor(target, __mark__) {
+        if (__mark__ !== __internalMark__) {
+            throw new TypeError('InternalSymbol cannot be constructed with new operator');
+        }
+        super(target);
+    }
+    static for(target) {
+        for (let i = 0, len = _symbols.length; i < len; i++) {
+            if (_symbols[i].target === target) {
+                return _symbols[i].instance;
+            }
+        }
+        const symbol = new InternalSymbol(target, __internalMark__);
+        _symbols.push({
+            target,
+            instance: symbol,
+        });
+        return symbol;
+    }
+}
+export default InternalSymbol;

package/dist/esm/utils/type.d.ts

@@ -0,0 +1,13 @@
+export declare const getType: (x: any) => string;
+export declare const isObject: <T extends object>(x: any) => x is T;
+export declare const isString: (x: any) => x is string;
+export declare const isNumber: (x: any) => x is number;
+export declare const isPromise: <T extends Promise<any> = Promise<any>>(x: any) => x is T;
+declare type AnyFn = (...args: any[]) => any;
+export declare const isFunction: <T extends AnyFn = AnyFn>(x: any) => x is T;
+export declare const isArray: <T extends any[] = any[]>(x: any) => x is T;
+export declare const isDate: (x: any) => x is Date;
+export declare const isRegExp: (x: any) => x is RegExp;
+export declare const isInternalObject: (x: any) => boolean;
+export declare const isPlainObject: (obj: any) => obj is object;
+export {};

package/dist/esm/utils/type.js

@@ -0,0 +1,20 @@
+import { InternalSymbol } from './symbol';
+export const getType = (x) => Object.prototype.toString.call(x).slice(8, -1).toLowerCase();
+export const isObject = (x) => getType(x) === 'object';
+export const isString = (x) => getType(x) === 'string';
+export const isNumber = (x) => getType(x) === 'number';
+export const isPromise = (x) => getType(x) === 'promise';
+export const isFunction = (x) => typeof x === 'function';
+export const isArray = (x) => Array.isArray(x);
+export const isDate = (x) => getType(x) === 'date';
+export const isRegExp = (x) => getType(x) === 'regexp';
+export const isInternalObject = (x) => x && (x._internalType instanceof InternalSymbol);
+export const isPlainObject = (obj) => {
+    if (typeof obj !== 'object' || obj === null)
+        return false;
+    let proto = obj;
+    while (Object.getPrototypeOf(proto) !== null) {
+        proto = Object.getPrototypeOf(proto);
+    }
+    return Object.getPrototypeOf(obj) === proto;
+};

package/dist/esm/utils/utils.d.ts

@@ -0,0 +1,19 @@
+import { QueryOption, UpdateOption } from '../query';
+export declare const sleep: (ms?: number) => Promise<unknown>;
+export declare const autoCount: (domain?: string) => number;
+export declare const getReqOpts: (apiOptions: QueryOption | UpdateOption) => any;
+export declare const filterUndefined: (o: any) => any;
+export declare const stringifyByEJSON: (params: any) => any;
+export declare const parseByEJSON: (params: any) => any;
+export declare class TcbError extends Error {
+    readonly code: string;
+    readonly message: string;
+    constructor(error: IErrorInfo);
+}
+export declare const E: (errObj: IErrorInfo) => TcbError;
+export declare function processReturn(throwOnCode: boolean, res: any): any;
+interface IErrorInfo {
+    code?: string;
+    message?: string;
+}
+export {};

package/dist/esm/utils/utils.js

@@ -0,0 +1,55 @@
+import { EJSON } from 'bson';
+import { isObject } from './type';
+export const sleep = (ms = 0) => new Promise(r => setTimeout(r, ms));
+const counters = {};
+export const autoCount = (domain = 'any') => {
+    if (!counters[domain]) {
+        counters[domain] = 0;
+    }
+    return counters[domain]++;
+};
+export const getReqOpts = (apiOptions) => {
+    if (apiOptions.timeout !== undefined) {
+        return {
+            timeout: apiOptions.timeout
+        };
+    }
+    return {};
+};
+export const filterUndefined = o => {
+    if (!isObject(o)) {
+        return o;
+    }
+    for (let key in o) {
+        if (o[key] === undefined) {
+            delete o[key];
+        }
+        else if (isObject(o[key])) {
+            o[key] = filterUndefined(o[key]);
+        }
+    }
+    return o;
+};
+export const stringifyByEJSON = params => {
+    params = filterUndefined(params);
+    return EJSON.stringify(params, { relaxed: false });
+};
+export const parseByEJSON = params => {
+    return EJSON.parse(params);
+};
+export class TcbError extends Error {
+    constructor(error) {
+        super(error.message);
+        this.code = error.code;
+        this.message = error.message;
+    }
+}
+export const E = (errObj) => {
+    return new TcbError(errObj);
+};
+export function processReturn(throwOnCode, res) {
+    if (throwOnCode === false) {
+        return res;
+    }
+    throw E(Object.assign({}, res));
+}

package/dist/esm/validate.d.ts

@@ -0,0 +1 @@
+export {};