@cloudbase/database 1.4.3 → 1.5.1

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,10 +1,14 @@
+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 const toWatchQuery: (ejsonStr: string) => string;
 export declare class TcbError extends Error {
     readonly code: string;
     readonly message: string;

package/dist/commonjs/utils/utils.js

@@ -1,16 +1,90 @@
 "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);
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 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.toWatchQuery = 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 +92,99 @@ 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 toWatchLegacyValue = function (val) {
+    var e_1, _a;
+    if (val instanceof Date) {
+        return { $date: +val };
     }
-}
+    if (val instanceof RegExp) {
+        return { $regex: val.source, $options: val.flags };
+    }
+    if (val && typeof val === 'object') {
+        if (val._bsontype === 'ObjectId') {
+            return { $oid: val.toHexString() };
+        }
+        if (val._bsontype === 'BSONRegExp') {
+            return { $regex: val.pattern, $options: val.options };
+        }
+        if (Array.isArray(val)) {
+            return val.map(toWatchLegacyValue);
+        }
+        var ret = {};
+        try {
+            for (var _b = __values(Object.keys(val)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var key = _c.value;
+                ret[key] = toWatchLegacyValue(val[key]);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return ret;
+    }
+    return val;
+};
+var toWatchQuery = function (ejsonStr) {
+    if (!ejsonStr) {
+        return '{}';
+    }
+    try {
+        var parsed = bson_1.EJSON.parse(ejsonStr);
+        return JSON.stringify(toWatchLegacyValue(parsed));
+    }
+    catch (e) {
+        return ejsonStr;
+    }
+};
+exports.toWatchQuery = toWatchQuery;
+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;