@cloudbase/database 1.4.3 → 1.5.1

package/dist/esm/utils/utils.js

@@ -1,14 +1,83 @@
+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.");
+};
+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 +85,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 +99,78 @@ 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 toWatchLegacyValue = function (val) {
+    var e_1, _a;
+    if (val instanceof Date) {
+        return { $date: +val };
     }
-}
-export const E = (errObj) => {
+    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;
+};
+export var toWatchQuery = function (ejsonStr) {
+    if (!ejsonStr) {
+        return '{}';
+    }
+    try {
+        var parsed = EJSON.parse(ejsonStr);
+        return JSON.stringify(toWatchLegacyValue(parsed));
+    }
+    catch (e) {
+        return ejsonStr;
+    }
+};
+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));
+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",
+  "version": "1.5.1",
   "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"
 }

package/src/aggregate.ts

@@ -5,9 +5,6 @@ import { stringifyByEJSON } from './utils/utils'
 import { getType } from './utils/type'
 import { Validate } from './validate'
 import { Point } from './geo/point'
-
-// const EARTH_RADIUS = 6378100
-
 export default class Aggregation {
   _db: any
   _request: any
@@ -18,7 +15,7 @@ export default class Aggregation {
 
     if (db && collectionName) {
       this._db = db
-      this._request = new Db.reqClass(this._db.config)
+      this._request = Db.createRequest(this._db.config)
       this._collectionName = collectionName
 
       if (rawPipeline && rawPipeline.length > 0) {
@@ -98,7 +95,6 @@ export default class Aggregation {
     if (param.query) {
       param.query = QuerySerializer.encode(param.query)
     }
-    
     // 判断是否有 distanceMultiplier 参数
     if (param.distanceMultiplier && typeof (param.distanceMultiplier) === 'number') {
       param.distanceMultiplier = param.distanceMultiplier

package/src/collection.ts

@@ -3,7 +3,7 @@ import { DocumentReference } from './document'
 import { Query, QueryOption, UpdateOption } from './query'
 import Aggregation from './aggregate'
 import { serialize } from './serializer/datatype'
-import { getReqOpts, stringifyByEJSON } from './utils/utils'
+import { getReqOpts, stringifyByEJSON, withCallback } from './utils/utils'
 import { Validate } from './validate'
 import { isArray } from './utils/type'
 
@@ -63,7 +63,20 @@ export class CollectionReference extends Query {
    * @param data  - 数据
    * @param opts  - 可选配置项
    */
-  async add(
+  add(
+    data: any,
+    callback?: any
+  ): Promise<{
+    ids?: string[]
+    id?: string
+    inserted?: number // 事务调用返回
+    ok?: number // 事务调用返回
+    requestId: string
+  }> {
+    return withCallback(this._add(data), callback) as any
+  }
+
+  private async _add(
     data: any
   ): Promise<{
     ids?: string[]