@cloudbase/database 1.4.3 → 1.5.0

package/dist/commonjs/serializer/common.js

@@ -1,31 +1,68 @@
 "use strict";
+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));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const type_1 = require("../utils/type");
-const datatype_1 = require("./datatype");
+exports.decodeInternalDataType = exports.encodeInternalDataType = exports.isConversionRequired = exports.mergeConditionAfterEncode = exports.flattenObject = exports.flattenQueryObject = void 0;
+var type_1 = require("../utils/type");
+var datatype_1 = require("./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;
         }
         if (!value)
             continue;
-        if (type_1.isObject(value) && !shouldPreserverObject(value)) {
+        if ((0, type_1.isObject)(value) && !shouldPreserverObject(value)) {
             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 {
@@ -44,29 +81,29 @@ function flattenQueryObject(query) {
 }
 exports.flattenQueryObject = flattenQueryObject;
 function flattenObject(object) {
-    return flatten(object, (_) => false, [], [object]);
+    return flatten(object, function (_) { return false; }, [], [object]);
 }
 exports.flattenObject = flattenObject;
 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 (type_1.isArray(query[conditionKey])) {
+            if ((0, type_1.isArray)(query[conditionKey])) {
                 query[conditionKey].push(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[conditionKey], condition[conditionKey]);
                 }
                 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];
             }
         }
@@ -77,14 +114,14 @@ function mergeConditionAfterEncode(query, condition, key) {
 }
 exports.mergeConditionAfterEncode = mergeConditionAfterEncode;
 function isConversionRequired(val) {
-    return type_1.isInternalObject(val) || type_1.isDate(val) || type_1.isRegExp(val);
+    return (0, type_1.isInternalObject)(val) || (0, type_1.isDate)(val) || (0, type_1.isRegExp)(val);
 }
 exports.isConversionRequired = isConversionRequired;
 function encodeInternalDataType(val) {
-    return datatype_1.serialize(val);
+    return (0, datatype_1.serialize)(val);
 }
 exports.encodeInternalDataType = encodeInternalDataType;
 function decodeInternalDataType(object) {
-    return datatype_1.deserialize(object);
+    return (0, datatype_1.deserialize)(object);
 }
 exports.decodeInternalDataType = decodeInternalDataType;

package/dist/commonjs/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/commonjs/serializer/datatype.js

@@ -1,15 +1,52 @@
 "use strict";
+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));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const symbol_1 = require("../helper/symbol");
-const type_1 = require("../utils/type");
-const index_1 = require("../geo/index");
-const index_2 = require("../serverDate/index");
+exports.deserialize = exports.serialize = void 0;
+var symbol_1 = require("../helper/symbol");
+var type_1 = require("../utils/type");
+var index_1 = require("../geo/index");
+var index_2 = require("../serverDate/index");
 function serialize(val) {
     return serializeHelper(val, [val]);
 }
 exports.serialize = serialize;
 function serializeHelper(val, visited) {
-    if (type_1.isInternalObject(val)) {
+    if ((0, type_1.isInternalObject)(val)) {
         switch (val._internalType) {
             case symbol_1.SYMBOL_GEO_POINT: {
                 return val.toJSON();
@@ -28,10 +65,10 @@ function serializeHelper(val, visited) {
             }
         }
     }
-    else if (type_1.isDate(val)) {
+    else if ((0, type_1.isDate)(val)) {
         return val;
     }
-    else if (type_1.isRegExp(val)) {
+    else if ((0, type_1.isRegExp)(val)) {
         return {
             $regularExpression: {
                 pattern: val.source,
@@ -39,23 +76,23 @@ function serializeHelper(val, visited) {
             }
         };
     }
-    else if (type_1.isArray(val)) {
-        return val.map(item => {
+    else if ((0, type_1.isArray)(val)) {
+        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 (type_1.isObject(val)) {
-        const rawRet = Object.assign({}, val);
-        const finalRet = {};
-        for (const key in rawRet) {
+    else if ((0, type_1.isObject)(val)) {
+        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;
@@ -65,11 +102,11 @@ function serializeHelper(val, visited) {
     }
 }
 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 (type_1.getType(ret[key])) {
+                switch ((0, type_1.getType)(ret[key])) {
                     case 'number': {
                         return new Date(ret[key]);
                     }
@@ -82,9 +119,9 @@ function deserialize(object) {
             case 'type': {
                 switch (ret.type) {
                     case 'Point': {
-                        if (type_1.isArray(ret.coordinates) &&
-                            type_1.isNumber(ret.coordinates[0]) &&
-                            type_1.isNumber(ret.coordinates[1])) {
+                        if ((0, type_1.isArray)(ret.coordinates) &&
+                            (0, type_1.isNumber)(ret.coordinates[0]) &&
+                            (0, type_1.isNumber)(ret.coordinates[1])) {
                             return new index_1.Point(ret.coordinates[0], ret.coordinates[1]);
                         }
                         break;

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