@cloudbase/database 1.4.3 → 1.5.0

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",
+  "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"
 }

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[]

package/src/document.ts

@@ -4,9 +4,8 @@ import { UpdateSerializer } from './serializer/update'
 import { serialize } from './serializer/datatype'
 import { UpdateCommand } from './commands/update'
 import { IWatchOptions, DBRealtimeListener } from './typings/index'
-import { RealtimeWebSocketClient } from './realtime/websocket-client'
 import { QueryType } from './constant'
-import { getReqOpts, stringifyByEJSON, processReturn } from './utils/utils'
+import { getWsInstance, getReqOpts, stringifyByEJSON, processReturn, withCallback } from './utils/utils'
 import { ERRORS } from './const/code'
 import { EJSON } from 'bson'
 import { QueryOption, UpdateOption } from './query'
@@ -24,11 +23,6 @@ export class DocumentReference {
 
   readonly _transactionId: string
 
-  /**
-   *
-   */
-  readonly projection: Object
-
   /**
    * 数据库引用
    *
@@ -73,7 +67,7 @@ export class DocumentReference {
     this.id = docID
     this._transactionId = transactionId
     /* eslint-disable new-cap*/
-    this.request = new Db.reqClass(this._db.config)
+    this.request = Db.createRequest(this._db.config)
     this._apiOptions = apiOptions
   }
 
@@ -83,16 +77,23 @@ export class DocumentReference {
    * @param data - 文档数据
    * @internal
    */
-  async create(data: any): Promise<any> {
+  create(data: any, callback?: any): Promise<any> {
+    return withCallback(this._create(data), callback)
+  }
+
+  private async _create(data: any): Promise<any> {
+    const isBatch = Array.isArray(data)
+
     // 存在docid 则放入data
-    if (this.id) {
+    if (!isBatch && this.id) {
       data['_id'] = this.id
     }
 
     let params = {
       collectionName: this._coll,
-      // data: Util.encodeDocumentDataForReq(data, false, false)
-      data: [stringifyByEJSON(serialize(data))],
+      data: isBatch
+        ? data.map((item: any) => stringifyByEJSON(serialize(item)))
+        : [stringifyByEJSON(serialize(data))],
       transactionId: this._transactionId
     }
 
@@ -116,11 +117,18 @@ export class DocumentReference {
       }
     }
 
+    // 批量创建，返回 ids
+    if (isBatch) {
+      return {
+        ids: (res.data && res.data.insertedIds) || [],
+        requestId: res.requestId
+      }
+    }
+
     return {
       id: res.data.insertedIds[0],
       requestId: res.requestId
     }
-    // }
   }
 
   /**
@@ -132,7 +140,11 @@ export class DocumentReference {
    * @param data - 文档数据
    * @param opts - 可选项
    */
-  async set(data: Object): Promise<any> {
+  set(data: Object, callback?: any): Promise<any> {
+    return withCallback(this._set(data), callback)
+  }
+
+  private async _set(data: Object): Promise<any> {
     if (!this.id) {
       return processReturn(this._db.config.throwOnCode, {
         ...ERRORS.INVALID_PARAM,
@@ -226,7 +238,11 @@ export class DocumentReference {
    * @param data - 文档数据
    * @param opts - 可选项
    */
-  async update(data: Object): Promise<any> {
+  update(data: Object, callback?: any): Promise<any> {
+    return withCallback(this._update(data), callback)
+  }
+
+  private async _update(data: Object): Promise<any> {
     if (!data || typeof data !== 'object') {
       return processReturn(this._db.config.throwOnCode, {
         ...ERRORS.INVALID_PARAM,
@@ -277,14 +293,18 @@ export class DocumentReference {
   /**
    * 删除文档（事务兼容delete接口）
    */
-  async delete(): Promise<any> {
-    return this.remove()
+  delete(callback?: any): Promise<any> {
+    return this.remove(callback)
   }
 
   /**
    * 删除文档
    */
-  async remove(): Promise<any> {
+  remove(callback?: any): Promise<any> {
+    return withCallback(this._remove(), callback)
+  }
+
+  private async _remove(): Promise<any> {
     const query = stringifyByEJSON({ _id: this.id })
     const param = {
       collectionName: this._coll,
@@ -317,7 +337,11 @@ export class DocumentReference {
   /**
    * 返回选中的文档（_id）
    */
-  async get(): Promise<any> {
+  get(callback?: any): Promise<any> {
+    return withCallback(this._get(), callback)
+  }
+
+  private async _get(): Promise<any> {
     const query = stringifyByEJSON({ _id: this.id })
     const { projection } = this._apiOptions as QueryOption
     const param: any = {
@@ -327,7 +351,6 @@ export class DocumentReference {
       queryType: QueryType.DOC,
       multi: false
     }
-
     if (projection) {
       param.projection = stringifyByEJSON(projection)
     }
@@ -387,20 +410,9 @@ export class DocumentReference {
    * 监听单个文档
    */
   watch = (options: IWatchOptions): DBRealtimeListener => {
-    if (!Db.ws) {
-      Db.ws = new RealtimeWebSocketClient({
-        context: {
-          appConfig: {
-            docSizeLimit: 1000,
-            realtimePingInterval: 10000,
-            realtimePongWaitTimeout: 5000,
-            request: this.request
-          }
-        }
-      })
-    }
+    const ws = getWsInstance(this._db)
 
-    return (Db.ws as RealtimeWebSocketClient).watch({
+    return ws.watch({
       ...options,
       envId: this._db.config.env,
       collectionName: this._coll,
@@ -409,6 +421,5 @@ export class DocumentReference {
         _id: this.id
       })
     })
-    // })
   }
 }