@cloudbase/database 1.4.1 → 1.4.2

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudbase/database",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "description": "database for (node.)js sdk ",
   "main": "dist/commonjs/index.js",
   "module": "dist/esm/index.js",
@@ -8,8 +8,7 @@
     "eslint": "eslint \"./**/*.ts\"",
     "eslint-fix": "eslint --fix \"./**/*.ts\"",
     "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "tsc -p tsconfig.json && tsc -p tsconfig.esm.json",
-    "prepublishOnly": "npm run build"
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.esm.json"
   },
   "author": "",
   "license": "ISC",

package/src/document.ts

@@ -352,9 +352,7 @@ export class DocumentReference {
 
     return {
       data: documents,
-      requestId: res.requestId,
-      offset: res.data.offset,
-      limit: res.data.limit
+      requestId: res.requestId
     }
     // }
   }

package/src/query.ts

@@ -242,6 +242,7 @@ export class Query {
       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

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

@@ -1,11 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-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;
-}

package/dist/esm/aggregate.js

@@ -1,121 +0,0 @@
-import { Db } from './index';
-import { EJSON } from 'bson';
-import { QuerySerializer } from './serializer/query';
-import { stringifyByEJSON } from './utils/utils';
-import { getType } from './utils/type';
-import { Validate } from './validate';
-import { Point } from './geo/point';
-export default class Aggregation {
-    constructor(db, collectionName, rawPipeline) {
-        this._stages = [];
-        if (db && collectionName) {
-            this._db = db;
-            this._request = new Db.reqClass(this._db.config);
-            this._collectionName = collectionName;
-            if (rawPipeline && rawPipeline.length > 0) {
-                rawPipeline.forEach((stage) => {
-                    Validate.isValidAggregation(stage);
-                    const stageName = Object.keys(stage)[0];
-                    this._pipe(stageName, stage[stageName], true);
-                });
-            }
-        }
-    }
-    async end() {
-        if (!this._collectionName || !this._db) {
-            throw new Error('Aggregation pipeline cannot send request');
-        }
-        const result = await this._request.send('database.aggregateDocuments', {
-            collectionName: this._collectionName,
-            stages: this._stages
-        });
-        if (result && result.data && result.data.list) {
-            return {
-                requestId: result.requestId,
-                data: result.data.list.map(EJSON.parse)
-            };
-        }
-        return result;
-    }
-    unwrap() {
-        return this._stages;
-    }
-    done() {
-        return this._stages.map(({ stageKey, stageValue }) => {
-            return {
-                [stageKey]: JSON.parse(stageValue)
-            };
-        });
-    }
-    _pipe(stage, param, raw = false) {
-        let transformParam = '';
-        if (getType(param) === 'object') {
-            transformParam = stringifyByEJSON(param);
-        }
-        else {
-            transformParam = JSON.stringify(param);
-        }
-        this._stages.push({
-            stageKey: raw ? stage : `$${stage}`,
-            stageValue: transformParam
-        });
-        return this;
-    }
-    addFields(param) {
-        return this._pipe('addFields', param);
-    }
-    bucket(param) {
-        return this._pipe('bucket', param);
-    }
-    bucketAuto(param) {
-        return this._pipe('bucketAuto', param);
-    }
-    count(param) {
-        return this._pipe('count', param);
-    }
-    geoNear(param) {
-        if (param.query) {
-            param.query = QuerySerializer.encode(param.query);
-        }
-        if (param.distanceMultiplier && typeof (param.distanceMultiplier) === 'number') {
-            param.distanceMultiplier = param.distanceMultiplier;
-        }
-        if (param.near) {
-            param.near = new Point(param.near.longitude, param.near.latitude).toJSON();
-        }
-        return this._pipe('geoNear', param);
-    }
-    group(param) {
-        return this._pipe('group', param);
-    }
-    limit(param) {
-        return this._pipe('limit', param);
-    }
-    match(param) {
-        return this._pipe('match', QuerySerializer.encode(param));
-    }
-    project(param) {
-        return this._pipe('project', param);
-    }
-    lookup(param) {
-        return this._pipe('lookup', param);
-    }
-    replaceRoot(param) {
-        return this._pipe('replaceRoot', param);
-    }
-    sample(param) {
-        return this._pipe('sample', param);
-    }
-    skip(param) {
-        return this._pipe('skip', param);
-    }
-    sort(param) {
-        return this._pipe('sort', param);
-    }
-    sortByCount(param) {
-        return this._pipe('sortByCount', param);
-    }
-    unwind(param) {
-        return this._pipe('unwind', param);
-    }
-}

package/dist/esm/collection.d.ts

@@ -1,17 +0,0 @@
-import { DocumentReference } from './document';
-import { Query, QueryOption, UpdateOption } from './query';
-import Aggregation from './aggregate';
-export declare class CollectionReference extends Query {
-    protected _transactionId: string;
-    readonly name: string;
-    doc(docID: string | number): DocumentReference;
-    add(data: any): Promise<{
-        ids?: string[];
-        id?: string;
-        inserted?: number;
-        ok?: number;
-        requestId: string;
-    }>;
-    aggregate(rawPipeline?: object[]): Aggregation;
-    options(apiOptions: QueryOption | UpdateOption): CollectionReference;
-}

package/dist/esm/collection.js

@@ -1,69 +0,0 @@
-import { DocumentReference } from './document';
-import { Query } from './query';
-import Aggregation from './aggregate';
-import { serialize } from './serializer/datatype';
-import { getReqOpts, stringifyByEJSON } from './utils/utils';
-import { Validate } from './validate';
-import { isArray } from './utils/type';
-export class CollectionReference extends Query {
-    constructor(db, coll, apiOptions, transactionId) {
-        super(db, coll, '', apiOptions, transactionId);
-        if (transactionId) {
-            this._transactionId = transactionId;
-        }
-    }
-    get name() {
-        return this._coll;
-    }
-    doc(docID) {
-        if (typeof docID !== 'string' && typeof docID !== 'number') {
-            throw new Error('docId必须为字符串或数字');
-        }
-        return new DocumentReference(this._db, this._coll, this._apiOptions, docID, this._transactionId);
-    }
-    async add(data) {
-        let transformData = data;
-        if (!isArray(data)) {
-            transformData = [data];
-        }
-        transformData = transformData.map(item => {
-            return stringifyByEJSON(serialize(item));
-        });
-        let params = {
-            collectionName: this._coll,
-            data: transformData
-        };
-        if (this._transactionId) {
-            params.transactionId = this._transactionId;
-        }
-        const res = await this._request.send('database.insertDocument', params, getReqOpts(this._apiOptions));
-        if (res.code) {
-            return res;
-        }
-        if (!isArray(data)) {
-            if (this._transactionId) {
-                return {
-                    inserted: 1,
-                    ok: 1,
-                    id: res.data.insertedIds[0],
-                    requestId: res.requestId
-                };
-            }
-            return {
-                id: res.data.insertedIds[0],
-                requestId: res.requestId
-            };
-        }
-        return {
-            ids: res.data.insertedIds,
-            requestId: res.requestId
-        };
-    }
-    aggregate(rawPipeline = []) {
-        return new Aggregation(this._db, this._coll, (this._apiOptions.raw || false) ? rawPipeline : []);
-    }
-    options(apiOptions) {
-        Validate.isValidOptions(apiOptions);
-        return new CollectionReference(this._db, this._coll, apiOptions, this._transactionId);
-    }
-}