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

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

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuerySerializer = void 0;
+var query_1 = require("../commands/query");
+var logic_1 = require("../commands/logic");
+var symbol_1 = require("../helper/symbol");
+var type_1 = require("../utils/type");
+var operator_map_1 = require("../operator-map");
+var common_1 = require("./common");
+var QuerySerializer = (function () {
+    function QuerySerializer() {
+    }
+    QuerySerializer.encode = function (query) {
+        var encoder = new QueryEncoder();
+        return encoder.encodeQuery(query);
+    };
+    return QuerySerializer;
+}());
+exports.QuerySerializer = QuerySerializer;
+var QueryEncoder = (function () {
+    function QueryEncoder() {
+    }
+    QueryEncoder.prototype.encodeQuery = function (query, key) {
+        var _a;
+        if ((0, common_1.isConversionRequired)(query)) {
+            if ((0, logic_1.isLogicCommand)(query)) {
+                return this.encodeLogicCommand(query);
+            }
+            else if ((0, query_1.isQueryCommand)(query)) {
+                return this.encodeQueryCommand(query);
+            }
+            else {
+                return _a = {}, _a[key] = this.encodeQueryObject(query), _a;
+            }
+        }
+        else {
+            if ((0, type_1.isObject)(query)) {
+                return this.encodeQueryObject(query);
+            }
+            else {
+                return query;
+            }
+        }
+    };
+    QueryEncoder.prototype.encodeRegExp = function (query) {
+        return {
+            $regex: query.source,
+            $options: query.flags
+        };
+    };
+    QueryEncoder.prototype.encodeLogicCommand = function (query) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        var _this = this;
+        switch (query.operator) {
+            case logic_1.LOGIC_COMMANDS_LITERAL.NOR:
+            case logic_1.LOGIC_COMMANDS_LITERAL.AND:
+            case logic_1.LOGIC_COMMANDS_LITERAL.OR: {
+                var $op = (0, operator_map_1.operatorToString)(query.operator);
+                var subqueries = query.operands.map(function (oprand) {
+                    return _this.encodeQuery(oprand, query.fieldName);
+                });
+                return _a = {},
+                    _a[$op] = subqueries,
+                    _a;
+            }
+            case logic_1.LOGIC_COMMANDS_LITERAL.NOT: {
+                var $op = (0, operator_map_1.operatorToString)(query.operator);
+                var operatorExpression = query.operands[0];
+                if ((0, type_1.isRegExp)(operatorExpression)) {
+                    return _b = {},
+                        _b[query.fieldName] = (_c = {},
+                            _c[$op] = this.encodeRegExp(operatorExpression),
+                            _c),
+                        _b;
+                }
+                else {
+                    var subqueries = this.encodeQuery(operatorExpression)[query.fieldName];
+                    return _d = {},
+                        _d[query.fieldName] = (_e = {},
+                            _e[$op] = subqueries,
+                            _e),
+                        _d;
+                }
+            }
+            default: {
+                var $op = (0, operator_map_1.operatorToString)(query.operator);
+                if (query.operands.length === 1) {
+                    var subquery = this.encodeQuery(query.operands[0]);
+                    return _f = {},
+                        _f[$op] = subquery,
+                        _f;
+                }
+                else {
+                    var subqueries = query.operands.map(this.encodeQuery.bind(this));
+                    return _g = {},
+                        _g[$op] = subqueries,
+                        _g;
+                }
+            }
+        }
+    };
+    QueryEncoder.prototype.encodeQueryCommand = function (query) {
+        if ((0, query_1.isComparisonCommand)(query)) {
+            return this.encodeComparisonCommand(query);
+        }
+        else {
+            return this.encodeComparisonCommand(query);
+        }
+    };
+    QueryEncoder.prototype.encodeComparisonCommand = function (query) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        if (query.fieldName === symbol_1.SYMBOL_UNSET_FIELD_NAME) {
+            throw new Error('Cannot encode a comparison command with unset field name');
+        }
+        var $op = (0, operator_map_1.operatorToString)(query.operator);
+        switch (query.operator) {
+            case query_1.QUERY_COMMANDS_LITERAL.EQ:
+            case query_1.QUERY_COMMANDS_LITERAL.NEQ:
+            case query_1.QUERY_COMMANDS_LITERAL.LT:
+            case query_1.QUERY_COMMANDS_LITERAL.LTE:
+            case query_1.QUERY_COMMANDS_LITERAL.GT:
+            case query_1.QUERY_COMMANDS_LITERAL.GTE:
+            case query_1.QUERY_COMMANDS_LITERAL.ELEM_MATCH:
+            case query_1.QUERY_COMMANDS_LITERAL.EXISTS:
+            case query_1.QUERY_COMMANDS_LITERAL.SIZE:
+            case query_1.QUERY_COMMANDS_LITERAL.MOD: {
+                return _a = {},
+                    _a[query.fieldName] = (_b = {},
+                        _b[$op] = (0, common_1.encodeInternalDataType)(query.operands[0]),
+                        _b),
+                    _a;
+            }
+            case query_1.QUERY_COMMANDS_LITERAL.IN:
+            case query_1.QUERY_COMMANDS_LITERAL.NIN:
+            case query_1.QUERY_COMMANDS_LITERAL.ALL: {
+                return _c = {},
+                    _c[query.fieldName] = (_d = {},
+                        _d[$op] = (0, common_1.encodeInternalDataType)(query.operands),
+                        _d),
+                    _c;
+            }
+            case query_1.QUERY_COMMANDS_LITERAL.GEO_NEAR: {
+                var options = query.operands[0];
+                return _e = {},
+                    _e[query.fieldName] = {
+                        $nearSphere: {
+                            $geometry: options.geometry.toJSON(),
+                            $maxDistance: options.maxDistance,
+                            $minDistance: options.minDistance
+                        }
+                    },
+                    _e;
+            }
+            case query_1.QUERY_COMMANDS_LITERAL.GEO_WITHIN: {
+                var options = query.operands[0];
+                return _f = {},
+                    _f[query.fieldName] = {
+                        $geoWithin: {
+                            $geometry: options.geometry.toJSON()
+                        }
+                    },
+                    _f;
+            }
+            case query_1.QUERY_COMMANDS_LITERAL.GEO_INTERSECTS: {
+                var options = query.operands[0];
+                return _g = {},
+                    _g[query.fieldName] = {
+                        $geoIntersects: {
+                            $geometry: options.geometry.toJSON()
+                        }
+                    },
+                    _g;
+            }
+            default: {
+                return _h = {},
+                    _h[query.fieldName] = (_j = {},
+                        _j[$op] = (0, common_1.encodeInternalDataType)(query.operands[0]),
+                        _j),
+                    _h;
+            }
+        }
+    };
+    QueryEncoder.prototype.encodeQueryObject = function (query) {
+        var flattened = (0, common_1.flattenQueryObject)(query);
+        for (var key in flattened) {
+            var val = flattened[key];
+            if ((0, logic_1.isLogicCommand)(val)) {
+                flattened[key] = val._setFieldName(key);
+                var condition = this.encodeLogicCommand(flattened[key]);
+                this.mergeConditionAfterEncode(flattened, condition, key);
+            }
+            else if ((0, query_1.isComparisonCommand)(val)) {
+                flattened[key] = val._setFieldName(key);
+                var condition = this.encodeComparisonCommand(flattened[key]);
+                this.mergeConditionAfterEncode(flattened, condition, key);
+            }
+            else if ((0, common_1.isConversionRequired)(val)) {
+                flattened[key] = (0, common_1.encodeInternalDataType)(val);
+            }
+        }
+        return flattened;
+    };
+    QueryEncoder.prototype.mergeConditionAfterEncode = function (query, condition, key) {
+        if (!condition[key]) {
+            delete query[key];
+        }
+        for (var conditionKey in condition) {
+            if (query[conditionKey]) {
+                if ((0, type_1.isArray)(query[conditionKey])) {
+                    query[conditionKey] = query[conditionKey].concat(condition[conditionKey]);
+                }
+                else if ((0, type_1.isObject)(query[conditionKey])) {
+                    if ((0, type_1.isObject)(condition[conditionKey])) {
+                        Object.assign(query, condition);
+                    }
+                    else {
+                        console.warn("unmergable condition, query is object but condition is ".concat((0, type_1.getType)(condition), ", can only overwrite"), condition, key);
+                        query[conditionKey] = condition[conditionKey];
+                    }
+                }
+                else {
+                    console.warn("to-merge query is of type ".concat((0, type_1.getType)(query), ", can only overwrite"), query, condition, key);
+                    query[conditionKey] = condition[conditionKey];
+                }
+            }
+            else {
+                query[conditionKey] = condition[conditionKey];
+            }
+        }
+    };
+    return QueryEncoder;
+}());

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

