@cloudbase/js-sdk 3.3.14-beta.3 → 3.3.14-beta.4

package/node_modules/@cloudbase/database/dist/commonjs/commands/query.d.ts

@@ -0,0 +1,68 @@
+import { LogicCommand } from './logic';
+import { InternalSymbol } from '../helper/symbol';
+import { Point, LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon } from '../geo/index';
+export declare const EQ = "eq";
+export declare const NEQ = "neq";
+export declare const GT = "gt";
+export declare const GTE = "gte";
+export declare const LT = "lt";
+export declare const LTE = "lte";
+export declare const IN = "in";
+export declare const NIN = "nin";
+export declare const ALL = "all";
+export declare const ELEM_MATCH = "elemMatch";
+export declare const EXISTS = "exists";
+export declare const SIZE = "size";
+export declare const MOD = "mod";
+export declare enum QUERY_COMMANDS_LITERAL {
+    EQ = "eq",
+    NEQ = "neq",
+    GT = "gt",
+    GTE = "gte",
+    LT = "lt",
+    LTE = "lte",
+    IN = "in",
+    NIN = "nin",
+    ALL = "all",
+    ELEM_MATCH = "elemMatch",
+    EXISTS = "exists",
+    SIZE = "size",
+    MOD = "mod",
+    GEO_NEAR = "geoNear",
+    GEO_WITHIN = "geoWithin",
+    GEO_INTERSECTS = "geoIntersects"
+}
+export declare class QueryCommand extends LogicCommand {
+    operator: QUERY_COMMANDS_LITERAL;
+    constructor(operator: QUERY_COMMANDS_LITERAL, operands: any, fieldName?: string | InternalSymbol);
+    toJSON(): {
+        [x: string]: any;
+    };
+    _setFieldName(fieldName: string): QueryCommand;
+    eq(val: any): LogicCommand;
+    neq(val: any): LogicCommand;
+    gt(val: any): LogicCommand;
+    gte(val: any): LogicCommand;
+    lt(val: any): LogicCommand;
+    lte(val: any): LogicCommand;
+    in(list: any[]): LogicCommand;
+    nin(list: any[]): LogicCommand;
+    geoNear(val: IGeoNearOptions): LogicCommand;
+    geoWithin(val: IGeoWithinOptions): LogicCommand;
+    geoIntersects(val: IGeoIntersectsOptions): LogicCommand;
+}
+export declare function isQueryCommand(object: any): object is QueryCommand;
+export declare function isKnownQueryCommand(object: any): object is QueryCommand;
+export declare function isComparisonCommand(object: any): object is QueryCommand;
+export default QueryCommand;
+export interface IGeoNearOptions {
+    geometry: Point;
+    maxDistance?: number;
+    minDistance?: number;
+}
+export interface IGeoWithinOptions {
+    geometry: Polygon | MultiPolygon;
+}
+export interface IGeoIntersectsOptions {
+    geometry: Point | LineString | Polygon | MultiPoint | MultiLineString | MultiPolygon;
+}

package/node_modules/@cloudbase/database/dist/commonjs/commands/query.js

