@cloudbase/database 1.4.3 → 1.5.0

package/dist/commonjs/utils/error.js

@@ -1,55 +1,91 @@
 "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 });
-const type_1 = require("./type");
-const error_config_1 = require("../config/error.config");
-class CloudSDKError extends Error {
-    constructor(options) {
-        super(options.errMsg);
-        this.errCode = 'UNKNOWN_ERROR';
-        Object.defineProperties(this, {
+exports.isCancelledError = exports.CancelledError = exports.isTimeoutError = exports.TimeoutError = exports.isGenericError = exports.isSDKError = exports.CloudSDKError = void 0;
+var type_1 = require("./type");
+var error_config_1 = require("../config/error.config");
+var CloudSDKError = (function (_super) {
+    __extends(CloudSDKError, _super);
+    function CloudSDKError(options) {
+        var _this = _super.call(this, options.errMsg) || this;
+        _this.errCode = 'UNKNOWN_ERROR';
+        Object.defineProperties(_this, {
             message: {
-                get() {
-                    return (`errCode: ${this.errCode} ${error_config_1.ERR_CODE[this.errCode] ||
-                        ''} | errMsg: ` + this.errMsg);
+                get: function () {
+                    return ("errCode: ".concat(this.errCode, " ").concat(error_config_1.ERR_CODE[this.errCode] ||
+                        '', " | errMsg: ") + this.errMsg);
                 },
-                set(msg) {
+                set: function (msg) {
                     this.errMsg = msg;
                 }
             }
         });
-        this.errCode = options.errCode || 'UNKNOWN_ERROR';
-        this.errMsg = options.errMsg;
+        _this.errCode = options.errCode || 'UNKNOWN_ERROR';
+        _this.errMsg = options.errMsg;
+        return _this;
     }
-    get message() {
-        return `errCode: ${this.errCode} | errMsg: ` + this.errMsg;
-    }
-    set message(msg) {
-        this.errMsg = msg;
-    }
-}
+    Object.defineProperty(CloudSDKError.prototype, "message", {
+        get: function () {
+            return "errCode: ".concat(this.errCode, " | errMsg: ") + this.errMsg;
+        },
+        set: function (msg) {
+            this.errMsg = msg;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return CloudSDKError;
+}(Error));
 exports.CloudSDKError = CloudSDKError;
 function isSDKError(error) {
-    return (error && error instanceof Error && type_1.isString(error.errMsg));
+    return (error && error instanceof Error && (0, type_1.isString)(error.errMsg));
 }
 exports.isSDKError = isSDKError;
-exports.isGenericError = (e) => e.generic;
-class TimeoutError extends Error {
-    constructor(message) {
-        super(message);
-        this.type = 'timeout';
-        this.payload = null;
-        this.generic = true;
+var isGenericError = function (e) { return e.generic; };
+exports.isGenericError = isGenericError;
+var TimeoutError = (function (_super) {
+    __extends(TimeoutError, _super);
+    function TimeoutError(message) {
+        var _this = _super.call(this, message) || this;
+        _this.type = 'timeout';
+        _this.payload = null;
+        _this.generic = true;
+        return _this;
     }
-}
+    return TimeoutError;
+}(Error));
 exports.TimeoutError = TimeoutError;
-exports.isTimeoutError = (e) => e.type === 'timeout';
-class CancelledError extends Error {
-    constructor(message) {
-        super(message);
-        this.type = 'cancelled';
-        this.payload = null;
-        this.generic = true;
+var isTimeoutError = function (e) {
+    return e.type === 'timeout';
+};
+exports.isTimeoutError = isTimeoutError;
+var CancelledError = (function (_super) {
+    __extends(CancelledError, _super);
+    function CancelledError(message) {
+        var _this = _super.call(this, message) || this;
+        _this.type = 'cancelled';
+        _this.payload = null;
+        _this.generic = true;
+        return _this;
     }
-}
+    return CancelledError;
+}(Error));
 exports.CancelledError = CancelledError;
-exports.isCancelledError = (e) => e.type === 'cancelled';
+var isCancelledError = function (e) {
+    return e.type === 'cancelled';
+};
+exports.isCancelledError = isCancelledError;

package/dist/commonjs/utils/symbol.js

@@ -1,9 +1,25 @@
 "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 });
-const _symbols = [];
-const __internalMark__ = {};
-class HiddenSymbol {
-    constructor(target) {
+exports.InternalSymbol = void 0;
+var _symbols = [];
+var __internalMark__ = {};
+var HiddenSymbol = (function () {
+    function HiddenSymbol(target) {
         Object.defineProperties(this, {
             target: {
                 enumerable: false,
@@ -13,27 +29,30 @@ class HiddenSymbol {
             },
         });
     }
-}
-class InternalSymbol extends HiddenSymbol {
-    constructor(target, __mark__) {
+    return HiddenSymbol;
+}());
+var InternalSymbol = (function (_super) {
+    __extends(InternalSymbol, _super);
+    function InternalSymbol(target, __mark__) {
         if (__mark__ !== __internalMark__) {
             throw new TypeError('InternalSymbol cannot be constructed with new operator');
         }
-        super(target);
+        return _super.call(this, target) || this;
     }
-    static for(target) {
-        for (let i = 0, len = _symbols.length; i < len; i++) {
+    InternalSymbol.for = function (target) {
+        for (var i = 0, len = _symbols.length; i < len; i++) {
             if (_symbols[i].target === target) {
                 return _symbols[i].instance;
             }
         }
-        const symbol = new InternalSymbol(target, __internalMark__);
+        var symbol = new InternalSymbol(target, __internalMark__);
         _symbols.push({
-            target,
+            target: target,
             instance: symbol,
         });
         return symbol;
-    }
-}
+    };
+    return InternalSymbol;
+}(HiddenSymbol));
 exports.InternalSymbol = InternalSymbol;
 exports.default = InternalSymbol;

package/dist/commonjs/utils/type.d.ts

@@ -3,7 +3,7 @@ export declare const isObject: <T extends object>(x: any) => x is T;
 export declare const isString: (x: any) => x is string;
 export declare const isNumber: (x: any) => x is number;
 export declare const isPromise: <T extends Promise<any> = Promise<any>>(x: any) => x is T;
-declare type AnyFn = (...args: any[]) => any;
+type AnyFn = (...args: any[]) => any;
 export declare const isFunction: <T extends AnyFn = AnyFn>(x: any) => x is T;
 export declare const isArray: <T extends any[] = any[]>(x: any) => x is T;
 export declare const isDate: (x: any) => x is Date;

package/dist/commonjs/utils/type.js

@@ -1,22 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const symbol_1 = require("./symbol");
-exports.getType = (x) => Object.prototype.toString.call(x).slice(8, -1).toLowerCase();
-exports.isObject = (x) => exports.getType(x) === 'object';
-exports.isString = (x) => exports.getType(x) === 'string';
-exports.isNumber = (x) => exports.getType(x) === 'number';
-exports.isPromise = (x) => exports.getType(x) === 'promise';
-exports.isFunction = (x) => typeof x === 'function';
-exports.isArray = (x) => Array.isArray(x);
-exports.isDate = (x) => exports.getType(x) === 'date';
-exports.isRegExp = (x) => exports.getType(x) === 'regexp';
-exports.isInternalObject = (x) => x && (x._internalType instanceof symbol_1.InternalSymbol);
-exports.isPlainObject = (obj) => {
+exports.isPlainObject = exports.isInternalObject = exports.isRegExp = exports.isDate = exports.isArray = exports.isFunction = exports.isPromise = exports.isNumber = exports.isString = exports.isObject = exports.getType = void 0;
+var symbol_1 = require("./symbol");
+var getType = function (x) { return Object.prototype.toString.call(x).slice(8, -1).toLowerCase(); };
+exports.getType = getType;
+var isObject = function (x) { return (0, exports.getType)(x) === 'object'; };
+exports.isObject = isObject;
+var isString = function (x) { return (0, exports.getType)(x) === 'string'; };
+exports.isString = isString;
+var isNumber = function (x) { return (0, exports.getType)(x) === 'number'; };
+exports.isNumber = isNumber;
+var isPromise = function (x) { return (0, exports.getType)(x) === 'promise'; };
+exports.isPromise = isPromise;
+var isFunction = function (x) { return typeof x === 'function'; };
+exports.isFunction = isFunction;
+var isArray = function (x) { return Array.isArray(x); };
+exports.isArray = isArray;
+var isDate = function (x) { return (0, exports.getType)(x) === 'date'; };
+exports.isDate = isDate;
+var isRegExp = function (x) { return (0, exports.getType)(x) === 'regexp'; };
+exports.isRegExp = isRegExp;
+var isInternalObject = function (x) { return x && (x._internalType instanceof symbol_1.InternalSymbol); };
+exports.isInternalObject = isInternalObject;
+var isPlainObject = function (obj) {
     if (typeof obj !== 'object' || obj === null)
         return false;
-    let proto = obj;
+    var proto = obj;
     while (Object.getPrototypeOf(proto) !== null) {
         proto = Object.getPrototypeOf(proto);
     }
     return Object.getPrototypeOf(obj) === proto;
 };
+exports.isPlainObject = isPlainObject;

package/dist/commonjs/utils/utils.d.ts

@@ -1,9 +1,12 @@
+import { Db } from '../';
 import { QueryOption, UpdateOption } from '../query';
 export declare const sleep: (ms?: number) => Promise<unknown>;
+export declare function withCallback<T>(promise: Promise<T>, callback?: any): Promise<T> | undefined;
 export declare const autoCount: (domain?: string) => number;
+export declare function getWsInstance(db: Db): any;
 export declare const getReqOpts: (apiOptions: QueryOption | UpdateOption) => any;
 export declare const filterUndefined: (o: any) => any;
-export declare const stringifyByEJSON: (params: any) => any;
+export declare const stringifyByEJSON: (params: any) => string;
 export declare const parseByEJSON: (params: any) => any;
 export declare class TcbError extends Error {
     readonly code: string;

package/dist/commonjs/utils/utils.js

@@ -1,16 +1,79 @@
 "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 __());
+    };
+})();
+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);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const bson_1 = require("bson");
-const type_1 = require("./type");
-exports.sleep = (ms = 0) => new Promise(r => setTimeout(r, ms));
-const counters = {};
-exports.autoCount = (domain = 'any') => {
+exports.processReturn = exports.E = exports.TcbError = exports.parseByEJSON = exports.stringifyByEJSON = exports.filterUndefined = exports.getReqOpts = exports.getWsInstance = exports.autoCount = exports.withCallback = exports.sleep = void 0;
+var __1 = require("../");
+var bson_1 = require("bson");
+var type_1 = require("./type");
+var sleep = function (ms) {
+    if (ms === void 0) { ms = 0; }
+    return new Promise(function (r) { return setTimeout(r, ms); });
+};
+exports.sleep = sleep;
+function withCallback(promise, callback) {
+    if (typeof callback === 'function') {
+        promise.then(function (res) { return callback(0, res); }, function (err) { return callback(err); });
+        return undefined;
+    }
+    return promise;
+}
+exports.withCallback = withCallback;
+var counters = {};
+var autoCount = function (domain) {
+    if (domain === void 0) { domain = 'any'; }
     if (!counters[domain]) {
         counters[domain] = 0;
     }
     return counters[domain]++;
 };
-exports.getReqOpts = (apiOptions) => {
+exports.autoCount = autoCount;
+var wsList = {};
+function getWsInstance(db) {
+    if (!__1.Db.wsClientClass) {
+        throw new Error('to use realtime you must import realtime module first');
+    }
+    var env = db.config.env;
+    if (!wsList[env]) {
+        wsList[env] = new __1.Db.wsClientClass({
+            context: {
+                appConfig: {
+                    docSizeLimit: 1000,
+                    realtimePingInterval: 10000,
+                    realtimePongWaitTimeout: 5000,
+                    request: __1.Db.createRequest(db.config)
+                }
+            }
+        });
+    }
+    return wsList[env];
+}
+exports.getWsInstance = getWsInstance;
+var getReqOpts = function (apiOptions) {
     if (apiOptions.timeout !== undefined) {
         return {
             timeout: apiOptions.timeout
@@ -18,42 +81,50 @@ exports.getReqOpts = (apiOptions) => {
     }
     return {};
 };
-exports.filterUndefined = o => {
-    if (!type_1.isObject(o)) {
+exports.getReqOpts = getReqOpts;
+var filterUndefined = function (o) {
+    if (!(0, type_1.isObject)(o)) {
         return o;
     }
-    for (let key in o) {
+    for (var key in o) {
         if (o[key] === undefined) {
             delete o[key];
         }
-        else if (type_1.isObject(o[key])) {
-            o[key] = exports.filterUndefined(o[key]);
+        else if ((0, type_1.isObject)(o[key])) {
+            o[key] = (0, exports.filterUndefined)(o[key]);
         }
     }
     return o;
 };
-exports.stringifyByEJSON = params => {
-    params = exports.filterUndefined(params);
+exports.filterUndefined = filterUndefined;
+var stringifyByEJSON = function (params) {
+    params = (0, exports.filterUndefined)(params);
     return bson_1.EJSON.stringify(params, { relaxed: false });
 };
-exports.parseByEJSON = params => {
+exports.stringifyByEJSON = stringifyByEJSON;
+var parseByEJSON = function (params) {
     return bson_1.EJSON.parse(params);
 };
-class TcbError extends Error {
-    constructor(error) {
-        super(error.message);
-        this.code = error.code;
-        this.message = error.message;
+exports.parseByEJSON = parseByEJSON;
+var TcbError = (function (_super) {
+    __extends(TcbError, _super);
+    function TcbError(error) {
+        var _this = _super.call(this, error.message) || this;
+        _this.code = error.code;
+        _this.message = error.message;
+        return _this;
     }
-}
+    return TcbError;
+}(Error));
 exports.TcbError = TcbError;
-exports.E = (errObj) => {
+var E = function (errObj) {
     return new TcbError(errObj);
 };
+exports.E = E;
 function processReturn(throwOnCode, res) {
     if (throwOnCode === false) {
         return res;
     }
-    throw exports.E(Object.assign({}, res));
+    throw (0, exports.E)(__assign({}, res));
 }
 exports.processReturn = processReturn;

package/dist/commonjs/validate.js

@@ -1,18 +1,32 @@
 "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);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const constant_1 = require("./constant");
-const util_1 = require("./util");
-const code_1 = require("./const/code");
-const utils_1 = require("./utils/utils");
-const type_1 = require("./utils/type");
-const symbol_1 = require("./helper/symbol");
-const validOptionsKeys = ['limit', 'offset', 'projection', 'order', 'multiple', 'timeout', 'raw'];
-class Validate {
-    static isGeopoint(point, degree) {
+exports.Validate = void 0;
+var constant_1 = require("./constant");
+var util_1 = require("./util");
+var code_1 = require("./const/code");
+var utils_1 = require("./utils/utils");
+var type_1 = require("./utils/type");
+var symbol_1 = require("./helper/symbol");
+var validOptionsKeys = ['limit', 'offset', 'projection', 'order', 'multiple', 'timeout', 'raw'];
+var Validate = (function () {
+    function Validate() {
+    }
+    Validate.isGeopoint = function (point, degree) {
         if (util_1.Util.whichType(degree) !== constant_1.FieldType.Number) {
             throw new Error('Geo Point must be number type');
         }
-        const degreeAbs = Math.abs(degree);
+        var degreeAbs = Math.abs(degree);
         if (point === 'latitude' && degreeAbs > 90) {
             throw new Error('latitude should be a number ranges from -90 to 90');
         }
@@ -20,92 +34,93 @@ class Validate {
             throw new Error('longitude should be a number ranges from -180 to 180');
         }
         return true;
-    }
-    static isInteger(param, num) {
+    };
+    Validate.isInteger = function (param, num) {
         if (!Number.isInteger(num)) {
             throw new Error(param + constant_1.ErrorCode.IntergerError);
         }
         return true;
-    }
-    static mustBeBoolean(param, bool) {
+    };
+    Validate.mustBeBoolean = function (param, bool) {
         if (typeof bool !== 'boolean') {
             throw new Error(param + constant_1.ErrorCode.BooleanError);
         }
         return true;
-    }
-    static isProjection(param, value) {
-        if (type_1.getType(value) !== 'object') {
-            throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: `${param} projection must be an object` }));
-        }
-        for (const key in value) {
-            const subValue = value[key];
-            if (type_1.getType(subValue) === 'number') {
+    };
+    Validate.isProjection = function (param, value) {
+        if ((0, type_1.getType)(value) !== 'object') {
+            throw (0, utils_1.E)(__assign(__assign({}, code_1.ERRORS.INVALID_PARAM), { message: "".concat(param, " projection must be an object") }));
+        }
+        for (var key in value) {
+            var subValue = value[key];
+            if ((0, type_1.getType)(subValue) === 'number') {
                 if (subValue !== 0 && subValue !== 1) {
-                    throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: `if the value in projection is of number, it must be 0 or 1` }));
+                    throw (0, utils_1.E)(__assign(__assign({}, code_1.ERRORS.INVALID_PARAM), { message: "if the value in projection is of number, it must be 0 or 1" }));
                 }
             }
-            else if (type_1.getType(subValue) === 'object') {
+            else if ((0, type_1.getType)(subValue) === 'object') {
             }
             else {
-                throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: 'invalid projection' }));
+                throw (0, utils_1.E)(__assign(__assign({}, code_1.ERRORS.INVALID_PARAM), { message: 'invalid projection' }));
             }
         }
         return true;
-    }
-    static isOrder(param, value) {
-        if (type_1.getType(value) !== 'object') {
-            throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: `${param} order must be an object` }));
+    };
+    Validate.isOrder = function (param, value) {
+        if ((0, type_1.getType)(value) !== 'object') {
+            throw (0, utils_1.E)(__assign(__assign({}, code_1.ERRORS.INVALID_PARAM), { message: "".concat(param, " order must be an object") }));
         }
-        for (let key in value) {
-            const subValue = value[key];
+        for (var key in value) {
+            var subValue = value[key];
             if (subValue !== 1 && subValue !== -1) {
-                throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: `order value must be 1 or -1` }));
+                throw (0, utils_1.E)(__assign(__assign({}, code_1.ERRORS.INVALID_PARAM), { message: "order value must be 1 or -1" }));
             }
         }
         return true;
-    }
-    static isFieldOrder(direction) {
+    };
+    Validate.isFieldOrder = function (direction) {
         if (constant_1.OrderDirectionList.indexOf(direction) === -1) {
             throw new Error(constant_1.ErrorCode.DirectionError);
         }
         return true;
-    }
-    static isFieldPath(path) {
+    };
+    Validate.isFieldPath = function (path) {
         if (!/^[a-zA-Z0-9-_\.]/.test(path)) {
             throw new Error();
         }
         return true;
-    }
-    static isOperator(op) {
+    };
+    Validate.isOperator = function (op) {
         if (constant_1.WhereFilterOpList.indexOf(op) === -1) {
             throw new Error(constant_1.ErrorCode.OpStrError);
         }
         return true;
-    }
-    static isCollName(name) {
+    };
+    Validate.isCollName = function (name) {
         if (!/^[a-zA-Z0-9]([a-zA-Z0-9-_]){1,32}$/.test(name)) {
             throw new Error(constant_1.ErrorCode.CollNameError);
         }
         return true;
-    }
-    static isDocID(docId) {
+    };
+    Validate.isDocID = function (docId) {
         if (!/^([a-fA-F0-9]){24}$/.test(docId)) {
             throw new Error(constant_1.ErrorCode.DocIDError);
         }
         return true;
-    }
-    static isValidOptions(options = {}) {
-        if (type_1.getType(options) !== 'object') {
-            throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: `options must be an object` }));
-        }
-        const keys = Object.keys(options);
-        for (const index in keys) {
+    };
+    Validate.isValidOptions = function (options) {
+        if (options === void 0) { options = {}; }
+        if ((0, type_1.getType)(options) !== 'object') {
+            throw (0, utils_1.E)(__assign(__assign({}, code_1.ERRORS.INVALID_PARAM), { message: "options must be an object" }));
+        }
+        var keys = Object.keys(options);
+        for (var index in keys) {
             if (validOptionsKeys.indexOf(keys[index]) < 0) {
-                throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: `${keys[index]} is invalid options key` }));
+                throw (0, utils_1.E)(__assign(__assign({}, code_1.ERRORS.INVALID_PARAM), { message: "".concat(keys[index], " is invalid options key") }));
             }
         }
-        const { limit, offset, projection, order } = options;
-        const { multiple } = options;
+        var _a = options, limit = _a.limit, offset = _a.offset, projection = _a.projection, order = _a.order;
+        var multiple = options.multiple;
         if (limit !== undefined) {
             Validate.isInteger('limit', limit);
         }
@@ -125,23 +140,23 @@ class Validate {
             Validate.isInteger('timeout', options.timeout);
         }
         return true;
-    }
-    static isValidAggregation(stage) {
+    };
+    Validate.isValidAggregation = function (stage) {
         if (Object.keys(stage).length !== 1) {
-            throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: `aggregation stage must have one key` }));
+            throw (0, utils_1.E)(__assign(__assign({}, code_1.ERRORS.INVALID_PARAM), { message: "aggregation stage must have one key" }));
         }
         return true;
-    }
-    static isCentersPhere(param) {
+    };
+    Validate.isCentersPhere = function (param) {
         if (Array.isArray(param) && param.length === 2) {
-            if (type_1.getType(param[0]) === 'object' &&
+            if ((0, type_1.getType)(param[0]) === 'object' &&
                 param[0]._internalType === symbol_1.SYMBOL_GEO_POINT &&
                 typeof param[1] === 'number') {
                 return true;
             }
             if (Array.isArray(param[0]) && param[0].length === 2) {
-                const longitude = param[0][0];
-                const latitude = param[0][1];
+                var longitude = param[0][0];
+                var latitude = param[0][1];
                 Validate.isGeopoint('longitude', longitude);
                 Validate.isGeopoint('latitude', latitude);
                 if (typeof param[1] === 'number') {
@@ -149,7 +164,8 @@ class Validate {
                 }
             }
         }
-        throw new Error(`${constant_1.ErrorCode.CentersPhereError}`);
-    }
-}
+        throw new Error("".concat(constant_1.ErrorCode.CentersPhereError));
+    };
+    return Validate;
+}());
 exports.Validate = Validate;