@@ -0,0 +1,15 @@
+import { UpdateCommand } from '../commands/update';
+import { LogicCommand } from '../commands/logic';
+export type IQueryCondition = Record<string, any> | LogicCommand;
+export interface IUpdateCondition {
+    [key: string]: any;
+}
+export declare class UpdateSerializer {
+    private constructor();
+    static encode(query: IQueryCondition | UpdateCommand): IUpdateCondition;
+    encodeUpdate(query: IQueryCondition | UpdateCommand): IUpdateCondition;
+    encodeUpdateCommand(query: UpdateCommand): IQueryCondition;
+    encodeFieldUpdateCommand(query: UpdateCommand): IQueryCondition;
+    encodeArrayUpdateCommand(query: UpdateCommand): IQueryCondition;
+    encodeUpdateObject(query: Record<string, any>): IQueryCondition;
+}

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

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateSerializer = void 0;
+var update_1 = require("../commands/update");
+var symbol_1 = require("../helper/symbol");
+var type_1 = require("../utils/type");
+var operator_map_1 = require("../operator-map");
+var common_1 = require("./common");
+var UpdateSerializer = (function () {
+    function UpdateSerializer() {
+    }
+    UpdateSerializer.encode = function (query) {
+        var stringifier = new UpdateSerializer();
+        return stringifier.encodeUpdate(query);
+    };
+    UpdateSerializer.prototype.encodeUpdate = function (query) {
+        if ((0, update_1.isUpdateCommand)(query)) {
+            return this.encodeUpdateCommand(query);
+        }
+        else if ((0, type_1.getType)(query) === 'object') {
+            return this.encodeUpdateObject(query);
+        }
+        else {
+            return query;
+        }
+    };
+    UpdateSerializer.prototype.encodeUpdateCommand = function (query) {
+        if (query.fieldName === symbol_1.SYMBOL_UNSET_FIELD_NAME) {
+            throw new Error('Cannot encode a comparison command with unset field name');
+        }
+        switch (query.operator) {
+            case update_1.UPDATE_COMMANDS_LITERAL.PUSH:
+            case update_1.UPDATE_COMMANDS_LITERAL.PULL:
+            case update_1.UPDATE_COMMANDS_LITERAL.PULL_ALL:
+            case update_1.UPDATE_COMMANDS_LITERAL.POP:
+            case update_1.UPDATE_COMMANDS_LITERAL.SHIFT:
+            case update_1.UPDATE_COMMANDS_LITERAL.UNSHIFT:
+            case update_1.UPDATE_COMMANDS_LITERAL.ADD_TO_SET: {
+                return this.encodeArrayUpdateCommand(query);
+            }
+            default: {
+                return this.encodeFieldUpdateCommand(query);
+            }
+        }
+    };
+    UpdateSerializer.prototype.encodeFieldUpdateCommand = function (query) {
+        var _a, _b, _c, _d;
+        var $op = (0, operator_map_1.operatorToString)(query.operator);
+        switch (query.operator) {
+            case update_1.UPDATE_COMMANDS_LITERAL.REMOVE: {
+                return _a = {},
+                    _a[$op] = (_b = {},
+                        _b[query.fieldName] = '',
+                        _b),
+                    _a;
+            }
+            default: {
+                return _c = {},
+                    _c[$op] = (_d = {},
+                        _d[query.fieldName] = query.operands[0],
+                        _d),
+                    _c;
+            }
+        }
+    };
+    UpdateSerializer.prototype.encodeArrayUpdateCommand = function (query) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        var $op = (0, operator_map_1.operatorToString)(query.operator);
+        switch (query.operator) {
+            case update_1.UPDATE_COMMANDS_LITERAL.PUSH: {
+                var modifiers = void 0;
+                if ((0, type_1.isArray)(query.operands)) {
+                    modifiers = {
+                        $each: query.operands.map(common_1.encodeInternalDataType)
+                    };
+                }
+                else {
+                    modifiers = query.operands;
+                }
+                return _a = {},
+                    _a[$op] = (_b = {},
+                        _b[query.fieldName] = modifiers,
+                        _b),
+                    _a;
+            }
+            case update_1.UPDATE_COMMANDS_LITERAL.UNSHIFT: {
+                var modifiers = {
+                    $each: query.operands.map(common_1.encodeInternalDataType),
+                    $position: 0
+                };
+                return _c = {},
+                    _c[$op] = (_d = {},
+                        _d[query.fieldName] = modifiers,
+                        _d),
+                    _c;
+            }
+            case update_1.UPDATE_COMMANDS_LITERAL.POP: {
+                return _e = {},
+                    _e[$op] = (_f = {},
+                        _f[query.fieldName] = 1,
+                        _f),
+                    _e;
+            }
+            case update_1.UPDATE_COMMANDS_LITERAL.SHIFT: {
+                return _g = {},
+                    _g[$op] = (_h = {},
+                        _h[query.fieldName] = -1,
+                        _h),
+                    _g;
+            }
+            default: {
+                return _j = {},
+                    _j[$op] = (_k = {},
+                        _k[query.fieldName] = (0, common_1.encodeInternalDataType)(query.operands),
+                        _k),
+                    _j;
+            }
+        }
+    };
+    UpdateSerializer.prototype.encodeUpdateObject = function (query) {
+        var flattened = (0, common_1.flattenQueryObject)(query);
+        for (var key in flattened) {
+            if (/^\$/.test(key))
+                continue;
+            var val = flattened[key];
+            if ((0, update_1.isUpdateCommand)(val)) {
+                flattened[key] = val._setFieldName(key);
+                var condition = this.encodeUpdateCommand(flattened[key]);
+                (0, common_1.mergeConditionAfterEncode)(flattened, condition, key);
+            }
+            else {
+                flattened[key] = val = (0, common_1.encodeInternalDataType)(val);
+                var $setCommand = new update_1.UpdateCommand(update_1.UPDATE_COMMANDS_LITERAL.SET, [val], key);
+                var condition = this.encodeUpdateCommand($setCommand);
+                (0, common_1.mergeConditionAfterEncode)(flattened, condition, key);
+            }
+        }
+        return flattened;
+    };
+    return UpdateSerializer;
+}());
+exports.UpdateSerializer = UpdateSerializer;