@@ -0,0 +1,160 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isComparisonCommand = exports.isKnownQueryCommand = exports.isQueryCommand = exports.QueryCommand = exports.QUERY_COMMANDS_LITERAL = exports.MOD = exports.SIZE = exports.EXISTS = exports.ELEM_MATCH = exports.ALL = exports.NIN = exports.IN = exports.LTE = exports.LT = exports.GTE = exports.GT = exports.NEQ = exports.EQ = void 0;
+var logic_1 = require("./logic");
+var symbol_1 = require("../helper/symbol");
+var index_1 = require("../geo/index");
+var type_1 = require("../utils/type");
+exports.EQ = 'eq';
+exports.NEQ = 'neq';
+exports.GT = 'gt';
+exports.GTE = 'gte';
+exports.LT = 'lt';
+exports.LTE = 'lte';
+exports.IN = 'in';
+exports.NIN = 'nin';
+exports.ALL = 'all';
+exports.ELEM_MATCH = 'elemMatch';
+exports.EXISTS = 'exists';
+exports.SIZE = 'size';
+exports.MOD = 'mod';
+var QUERY_COMMANDS_LITERAL;
+(function (QUERY_COMMANDS_LITERAL) {
+    QUERY_COMMANDS_LITERAL["EQ"] = "eq";
+    QUERY_COMMANDS_LITERAL["NEQ"] = "neq";
+    QUERY_COMMANDS_LITERAL["GT"] = "gt";
+    QUERY_COMMANDS_LITERAL["GTE"] = "gte";
+    QUERY_COMMANDS_LITERAL["LT"] = "lt";
+    QUERY_COMMANDS_LITERAL["LTE"] = "lte";
+    QUERY_COMMANDS_LITERAL["IN"] = "in";
+    QUERY_COMMANDS_LITERAL["NIN"] = "nin";
+    QUERY_COMMANDS_LITERAL["ALL"] = "all";
+    QUERY_COMMANDS_LITERAL["ELEM_MATCH"] = "elemMatch";
+    QUERY_COMMANDS_LITERAL["EXISTS"] = "exists";
+    QUERY_COMMANDS_LITERAL["SIZE"] = "size";
+    QUERY_COMMANDS_LITERAL["MOD"] = "mod";
+    QUERY_COMMANDS_LITERAL["GEO_NEAR"] = "geoNear";
+    QUERY_COMMANDS_LITERAL["GEO_WITHIN"] = "geoWithin";
+    QUERY_COMMANDS_LITERAL["GEO_INTERSECTS"] = "geoIntersects";
+})(QUERY_COMMANDS_LITERAL = exports.QUERY_COMMANDS_LITERAL || (exports.QUERY_COMMANDS_LITERAL = {}));
+var QueryCommand = (function (_super) {
+    __extends(QueryCommand, _super);
+    function QueryCommand(operator, operands, fieldName) {
+        var _this = _super.call(this, operator, operands, fieldName) || this;
+        _this.operator = operator;
+        _this._internalType = symbol_1.SYMBOL_QUERY_COMMAND;
+        return _this;
+    }
+    QueryCommand.prototype.toJSON = function () {
+        var _a, _b;
+        switch (this.operator) {
+            case QUERY_COMMANDS_LITERAL.IN:
+            case QUERY_COMMANDS_LITERAL.NIN:
+                return _a = {},
+                    _a['$' + this.operator] = this.operands,
+                    _a;
+            default:
+                return _b = {},
+                    _b['$' + this.operator] = this.operands[0],
+                    _b;
+        }
+    };
+    QueryCommand.prototype._setFieldName = function (fieldName) {
+        var command = new QueryCommand(this.operator, this.operands, fieldName);
+        return command;
+    };
+    QueryCommand.prototype.eq = function (val) {
+        var command = new QueryCommand(QUERY_COMMANDS_LITERAL.EQ, [val], this.fieldName);
+        return this.and(command);
+    };
+    QueryCommand.prototype.neq = function (val) {
+        var command = new QueryCommand(QUERY_COMMANDS_LITERAL.NEQ, [val], this.fieldName);
+        return this.and(command);
+    };
+    QueryCommand.prototype.gt = function (val) {
+        var command = new QueryCommand(QUERY_COMMANDS_LITERAL.GT, [val], this.fieldName);
+        return this.and(command);
+    };
+    QueryCommand.prototype.gte = function (val) {
+        var command = new QueryCommand(QUERY_COMMANDS_LITERAL.GTE, [val], this.fieldName);
+        return this.and(command);
+    };
+    QueryCommand.prototype.lt = function (val) {
+        var command = new QueryCommand(QUERY_COMMANDS_LITERAL.LT, [val], this.fieldName);
+        return this.and(command);
+    };
+    QueryCommand.prototype.lte = function (val) {
+        var command = new QueryCommand(QUERY_COMMANDS_LITERAL.LTE, [val], this.fieldName);
+        return this.and(command);
+    };
+    QueryCommand.prototype.in = function (list) {
+        var command = new QueryCommand(QUERY_COMMANDS_LITERAL.IN, list, this.fieldName);
+        return this.and(command);
+    };
+    QueryCommand.prototype.nin = function (list) {
+        var command = new QueryCommand(QUERY_COMMANDS_LITERAL.NIN, list, this.fieldName);
+        return this.and(command);
+    };
+    QueryCommand.prototype.geoNear = function (val) {
+        if (!(val.geometry instanceof index_1.Point)) {
+            throw new TypeError("\"geometry\" must be of type Point. Received type ".concat(typeof val.geometry));
+        }
+        if (val.maxDistance !== undefined && !(0, type_1.isNumber)(val.maxDistance)) {
+            throw new TypeError("\"maxDistance\" must be of type Number. Received type ".concat(typeof val.maxDistance));
+        }
+        if (val.minDistance !== undefined && !(0, type_1.isNumber)(val.minDistance)) {
+            throw new TypeError("\"minDistance\" must be of type Number. Received type ".concat(typeof val.minDistance));
+        }
+        var command = new QueryCommand(QUERY_COMMANDS_LITERAL.GEO_NEAR, [val], this.fieldName);
+        return this.and(command);
+    };
+    QueryCommand.prototype.geoWithin = function (val) {
+        if (!(val.geometry instanceof index_1.MultiPolygon) && !(val.geometry instanceof index_1.Polygon)) {
+            throw new TypeError("\"geometry\" must be of type Polygon or MultiPolygon. Received type ".concat(typeof val.geometry));
+        }
+        var command = new QueryCommand(QUERY_COMMANDS_LITERAL.GEO_WITHIN, [val], this.fieldName);
+        return this.and(command);
+    };
+    QueryCommand.prototype.geoIntersects = function (val) {
+        if (!(val.geometry instanceof index_1.Point) &&
+            !(val.geometry instanceof index_1.LineString) &&
+            !(val.geometry instanceof index_1.Polygon) &&
+            !(val.geometry instanceof index_1.MultiPoint) &&
+            !(val.geometry instanceof index_1.MultiLineString) &&
+            !(val.geometry instanceof index_1.MultiPolygon)) {
+            throw new TypeError("\"geometry\" must be of type Point, LineString, Polygon, MultiPoint, MultiLineString or MultiPolygon. Received type ".concat(typeof val.geometry));
+        }
+        var command = new QueryCommand(QUERY_COMMANDS_LITERAL.GEO_INTERSECTS, [val], this.fieldName);
+        return this.and(command);
+    };
+    return QueryCommand;
+}(logic_1.LogicCommand));
+exports.QueryCommand = QueryCommand;
+function isQueryCommand(object) {
+    return object && object instanceof QueryCommand && object._internalType === symbol_1.SYMBOL_QUERY_COMMAND;
+}
+exports.isQueryCommand = isQueryCommand;
+function isKnownQueryCommand(object) {
+    return isQueryCommand(object) && object.operator.toUpperCase() in QUERY_COMMANDS_LITERAL;
+}
+exports.isKnownQueryCommand = isKnownQueryCommand;
+function isComparisonCommand(object) {
+    return isQueryCommand(object);
+}
+exports.isComparisonCommand = isComparisonCommand;
+exports.default = QueryCommand;

