@cloudbase/js-sdk 2.28.8 → 2.30.0

package/database/dist/esm/commands/query.js

@@ -0,0 +1,154 @@
+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 __());
+    };
+})();
+import { LogicCommand } from './logic';
+import { SYMBOL_QUERY_COMMAND } from '../helper/symbol';
+import { Point, LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon } from '../geo/index';
+import { isNumber } from '../utils/type';
+export var EQ = 'eq';
+export var NEQ = 'neq';
+export var GT = 'gt';
+export var GTE = 'gte';
+export var LT = 'lt';
+export var LTE = 'lte';
+export var IN = 'in';
+export var NIN = 'nin';
+export var ALL = 'all';
+export var ELEM_MATCH = 'elemMatch';
+export var EXISTS = 'exists';
+export var SIZE = 'size';
+export var MOD = 'mod';
+export 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 || (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_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 Point)) {
+            throw new TypeError("\"geometry\" must be of type Point. Received type ".concat(typeof val.geometry));
+        }
+        if (val.maxDistance !== undefined && !isNumber(val.maxDistance)) {
+            throw new TypeError("\"maxDistance\" must be of type Number. Received type ".concat(typeof val.maxDistance));
+        }
+        if (val.minDistance !== undefined && !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 MultiPolygon) && !(val.geometry instanceof 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 Point) &&
+            !(val.geometry instanceof LineString) &&
+            !(val.geometry instanceof Polygon) &&
+            !(val.geometry instanceof MultiPoint) &&
+            !(val.geometry instanceof MultiLineString) &&
+            !(val.geometry instanceof 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;
+}(LogicCommand));
+export { QueryCommand };
+export function isQueryCommand(object) {
+    return object && object instanceof QueryCommand && object._internalType === SYMBOL_QUERY_COMMAND;
+}
+export function isKnownQueryCommand(object) {
+    return isQueryCommand(object) && object.operator.toUpperCase() in QUERY_COMMANDS_LITERAL;
+}
+export function isComparisonCommand(object) {
+    return isQueryCommand(object);
+}
+export default QueryCommand;

package/database/dist/esm/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/database/dist/esm/commands/update.js

@@ -0,0 +1,46 @@
+import { SYMBOL_UNSET_FIELD_NAME, SYMBOL_UPDATE_COMMAND } from '../helper/symbol';
+export 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 || (UPDATE_COMMANDS_LITERAL = {}));
+var UpdateCommand = (function () {
+    function UpdateCommand(operator, operands, fieldName) {
+        this._internalType = SYMBOL_UPDATE_COMMAND;
+        Object.defineProperties(this, {
+            _internalType: {
+                enumerable: false,
+                configurable: false,
+            },
+        });
+        this.operator = operator;
+        this.operands = operands;
+        this.fieldName = fieldName || SYMBOL_UNSET_FIELD_NAME;
+    }
+    UpdateCommand.prototype._setFieldName = function (fieldName) {
+        var command = new UpdateCommand(this.operator, this.operands, fieldName);
+        return command;
+    };
+    return UpdateCommand;
+}());
+export { UpdateCommand };
+export function isUpdateCommand(object) {
+    return object && (object instanceof UpdateCommand) && (object._internalType === SYMBOL_UPDATE_COMMAND);
+}
+export function isKnownUpdateCommand(object) {
+    return isUpdateCommand(object) && (object.operator.toUpperCase() in UPDATE_COMMANDS_LITERAL);
+}
+export default UpdateCommand;

package/database/dist/esm/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/database/dist/esm/config/app.config.js

@@ -0,0 +1,5 @@
+export default {
+    db_doc_size_limit: 512 * 1024,
+    db_realtime_ping_interval: 15 * 1000,
+    db_realtime_pong_wait_timeout: 15 * 1000,
+};

package/database/dist/esm/config/error.config.d.ts

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

package/database/dist/esm/config/error.config.js

@@ -0,0 +1,13 @@
+export var 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/database/dist/esm/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/database/dist/esm/const/code.js

@@ -0,0 +1,30 @@
+export var 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/database/dist/esm/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/database/dist/esm/constant.js

@@ -0,0 +1,65 @@
+var _a;
+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 = {}));
+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'
+};
+var OrderDirectionList = ['desc', 'asc'];
+var WhereFilterOpList = ['<', '<=', '==', '>=', '>'];
+var Opeartor;
+(function (Opeartor) {
+    Opeartor["lt"] = "<";
+    Opeartor["gt"] = ">";
+    Opeartor["lte"] = "<=";
+    Opeartor["gte"] = ">=";
+    Opeartor["eq"] = "==";
+})(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);
+var UpdateOperatorList = [
+    '$set',
+    '$inc',
+    '$mul',
+    '$unset',
+    '$push',
+    '$pop',
+    '$unshift',
+    '$shift',
+    '$currentDate',
+    '$each',
+    '$position'
+];
+var QueryType;
+(function (QueryType) {
+    QueryType["WHERE"] = "WHERE";
+    QueryType["DOC"] = "DOC";
+})(QueryType || (QueryType = {}));
+export { ErrorCode, FieldType, WhereFilterOpList, Opeartor, OperatorMap, OrderDirectionList, UpdateOperatorList, QueryType };

package/database/dist/esm/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;
+}