@cloudbase/database 1.4.1 → 1.4.2

package/dist/esm/transaction.js

@@ -1,121 +0,0 @@
-import { EJSON } from 'bson';
-import { Db } from './index';
-class DocumentSnapshot {
-    constructor(data, requestId) {
-        this._data = data;
-        this.requestId = requestId;
-    }
-    data() {
-        return this._data;
-    }
-}
-const START = 'database.startTransaction';
-const COMMIT = 'database.commitTransaction';
-const ABORT = 'database.abortTransaction';
-const GET_DOC = 'database.getInTransaction';
-const UPDATE_DOC = 'database.updateDocInTransaction';
-const DELETE_DOC = 'database.deleteDocInTransaction';
-export class Transaction {
-    constructor(db) {
-        this._db = db;
-        this._request = new Db.reqClass(this._db.config);
-    }
-    async init() {
-        const res = await this._request.send(START, {});
-        if (res.code) {
-            throw res;
-        }
-        this._id = res.transactionId;
-    }
-    async get(documentRef) {
-        const param = {
-            collectionName: documentRef._coll,
-            transactionId: this._id,
-            _id: documentRef.id
-        };
-        const res = await this._request.send(GET_DOC, param);
-        if (res.code)
-            throw res;
-        return new DocumentSnapshot(EJSON.parse(res.data), res.requestId);
-    }
-    async set(documentRef, data) {
-        const param = {
-            collectionName: documentRef._coll,
-            transactionId: this._id,
-            _id: documentRef.id,
-            data: EJSON.stringify(data, { relaxed: false }),
-            upsert: true
-        };
-        const res = await this._request.send(UPDATE_DOC, param);
-        if (res.code)
-            throw res;
-        return Object.assign(Object.assign({}, res), { updated: EJSON.parse(res.updated), upserted: res.upserted
-                ? JSON.parse(res.upserted)
-                : null });
-    }
-    async update(documentRef, data) {
-        const param = {
-            collectionName: documentRef._coll,
-            transactionId: this._id,
-            _id: documentRef.id,
-            data: EJSON.stringify({
-                $set: data
-            }, {
-                relaxed: false
-            })
-        };
-        const res = await this._request.send(UPDATE_DOC, param);
-        if (res.code)
-            throw res;
-        return Object.assign(Object.assign({}, res), { updated: EJSON.parse(res.updated) });
-    }
-    async delete(documentRef) {
-        const param = {
-            collectionName: documentRef._coll,
-            transactionId: this._id,
-            _id: documentRef.id
-        };
-        const res = await this._request.send(DELETE_DOC, param);
-        if (res.code)
-            throw res;
-        return Object.assign(Object.assign({}, res), { deleted: EJSON.parse(res.deleted) });
-    }
-    async commit() {
-        const param = {
-            transactionId: this._id
-        };
-        const res = await this._request.send(COMMIT, param);
-        if (res.code)
-            throw res;
-        return res;
-    }
-    async rollback() {
-        const param = {
-            transactionId: this._id
-        };
-        const res = await this._request.send(ABORT, param);
-        if (res.code)
-            throw res;
-        return res;
-    }
-}
-export async function startTransaction() {
-    const transaction = new Transaction(this);
-    await transaction.init();
-    return transaction;
-}
-export async function runTransaction(callback, times = 3) {
-    if (times <= 0) {
-        throw new Error('Transaction failed');
-    }
-    try {
-        const transaction = new Transaction(this);
-        await transaction.init();
-        await callback(transaction);
-        await transaction.commit();
-    }
-    catch (error) {
-        console.log(error);
-        return runTransaction.bind(this)(callback, --times);
-    }
-}

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

@@ -1,45 +0,0 @@
-import { Point } from '../geo/index';
-export declare type DataType = 'init' | 'update' | 'add' | 'remove' | 'replace' | 'limit';
-export declare type QueueType = 'init' | 'enqueue' | 'dequeue' | 'update';
-export interface IDatabaseServiceContext extends IServiceContext {
-    appConfig: IAppConfig;
-    ws?: any;
-}
-export interface IAppConfig {
-    docSizeLimit: number;
-    realtimePingInterval: number;
-    realtimePongWaitTimeout: number;
-    request: any;
-}
-export interface IWatchOptions {
-    onChange: (snapshot: ISnapshot) => void;
-    onError: (error: any) => void;
-}
-export interface ISnapshot {
-    id: number;
-    docChanges: ISingleDBEvent[];
-    docs: Record<string, any>;
-    type?: SnapshotType;
-}
-export interface ISingleDBEvent {
-    id: number;
-    dataType: DataType;
-    queueType: QueueType;
-    docId: string;
-    doc: Record<string, any>;
-    updatedFields?: any;
-    removedFields?: any;
-}
-export declare type SnapshotType = 'init';
-export interface DBRealtimeListener {
-    close: () => void;
-}
-export interface IRealtimeListenerConstructorOptions extends IWatchOptions {
-}
-export interface IServiceContext {
-    env?: string;
-}
-export interface IReqOpts {
-    timeout: number;
-}
-export declare type CenterSphere = [Point, number] | [[number, number], number];

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

@@ -1,219 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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;
-};