package/node_modules/@cloudbase/database/dist/commonjs/commands/update.d.ts

@@ -0,0 +1,29 @@
+import { InternalSymbol } from '../helper/symbol';
+export declare enum UPDATE_COMMANDS_LITERAL {
+    SET = "set",
+    REMOVE = "remove",
+    INC = "inc",
+    MUL = "mul",
+    PUSH = "push",
+    PULL = "pull",
+    PULL_ALL = "pullAll",
+    POP = "pop",
+    SHIFT = "shift",
+    UNSHIFT = "unshift",
+    ADD_TO_SET = "addToSet",
+    BIT = "bit",
+    RENAME = "rename",
+    MAX = "max",
+    MIN = "min"
+}
+export declare class UpdateCommand {
+    fieldName: string | InternalSymbol;
+    operator: UPDATE_COMMANDS_LITERAL;
+    operands: any;
+    _internalType: InternalSymbol;
+    constructor(operator: UPDATE_COMMANDS_LITERAL, operands?: any, fieldName?: string | InternalSymbol);
+    _setFieldName(fieldName: string): UpdateCommand;
+}
+export declare function isUpdateCommand(object: any): object is UpdateCommand;
+export declare function isKnownUpdateCommand(object: any): object is UpdateCommand;
+export default UpdateCommand;

