@cloudbase/database 1.4.1 → 1.4.3-alpha.0

package/dist/commonjs/utils/utils.js

@@ -1,59 +1,59 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const bson_1 = require("bson");
-const type_1 = require("./type");
-exports.sleep = (ms = 0) => new Promise(r => setTimeout(r, ms));
-const counters = {};
-exports.autoCount = (domain = 'any') => {
-    if (!counters[domain]) {
-        counters[domain] = 0;
-    }
-    return counters[domain]++;
-};
-exports.getReqOpts = (apiOptions) => {
-    if (apiOptions.timeout !== undefined) {
-        return {
-            timeout: apiOptions.timeout
-        };
-    }
-    return {};
-};
-exports.filterUndefined = o => {
-    if (!type_1.isObject(o)) {
-        return o;
-    }
-    for (let key in o) {
-        if (o[key] === undefined) {
-            delete o[key];
-        }
-        else if (type_1.isObject(o[key])) {
-            o[key] = exports.filterUndefined(o[key]);
-        }
-    }
-    return o;
-};
-exports.stringifyByEJSON = params => {
-    params = exports.filterUndefined(params);
-    return bson_1.EJSON.stringify(params, { relaxed: false });
-};
-exports.parseByEJSON = params => {
-    return bson_1.EJSON.parse(params);
-};
-class TcbError extends Error {
-    constructor(error) {
-        super(error.message);
-        this.code = error.code;
-        this.message = error.message;
-    }
-}
-exports.TcbError = TcbError;
-exports.E = (errObj) => {
-    return new TcbError(errObj);
-};
-function processReturn(throwOnCode, res) {
-    if (throwOnCode === false) {
-        return res;
-    }
-    throw exports.E(Object.assign({}, res));
-}
-exports.processReturn = processReturn;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bson_1 = require("bson");
+const type_1 = require("./type");
+exports.sleep = (ms = 0) => new Promise(r => setTimeout(r, ms));
+const counters = {};
+exports.autoCount = (domain = 'any') => {
+    if (!counters[domain]) {
+        counters[domain] = 0;
+    }
+    return counters[domain]++;
+};
+exports.getReqOpts = (apiOptions) => {
+    if (apiOptions.timeout !== undefined) {
+        return {
+            timeout: apiOptions.timeout
+        };
+    }
+    return {};
+};
+exports.filterUndefined = o => {
+    if (!type_1.isObject(o)) {
+        return o;
+    }
+    for (let key in o) {
+        if (o[key] === undefined) {
+            delete o[key];
+        }
+        else if (type_1.isObject(o[key])) {
+            o[key] = exports.filterUndefined(o[key]);
+        }
+    }
+    return o;
+};
+exports.stringifyByEJSON = params => {
+    params = exports.filterUndefined(params);
+    return bson_1.EJSON.stringify(params, { relaxed: false });
+};
+exports.parseByEJSON = params => {
+    return bson_1.EJSON.parse(params);
+};
+class TcbError extends Error {
+    constructor(error) {
+        super(error.message);
+        this.code = error.code;
+        this.message = error.message;
+    }
+}
+exports.TcbError = TcbError;
+exports.E = (errObj) => {
+    return new TcbError(errObj);
+};
+function processReturn(throwOnCode, res) {
+    if (throwOnCode === false) {
+        return res;
+    }
+    throw exports.E(Object.assign({}, res));
+}
+exports.processReturn = processReturn;

package/dist/commonjs/validate.d.ts

@@ -1 +1 @@
-export {};
+export {};

package/dist/commonjs/validate.js

