@cloudbase/database 0.9.20 → 0.9.22

package/dist/esm/operator-map.js

@@ -0,0 +1,20 @@
+import { QUERY_COMMANDS_LITERAL } from './commands/query';
+import { LOGIC_COMMANDS_LITERAL } from './commands/logic';
+import { UPDATE_COMMANDS_LITERAL } from './commands/update';
+export var OperatorMap = {};
+for (var key in QUERY_COMMANDS_LITERAL) {
+    OperatorMap[key] = '$' + key;
+}
+for (var key in LOGIC_COMMANDS_LITERAL) {
+    OperatorMap[key] = '$' + key;
+}
+for (var key in UPDATE_COMMANDS_LITERAL) {
+    OperatorMap[key] = '$' + key;
+}
+OperatorMap[QUERY_COMMANDS_LITERAL.NEQ] = '$ne';
+OperatorMap[UPDATE_COMMANDS_LITERAL.REMOVE] = '$unset';
+OperatorMap[UPDATE_COMMANDS_LITERAL.SHIFT] = '$pop';
+OperatorMap[UPDATE_COMMANDS_LITERAL.UNSHIFT] = '$push';
+export function operatorToString(operator) {
+    return OperatorMap[operator] || '$' + operator;
+}

package/dist/esm/query.d.ts

@@ -0,0 +1,22 @@
+import { OrderByDirection } from './constant';
+import { IWatchOptions, DBRealtimeListener } from './typings/index';
+interface GetRes {
+    data: any[];
+    requestId: string;
+    total: number;
+    limit: number;
+    offset: number;
+}
+export declare class Query {
+    get(callback?: any): Promise<GetRes>;
+    count(callback?: any): any;
+    where(query: object): Query;
+    orderBy(fieldPath: string, directionStr: OrderByDirection): Query;
+    limit(limit: number): Query;
+    skip(offset: number): Query;
+    update(data: Object, callback?: any): Promise<any>;
+    field(projection: any): Query;
+    remove(callback?: any): any;
+    watch: (options: IWatchOptions) => DBRealtimeListener;
+}
+export {};

package/dist/esm/query.js