package/node_modules/@cloudbase/database/dist/commonjs/commands/update.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isKnownUpdateCommand = exports.isUpdateCommand = exports.UpdateCommand = exports.UPDATE_COMMANDS_LITERAL = void 0;
+var symbol_1 = require("../helper/symbol");
+var UPDATE_COMMANDS_LITERAL;
+(function (UPDATE_COMMANDS_LITERAL) {
+    UPDATE_COMMANDS_LITERAL["SET"] = "set";
+    UPDATE_COMMANDS_LITERAL["REMOVE"] = "remove";
+    UPDATE_COMMANDS_LITERAL["INC"] = "inc";
+    UPDATE_COMMANDS_LITERAL["MUL"] = "mul";
+    UPDATE_COMMANDS_LITERAL["PUSH"] = "push";
+    UPDATE_COMMANDS_LITERAL["PULL"] = "pull";
+    UPDATE_COMMANDS_LITERAL["PULL_ALL"] = "pullAll";
+    UPDATE_COMMANDS_LITERAL["POP"] = "pop";
+    UPDATE_COMMANDS_LITERAL["SHIFT"] = "shift";
+    UPDATE_COMMANDS_LITERAL["UNSHIFT"] = "unshift";
+    UPDATE_COMMANDS_LITERAL["ADD_TO_SET"] = "addToSet";
+    UPDATE_COMMANDS_LITERAL["BIT"] = "bit";
+    UPDATE_COMMANDS_LITERAL["RENAME"] = "rename";
+    UPDATE_COMMANDS_LITERAL["MAX"] = "max";
+    UPDATE_COMMANDS_LITERAL["MIN"] = "min";
+})(UPDATE_COMMANDS_LITERAL = exports.UPDATE_COMMANDS_LITERAL || (exports.UPDATE_COMMANDS_LITERAL = {}));
+var UpdateCommand = (function () {
+    function UpdateCommand(operator, operands, fieldName) {
+        this._internalType = symbol_1.SYMBOL_UPDATE_COMMAND;
+        Object.defineProperties(this, {
+            _internalType: {
+                enumerable: false,
+                configurable: false,
+            },
+        });
+        this.operator = operator;
+        this.operands = operands;
+        this.fieldName = fieldName || symbol_1.SYMBOL_UNSET_FIELD_NAME;
+    }
+    UpdateCommand.prototype._setFieldName = function (fieldName) {
+        var command = new UpdateCommand(this.operator, this.operands, fieldName);
+        return command;
+    };
+    return UpdateCommand;
+}());
+exports.UpdateCommand = UpdateCommand;
+function isUpdateCommand(object) {
+    return object && (object instanceof UpdateCommand) && (object._internalType === symbol_1.SYMBOL_UPDATE_COMMAND);
+}
+exports.isUpdateCommand = isUpdateCommand;
+function isKnownUpdateCommand(object) {
+    return isUpdateCommand(object) && (object.operator.toUpperCase() in UPDATE_COMMANDS_LITERAL);
+}
+exports.isKnownUpdateCommand = isKnownUpdateCommand;
+exports.default = UpdateCommand;