package/node_modules/@cloudbase/database/dist/commonjs/serverDate/index.d.ts

@@ -0,0 +1,13 @@
+export declare class ServerDate {
+    readonly offset: number;
+    constructor({ offset }?: {
+        offset?: number;
+    });
+    get _internalType(): import("../utils/symbol").InternalSymbol;
+    parse(): {
+        $date: {
+            offset: number;
+        };
+    };
+}
+export declare function ServerDateConstructor(opt: any): ServerDate;

package/node_modules/@cloudbase/database/dist/commonjs/serverDate/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerDateConstructor = exports.ServerDate = void 0;
+var symbol_1 = require("../helper/symbol");
+var ServerDate = (function () {
+    function ServerDate(_a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.offset, offset = _c === void 0 ? 0 : _c;
+        this.offset = offset;
+    }
+    Object.defineProperty(ServerDate.prototype, "_internalType", {
+        get: function () {
+            return symbol_1.SYMBOL_SERVER_DATE;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ServerDate.prototype.parse = function () {
+        return {
+            $date: {
+                offset: this.offset
+            }
+        };
+    };
+    return ServerDate;
+}());
+exports.ServerDate = ServerDate;
+function ServerDateConstructor(opt) {
+    return new ServerDate(opt);
+}
+exports.ServerDateConstructor = ServerDateConstructor;

package/node_modules/@cloudbase/database/dist/commonjs/transaction/collection.d.ts

@@ -0,0 +1,7 @@
+import { DocumentReference } from './document';
+import { Query } from './query';
+export declare class CollectionReference extends Query {
+    get name(): string;
+    doc(docID?: string | number): DocumentReference;
+    add(data: any): Promise<any>;
+}

package/node_modules/@cloudbase/database/dist/commonjs/transaction/collection.js

@@ -0,0 +1,49 @@
+"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.CollectionReference = void 0;
+var document_1 = require("./document");
+var query_1 = require("./query");
+var CollectionReference = (function (_super) {
+    __extends(CollectionReference, _super);
+    function CollectionReference(transaction, coll) {
+        return _super.call(this, transaction, coll) || this;
+    }
+    Object.defineProperty(CollectionReference.prototype, "name", {
+        get: function () {
+            return this._coll;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CollectionReference.prototype.doc = function (docID) {
+        if (typeof docID !== 'string' && typeof docID !== 'number') {
+            throw new Error('docId必须为字符串或数字');
+        }
+        return new document_1.DocumentReference(this._transaction, this._coll, docID);
+    };
+    CollectionReference.prototype.add = function (data) {
+        var docID;
+        if (data._id !== undefined) {
+            docID = data._id;
+        }
+        var docRef = new document_1.DocumentReference(this._transaction, this._coll, docID);
+        return docRef.create(data);
+    };
+    return CollectionReference;
+}(query_1.Query));
+exports.CollectionReference = CollectionReference;

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

@@ -0,0 +1,27 @@
+interface GetResult {
+    requestId: string;
+    data: any;
+}
+interface UpdateResult {
+    requestId: string;
+    updated: number;
+}
+type JsonString = string;
+interface SetResult extends UpdateResult {
+    upserted: JsonString;
+}
+interface DeleteResult {
+    requestId: string;
+    deleted: number | string;
+}
+export declare class DocumentReference {
+    readonly id: string | number;
+    private _transaction;
+    private _transactionId;
+    create(data: any): Promise<any>;
+    get(): Promise<GetResult>;
+    set(data: Object): Promise<SetResult>;
+    update(data: Object): Promise<UpdateResult>;
+    delete(): Promise<DeleteResult>;
+}
+export {};