@cloudbase/database 1.4.3 → 1.5.1

package/dist/esm/query.js

@@ -1,181 +1,278 @@
+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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
 import { QueryType } from './constant';
 import { Db } from './index';
 import { Validate } from './validate';
 import { Util } from './util';
 import { QuerySerializer } from './serializer/query';
 import { UpdateSerializer } from './serializer/update';
-import { RealtimeWebSocketClient } from './realtime/websocket-client';
 import { ErrorCode } from './constant';
-import { getReqOpts, stringifyByEJSON, processReturn } from './utils/utils';
+import { getWsInstance, getReqOpts, stringifyByEJSON, toWatchQuery, processReturn, withCallback } from './utils/utils';
 import { ERRORS } from './const/code';
 import { EJSON } from 'bson';
-export class Query {
-    constructor(db, coll, fieldFilters, apiOptions, transactionId) {
-        this.watch = (options) => {
-            if (!Db.ws) {
-                Db.ws = new RealtimeWebSocketClient({
-                    context: {
-                        appConfig: {
-                            docSizeLimit: 1000,
-                            realtimePingInterval: 10000,
-                            realtimePongWaitTimeout: 5000,
-                            request: this._request
-                        }
-                    }
-                });
-            }
-            const { limit, order } = this._apiOptions;
-            return Db.ws.watch(Object.assign(Object.assign({}, options), { envId: this._db.config.env, collectionName: this._coll, query: JSON.stringify(this._fieldFilters), limit, orderBy: order
-                    ? order.reduce((acc, cur) => {
-                        acc[cur.field] = cur.direction;
-                        return acc;
-                    }, {})
-                    : undefined }));
+var Query = (function () {
+    function Query(db, coll, fieldFilters, apiOptions, transactionId) {
+        var _this = this;
+        this.watch = function (options) {
+            var ws = getWsInstance(_this._db);
+            var _a = _this._apiOptions, limit = _a.limit, order = _a.order;
+            var orderBy = order
+                ? Object.entries(order).reduce(function (acc, _a) {
+                    var _b = __read(_a, 2), field = _b[0], direction = _b[1];
+                    acc[field] = direction === -1 ? 'desc' : 'asc';
+                    return acc;
+                }, {})
+                : undefined;
+            return ws.watch(__assign(__assign({}, options), { envId: _this._db.config.env, collectionName: _this._coll, query: toWatchQuery(_this._fieldFilters), limit: limit, orderBy: orderBy }));
         };
         this._db = db;
         this._coll = coll;
         this._fieldFilters = fieldFilters;
         this._apiOptions = apiOptions || {};
-        this._request = new Db.reqClass(this._db.config);
+        this._request = Db.createRequest(this._db.config);
         this._transactionId = transactionId;
     }
-    async get() {
-        const order = this._apiOptions.order;
-        let param = {
-            collectionName: this._coll,
-            queryType: QueryType.WHERE,
-            transactionId: this._transactionId
-        };
-        if (this._fieldFilters) {
-            param.query = this._fieldFilters;
-        }
-        if (order) {
-            param.order = stringifyByEJSON(order);
-        }
-        const offset = this._apiOptions.offset;
-        if (offset) {
-            param.offset = offset;
-        }
-        const limit = this._apiOptions.limit;
-        if (limit) {
-            param.limit = limit < 1000 ? limit : 1000;
-        }
-        else {
-            param.limit = 100;
-        }
-        const projection = this._apiOptions.projection;
-        if (projection) {
-            param.projection = stringifyByEJSON(projection);
-        }
-        const res = await this._request.send('database.getDocument', param, getReqOpts(this._apiOptions));
-        if (res.code) {
-            return res;
-        }
-        const list = res.data.list.map(item => EJSON.parse(item));
-        const documents = Util.formatResDocumentData(list);
-        const result = {
-            data: documents,
-            requestId: res.requestId
-        };
-        if (res.total)
-            result.total = res.total;
-        if (res.limit)
-            result.limit = res.limit;
-        if (res.offset)
-            result.offset = res.offset;
-        return result;
-    }
-    async count() {
-        let param = {
-            collectionName: this._coll,
-            queryType: QueryType.WHERE
-        };
-        if (this._fieldFilters) {
-            param.query = this._fieldFilters;
-        }
-        const res = await this._request.send('database.calculateDocument', param, getReqOpts(this._apiOptions));
-        if (res.code) {
-            return res;
-        }
-        return {
-            requestId: res.requestId,
-            total: res.data.total
-        };
-    }
-    where(query) {
+    Query.prototype.get = function (callback) {
+        return withCallback(this._get(), callback);
+    };
+    Query.prototype._get = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var order, param, offset, limit, projection, res, list, documents, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        order = this._apiOptions.order;
+                        param = {
+                            collectionName: this._coll,
+                            queryType: QueryType.WHERE,
+                            transactionId: this._transactionId
+                        };
+                        if (this._fieldFilters) {
+                            param.query = this._fieldFilters;
+                        }
+                        if (order) {
+                            param.order = stringifyByEJSON(order);
+                        }
+                        offset = this._apiOptions.offset;
+                        if (offset) {
+                            param.offset = offset;
+                        }
+                        limit = this._apiOptions.limit;
+                        if (limit) {
+                            param.limit = limit < 1000 ? limit : 1000;
+                        }
+                        else {
+                            param.limit = 100;
+                        }
+                        projection = this._apiOptions.projection;
+                        if (projection) {
+                            param.projection = stringifyByEJSON(projection);
+                        }
+                        return [4, this._request.send('database.getDocument', param, getReqOpts(this._apiOptions))];
+                    case 1:
+                        res = _a.sent();
+                        if (res.code) {
+                            return [2, res];
+                        }
+                        list = res.data.list.map(function (item) { return EJSON.parse(item); });
+                        documents = Util.formatResDocumentData(list);
+                        result = {
+                            data: documents,
+                            requestId: res.requestId
+                        };
+                        if (res.total)
+                            result.total = res.total;
+                        if (res.limit)
+                            result.limit = res.limit;
+                        if (res.offset)
+                            result.offset = res.offset;
+                        return [2, result];
+                }
+            });
+        });
+    };
+    Query.prototype.count = function (callback) {
+        return withCallback(this._count(), callback);
+    };
+    Query.prototype._count = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var param, res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        param = {
+                            collectionName: this._coll,
+                            queryType: QueryType.WHERE
+                        };
+                        if (this._fieldFilters) {
+                            param.query = this._fieldFilters;
+                        }
+                        return [4, this._request.send('database.calculateDocument', param, getReqOpts(this._apiOptions))];
+                    case 1:
+                        res = _a.sent();
+                        if (res.code) {
+                            return [2, res];
+                        }
+                        return [2, {
+                                requestId: res.requestId,
+                                total: res.data.total
+                            }];
+                }
+            });
+        });
+    };
+    Query.prototype.where = function (query) {
         if (Object.prototype.toString.call(query).slice(8, -1) !== 'Object') {
             throw Error(ErrorCode.QueryParamTypeError);
         }
-        const keys = Object.keys(query);
-        const checkFlag = keys.some(item => {
+        var keys = Object.keys(query);
+        var checkFlag = keys.some(function (item) {
             return query[item] !== undefined;
         });
         if (keys.length && !checkFlag) {
             throw Error(ErrorCode.QueryParamValueError);
         }
         return new Query(this._db, this._coll, QuerySerializer.encodeEJSON(query, this._apiOptions.raw || false), this._apiOptions, this._transactionId);
-    }
-    options(apiOptions) {
+    };
+    Query.prototype.options = function (apiOptions) {
         Validate.isValidOptions(apiOptions);
         return new Query(this._db, this._coll, this._fieldFilters, apiOptions, this._transactionId);
-    }
-    orderBy(fieldPath, directionStr) {
+    };
+    Query.prototype.orderBy = function (fieldPath, directionStr) {
+        var _a;
         Validate.isFieldPath(fieldPath);
         Validate.isFieldOrder(directionStr);
-        const newOrder = {
-            [fieldPath]: directionStr === 'desc' ? -1 : 1
-        };
-        const order = this._apiOptions.order || {};
-        const newApiOption = Object.assign({}, this._apiOptions, {
+        var newOrder = (_a = {},
+            _a[fieldPath] = directionStr === 'desc' ? -1 : 1,
+            _a);
+        var order = this._apiOptions.order || {};
+        var newApiOption = Object.assign({}, this._apiOptions, {
             order: Object.assign({}, order, newOrder)
         });
         return new Query(this._db, this._coll, this._fieldFilters, newApiOption, this._transactionId);
-    }
-    limit(limit) {
+    };
+    Query.prototype.limit = function (limit) {
         Validate.isInteger('limit', limit);
-        let newApiOption = Object.assign({}, this._apiOptions);
+        var newApiOption = __assign({}, this._apiOptions);
         newApiOption.limit = limit;
         return new Query(this._db, this._coll, this._fieldFilters, newApiOption, this._transactionId);
-    }
-    skip(offset) {
+    };
+    Query.prototype.skip = function (offset) {
         Validate.isInteger('offset', offset);
-        let newApiOption = Object.assign({}, this._apiOptions);
+        var newApiOption = __assign({}, this._apiOptions);
         newApiOption.offset = offset;
         return new Query(this._db, this._coll, this._fieldFilters, newApiOption, this._transactionId);
-    }
-    async update(data) {
-        if (!data || typeof data !== 'object') {
-            return processReturn(this._db.config.throwOnCode, Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: '参数必需是非空对象' }));
-        }
-        if (data.hasOwnProperty('_id')) {
-            return processReturn(this._db.config.throwOnCode, Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: '不能更新_id的值' }));
-        }
-        let { multiple } = this._apiOptions;
-        const multi = multiple === undefined ? true : multiple;
-        let param = {
-            collectionName: this._coll,
-            queryType: QueryType.WHERE,
-            multi,
-            merge: true,
-            upsert: false,
-            data: UpdateSerializer.encodeEJSON(data, this._apiOptions.raw || false)
-        };
-        if (this._fieldFilters) {
-            param.query = this._fieldFilters;
-        }
-        const res = await this._request.send('database.modifyDocument', param, getReqOpts(this._apiOptions));
-        if (res.code) {
-            return res;
-        }
-        return {
-            requestId: res.requestId,
-            updated: res.data.updated,
-            upsertId: res.data.upsert_id
-        };
-    }
-    field(projection) {
-        let transformProjection = {};
-        for (let k in projection) {
+    };
+    Query.prototype.update = function (data, callback) {
+        return withCallback(this._update(data), callback);
+    };
+    Query.prototype._update = function (data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var multiple, multi, param, res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!data || typeof data !== 'object') {
+                            return [2, processReturn(this._db.config.throwOnCode, __assign(__assign({}, ERRORS.INVALID_PARAM), { message: '参数必需是非空对象' }))];
+                        }
+                        if (data.hasOwnProperty('_id')) {
+                            return [2, processReturn(this._db.config.throwOnCode, __assign(__assign({}, ERRORS.INVALID_PARAM), { message: '不能更新_id的值' }))];
+                        }
+                        multiple = this._apiOptions.multiple;
+                        multi = multiple === undefined ? true : multiple;
+                        param = {
+                            collectionName: this._coll,
+                            queryType: QueryType.WHERE,
+                            multi: multi,
+                            merge: true,
+                            upsert: false,
+                            data: UpdateSerializer.encodeEJSON(data, this._apiOptions.raw || false)
+                        };
+                        if (this._transactionId) {
+                            param.transactionId = this._transactionId;
+                        }
+                        if (this._fieldFilters) {
+                            param.query = this._fieldFilters;
+                        }
+                        return [4, this._request.send('database.modifyDocument', param, getReqOpts(this._apiOptions))];
+                    case 1:
+                        res = _a.sent();
+                        if (res.code) {
+                            return [2, res];
+                        }
+                        return [2, {
+                                requestId: res.requestId,
+                                updated: res.data.updated,
+                                upsertId: res.data.upsert_id
+                            }];
+                }
+            });
+        });
+    };
+    Query.prototype.field = function (projection) {
+        var transformProjection = {};
+        for (var k in projection) {
             if (typeof projection[k] === 'boolean') {
                 transformProjection[k] = projection[k] === true ? 1 : 0;
             }
@@ -186,61 +283,89 @@ export class Query {
                 transformProjection[k] = projection[k];
             }
         }
-        let newApiOption = Object.assign({}, this._apiOptions);
+        var newApiOption = __assign({}, this._apiOptions);
         newApiOption.projection = transformProjection;
         return new Query(this._db, this._coll, this._fieldFilters, newApiOption, this._transactionId);
-    }
-    async remove() {
-        const { offset, limit, projection, order } = this._apiOptions;
-        if (offset !== undefined ||
-            limit !== undefined ||
-            projection !== undefined ||
-            order !== undefined) {
-            console.warn('`offset`, `limit`, `projection`, `orderBy` are not supported in remove() operation');
-        }
-        let { multiple } = this._apiOptions;
-        const multi = multiple === undefined ? true : multiple;
-        const param = {
-            collectionName: this._coll,
-            query: this._fieldFilters,
-            queryType: QueryType.WHERE,
-            multi
-        };
-        const res = await this._request.send('database.removeDocument', param, getReqOpts(this._apiOptions));
-        if (res.code) {
-            return res;
-        }
-        return {
-            requestId: res.requestId,
-            deleted: res.data.deleted
-        };
-    }
-    async updateAndReturn(data) {
-        if (!data || typeof data !== 'object') {
-            return processReturn(this._db.config.throwOnCode, Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: '参数必需是非空对象' }));
-        }
-        if (data.hasOwnProperty('_id')) {
-            return processReturn(this._db.config.throwOnCode, Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: '不能更新_id的值' }));
-        }
-        let param = {
-            collectionName: this._coll,
-            queryType: QueryType.WHERE,
-            data: UpdateSerializer.encodeEJSON(data, false)
-        };
-        if (this._transactionId) {
-            param.transactionId = this._transactionId;
-        }
-        if (this._fieldFilters) {
-            param.query = this._fieldFilters;
-        }
-        const res = await this._request.send('database.modifyAndReturnDoc', param, getReqOpts(this._apiOptions));
-        if (res.code) {
-            return res;
-        }
-        return {
-            requestId: res.requestId,
-            updated: res.data.updated,
-            doc: res.data.doc && EJSON.parse(res.data.doc)
-        };
-    }
-}
+    };
+    Query.prototype.remove = function (callback) {
+        return withCallback(this._remove(), callback);
+    };
+    Query.prototype._remove = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, offset, limit, projection, order, multiple, multi, param, res;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this._apiOptions, offset = _a.offset, limit = _a.limit, projection = _a.projection, order = _a.order;
+                        if (offset !== undefined ||
+                            limit !== undefined ||
+                            projection !== undefined ||
+                            order !== undefined) {
+                            console.warn('`offset`, `limit`, `projection`, `orderBy` are not supported in remove() operation');
+                        }
+                        multiple = this._apiOptions.multiple;
+                        multi = multiple === undefined ? true : multiple;
+                        param = {
+                            collectionName: this._coll,
+                            query: this._fieldFilters,
+                            queryType: QueryType.WHERE,
+                            multi: multi
+                        };
+                        if (this._transactionId) {
+                            param.transactionId = this._transactionId;
+                        }
+                        return [4, this._request.send('database.removeDocument', param, getReqOpts(this._apiOptions))];
+                    case 1:
+                        res = _b.sent();
+                        if (res.code) {
+                            return [2, res];
+                        }
+                        return [2, {
+                                requestId: res.requestId,
+                                deleted: res.data.deleted
+                            }];
+                }
+            });
+        });
+    };
+    Query.prototype.updateAndReturn = function (data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var param, res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!data || typeof data !== 'object') {
+                            return [2, processReturn(this._db.config.throwOnCode, __assign(__assign({}, ERRORS.INVALID_PARAM), { message: '参数必需是非空对象' }))];
+                        }
+                        if (data.hasOwnProperty('_id')) {
+                            return [2, processReturn(this._db.config.throwOnCode, __assign(__assign({}, ERRORS.INVALID_PARAM), { message: '不能更新_id的值' }))];
+                        }
+                        param = {
+                            collectionName: this._coll,
+                            queryType: QueryType.WHERE,
+                            data: UpdateSerializer.encodeEJSON(data, false)
+                        };
+                        if (this._transactionId) {
+                            param.transactionId = this._transactionId;
+                        }
+                        if (this._fieldFilters) {
+                            param.query = this._fieldFilters;
+                        }
+                        return [4, this._request.send('database.modifyAndReturnDoc', param, getReqOpts(this._apiOptions))];
+                    case 1:
+                        res = _a.sent();
+                        if (res.code) {
+                            return [2, res];
+                        }
+                        return [2, {
+                                requestId: res.requestId,
+                                updated: res.data.updated,
+                                doc: res.data.doc && EJSON.parse(res.data.doc)
+                            }];
+                }
+            });
+        });
+    };
+    return Query;
+}());
+export { Query };