package/node_modules/@cloudbase/database/dist/commonjs/config/app.config.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    db_doc_size_limit: number;
+    db_realtime_ping_interval: number;
+    db_realtime_pong_wait_timeout: number;
+};
+export default _default;

package/node_modules/@cloudbase/database/dist/commonjs/config/app.config.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    db_doc_size_limit: 512 * 1024,
+    db_realtime_ping_interval: 15 * 1000,
+    db_realtime_pong_wait_timeout: 15 * 1000,
+};

package/node_modules/@cloudbase/database/dist/commonjs/config/error.config.d.ts

@@ -0,0 +1,3 @@
+export declare const ERR_CODE: {
+    [key: string]: string | number;
+};

package/node_modules/@cloudbase/database/dist/commonjs/config/error.config.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERR_CODE = void 0;
+exports.ERR_CODE = {
+    UNKNOWN_ERROR: 'UNKNOWN_ERROR',
+    SDK_DATABASE_REALTIME_LISTENER_INIT_WATCH_FAIL: 'SDK_DATABASE_REALTIME_LISTENER_INIT_WATCH_FAIL',
+    SDK_DATABASE_REALTIME_LISTENER_RECONNECT_WATCH_FAIL: 'SDK_DATABASE_REALTIME_LISTENER_RECONNECT_WATCH_FAIL',
+    SDK_DATABASE_REALTIME_LISTENER_REBUILD_WATCH_FAIL: 'SDK_DATABASE_REALTIME_LISTENER_REBUILD_WATCH_FAIL',
+    SDK_DATABASE_REALTIME_LISTENER_CLOSE_WATCH_FAIL: 'SDK_DATABASE_REALTIME_LISTENER_CLOSE_WATCH_FAIL',
+    SDK_DATABASE_REALTIME_LISTENER_SERVER_ERROR_MSG: 'SDK_DATABASE_REALTIME_LISTENER_SERVER_ERROR_MSG',
+    SDK_DATABASE_REALTIME_LISTENER_RECEIVE_INVALID_SERVER_DATA: 'SDK_DATABASE_REALTIME_LISTENER_RECEIVE_INVALID_SERVER_DATA',
+    SDK_DATABASE_REALTIME_LISTENER_WEBSOCKET_CONNECTION_ERROR: 'SDK_DATABASE_REALTIME_LISTENER_WEBSOCKET_CONNECTION_ERROR',
+    SDK_DATABASE_REALTIME_LISTENER_WEBSOCKET_CONNECTION_CLOSED: 'SDK_DATABASE_REALTIME_LISTENER_WEBSOCKET_CONNECTION_CLOSED',
+    SDK_DATABASE_REALTIME_LISTENER_CHECK_LAST_FAIL: 'SDK_DATABASE_REALTIME_LISTENER_CHECK_LAST_FAIL',
+    SDK_DATABASE_REALTIME_LISTENER_UNEXPECTED_FATAL_ERROR: 'SDK_DATABASE_REALTIME_LISTENER_UNEXPECTED_FATAL_ERROR'
+};

package/node_modules/@cloudbase/database/dist/commonjs/const/code.d.ts

@@ -0,0 +1,30 @@
+export declare const ERRORS: {
+    CREATE_WATCH_NET_ERROR: {
+        code: string;
+        message: string;
+    };
+    CREATE_WACTH_EXCEED_ERROR: {
+        code: string;
+        message: string;
+    };
+    CREATE_WATCH_SERVER_ERROR: {
+        code: string;
+        message: string;
+    };
+    CONN_ERROR: {
+        code: string;
+        message: string;
+    };
+    INVALID_PARAM: {
+        code: string;
+        message: string;
+    };
+    INSERT_DOC_FAIL: {
+        code: string;
+        message: string;
+    };
+    DATABASE_TRANSACTION_CONFLICT: {
+        code: string;
+        message: string;
+    };
+};