@@ -0,0 +1,249 @@
+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 { createPromiseCallback } from './lib/util';
+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 { ErrorCode } from './constant';
+import { getWsInstance } from './utils/utils';
+var Query = (function () {
+    function Query(db, coll, fieldFilters, fieldOrders, queryOptions) {
+        var _this = this;
+        this.watch = function (options) {
+            var ws = getWsInstance(_this._db);
+            return ws.watch(__assign(__assign({}, options), { envId: _this._db.config.env, collectionName: _this._coll, query: JSON.stringify(_this._fieldFilters || {}), limit: _this._queryOptions.limit, orderBy: _this._fieldOrders
+                    ? _this._fieldOrders.reduce(function (acc, cur) {
+                        acc[cur.field] = cur.direction;
+                        return acc;
+                    }, {})
+                    : undefined }));
+        };
+        this._db = db;
+        this._coll = coll;
+        this._fieldFilters = fieldFilters;
+        this._fieldOrders = fieldOrders || [];
+        this._queryOptions = queryOptions || {};
+        this._request = new Db.reqClass(this._db.config);
+    }
+    Query.prototype.get = function (callback) {
+        callback = callback || createPromiseCallback();
+        var newOder = [];
+        if (this._fieldOrders) {
+            this._fieldOrders.forEach(function (order) {
+                newOder.push(order);
+            });
+        }
+        var param = {
+            collectionName: this._coll,
+            queryType: QueryType.WHERE
+        };
+        if (this._fieldFilters) {
+            param.query = this._fieldFilters;
+        }
+        if (newOder.length > 0) {
+            param.order = newOder;
+        }
+        if (this._queryOptions.offset) {
+            param.offset = this._queryOptions.offset;
+        }
+        if (this._queryOptions.limit) {
+            param.limit = this._queryOptions.limit < 1000 ? this._queryOptions.limit : 1000;
+        }
+        else {
+            param.limit = 100;
+        }
+        if (this._queryOptions.projection) {
+            param.projection = this._queryOptions.projection;
+        }
+        this._request
+            .send('database.queryDocument', param)
+            .then(function (res) {
+            if (res.code) {
+                callback(0, res);
+            }
+            else {
+                var documents = Util.formatResDocumentData(res.data.list);
+                var 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;
+                callback(0, result);
+            }
+        })
+            .catch(function (err) {
+            callback(err);
+        });
+        return callback.promise;
+    };
+    Query.prototype.count = function (callback) {
+        callback = callback || createPromiseCallback();
+        var param = {
+            collectionName: this._coll,
+            queryType: QueryType.WHERE
+        };
+        if (this._fieldFilters) {
+            param.query = this._fieldFilters;
+        }
+        this._request
+            .send('database.countDocument', param)
+            .then(function (res) {
+            if (res.code) {
+                callback(0, res);
+            }
+            else {
+                callback(0, {
+                    requestId: res.requestId,
+                    total: res.data.total
+                });
+            }
+        })
+            .catch(function (e) {
+            callback(e);
+        });
+        return callback.promise;
+    };
+    Query.prototype.where = function (query) {
+        if (Object.prototype.toString.call(query).slice(8, -1) !== 'Object') {
+            throw Error(ErrorCode.QueryParamTypeError);
+        }
+        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.encode(query), this._fieldOrders, this._queryOptions);
+    };
+    Query.prototype.orderBy = function (fieldPath, directionStr) {
+        Validate.isFieldPath(fieldPath);
+        Validate.isFieldOrder(directionStr);
+        var newOrder = {
+            field: fieldPath,
+            direction: directionStr
+        };
+        var combinedOrders = this._fieldOrders.concat(newOrder);
+        return new Query(this._db, this._coll, this._fieldFilters, combinedOrders, this._queryOptions);
+    };
+    Query.prototype.limit = function (limit) {
+        Validate.isInteger('limit', limit);
+        var option = __assign({}, this._queryOptions);
+        option.limit = limit;
+        return new Query(this._db, this._coll, this._fieldFilters, this._fieldOrders, option);
+    };
+    Query.prototype.skip = function (offset) {
+        Validate.isInteger('offset', offset);
+        var option = __assign({}, this._queryOptions);
+        option.offset = offset;
+        return new Query(this._db, this._coll, this._fieldFilters, this._fieldOrders, option);
+    };
+    Query.prototype.update = function (data, callback) {
+        callback = callback || createPromiseCallback();
+        if (!data || typeof data !== 'object') {
+            return Promise.resolve({
+                code: 'INVALID_PARAM',
+                message: '参数必需是非空对象'
+            });
+        }
+        if (data.hasOwnProperty('_id')) {
+            return Promise.resolve({
+                code: 'INVALID_PARAM',
+                message: '不能更新_id的值'
+            });
+        }
+        var param = {
+            collectionName: this._coll,
+            query: this._fieldFilters,
+            queryType: QueryType.WHERE,
+            multi: true,
+            merge: true,
+            upsert: false,
+            data: UpdateSerializer.encode(data)
+        };
+        this._request
+            .send('database.updateDocument', param)
+            .then(function (res) {
+            if (res.code) {
+                callback(0, res);
+            }
+            else {
+                callback(0, {
+                    requestId: res.requestId,
+                    updated: res.data.updated,
+                    upsertId: res.data.upsert_id
+                });
+            }
+        })
+            .catch(function (e) {
+            callback(e);
+        });
+        return callback.promise;
+    };
+    Query.prototype.field = function (projection) {
+        for (var k in projection) {
+            if (projection[k]) {
+                if (typeof projection[k] !== 'object') {
+                    projection[k] = 1;
+                }
+            }
+            else {
+                projection[k] = 0;
+            }
+        }
+        var option = __assign({}, this._queryOptions);
+        option.projection = projection;
+        return new Query(this._db, this._coll, this._fieldFilters, this._fieldOrders, option);
+    };
+    Query.prototype.remove = function (callback) {
+        callback = callback || createPromiseCallback();
+        if (Object.keys(this._queryOptions).length > 0) {
+            console.warn('`offset`, `limit` and `projection` are not supported in remove() operation');
+        }
+        if (this._fieldOrders.length > 0) {
+            console.warn('`orderBy` is not supported in remove() operation');
+        }
+        var param = {
+            collectionName: this._coll,
+            query: QuerySerializer.encode(this._fieldFilters),
+            queryType: QueryType.WHERE,
+            multi: true
+        };
+        this._request
+            .send('database.deleteDocument', param)
+            .then(function (res) {
+            if (res.code) {
+                callback(0, res);
+            }
+            else {
+                callback(0, {
+                    requestId: res.requestId,
+                    deleted: res.data.deleted
+                });
+            }
+        })
+            .catch(function (e) {
+            callback(e);
+        });
+        return callback.promise;
+    };
+    return Query;
+}());
+export { Query };

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