package/dist/esm/regexp/index.d.ts

@@ -13,6 +13,6 @@ export declare class RegExp {
             options: string;
         };
     };
-    readonly _internalType: import("../utils/symbol").InternalSymbol;
+    get _internalType(): import("../utils/symbol").InternalSymbol;
 }
 export declare function RegExpConstructor(param: any): RegExp;

package/dist/esm/regexp/index.js

@@ -1,6 +1,7 @@
 import { SYMBOL_REGEXP } from '../helper/symbol';
-export class RegExp {
-    constructor({ regexp, options }) {
+var RegExp = (function () {
+    function RegExp(_a) {
+        var regexp = _a.regexp, options = _a.options;
         if (!regexp) {
             throw new TypeError('regexp must be a string');
         }
@@ -9,18 +10,24 @@ export class RegExp {
             options: options || ''
         };
     }
-    parse() {
+    RegExp.prototype.parse = function () {
         return {
             $regularExpression: {
                 pattern: this.$regularExpression.pattern,
                 options: this.$regularExpression.options
             }
         };
-    }
-    get _internalType() {
-        return SYMBOL_REGEXP;
-    }
-}
+    };
+    Object.defineProperty(RegExp.prototype, "_internalType", {
+        get: function () {
+            return SYMBOL_REGEXP;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return RegExp;
+}());
+export { RegExp };
 export function RegExpConstructor(param) {
     return new RegExp(param);
 }

package/dist/esm/serializer/common.d.ts

@@ -1,6 +1,6 @@
 import { LogicCommand } from '../commands/logic';
-export declare type IQueryCondition = Record<string, any> | LogicCommand;
-export declare type AnyObject = {
+export type IQueryCondition = Record<string, any> | LogicCommand;
+export type AnyObject = {
     [x: string]: any;
 };
 export declare function flattenQueryObject(query: Record<string, any>): Record<string, any>;