package/node_modules/@cloudbase/database/dist/commonjs/const/code.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERRORS = void 0;
+exports.ERRORS = {
+    CREATE_WATCH_NET_ERROR: {
+        code: 'CREATE_WATCH_NET_ERROR',
+        message: 'create watch network error'
+    },
+    CREATE_WACTH_EXCEED_ERROR: {
+        code: 'CREATE_WACTH_EXCEED_ERROR',
+        message: 'maximum connections exceed'
+    },
+    CREATE_WATCH_SERVER_ERROR: {
+        code: 'CREATE_WATCH_SERVER_ERROR',
+        message: 'create watch server error'
+    },
+    CONN_ERROR: {
+        code: 'CONN_ERROR',
+        message: 'connection error'
+    },
+    INVALID_PARAM: {
+        code: 'INVALID_PARAM',
+        message: 'Invalid request param'
+    },
+    INSERT_DOC_FAIL: {
+        code: 'INSERT_DOC_FAIL',
+        message: 'insert document failed'
+    },
+    DATABASE_TRANSACTION_CONFLICT: {
+        code: 'DATABASE_TRANSACTION_CONFLICT',
+        message: 'database transaction conflict'
+    }
+};

package/node_modules/@cloudbase/database/dist/commonjs/constant.d.ts

@@ -0,0 +1,51 @@
+declare enum ErrorCode {
+    DocIDError = "\u6587\u6863ID\u4E0D\u5408\u6CD5",
+    CollNameError = "\u96C6\u5408\u540D\u79F0\u4E0D\u5408\u6CD5",
+    OpStrError = "\u64CD\u4F5C\u7B26\u4E0D\u5408\u6CD5",
+    DirectionError = "\u6392\u5E8F\u5B57\u7B26\u4E0D\u5408\u6CD5",
+    IntergerError = "must be integer",
+    QueryParamTypeError = "\u67E5\u8BE2\u53C2\u6570\u5FC5\u987B\u4E3A\u5BF9\u8C61",
+    QueryParamValueError = "\u67E5\u8BE2\u53C2\u6570\u5BF9\u8C61\u503C\u4E0D\u80FD\u5747\u4E3Aundefined"
+}
+declare const FieldType: {
+    String: string;
+    Number: string;
+    Object: string;
+    Array: string;
+    Boolean: string;
+    Null: string;
+    GeoPoint: string;
+    GeoLineString: string;
+    GeoPolygon: string;
+    GeoMultiPoint: string;
+    GeoMultiLineString: string;
+    GeoMultiPolygon: string;
+    Timestamp: string;
+    Command: string;
+    ServerDate: string;
+    BsonDate: string;
+};
+type OrderByDirection = 'desc' | 'asc';
+declare const OrderDirectionList: string[];
+type WhereFilterOp = '<' | '<=' | '==' | '>=' | '>';
+declare const WhereFilterOpList: string[];
+declare enum Opeartor {
+    lt = "<",
+    gt = ">",
+    lte = "<=",
+    gte = ">=",
+    eq = "=="
+}
+declare const OperatorMap: {
+    "==": string;
+    "<": string;
+    "<=": string;
+    ">": string;
+    ">=": string;
+};
+declare const UpdateOperatorList: string[];
+declare enum QueryType {
+    WHERE = "WHERE",
+    DOC = "DOC"
+}
+export { ErrorCode, FieldType, WhereFilterOp, WhereFilterOpList, Opeartor, OperatorMap, OrderByDirection, OrderDirectionList, UpdateOperatorList, QueryType };

package/node_modules/@cloudbase/database/dist/commonjs/constant.js

