@cloudbase/database 1.4.3 → 1.5.0

package/dist/esm/serializer/common.js

@@ -1,11 +1,47 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import { getType, isObject, isArray, isDate, isRegExp, isInternalObject } from '../utils/type';
 import { serialize as serializeInternalDataType, deserialize as deserializeInternalDataType } from './datatype';
 function flatten(query, shouldPreserverObject, parents, visited) {
-    const cloned = Object.assign({}, query);
-    for (const key in query) {
+    var cloned = __assign({}, query);
+    for (var key in query) {
         if (/^\$/.test(key))
             continue;
-        const value = query[key];
+        var value = query[key];
         if (value === undefined) {
             delete cloned[key];
             continue;
@@ -16,14 +52,14 @@ function flatten(query, shouldPreserverObject, parents, visited) {
             if (visited.indexOf(value) > -1) {
                 throw new Error('Cannot convert circular structure to JSON');
             }
-            const newParents = [...parents, key];
-            const newVisited = [...visited, value];
-            const flattenedChild = flatten(value, shouldPreserverObject, newParents, newVisited);
+            var newParents = __spreadArray(__spreadArray([], __read(parents), false), [key], false);
+            var newVisited = __spreadArray(__spreadArray([], __read(visited), false), [value], false);
+            var flattenedChild = flatten(value, shouldPreserverObject, newParents, newVisited);
             cloned[key] = flattenedChild;
-            let hasKeyNotCombined = false;
-            for (const childKey in flattenedChild) {
+            var hasKeyNotCombined = false;
+            for (var childKey in flattenedChild) {
                 if (!/^\$/.test(childKey)) {
-                    cloned[`${key}.${childKey}`] = flattenedChild[childKey];
+                    cloned["".concat(key, ".").concat(childKey)] = flattenedChild[childKey];
                     delete cloned[key][childKey];
                 }
                 else {
@@ -41,13 +77,13 @@ export function flattenQueryObject(query) {
     return flatten(query, isConversionRequired, [], [query]);
 }
 export function flattenObject(object) {
-    return flatten(object, (_) => false, [], [object]);
+    return flatten(object, function (_) { return false; }, [], [object]);
 }
 export function mergeConditionAfterEncode(query, condition, key) {
     if (!condition[key]) {
         delete query[key];
     }
-    for (const conditionKey in condition) {
+    for (var conditionKey in condition) {
         if (query[conditionKey]) {
             if (isArray(query[conditionKey])) {
                 query[conditionKey].push(condition[conditionKey]);
@@ -57,12 +93,12 @@ export function mergeConditionAfterEncode(query, condition, key) {
                     Object.assign(query[conditionKey], condition[conditionKey]);
                 }
                 else {
-                    console.warn(`unmergable condition, query is object but condition is ${getType(condition)}, can only overwrite`, condition, key);
+                    console.warn("unmergable condition, query is object but condition is ".concat(getType(condition), ", can only overwrite"), condition, key);
                     query[conditionKey] = condition[conditionKey];
                 }
             }
             else {
-                console.warn(`to-merge query is of type ${getType(query)}, can only overwrite`, query, condition, key);
+                console.warn("to-merge query is of type ".concat(getType(query), ", can only overwrite"), query, condition, key);
                 query[conditionKey] = condition[conditionKey];
             }
         }

package/dist/esm/serializer/datatype.d.ts

@@ -1,6 +1,6 @@
 import { LogicCommand } from '../commands/logic';
-export declare type IQueryCondition = Record<string, any> | LogicCommand;
-export declare type AnyObject = {
+export type IQueryCondition = Record<string, any> | LogicCommand;
+export type AnyObject = {
     [x: string]: any;
 };
 export declare function serialize(val: any): IQueryCondition;

package/dist/esm/serializer/datatype.js

@@ -1,3 +1,39 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import { SYMBOL_GEO_POINT, SYMBOL_SERVER_DATE, SYMBOL_OBJECTID, SYMBOL_REGEXP } from '../helper/symbol';
 import { getType, isObject, isArray, isDate, isNumber, isInternalObject, isRegExp } from '../utils/type';
 import { Point } from '../geo/index';
@@ -37,22 +73,22 @@ function serializeHelper(val, visited) {
         };
     }
     else if (isArray(val)) {
-        return val.map(item => {
+        return val.map(function (item) {
             if (visited.indexOf(item) > -1) {
                 throw new Error('Cannot convert circular structure to JSON');
             }
-            return serializeHelper(item, [...visited, item]);
+            return serializeHelper(item, __spreadArray(__spreadArray([], __read(visited), false), [item], false));
         });
     }
     else if (isObject(val)) {
-        const rawRet = Object.assign({}, val);
-        const finalRet = {};
-        for (const key in rawRet) {
+        var rawRet = __assign({}, val);
+        var finalRet = {};
+        for (var key in rawRet) {
             if (visited.indexOf(rawRet[key]) > -1) {
                 throw new Error('Cannot convert circular structure to JSON');
             }
             if (rawRet[key] !== undefined) {
-                finalRet[key] = serializeHelper(rawRet[key], [...visited, rawRet[key]]);
+                finalRet[key] = serializeHelper(rawRet[key], __spreadArray(__spreadArray([], __read(visited), false), [rawRet[key]], false));
             }
         }
         return finalRet;
@@ -62,8 +98,8 @@ function serializeHelper(val, visited) {
     }
 }
 export function deserialize(object) {
-    const ret = Object.assign({}, object);
-    for (const key in ret) {
+    var ret = __assign({}, object);
+    for (var key in ret) {
         switch (key) {
             case '$date': {
                 switch (getType(ret[key])) {

package/dist/esm/serializer/query.d.ts

@@ -1,6 +1,6 @@
 import { QueryCommand } from '../commands/query';
 import { LogicCommand } from '../commands/logic';
-export declare type IQueryCondition = Record<string, any> | LogicCommand;
+export type IQueryCondition = Record<string, any> | LogicCommand;
 export declare class QuerySerializer {
     constructor();
     static encode(query: IQueryCondition | QueryCommand | LogicCommand): IQueryCondition;

package/dist/esm/serializer/query.js

@@ -6,19 +6,25 @@ import { operatorToString } from '../operator-map';
 import { flattenQueryObject, isConversionRequired, encodeInternalDataType } from './common';
 import { stringifyByEJSON } from '../utils/utils';
 import { Validate } from '../validate';
-export class QuerySerializer {
-    constructor() { }
-    static encode(query) {
-        const encoder = new QueryEncoder();
-        return encoder.encodeQuery(query);
+var QuerySerializer = (function () {
+    function QuerySerializer() {
     }
-    static encodeEJSON(query, raw) {
-        const encoder = new QueryEncoder();
+    QuerySerializer.encode = function (query) {
+        var encoder = new QueryEncoder();
+        return encoder.encodeQuery(query);
+    };
+    QuerySerializer.encodeEJSON = function (query, raw) {
+        var encoder = new QueryEncoder();
         return stringifyByEJSON(raw ? query : encoder.encodeQuery(query));
+    };
+    return QuerySerializer;
+}());
+export { QuerySerializer };
+var QueryEncoder = (function () {
+    function QueryEncoder() {
     }
-}
-class QueryEncoder {
-    encodeQuery(query, key) {
+    QueryEncoder.prototype.encodeQuery = function (query, key) {
+        var _a, _b, _c;
         if (isConversionRequired(query)) {
             if (isLogicCommand(query)) {
                 return this.encodeLogicCommand(query);
@@ -27,13 +33,13 @@ class QueryEncoder {
                 return this.encodeQueryCommand(query);
             }
             else if (isRegExp(query)) {
-                return { [key]: this.encodeRegExp(query) };
+                return _a = {}, _a[key] = this.encodeRegExp(query), _a;
             }
             else if (isDate(query)) {
-                return { [key]: query };
+                return _b = {}, _b[key] = encodeInternalDataType(query), _b;
             }
             else {
-                return { [key]: this.encodeQueryObject(query) };
+                return _c = {}, _c[key] = this.encodeQueryObject(query), _c;
             }
         }
         else {
@@ -44,75 +50,78 @@ class QueryEncoder {
                 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_COMMANDS_LITERAL.NOR:
             case LOGIC_COMMANDS_LITERAL.AND:
             case LOGIC_COMMANDS_LITERAL.OR: {
-                const $op = operatorToString(query.operator);
-                const subqueries = query.operands.map((oprand) => this.encodeQuery(oprand, query.fieldName));
-                return {
-                    [$op]: subqueries
-                };
+                var $op = operatorToString(query.operator);
+                var subqueries = query.operands.map(function (oprand) { return _this.encodeQuery(oprand, query.fieldName); });
+                return _a = {},
+                    _a[$op] = subqueries,
+                    _a;
             }
             case LOGIC_COMMANDS_LITERAL.NOT: {
-                const $op = operatorToString(query.operator);
-                const operatorExpression = query.operands[0];
+                var $op = operatorToString(query.operator);
+                var operatorExpression = query.operands[0];
                 if (isRegExp(operatorExpression)) {
-                    return {
-                        [query.fieldName]: {
-                            [$op]: this.encodeRegExp(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 = operatorToString(query.operator);
+                var $op = 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) {
+    };
+    QueryEncoder.prototype.encodeQueryCommand = function (query) {
         if (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_UNSET_FIELD_NAME) {
             throw new Error('Cannot encode a comparison command with unset field name');
         }
-        const $op = operatorToString(query.operator);
+        var $op = operatorToString(query.operator);
         switch (query.operator) {
             case QUERY_COMMANDS_LITERAL.EQ:
             case QUERY_COMMANDS_LITERAL.NEQ:
@@ -124,94 +133,94 @@ class QueryEncoder {
             case QUERY_COMMANDS_LITERAL.EXISTS:
             case QUERY_COMMANDS_LITERAL.SIZE:
             case QUERY_COMMANDS_LITERAL.MOD: {
-                return {
-                    [query.fieldName]: {
-                        [$op]: encodeInternalDataType(query.operands[0])
-                    }
-                };
+                return _a = {},
+                    _a[query.fieldName] = (_b = {},
+                        _b[$op] = encodeInternalDataType(query.operands[0]),
+                        _b),
+                    _a;
             }
             case QUERY_COMMANDS_LITERAL.IN:
             case QUERY_COMMANDS_LITERAL.NIN:
             case QUERY_COMMANDS_LITERAL.ALL: {
-                return {
-                    [query.fieldName]: {
-                        [$op]: encodeInternalDataType(query.operands)
-                    }
-                };
+                return _c = {},
+                    _c[query.fieldName] = (_d = {},
+                        _d[$op] = encodeInternalDataType(query.operands),
+                        _d),
+                    _c;
             }
             case 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_COMMANDS_LITERAL.GEO_WITHIN: {
-                const options = query.operands[0];
+                var options = query.operands[0];
                 if (options.centerSphere) {
                     Validate.isCentersPhere(options.centerSphere);
-                    const centerSphere = options.centerSphere;
+                    var centerSphere = options.centerSphere;
                     if (centerSphere[0]._internalType === 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_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]: encodeInternalDataType(query.operands[0])
-                    }
-                };
+                return _k = {},
+                    _k[query.fieldName] = (_l = {},
+                        _l[$op] = encodeInternalDataType(query.operands[0]),
+                        _l),
+                    _k;
             }
         }
-    }
-    encodeQueryObject(query) {
-        const flattened = flattenQueryObject(query);
-        for (const key in flattened) {
-            const val = flattened[key];
+    };
+    QueryEncoder.prototype.encodeQueryObject = function (query) {
+        var flattened = flattenQueryObject(query);
+        for (var key in flattened) {
+            var val = flattened[key];
             if (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 (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 (isConversionRequired(val)) {
@@ -219,12 +228,12 @@ class QueryEncoder {
             }
         }
         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 (isArray(query[conditionKey])) {
                     query[conditionKey] = query[conditionKey].concat(condition[conditionKey]);
@@ -234,12 +243,12 @@ class QueryEncoder {
                         Object.assign(query, condition);
                     }
                     else {
-                        console.warn(`unmergable condition, query is object but condition is ${getType(condition)}, can only overwrite`, condition, key);
+                        console.warn("unmergable condition, query is object but condition is ".concat(getType(condition), ", can only overwrite"), condition, key);
                         query[conditionKey] = condition[conditionKey];
                     }
                 }
                 else {
-                    console.warn(`to-merge query is of type ${getType(query)}, can only overwrite`, query, condition, key);
+                    console.warn("to-merge query is of type ".concat(getType(query), ", can only overwrite"), query, condition, key);
                     query[conditionKey] = condition[conditionKey];
                 }
             }
@@ -247,5 +256,6 @@ class QueryEncoder {
                 query[conditionKey] = condition[conditionKey];
             }
         }
-    }
-}
+    };
+    return QueryEncoder;
+}());

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