@@ -1,155 +1,155 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const constant_1 = require("./constant");
-const util_1 = require("./util");
-const code_1 = require("./const/code");
-const utils_1 = require("./utils/utils");
-const type_1 = require("./utils/type");
-const symbol_1 = require("./helper/symbol");
-const validOptionsKeys = ['limit', 'offset', 'projection', 'order', 'multiple', 'timeout', 'raw'];
-class Validate {
-    static isGeopoint(point, degree) {
-        if (util_1.Util.whichType(degree) !== constant_1.FieldType.Number) {
-            throw new Error('Geo Point must be number type');
-        }
-        const degreeAbs = Math.abs(degree);
-        if (point === 'latitude' && degreeAbs > 90) {
-            throw new Error('latitude should be a number ranges from -90 to 90');
-        }
-        else if (point === 'longitude' && degreeAbs > 180) {
-            throw new Error('longitude should be a number ranges from -180 to 180');
-        }
-        return true;
-    }
-    static isInteger(param, num) {
-        if (!Number.isInteger(num)) {
-            throw new Error(param + constant_1.ErrorCode.IntergerError);
-        }
-        return true;
-    }
-    static mustBeBoolean(param, bool) {
-        if (typeof bool !== 'boolean') {
-            throw new Error(param + constant_1.ErrorCode.BooleanError);
-        }
-        return true;
-    }
-    static isProjection(param, value) {
-        if (type_1.getType(value) !== 'object') {
-            throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: `${param} projection must be an object` }));
-        }
-        for (const key in value) {
-            const subValue = value[key];
-            if (type_1.getType(subValue) === 'number') {
-                if (subValue !== 0 && subValue !== 1) {
-                    throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: `if the value in projection is of number, it must be 0 or 1` }));
-                }
-            }
-            else if (type_1.getType(subValue) === 'object') {
-            }
-            else {
-                throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: 'invalid projection' }));
-            }
-        }
-        return true;
-    }
-    static isOrder(param, value) {
-        if (type_1.getType(value) !== 'object') {
-            throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: `${param} order must be an object` }));
-        }
-        for (let key in value) {
-            const subValue = value[key];
-            if (subValue !== 1 && subValue !== -1) {
-                throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: `order value must be 1 or -1` }));
-            }
-        }
-        return true;
-    }
-    static isFieldOrder(direction) {
-        if (constant_1.OrderDirectionList.indexOf(direction) === -1) {
-            throw new Error(constant_1.ErrorCode.DirectionError);
-        }
-        return true;
-    }
-    static isFieldPath(path) {
-        if (!/^[a-zA-Z0-9-_\.]/.test(path)) {
-            throw new Error();
-        }
-        return true;
-    }
-    static isOperator(op) {
-        if (constant_1.WhereFilterOpList.indexOf(op) === -1) {
-            throw new Error(constant_1.ErrorCode.OpStrError);
-        }
-        return true;
-    }
-    static isCollName(name) {
-        if (!/^[a-zA-Z0-9]([a-zA-Z0-9-_]){1,32}$/.test(name)) {
-            throw new Error(constant_1.ErrorCode.CollNameError);
-        }
-        return true;
-    }
-    static isDocID(docId) {
-        if (!/^([a-fA-F0-9]){24}$/.test(docId)) {
-            throw new Error(constant_1.ErrorCode.DocIDError);
-        }
-        return true;
-    }
-    static isValidOptions(options = {}) {
-        if (type_1.getType(options) !== 'object') {
-            throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: `options must be an object` }));
-        }
-        const keys = Object.keys(options);
-        for (const index in keys) {
-            if (validOptionsKeys.indexOf(keys[index]) < 0) {
-                throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: `${keys[index]} is invalid options key` }));
-            }
-        }
-        const { limit, offset, projection, order } = options;
-        const { multiple } = options;
-        if (limit !== undefined) {
-            Validate.isInteger('limit', limit);
-        }
-        if (offset !== undefined) {
-            Validate.isInteger('offset', offset);
-        }
-        if (projection !== undefined) {
-            Validate.isProjection('projection', projection);
-        }
-        if (order !== undefined) {
-            Validate.isOrder('order', order);
-        }
-        if (multiple !== undefined) {
-            Validate.mustBeBoolean('multiple', multiple);
-        }
-        if (options.timeout !== undefined) {
-            Validate.isInteger('timeout', options.timeout);
-        }
-        return true;
-    }
-    static isValidAggregation(stage) {
-        if (Object.keys(stage).length !== 1) {
-            throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: `aggregation stage must have one key` }));
-        }
-        return true;
-    }
-    static isCentersPhere(param) {
-        if (Array.isArray(param) && param.length === 2) {
-            if (type_1.getType(param[0]) === 'object' &&
-                param[0]._internalType === symbol_1.SYMBOL_GEO_POINT &&
-                typeof param[1] === 'number') {
-                return true;
-            }
-            if (Array.isArray(param[0]) && param[0].length === 2) {
-                const longitude = param[0][0];
-                const latitude = param[0][1];
-                Validate.isGeopoint('longitude', longitude);
-                Validate.isGeopoint('latitude', latitude);
-                if (typeof param[1] === 'number') {
-                    return true;
-                }
-            }
-        }
-        throw new Error(`${constant_1.ErrorCode.CentersPhereError}`);
-    }
-}
-exports.Validate = Validate;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constant_1 = require("./constant");
+const util_1 = require("./util");
+const code_1 = require("./const/code");
+const utils_1 = require("./utils/utils");
+const type_1 = require("./utils/type");
+const symbol_1 = require("./helper/symbol");
+const validOptionsKeys = ['limit', 'offset', 'projection', 'order', 'multiple', 'timeout', 'raw'];
+class Validate {
+    static isGeopoint(point, degree) {
+        if (util_1.Util.whichType(degree) !== constant_1.FieldType.Number) {
+            throw new Error('Geo Point must be number type');
+        }
+        const degreeAbs = Math.abs(degree);
+        if (point === 'latitude' && degreeAbs > 90) {
+            throw new Error('latitude should be a number ranges from -90 to 90');
+        }
+        else if (point === 'longitude' && degreeAbs > 180) {
+            throw new Error('longitude should be a number ranges from -180 to 180');
+        }
+        return true;
+    }
+    static isInteger(param, num) {
+        if (!Number.isInteger(num)) {
+            throw new Error(param + constant_1.ErrorCode.IntergerError);
+        }
+        return true;
+    }
+    static mustBeBoolean(param, bool) {
+        if (typeof bool !== 'boolean') {
+            throw new Error(param + constant_1.ErrorCode.BooleanError);
+        }
+        return true;
+    }
+    static isProjection(param, value) {
+        if (type_1.getType(value) !== 'object') {
+            throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: `${param} projection must be an object` }));
+        }
+        for (const key in value) {
+            const subValue = value[key];
+            if (type_1.getType(subValue) === 'number') {
+                if (subValue !== 0 && subValue !== 1) {
+                    throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: `if the value in projection is of number, it must be 0 or 1` }));
+                }
+            }
+            else if (type_1.getType(subValue) === 'object') {
+            }
+            else {
+                throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: 'invalid projection' }));
+            }
+        }
+        return true;
+    }
+    static isOrder(param, value) {
+        if (type_1.getType(value) !== 'object') {
+            throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: `${param} order must be an object` }));
+        }
+        for (let key in value) {
+            const subValue = value[key];
+            if (subValue !== 1 && subValue !== -1) {
+                throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: `order value must be 1 or -1` }));
+            }
+        }
+        return true;
+    }
+    static isFieldOrder(direction) {
+        if (constant_1.OrderDirectionList.indexOf(direction) === -1) {
+            throw new Error(constant_1.ErrorCode.DirectionError);
+        }
+        return true;
+    }
+    static isFieldPath(path) {
+        if (!/^[a-zA-Z0-9-_\.]/.test(path)) {
+            throw new Error();
+        }
+        return true;
+    }
+    static isOperator(op) {
+        if (constant_1.WhereFilterOpList.indexOf(op) === -1) {
+            throw new Error(constant_1.ErrorCode.OpStrError);
+        }
+        return true;
+    }
+    static isCollName(name) {
+        if (!/^[a-zA-Z0-9]([a-zA-Z0-9-_]){1,32}$/.test(name)) {
+            throw new Error(constant_1.ErrorCode.CollNameError);
+        }
+        return true;
+    }
+    static isDocID(docId) {
+        if (!/^([a-fA-F0-9]){24}$/.test(docId)) {
+            throw new Error(constant_1.ErrorCode.DocIDError);
+        }
+        return true;
+    }
+    static isValidOptions(options = {}) {
+        if (type_1.getType(options) !== 'object') {
+            throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: `options must be an object` }));
+        }
+        const keys = Object.keys(options);
+        for (const index in keys) {
+            if (validOptionsKeys.indexOf(keys[index]) < 0) {
+                throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: `${keys[index]} is invalid options key` }));
+            }
+        }
+        const { limit, offset, projection, order } = options;
+        const { multiple } = options;
+        if (limit !== undefined) {
+            Validate.isInteger('limit', limit);
+        }
+        if (offset !== undefined) {
+            Validate.isInteger('offset', offset);
+        }
+        if (projection !== undefined) {
+            Validate.isProjection('projection', projection);
+        }
+        if (order !== undefined) {
+            Validate.isOrder('order', order);
+        }
+        if (multiple !== undefined) {
+            Validate.mustBeBoolean('multiple', multiple);
+        }
+        if (options.timeout !== undefined) {
+            Validate.isInteger('timeout', options.timeout);
+        }
+        return true;
+    }
+    static isValidAggregation(stage) {
+        if (Object.keys(stage).length !== 1) {
+            throw utils_1.E(Object.assign(Object.assign({}, code_1.ERRORS.INVALID_PARAM), { message: `aggregation stage must have one key` }));
+        }
+        return true;
+    }
+    static isCentersPhere(param) {
+        if (Array.isArray(param) && param.length === 2) {
+            if (type_1.getType(param[0]) === 'object' &&
+                param[0]._internalType === symbol_1.SYMBOL_GEO_POINT &&
+                typeof param[1] === 'number') {
+                return true;
+            }
+            if (Array.isArray(param[0]) && param[0].length === 2) {
+                const longitude = param[0][0];
+                const latitude = param[0][1];
+                Validate.isGeopoint('longitude', longitude);
+                Validate.isGeopoint('latitude', latitude);
+                if (typeof param[1] === 'number') {
+                    return true;
+                }
+            }
+        }
+        throw new Error(`${constant_1.ErrorCode.CentersPhereError}`);
+    }
+}
+exports.Validate = Validate;

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