@@ -0,0 +1,75 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryType = exports.UpdateOperatorList = exports.OrderDirectionList = exports.OperatorMap = exports.Opeartor = exports.WhereFilterOpList = exports.FieldType = exports.ErrorCode = void 0;
+var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode["DocIDError"] = "\u6587\u6863ID\u4E0D\u5408\u6CD5";
+    ErrorCode["CollNameError"] = "\u96C6\u5408\u540D\u79F0\u4E0D\u5408\u6CD5";
+    ErrorCode["OpStrError"] = "\u64CD\u4F5C\u7B26\u4E0D\u5408\u6CD5";
+    ErrorCode["DirectionError"] = "\u6392\u5E8F\u5B57\u7B26\u4E0D\u5408\u6CD5";
+    ErrorCode["IntergerError"] = "must be integer";
+    ErrorCode["QueryParamTypeError"] = "\u67E5\u8BE2\u53C2\u6570\u5FC5\u987B\u4E3A\u5BF9\u8C61";
+    ErrorCode["QueryParamValueError"] = "\u67E5\u8BE2\u53C2\u6570\u5BF9\u8C61\u503C\u4E0D\u80FD\u5747\u4E3Aundefined";
+})(ErrorCode || (ErrorCode = {}));
+exports.ErrorCode = ErrorCode;
+var FieldType = {
+    String: 'String',
+    Number: 'Number',
+    Object: 'Object',
+    Array: 'Array',
+    Boolean: 'Boolean',
+    Null: 'Null',
+    GeoPoint: 'GeoPoint',
+    GeoLineString: 'GeoLineString',
+    GeoPolygon: 'GeoPolygon',
+    GeoMultiPoint: 'GeoMultiPoint',
+    GeoMultiLineString: 'GeoMultiLineString',
+    GeoMultiPolygon: 'GeoMultiPolygon',
+    Timestamp: 'Date',
+    Command: 'Command',
+    ServerDate: 'ServerDate',
+    BsonDate: 'BsonDate'
+};
+exports.FieldType = FieldType;
+var OrderDirectionList = ['desc', 'asc'];
+exports.OrderDirectionList = OrderDirectionList;
+var WhereFilterOpList = ['<', '<=', '==', '>=', '>'];
+exports.WhereFilterOpList = WhereFilterOpList;
+var Opeartor;
+(function (Opeartor) {
+    Opeartor["lt"] = "<";
+    Opeartor["gt"] = ">";
+    Opeartor["lte"] = "<=";
+    Opeartor["gte"] = ">=";
+    Opeartor["eq"] = "==";
+})(Opeartor || (Opeartor = {}));
+exports.Opeartor = Opeartor;
+var OperatorMap = (_a = {},
+    _a[Opeartor.eq] = '$eq',
+    _a[Opeartor.lt] = '$lt',
+    _a[Opeartor.lte] = '$lte',
+    _a[Opeartor.gt] = '$gt',
+    _a[Opeartor.gte] = '$gte',
+    _a);
+exports.OperatorMap = OperatorMap;
+var UpdateOperatorList = [
+    '$set',
+    '$inc',
+    '$mul',
+    '$unset',
+    '$push',
+    '$pop',
+    '$unshift',
+    '$shift',
+    '$currentDate',
+    '$each',
+    '$position'
+];
+exports.UpdateOperatorList = UpdateOperatorList;
+var QueryType;
+(function (QueryType) {
+    QueryType["WHERE"] = "WHERE";
+    QueryType["DOC"] = "DOC";
+})(QueryType || (QueryType = {}));
+exports.QueryType = QueryType;

package/node_modules/@cloudbase/database/dist/commonjs/document.d.ts

@@ -0,0 +1,11 @@
+import { IWatchOptions, DBRealtimeListener } from './typings/index';
+export declare class DocumentReference {
+    readonly id: string | number;
+    readonly projection: Object;
+    set(data: Object, callback?: any): Promise<any>;
+    update(data: Object, callback?: any): any;
+    remove(callback?: any): Promise<any>;
+    get(callback?: any): Promise<any>;
+    field(projection: Object): DocumentReference;
+    watch: (options: IWatchOptions) => DBRealtimeListener;
+}