@cloudbase/database 1.4.3 → 1.5.0

package/dist/commonjs/serializer/query.js

@@ -1,121 +1,130 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const query_1 = require("../commands/query");
-const logic_1 = require("../commands/logic");
-const symbol_1 = require("../helper/symbol");
-const type_1 = require("../utils/type");
-const operator_map_1 = require("../operator-map");
-const common_1 = require("./common");
-const utils_1 = require("../utils/utils");
-const validate_1 = require("../validate");
-class QuerySerializer {
-    constructor() { }
-    static encode(query) {
-        const encoder = new QueryEncoder();
-        return encoder.encodeQuery(query);
-    }
-    static encodeEJSON(query, raw) {
-        const encoder = new QueryEncoder();
-        return utils_1.stringifyByEJSON(raw ? query : encoder.encodeQuery(query));
+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 utils_1 = require("../utils/utils");
+var validate_1 = require("../validate");
+var QuerySerializer = (function () {
+    function QuerySerializer() {
     }
-}
+    QuerySerializer.encode = function (query) {
+        var encoder = new QueryEncoder();
+        return encoder.encodeQuery(query);
+    };
+    QuerySerializer.encodeEJSON = function (query, raw) {
+        var encoder = new QueryEncoder();
+        return (0, utils_1.stringifyByEJSON)(raw ? query : encoder.encodeQuery(query));
+    };
+    return QuerySerializer;
+}());
 exports.QuerySerializer = QuerySerializer;
-class QueryEncoder {
-    encodeQuery(query, key) {
-        if (common_1.isConversionRequired(query)) {
-            if (logic_1.isLogicCommand(query)) {
+var QueryEncoder = (function () {
+    function QueryEncoder() {
+    }
+    QueryEncoder.prototype.encodeQuery = function (query, key) {
+        var _a, _b, _c;
+        if ((0, common_1.isConversionRequired)(query)) {
+            if ((0, logic_1.isLogicCommand)(query)) {
                 return this.encodeLogicCommand(query);
             }
-            else if (query_1.isQueryCommand(query)) {
+            else if ((0, query_1.isQueryCommand)(query)) {
                 return this.encodeQueryCommand(query);
             }
-            else if (type_1.isRegExp(query)) {
-                return { [key]: this.encodeRegExp(query) };
+            else if ((0, type_1.isRegExp)(query)) {
+                return _a = {}, _a[key] = this.encodeRegExp(query), _a;
             }
-            else if (type_1.isDate(query)) {
-                return { [key]: query };
+            else if ((0, type_1.isDate)(query)) {
+                return _b = {}, _b[key] = (0, common_1.encodeInternalDataType)(query), _b;
             }
             else {
-                return { [key]: this.encodeQueryObject(query) };
+                return _c = {}, _c[key] = this.encodeQueryObject(query), _c;
             }
         }
         else {
-            if (type_1.isObject(query)) {
+            if ((0, type_1.isObject)(query)) {
                 return this.encodeQueryObject(query);
             }
             else {
                 return query;
             }
         }
-    }
-    encodeRegExp(query) {
+    };
+    QueryEncoder.prototype.encodeRegExp = function (query) {
         return {
             $regularExpression: {
                 pattern: query.source,
                 options: query.flags
             }
         };
-    }
-    encodeLogicCommand(query) {
+    };
+    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: {
-                const $op = operator_map_1.operatorToString(query.operator);
-                const subqueries = query.operands.map((oprand) => this.encodeQuery(oprand, query.fieldName));
-                return {
-                    [$op]: subqueries
-                };
+                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: {
-                const $op = operator_map_1.operatorToString(query.operator);
-                const operatorExpression = query.operands[0];
-                if (type_1.isRegExp(operatorExpression)) {
-                    return {
-                        [query.fieldName]: {
-                            [$op]: this.encodeRegExp(operatorExpression)
-                        }
-                    };
+                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 {
-                    const subqueries = this.encodeQuery(operatorExpression)[query.fieldName];
-                    return {
-                        [query.fieldName]: {
-                            [$op]: subqueries
-                        }
-                    };
+                    var subqueries = this.encodeQuery(operatorExpression)[query.fieldName];
+                    return _d = {},
+                        _d[query.fieldName] = (_e = {},
+                            _e[$op] = subqueries,
+                            _e),
+                        _d;
                 }
             }
             default: {
-                const $op = operator_map_1.operatorToString(query.operator);
+                var $op = (0, operator_map_1.operatorToString)(query.operator);
                 if (query.operands.length === 1) {
-                    const subquery = this.encodeQuery(query.operands[0]);
-                    return {
-                        [$op]: subquery
-                    };
+                    var subquery = this.encodeQuery(query.operands[0]);
+                    return _f = {},
+                        _f[$op] = subquery,
+                        _f;
                 }
                 else {
-                    const subqueries = query.operands.map(this.encodeQuery.bind(this));
-                    return {
-                        [$op]: subqueries
-                    };
+                    var subqueries = query.operands.map(this.encodeQuery.bind(this));
+                    return _g = {},
+                        _g[$op] = subqueries,
+                        _g;
                 }
             }
         }
-    }
-    encodeQueryCommand(query) {
-        if (query_1.isComparisonCommand(query)) {
+    };
+    QueryEncoder.prototype.encodeQueryCommand = function (query) {
+        if ((0, query_1.isComparisonCommand)(query)) {
             return this.encodeComparisonCommand(query);
         }
         else {
             return this.encodeComparisonCommand(query);
         }
-    }
-    encodeComparisonCommand(query) {
+    };
+    QueryEncoder.prototype.encodeComparisonCommand = function (query) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         if (query.fieldName === symbol_1.SYMBOL_UNSET_FIELD_NAME) {
             throw new Error('Cannot encode a comparison command with unset field name');
         }
-        const $op = operator_map_1.operatorToString(query.operator);
+        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:
@@ -127,122 +136,122 @@ class QueryEncoder {
             case query_1.QUERY_COMMANDS_LITERAL.EXISTS:
             case query_1.QUERY_COMMANDS_LITERAL.SIZE:
             case query_1.QUERY_COMMANDS_LITERAL.MOD: {
-                return {
-                    [query.fieldName]: {
-                        [$op]: common_1.encodeInternalDataType(query.operands[0])
-                    }
-                };
+                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 {
-                    [query.fieldName]: {
-                        [$op]: common_1.encodeInternalDataType(query.operands)
-                    }
-                };
+                return _c = {},
+                    _c[query.fieldName] = (_d = {},
+                        _d[$op] = (0, common_1.encodeInternalDataType)(query.operands),
+                        _d),
+                    _c;
             }
             case query_1.QUERY_COMMANDS_LITERAL.GEO_NEAR: {
-                const options = query.operands[0];
-                return {
-                    [query.fieldName]: {
+                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: {
-                const options = query.operands[0];
+                var options = query.operands[0];
                 if (options.centerSphere) {
                     validate_1.Validate.isCentersPhere(options.centerSphere);
-                    const centerSphere = options.centerSphere;
+                    var centerSphere = options.centerSphere;
                     if (centerSphere[0]._internalType === symbol_1.SYMBOL_GEO_POINT) {
-                        return {
-                            [query.fieldName]: {
+                        return _f = {},
+                            _f[query.fieldName] = {
                                 $geoWithin: {
                                     $centerSphere: [centerSphere[0].toJSON().coordinates, centerSphere[1]]
                                 }
-                            }
-                        };
+                            },
+                            _f;
                     }
-                    return {
-                        [query.fieldName]: {
+                    return _g = {},
+                        _g[query.fieldName] = {
                             $geoWithin: {
                                 $centerSphere: options.centerSphere
                             }
-                        }
-                    };
+                        },
+                        _g;
                 }
-                return {
-                    [query.fieldName]: {
+                return _h = {},
+                    _h[query.fieldName] = {
                         $geoWithin: {
                             $geometry: options.geometry.toJSON()
                         }
-                    }
-                };
+                    },
+                    _h;
             }
             case query_1.QUERY_COMMANDS_LITERAL.GEO_INTERSECTS: {
-                const options = query.operands[0];
-                return {
-                    [query.fieldName]: {
+                var options = query.operands[0];
+                return _j = {},
+                    _j[query.fieldName] = {
                         $geoIntersects: {
                             $geometry: options.geometry.toJSON()
                         }
-                    }
-                };
+                    },
+                    _j;
             }
             default: {
-                return {
-                    [query.fieldName]: {
-                        [$op]: common_1.encodeInternalDataType(query.operands[0])
-                    }
-                };
+                return _k = {},
+                    _k[query.fieldName] = (_l = {},
+                        _l[$op] = (0, common_1.encodeInternalDataType)(query.operands[0]),
+                        _l),
+                    _k;
             }
         }
-    }
-    encodeQueryObject(query) {
-        const flattened = common_1.flattenQueryObject(query);
-        for (const key in flattened) {
-            const val = flattened[key];
-            if (logic_1.isLogicCommand(val)) {
+    };
+    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);
-                const condition = this.encodeLogicCommand(flattened[key]);
+                var condition = this.encodeLogicCommand(flattened[key]);
                 this.mergeConditionAfterEncode(flattened, condition, key);
             }
-            else if (query_1.isComparisonCommand(val)) {
+            else if ((0, query_1.isComparisonCommand)(val)) {
                 flattened[key] = val._setFieldName(key);
-                const condition = this.encodeComparisonCommand(flattened[key]);
+                var condition = this.encodeComparisonCommand(flattened[key]);
                 this.mergeConditionAfterEncode(flattened, condition, key);
             }
-            else if (common_1.isConversionRequired(val)) {
-                flattened[key] = common_1.encodeInternalDataType(val);
+            else if ((0, common_1.isConversionRequired)(val)) {
+                flattened[key] = (0, common_1.encodeInternalDataType)(val);
             }
         }
         return flattened;
-    }
-    mergeConditionAfterEncode(query, condition, key) {
+    };
+    QueryEncoder.prototype.mergeConditionAfterEncode = function (query, condition, key) {
         if (!condition[key]) {
             delete query[key];
         }
-        for (const conditionKey in condition) {
+        for (var conditionKey in condition) {
             if (query[conditionKey]) {
-                if (type_1.isArray(query[conditionKey])) {
+                if ((0, type_1.isArray)(query[conditionKey])) {
                     query[conditionKey] = query[conditionKey].concat(condition[conditionKey]);
                 }
-                else if (type_1.isObject(query[conditionKey])) {
-                    if (type_1.isObject(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 ${type_1.getType(condition)}, can only overwrite`, condition, key);
+                        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 ${type_1.getType(query)}, can only overwrite`, query, condition, key);
+                    console.warn("to-merge query is of type ".concat((0, type_1.getType)(query), ", can only overwrite"), query, condition, key);
                     query[conditionKey] = condition[conditionKey];
                 }
             }
@@ -250,5 +259,6 @@ class QueryEncoder {
                 query[conditionKey] = condition[conditionKey];
             }
         }
-    }
-}
+    };
+    return QueryEncoder;
+}());

package/dist/commonjs/serializer/update.d.ts

@@ -1,6 +1,6 @@
 import { UpdateCommand } from '../commands/update';
 import { LogicCommand } from '../commands/logic';
-export declare type IQueryCondition = Record<string, any> | LogicCommand;
+export type IQueryCondition = Record<string, any> | LogicCommand;
 export interface IUpdateCondition {
     [key: string]: any;
 }

package/dist/commonjs/serializer/update.js

@@ -1,33 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const update_1 = require("../commands/update");
-const symbol_1 = require("../helper/symbol");
-const type_1 = require("../utils/type");
-const operator_map_1 = require("../operator-map");
-const common_1 = require("./common");
-const utils_1 = require("../utils/utils");
-class UpdateSerializer {
-    constructor() { }
-    static encode(query) {
-        const stringifier = new UpdateSerializer();
-        return stringifier.encodeUpdate(query);
-    }
-    static encodeEJSON(query, raw) {
-        const stringifier = new UpdateSerializer();
-        return utils_1.stringifyByEJSON(raw ? query : stringifier.encodeUpdate(query));
+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 utils_1 = require("../utils/utils");
+var UpdateSerializer = (function () {
+    function UpdateSerializer() {
     }
-    encodeUpdate(query) {
-        if (update_1.isUpdateCommand(query)) {
+    UpdateSerializer.encode = function (query) {
+        var stringifier = new UpdateSerializer();
+        return stringifier.encodeUpdate(query);
+    };
+    UpdateSerializer.encodeEJSON = function (query, raw) {
+        var stringifier = new UpdateSerializer();
+        return (0, utils_1.stringifyByEJSON)(raw ? query : stringifier.encodeUpdate(query));
+    };
+    UpdateSerializer.prototype.encodeUpdate = function (query) {
+        if ((0, update_1.isUpdateCommand)(query)) {
             return this.encodeUpdateCommand(query);
         }
-        else if (type_1.getType(query) === 'object') {
+        else if ((0, type_1.getType)(query) === 'object') {
             return this.encodeUpdateObject(query);
         }
         else {
             return query;
         }
-    }
-    encodeUpdateCommand(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');
         }
@@ -45,32 +47,34 @@ class UpdateSerializer {
                 return this.encodeFieldUpdateCommand(query);
             }
         }
-    }
-    encodeFieldUpdateCommand(query) {
-        const $op = operator_map_1.operatorToString(query.operator);
+    };
+    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 {
-                    [$op]: {
-                        [query.fieldName]: ''
-                    }
-                };
+                return _a = {},
+                    _a[$op] = (_b = {},
+                        _b[query.fieldName] = '',
+                        _b),
+                    _a;
             }
             default: {
-                return {
-                    [$op]: {
-                        [query.fieldName]: query.operands[0]
-                    }
-                };
+                return _c = {},
+                    _c[$op] = (_d = {},
+                        _d[query.fieldName] = query.operands[0],
+                        _d),
+                    _c;
             }
         }
-    }
-    encodeArrayUpdateCommand(query) {
-        const $op = operator_map_1.operatorToString(query.operator);
+    };
+    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: {
-                let modifiers;
-                if (type_1.isArray(query.operands)) {
+                var modifiers = void 0;
+                if ((0, type_1.isArray)(query.operands)) {
                     modifiers = {
                         $each: query.operands.map(common_1.encodeInternalDataType)
                     };
@@ -78,65 +82,66 @@ class UpdateSerializer {
                 else {
                     modifiers = query.operands;
                 }
-                return {
-                    [$op]: {
-                        [query.fieldName]: modifiers
-                    }
-                };
+                return _a = {},
+                    _a[$op] = (_b = {},
+                        _b[query.fieldName] = modifiers,
+                        _b),
+                    _a;
             }
             case update_1.UPDATE_COMMANDS_LITERAL.UNSHIFT: {
-                const modifiers = {
+                var modifiers = {
                     $each: query.operands.map(common_1.encodeInternalDataType),
                     $position: 0
                 };
-                return {
-                    [$op]: {
-                        [query.fieldName]: modifiers
-                    }
-                };
+                return _c = {},
+                    _c[$op] = (_d = {},
+                        _d[query.fieldName] = modifiers,
+                        _d),
+                    _c;
             }
             case update_1.UPDATE_COMMANDS_LITERAL.POP: {
-                return {
-                    [$op]: {
-                        [query.fieldName]: 1
-                    }
-                };
+                return _e = {},
+                    _e[$op] = (_f = {},
+                        _f[query.fieldName] = 1,
+                        _f),
+                    _e;
             }
             case update_1.UPDATE_COMMANDS_LITERAL.SHIFT: {
-                return {
-                    [$op]: {
-                        [query.fieldName]: -1
-                    }
-                };
+                return _g = {},
+                    _g[$op] = (_h = {},
+                        _h[query.fieldName] = -1,
+                        _h),
+                    _g;
             }
             default: {
-                return {
-                    [$op]: {
-                        [query.fieldName]: common_1.encodeInternalDataType(query.operands)
-                    }
-                };
+                return _j = {},
+                    _j[$op] = (_k = {},
+                        _k[query.fieldName] = (0, common_1.encodeInternalDataType)(query.operands),
+                        _k),
+                    _j;
             }
         }
-    }
-    encodeUpdateObject(query) {
-        const flattened = common_1.flattenQueryObject(query);
-        for (const key in flattened) {
+    };
+    UpdateSerializer.prototype.encodeUpdateObject = function (query) {
+        var flattened = (0, common_1.flattenQueryObject)(query);
+        for (var key in flattened) {
             if (/^\$/.test(key))
                 continue;
-            let val = flattened[key];
-            if (update_1.isUpdateCommand(val)) {
+            var val = flattened[key];
+            if ((0, update_1.isUpdateCommand)(val)) {
                 flattened[key] = val._setFieldName(key);
-                const condition = this.encodeUpdateCommand(flattened[key]);
-                common_1.mergeConditionAfterEncode(flattened, condition, key);
+                var condition = this.encodeUpdateCommand(flattened[key]);
+                (0, common_1.mergeConditionAfterEncode)(flattened, condition, key);
             }
             else {
-                flattened[key] = val = common_1.encodeInternalDataType(val);
-                const $setCommand = new update_1.UpdateCommand(update_1.UPDATE_COMMANDS_LITERAL.SET, [val], key);
-                const condition = this.encodeUpdateCommand($setCommand);
-                common_1.mergeConditionAfterEncode(flattened, condition, key);
+                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/dist/commonjs/serverDate/index.d.ts

@@ -3,7 +3,7 @@ export declare class ServerDate {
     constructor({ offset }?: {
         offset?: number;
     });
-    readonly _internalType: import("../utils/symbol").InternalSymbol;
+    get _internalType(): import("../utils/symbol").InternalSymbol;
     parse(): {
         $tcb_server_date: {
             offset: number;