@@ -1,11 +1,11 @@
-export declare class ObjectId {
-    id: string;
-    constructor({ id }?: {
-        id?: string;
-    });
-    readonly _internalType: import("../utils/symbol").InternalSymbol;
-    parse(): {
-        $oid: string;
-    };
-}
-export declare function ObjectIdConstructor(opt: any): ObjectId;
+export declare class ObjectId {
+    id: string;
+    constructor({ id }?: {
+        id?: string;
+    });
+    readonly _internalType: import("../utils/symbol").InternalSymbol;
+    parse(): {
+        $oid: string;
+    };
+}
+export declare function ObjectIdConstructor(opt: any): ObjectId;

package/dist/esm/ObjectId/index.js

@@ -1,17 +1,17 @@
-import { SYMBOL_OBJECTID } from '../helper/symbol';
-export class ObjectId {
-    constructor({ id = '' } = {}) {
-        this.id = id;
-    }
-    get _internalType() {
-        return SYMBOL_OBJECTID;
-    }
-    parse() {
-        return {
-            $oid: this.id
-        };
-    }
-}
-export function ObjectIdConstructor(opt) {
-    return new ObjectId(opt);
-}
+import { SYMBOL_OBJECTID } from '../helper/symbol';
+export class ObjectId {
+    constructor({ id = '' } = {}) {
+        this.id = id;
+    }
+    get _internalType() {
+        return SYMBOL_OBJECTID;
+    }
+    parse() {
+        return {
+            $oid: this.id
+        };
+    }
+}
+export function ObjectIdConstructor(opt) {
+    return new ObjectId(opt);
+}