@@ -0,0 +1,14 @@
+export declare class RegExp {
+    $regex: string;
+    $options: string;
+    constructor({ regexp, options }: {
+        regexp: any;
+        options: any;
+    });
+    parse(): {
+        $regex: string;
+        $options: string;
+    };
+    readonly _internalType: import("../utils/symbol").InternalSymbol;
+}
+export declare function RegExpConstructor(param: any): RegExp;

package/dist/esm/regexp/index.js

@@ -0,0 +1,29 @@
+import { SYMBOL_REGEXP } from '../helper/symbol';
+var RegExp = (function () {
+    function RegExp(_a) {
+        var regexp = _a.regexp, options = _a.options;
+        if (!regexp) {
+            throw new TypeError('regexp must be a string');
+        }
+        this.$regex = regexp;
+        this.$options = options;
+    }
+    RegExp.prototype.parse = function () {
+        return {
+            $regex: this.$regex,
+            $options: this.$options
+        };
+    };
+    Object.defineProperty(RegExp.prototype, "_internalType", {
+        get: function () {
+            return SYMBOL_REGEXP;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return RegExp;
+}());
+export { RegExp };
+export function RegExpConstructor(param) {
+    return new RegExp(param);
+}

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

@@ -0,0 +1,11 @@
+import { LogicCommand } from '../commands/logic';
+export declare type IQueryCondition = Record<string, any> | LogicCommand;
+export declare type AnyObject = {
+    [x: string]: any;
+};
+export declare function flattenQueryObject(query: Record<string, any>): Record<string, any>;
+export declare function flattenObject(object: AnyObject): AnyObject;
+export declare function mergeConditionAfterEncode(query: Record<string, any>, condition: Record<string, any>, key: string): void;
+export declare function isConversionRequired(val: any): boolean;
+export declare function encodeInternalDataType(val: any): IQueryCondition;
+export declare function decodeInternalDataType(object: AnyObject): any;

package/dist/esm/serializer/common.js

@@ -0,0 +1,113 @@
+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 __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;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+import { getType, isObject, isArray, isDate, isRegExp, isInternalObject } from '../utils/type';
+import { serialize as serializeInternalDataType, deserialize as deserializeInternalDataType } from './datatype';
+function flatten(query, shouldPreserverObject, parents, visited) {
+    var cloned = __assign({}, query);
+    for (var key in query) {
+        if (/^\$/.test(key))
+            continue;
+        var value = query[key];
+        if (!value)
+            continue;
+        if (isObject(value) && !shouldPreserverObject(value)) {
+            if (visited.indexOf(value) > -1) {
+                throw new Error('Cannot convert circular structure to JSON');
+            }
+            var newParents = __spread(parents, [
+                key,
+            ]);
+            var newVisited = __spread(visited, [
+                value,
+            ]);
+            var flattenedChild = flatten(value, shouldPreserverObject, newParents, newVisited);
+            cloned[key] = flattenedChild;
+            var hasKeyNotCombined = false;
+            for (var childKey in flattenedChild) {
+                if (!/^\$/.test(childKey)) {
+                    cloned[key + "." + childKey] = flattenedChild[childKey];
+                    delete cloned[key][childKey];
+                }
+                else {
+                    hasKeyNotCombined = true;
+                }
+            }
+            if (!hasKeyNotCombined) {
+                delete cloned[key];
+            }
+        }
+    }
+    return cloned;
+}
+export function flattenQueryObject(query) {
+    return flatten(query, isConversionRequired, [], [query]);
+}
+export function flattenObject(object) {
+    return flatten(object, function (_) { return false; }, [], [object]);
+}
+export function mergeConditionAfterEncode(query, condition, key) {
+    if (!condition[key]) {
+        delete query[key];
+    }
+    for (var conditionKey in condition) {
+        if (query[conditionKey]) {
+            if (isArray(query[conditionKey])) {
+                query[conditionKey].push(condition[conditionKey]);
+            }
+            else if (isObject(query[conditionKey])) {
+                if (isObject(condition[conditionKey])) {
+                    Object.assign(query[conditionKey], condition[conditionKey]);
+                }
+                else {
+                    console.warn("unmergable condition, query is object but condition is " + getType(condition) + ", can only overwrite", condition, key);
+                    query[conditionKey] = condition[conditionKey];
+                }
+            }
+            else {
+                console.warn("to-merge query is of type " + getType(query) + ", can only overwrite", query, condition, key);
+                query[conditionKey] = condition[conditionKey];
+            }
+        }
+        else {
+            query[conditionKey] = condition[conditionKey];
+        }
+    }
+}
+export function isConversionRequired(val) {
+    return isInternalObject(val) || isDate(val) || isRegExp(val);
+}
+export function encodeInternalDataType(val) {
+    return serializeInternalDataType(val);
+}
+export function decodeInternalDataType(object) {
+    return deserializeInternalDataType(object);
+}

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

@@ -0,0 +1,7 @@
+import { LogicCommand } from '../commands/logic';
+export declare type IQueryCondition = Record<string, any> | LogicCommand;
+export declare type AnyObject = {
+    [x: string]: any;
+};
+export declare function serialize(val: any): IQueryCondition;
+export declare function deserialize(object: AnyObject): any;

package/dist/esm/serializer/datatype.js

@@ -0,0 +1,122 @@
+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 __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;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+import { SYMBOL_GEO_POINT, SYMBOL_SERVER_DATE, SYMBOL_REGEXP } from '../helper/symbol';
+import { getType, isObject, isArray, isDate, isNumber, isInternalObject, isRegExp } from '../utils/type';
+import { Point } from '../geo/index';
+import { ServerDate } from '../serverDate/index';
+export function serialize(val) {
+    return serializeHelper(val, [val]);
+}
+function serializeHelper(val, visited) {
+    if (isInternalObject(val)) {
+        switch (val._internalType) {
+            case SYMBOL_GEO_POINT: {
+                return val.toJSON();
+            }
+            case SYMBOL_SERVER_DATE: {
+                return val.parse();
+            }
+            case SYMBOL_REGEXP: {
+                return val.parse();
+            }
+            default: {
+                return val.toJSON ? val.toJSON() : val;
+            }
+        }
+    }
+    else if (isDate(val)) {
+        return {
+            $date: +val,
+        };
+    }
+    else if (isRegExp(val)) {
+        return {
+            $regex: val.source,
+            $options: val.flags,
+        };
+    }
+    else if (isArray(val)) {
+        return val.map(function (item) {
+            if (visited.indexOf(item) > -1) {
+                throw new Error('Cannot convert circular structure to JSON');
+            }
+            return serializeHelper(item, __spread(visited, [
+                item,
+            ]));
+        });
+    }
+    else if (isObject(val)) {
+        var ret = __assign({}, val);
+        for (var key in ret) {
+            if (visited.indexOf(ret[key]) > -1) {
+                throw new Error('Cannot convert circular structure to JSON');
+            }
+            ret[key] = serializeHelper(ret[key], __spread(visited, [
+                ret[key],
+            ]));
+        }
+        return ret;
+    }
+    else {
+        return val;
+    }
+}
+export function deserialize(object) {
+    var ret = __assign({}, object);
+    for (var key in ret) {
+        switch (key) {
+            case '$date': {
+                switch (getType(ret[key])) {
+                    case 'number': {
+                        return new Date(ret[key]);
+                    }
+                    case 'object': {
+                        return new ServerDate(ret[key]);
+                    }
+                }
+                break;
+            }
+            case 'type': {
+                switch (ret.type) {
+                    case 'Point': {
+                        if (isArray(ret.coordinates) && isNumber(ret.coordinates[0]) && isNumber(ret.coordinates[1])) {
+                            return new Point(ret.coordinates[0], ret.coordinates[1]);
+                        }
+                        break;
+                    }
+                }
+                break;
+            }
+        }
+    }
+    return object;
+}

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

@@ -0,0 +1,7 @@
+import { QueryCommand } from '../commands/query';
+import { LogicCommand } from '../commands/logic';
+export declare type IQueryCondition = Record<string, any> | LogicCommand;
+export declare class QuerySerializer {
+    constructor();
+    static encode(query: IQueryCondition | QueryCommand | LogicCommand): IQueryCondition;
+}