@cloudbase/database 1.4.3-alpha.0 → 1.5.0

package/dist/esm/utils/error.js

@@ -1,49 +1,84 @@
+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 __());
+    };
+})();
 import { isString } from './type';
 import { ERR_CODE } from '../config/error.config';
-export class CloudSDKError extends Error {
-    constructor(options) {
-        super(options.errMsg);
-        this.errCode = 'UNKNOWN_ERROR';
-        Object.defineProperties(this, {
+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} ${ERR_CODE[this.errCode] ||
-                        ''} | errMsg: ` + this.errMsg);
+                get: function () {
+                    return ("errCode: ".concat(this.errCode, " ").concat(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));
+export { CloudSDKError };
 export function isSDKError(error) {
     return (error && error instanceof Error && isString(error.errMsg));
 }
-export const isGenericError = (e) => e.generic;
-export class TimeoutError extends Error {
-    constructor(message) {
-        super(message);
-        this.type = 'timeout';
-        this.payload = null;
-        this.generic = true;
+export var isGenericError = function (e) { return e.generic; };
+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;
     }
-}
-export const isTimeoutError = (e) => e.type === 'timeout';
-export class CancelledError extends Error {
-    constructor(message) {
-        super(message);
-        this.type = 'cancelled';
-        this.payload = null;
-        this.generic = true;
+    return TimeoutError;
+}(Error));
+export { TimeoutError };
+export var isTimeoutError = function (e) {
+    return e.type === 'timeout';
+};
+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;
     }
-}
-export const isCancelledError = (e) => e.type === 'cancelled';
+    return CancelledError;
+}(Error));
+export { CancelledError };
+export var isCancelledError = function (e) {
+    return e.type === 'cancelled';
+};

package/dist/esm/utils/symbol.js

@@ -1,7 +1,22 @@
-const _symbols = [];
-const __internalMark__ = {};
-class HiddenSymbol {
-    constructor(target) {
+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 _symbols = [];
+var __internalMark__ = {};
+var HiddenSymbol = (function () {
+    function HiddenSymbol(target) {
         Object.defineProperties(this, {
             target: {
                 enumerable: false,
@@ -11,26 +26,30 @@ class HiddenSymbol {
             },
         });
     }
-}
-export 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));
+export { InternalSymbol };
 export default InternalSymbol;

package/dist/esm/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/esm/utils/type.js

@@ -1,18 +1,18 @@
 import { InternalSymbol } from './symbol';
-export const getType = (x) => Object.prototype.toString.call(x).slice(8, -1).toLowerCase();
-export const isObject = (x) => getType(x) === 'object';
-export const isString = (x) => getType(x) === 'string';
-export const isNumber = (x) => getType(x) === 'number';
-export const isPromise = (x) => getType(x) === 'promise';
-export const isFunction = (x) => typeof x === 'function';
-export const isArray = (x) => Array.isArray(x);
-export const isDate = (x) => getType(x) === 'date';
-export const isRegExp = (x) => getType(x) === 'regexp';
-export const isInternalObject = (x) => x && (x._internalType instanceof InternalSymbol);
-export const isPlainObject = (obj) => {
+export var getType = function (x) { return Object.prototype.toString.call(x).slice(8, -1).toLowerCase(); };
+export var isObject = function (x) { return getType(x) === 'object'; };
+export var isString = function (x) { return getType(x) === 'string'; };
+export var isNumber = function (x) { return getType(x) === 'number'; };
+export var isPromise = function (x) { return getType(x) === 'promise'; };
+export var isFunction = function (x) { return typeof x === 'function'; };
+export var isArray = function (x) { return Array.isArray(x); };
+export var isDate = function (x) { return getType(x) === 'date'; };
+export var isRegExp = function (x) { return getType(x) === 'regexp'; };
+export var isInternalObject = function (x) { return x && (x._internalType instanceof InternalSymbol); };
+export 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);
     }

package/dist/esm/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/esm/utils/utils.js

@@ -1,14 +1,72 @@
+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);
+};
+import { Db } from '../';
 import { EJSON } from 'bson';
 import { isObject } from './type';
-export const sleep = (ms = 0) => new Promise(r => setTimeout(r, ms));
-const counters = {};
-export const autoCount = (domain = 'any') => {
+export var sleep = function (ms) {
+    if (ms === void 0) { ms = 0; }
+    return new Promise(function (r) { return setTimeout(r, ms); });
+};
+export 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;
+}
+var counters = {};
+export var autoCount = function (domain) {
+    if (domain === void 0) { domain = 'any'; }
     if (!counters[domain]) {
         counters[domain] = 0;
     }
     return counters[domain]++;
 };
-export const getReqOpts = (apiOptions) => {
+var wsList = {};
+export function getWsInstance(db) {
+    if (!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 Db.wsClientClass({
+            context: {
+                appConfig: {
+                    docSizeLimit: 1000,
+                    realtimePingInterval: 10000,
+                    realtimePongWaitTimeout: 5000,
+                    request: Db.createRequest(db.config)
+                }
+            }
+        });
+    }
+    return wsList[env];
+}
+export var getReqOpts = function (apiOptions) {
     if (apiOptions.timeout !== undefined) {
         return {
             timeout: apiOptions.timeout
@@ -16,11 +74,11 @@ export const getReqOpts = (apiOptions) => {
     }
     return {};
 };
-export const filterUndefined = o => {
+export var filterUndefined = function (o) {
     if (!isObject(o)) {
         return o;
     }
-    for (let key in o) {
+    for (var key in o) {
         if (o[key] === undefined) {
             delete o[key];
         }
@@ -30,26 +88,30 @@ export const filterUndefined = o => {
     }
     return o;
 };
-export const stringifyByEJSON = params => {
+export var stringifyByEJSON = function (params) {
     params = filterUndefined(params);
     return EJSON.stringify(params, { relaxed: false });
 };
-export const parseByEJSON = params => {
+export var parseByEJSON = function (params) {
     return EJSON.parse(params);
 };
-export class TcbError extends Error {
-    constructor(error) {
-        super(error.message);
-        this.code = error.code;
-        this.message = error.message;
+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;
     }
-}
-export const E = (errObj) => {
+    return TcbError;
+}(Error));
+export { TcbError };
+export var E = function (errObj) {
     return new TcbError(errObj);
 };
 export function processReturn(throwOnCode, res) {
     if (throwOnCode === false) {
         return res;
     }
-    throw E(Object.assign({}, res));
+    throw E(__assign({}, res));
 }

package/dist/esm/validate.js

@@ -1,16 +1,29 @@
+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);
+};
 import { ErrorCode, WhereFilterOpList, OrderDirectionList, FieldType } from './constant';
 import { Util } from './util';
 import { ERRORS } from './const/code';
 import { E } from './utils/utils';
 import { getType } from './utils/type';
 import { SYMBOL_GEO_POINT } from './helper/symbol';
-const validOptionsKeys = ['limit', 'offset', 'projection', 'order', 'multiple', 'timeout', 'raw'];
-export class Validate {
-    static isGeopoint(point, degree) {
+var validOptionsKeys = ['limit', 'offset', 'projection', 'order', 'multiple', 'timeout', 'raw'];
+var Validate = (function () {
+    function Validate() {
+    }
+    Validate.isGeopoint = function (point, degree) {
         if (Util.whichType(degree) !== 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');
         }
@@ -18,92 +31,93 @@ export 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 + ErrorCode.IntergerError);
         }
         return true;
-    }
-    static mustBeBoolean(param, bool) {
+    };
+    Validate.mustBeBoolean = function (param, bool) {
         if (typeof bool !== 'boolean') {
             throw new Error(param + ErrorCode.BooleanError);
         }
         return true;
-    }
-    static isProjection(param, value) {
+    };
+    Validate.isProjection = function (param, value) {
         if (getType(value) !== 'object') {
-            throw E(Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: `${param} projection must be an object` }));
+            throw E(__assign(__assign({}, ERRORS.INVALID_PARAM), { message: "".concat(param, " projection must be an object") }));
         }
-        for (const key in value) {
-            const subValue = value[key];
+        for (var key in value) {
+            var subValue = value[key];
             if (getType(subValue) === 'number') {
                 if (subValue !== 0 && subValue !== 1) {
-                    throw E(Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: `if the value in projection is of number, it must be 0 or 1` }));
+                    throw E(__assign(__assign({}, ERRORS.INVALID_PARAM), { message: "if the value in projection is of number, it must be 0 or 1" }));
                 }
             }
             else if (getType(subValue) === 'object') {
             }
             else {
-                throw E(Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: 'invalid projection' }));
+                throw E(__assign(__assign({}, ERRORS.INVALID_PARAM), { message: 'invalid projection' }));
             }
         }
         return true;
-    }
-    static isOrder(param, value) {
+    };
+    Validate.isOrder = function (param, value) {
         if (getType(value) !== 'object') {
-            throw E(Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: `${param} order must be an object` }));
+            throw E(__assign(__assign({}, 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 E(Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: `order value must be 1 or -1` }));
+                throw E(__assign(__assign({}, ERRORS.INVALID_PARAM), { message: "order value must be 1 or -1" }));
             }
         }
         return true;
-    }
-    static isFieldOrder(direction) {
+    };
+    Validate.isFieldOrder = function (direction) {
         if (OrderDirectionList.indexOf(direction) === -1) {
             throw new Error(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 (WhereFilterOpList.indexOf(op) === -1) {
             throw new Error(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(ErrorCode.CollNameError);
         }
         return true;
-    }
-    static isDocID(docId) {
+    };
+    Validate.isDocID = function (docId) {
         if (!/^([a-fA-F0-9]){24}$/.test(docId)) {
             throw new Error(ErrorCode.DocIDError);
         }
         return true;
-    }
-    static isValidOptions(options = {}) {
+    };
+    Validate.isValidOptions = function (options) {
+        if (options === void 0) { options = {}; }
         if (getType(options) !== 'object') {
-            throw E(Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: `options must be an object` }));
+            throw E(__assign(__assign({}, ERRORS.INVALID_PARAM), { message: "options must be an object" }));
         }
-        const keys = Object.keys(options);
-        for (const index in keys) {
+        var keys = Object.keys(options);
+        for (var index in keys) {
             if (validOptionsKeys.indexOf(keys[index]) < 0) {
-                throw E(Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: `${keys[index]} is invalid options key` }));
+                throw E(__assign(__assign({}, 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);
         }
@@ -123,14 +137,14 @@ export class Validate {
             Validate.isInteger('timeout', options.timeout);
         }
         return true;
-    }
-    static isValidAggregation(stage) {
+    };
+    Validate.isValidAggregation = function (stage) {
         if (Object.keys(stage).length !== 1) {
-            throw E(Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: `aggregation stage must have one key` }));
+            throw E(__assign(__assign({}, 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 (getType(param[0]) === 'object' &&
                 param[0]._internalType === SYMBOL_GEO_POINT &&
@@ -138,8 +152,8 @@ export class Validate {
                 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') {
@@ -147,6 +161,8 @@ export class Validate {
                 }
             }
         }
-        throw new Error(`${ErrorCode.CentersPhereError}`);
-    }
-}
+        throw new Error("".concat(ErrorCode.CentersPhereError));
+    };
+    return Validate;
+}());
+export { Validate };

package/jest.config.js

@@ -0,0 +1,14 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testMatch: ['**/tests/**/*.ts'],
+  moduleFileExtensions: ['ts', 'js'],
+  transform: {
+    '^.+\\.ts$': ['ts-jest', {
+      tsconfig: 'tsconfig.test.json'
+    }]
+  },
+  transformIgnorePatterns: [
+    '/node_modules/(?!@types)/'
+  ]
+};

package/package.json

@@ -1,32 +1,36 @@
 {
   "name": "@cloudbase/database",
-  "version": "1.4.3-alpha.0",
+  "version": "1.5.0",
   "description": "database for (node.)js sdk ",
   "main": "dist/commonjs/index.js",
   "module": "dist/esm/index.js",
+  "publishConfig": {
+    "tag": "next"
+  },
   "scripts": {
     "eslint": "eslint \"./**/*.ts\"",
     "eslint-fix": "eslint --fix \"./**/*.ts\"",
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "jest",
     "build": "tsc -p tsconfig.json && tsc -p tsconfig.esm.json",
     "prepublishOnly": "npm run build"
   },
   "author": "",
   "license": "ISC",
   "devDependencies": {
+    "@types/jest": "26.0.24",
+    "@types/node": "14.14.31",
     "eslint": "^5.15.3",
     "eslint-config-prettier": "^4.1.0",
     "eslint-plugin-prettier": "^3.0.1",
     "eslint-plugin-typescript": "^0.14.0",
-    "typescript": "^3.6.2",
-    "typescript-eslint-parser": "^22.0.0",
-    "@types/node": "^13.13.4"
+    "jest": "26.6.3",
+    "ts-jest": "26.5.6",
+    "typescript": "^4.1.0",
+    "typescript-eslint-parser": "^22.0.0"
   },
   "sideEffects": false,
   "dependencies": {
-    "bson": "^4.0.3",
-    "lodash.clonedeep": "4.5.0",
-    "lodash.set": "4.3.2",
-    "lodash.unset": "4.5.2"
-  }
+    "bson": "^6.10.4"
+  },
+  "packageManager": "yarn@1.22.22"
 }