package/dist/esm/aggregate.d.ts

@@ -1,29 +1,29 @@
-export default class Aggregation {
-    _db: any;
-    _request: any;
-    _stages: any[];
-    _collectionName: string;
-    constructor(db?: any, collectionName?: any, rawPipeline?: any);
-    end(): Promise<any>;
-    unwrap(): any[];
-    done(): {
-        [x: number]: any;
-    }[];
-    _pipe(stage: any, param: any, raw?: boolean): this;
-    addFields(param: any): this;
-    bucket(param: any): this;
-    bucketAuto(param: any): this;
-    count(param: any): this;
-    geoNear(param: any): this;
-    group(param: any): this;
-    limit(param: any): this;
-    match(param: any): this;
-    project(param: any): this;
-    lookup(param: any): this;
-    replaceRoot(param: any): this;
-    sample(param: any): this;
-    skip(param: any): this;
-    sort(param: any): this;
-    sortByCount(param: any): this;
-    unwind(param: any): this;
-}
+export default class Aggregation {
+    _db: any;
+    _request: any;
+    _stages: any[];
+    _collectionName: string;
+    constructor(db?: any, collectionName?: any, rawPipeline?: any);
+    end(): Promise<any>;
+    unwrap(): any[];
+    done(): {
+        [x: number]: any;
+    }[];
+    _pipe(stage: any, param: any, raw?: boolean): this;
+    addFields(param: any): this;
+    bucket(param: any): this;
+    bucketAuto(param: any): this;
+    count(param: any): this;
+    geoNear(param: any): this;
+    group(param: any): this;
+    limit(param: any): this;
+    match(param: any): this;
+    project(param: any): this;
+    lookup(param: any): this;
+    replaceRoot(param: any): this;
+    sample(param: any): this;
+    skip(param: any): this;
+    sort(param: any): this;
+    sortByCount(param: any): this;
+    unwind(param: any): this;
+}