@cloudbase/js-sdk 3.6.4 → 3.6.5-alpha.1

package/database/dist/esm/query.js

@@ -1,249 +0,0 @@
-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 = Db.createRequest(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 !== undefined)
-                    result.total = res.total;
-                if (res.limit !== undefined)
-                    result.limit = res.limit;
-                if (res.offset !== undefined)
-                    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/database/dist/esm/regexp/index.d.ts

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

package/database/dist/esm/regexp/index.js

@@ -1,29 +0,0 @@
-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: false,
-        configurable: true
-    });
-    return RegExp;
-}());
-export { RegExp };
-export function RegExpConstructor(param) {
-    return new RegExp(param);
-}

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

@@ -1,11 +0,0 @@
-import { LogicCommand } from '../commands/logic';
-export type IQueryCondition = Record<string, any> | LogicCommand;
-export 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/database/dist/esm/serializer/common.js

@@ -1,118 +0,0 @@
-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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-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 = __spreadArray(__spreadArray([], __read(parents), false), [
-                key,
-            ], false);
-            var newVisited = __spreadArray(__spreadArray([], __read(visited), false), [
-                value,
-            ], false);
-            var flattenedChild = flatten(value, shouldPreserverObject, newParents, newVisited);
-            cloned[key] = flattenedChild;
-            var hasKeyNotCombined = false;
-            for (var childKey in flattenedChild) {
-                if (!/^\$/.test(childKey)) {
-                    cloned["".concat(key, ".").concat(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 ".concat(getType(condition), ", can only overwrite"), condition, key);
-                    query[conditionKey] = condition[conditionKey];
-                }
-            }
-            else {
-                console.warn("to-merge query is of type ".concat(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/database/dist/esm/serializer/datatype.d.ts

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

package/database/dist/esm/serializer/datatype.js

@@ -1,127 +0,0 @@
-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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-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, __spreadArray(__spreadArray([], __read(visited), false), [
-                item,
-            ], false));
-        });
-    }
-    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], __spreadArray(__spreadArray([], __read(visited), false), [
-                ret[key],
-            ], false));
-        }
-        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/database/dist/esm/serializer/query.d.ts

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