@cloudbase/database 1.2.3 → 1.4.1-alpha.0

package/dist/esm/validate.js

@@ -1,146 +1,152 @@
-import { ErrorCode, WhereFilterOpList, OrderDirectionList, FieldType } from './constant';
-import { Util } from './util';
-import { ERRORS } from './const/code';
-import { E } from './utils/utils';
-import { getType } from './utils/type';
-import { SYMBOL_GEO_POINT } from './helper/symbol';
-const validOptionsKeys = ['limit', 'offset', 'projection', 'order', 'multiple', 'timeout'];
-export class Validate {
-    static isGeopoint(point, degree) {
-        if (Util.whichType(degree) !== 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 + ErrorCode.IntergerError);
-        }
-        return true;
-    }
-    static mustBeBoolean(param, bool) {
-        if (typeof bool !== 'boolean') {
-            throw new Error(param + ErrorCode.BooleanError);
-        }
-        return true;
-    }
-    static isProjection(param, value) {
-        if (getType(value) !== 'object') {
-            throw E(Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: `${param} projection must be an object` }));
-        }
-        for (const key in value) {
-            const subValue = value[key];
-            if (getType(subValue) === 'number') {
-                if (subValue !== 0 && subValue !== 1) {
-                    throw E(Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: `if the value in projection is of number, it must be 0 or 1` }));
-                }
-            }
-            else if (getType(subValue) === 'object') {
-            }
-            else {
-                throw E(Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: 'invalid projection' }));
-            }
-        }
-        return true;
-    }
-    static isOrder(param, value) {
-        if (getType(value) !== 'object') {
-            throw E(Object.assign(Object.assign({}, 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 E(Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: `order value must be 1 or -1` }));
-            }
-        }
-        return true;
-    }
-    static isFieldOrder(direction) {
-        if (OrderDirectionList.indexOf(direction) === -1) {
-            throw new Error(ErrorCode.DirectionError);
-        }
-        return true;
-    }
-    static isFieldPath(path) {
-        if (!/^[a-zA-Z0-9-_\.]/.test(path)) {
-            throw new Error();
-        }
-        return true;
-    }
-    static isOperator(op) {
-        if (WhereFilterOpList.indexOf(op) === -1) {
-            throw new Error(ErrorCode.OpStrError);
-        }
-        return true;
-    }
-    static isCollName(name) {
-        if (!/^[a-zA-Z0-9]([a-zA-Z0-9-_]){1,32}$/.test(name)) {
-            throw new Error(ErrorCode.CollNameError);
-        }
-        return true;
-    }
-    static isDocID(docId) {
-        if (!/^([a-fA-F0-9]){24}$/.test(docId)) {
-            throw new Error(ErrorCode.DocIDError);
-        }
-        return true;
-    }
-    static isValidOptions(options = {}) {
-        if (getType(options) !== 'object') {
-            throw E(Object.assign(Object.assign({}, 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 E(Object.assign(Object.assign({}, 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 isCentersPhere(param) {
-        if (Array.isArray(param) && param.length === 2) {
-            if (getType(param[0]) === 'object' &&
-                param[0]._internalType === 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(`${ErrorCode.CentersPhereError}`);
-    }
-}
+import { ErrorCode, WhereFilterOpList, OrderDirectionList, FieldType } from './constant';
+import { Util } from './util';
+import { ERRORS } from './const/code';
+import { E } from './utils/utils';
+import { getType } from './utils/type';
+import { SYMBOL_GEO_POINT } from './helper/symbol';
+const validOptionsKeys = ['limit', 'offset', 'projection', 'order', 'multiple', 'timeout', 'raw'];
+export class Validate {
+    static isGeopoint(point, degree) {
+        if (Util.whichType(degree) !== 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 + ErrorCode.IntergerError);
+        }
+        return true;
+    }
+    static mustBeBoolean(param, bool) {
+        if (typeof bool !== 'boolean') {
+            throw new Error(param + ErrorCode.BooleanError);
+        }
+        return true;
+    }
+    static isProjection(param, value) {
+        if (getType(value) !== 'object') {
+            throw E(Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: `${param} projection must be an object` }));
+        }
+        for (const key in value) {
+            const subValue = value[key];
+            if (getType(subValue) === 'number') {
+                if (subValue !== 0 && subValue !== 1) {
+                    throw E(Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: `if the value in projection is of number, it must be 0 or 1` }));
+                }
+            }
+            else if (getType(subValue) === 'object') {
+            }
+            else {
+                throw E(Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: 'invalid projection' }));
+            }
+        }
+        return true;
+    }
+    static isOrder(param, value) {
+        if (getType(value) !== 'object') {
+            throw E(Object.assign(Object.assign({}, 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 E(Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: `order value must be 1 or -1` }));
+            }
+        }
+        return true;
+    }
+    static isFieldOrder(direction) {
+        if (OrderDirectionList.indexOf(direction) === -1) {
+            throw new Error(ErrorCode.DirectionError);
+        }
+        return true;
+    }
+    static isFieldPath(path) {
+        if (!/^[a-zA-Z0-9-_\.]/.test(path)) {
+            throw new Error();
+        }
+        return true;
+    }
+    static isOperator(op) {
+        if (WhereFilterOpList.indexOf(op) === -1) {
+            throw new Error(ErrorCode.OpStrError);
+        }
+        return true;
+    }
+    static isCollName(name) {
+        if (!/^[a-zA-Z0-9]([a-zA-Z0-9-_]){1,32}$/.test(name)) {
+            throw new Error(ErrorCode.CollNameError);
+        }
+        return true;
+    }
+    static isDocID(docId) {
+        if (!/^([a-fA-F0-9]){24}$/.test(docId)) {
+            throw new Error(ErrorCode.DocIDError);
+        }
+        return true;
+    }
+    static isValidOptions(options = {}) {
+        if (getType(options) !== 'object') {
+            throw E(Object.assign(Object.assign({}, 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 E(Object.assign(Object.assign({}, 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 E(Object.assign(Object.assign({}, ERRORS.INVALID_PARAM), { message: `aggregation stage must have one key` }));
+        }
+        return true;
+    }
+    static isCentersPhere(param) {
+        if (Array.isArray(param) && param.length === 2) {
+            if (getType(param[0]) === 'object' &&
+                param[0]._internalType === 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(`${ErrorCode.CentersPhereError}`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudbase/database",
-  "version": "1.2.3",
+  "version": "1.4.1-alpha.0",
   "description": "database for (node.)js sdk ",
   "main": "dist/commonjs/index.js",
   "module": "dist/esm/index.js",

package/src/ObjectId/index.ts

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

package/src/aggregate.ts

@@ -3,21 +3,31 @@ 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'
 
-const EARTH_RADIUS = 6378100
+// const EARTH_RADIUS = 6378100
 
 export default class Aggregation {
   _db: any
   _request: any
   _stages: any[]
   _collectionName: string
-  constructor(db?, collectionName?) {
+  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)
+        })
+      }
     }
   }
 
@@ -52,7 +62,7 @@ export default class Aggregation {
     })
   }
 
-  _pipe(stage, param) {
+  _pipe(stage, param, raw = false) {
     // 区分param是否为字符串
     let transformParam = ''
     if (getType(param) === 'object') {
@@ -62,7 +72,7 @@ export default class Aggregation {
     }
 
     this._stages.push({
-      stageKey: `$${stage}`,
+      stageKey: raw ? stage : `$${stage}`,
       stageValue: transformParam
     })
     return this
@@ -88,12 +98,14 @@ export default class Aggregation {
     if (param.query) {
       param.query = QuerySerializer.encode(param.query)
     }
-
+    
     // 判断是否有 distanceMultiplier 参数
     if (param.distanceMultiplier && typeof (param.distanceMultiplier) === 'number') {
-      param.distanceMultiplier = param.distanceMultiplier * EARTH_RADIUS
-    } else {
-      param.distanceMultiplier = EARTH_RADIUS
+      param.distanceMultiplier = param.distanceMultiplier
+    }
+    
+    if(param.near) {
+      param.near = new Point(param.near.longitude, param.near.latitude).toJSON()
     }
     return this._pipe('geoNear', param)
   }

package/src/collection.ts

@@ -127,8 +127,8 @@ export class CollectionReference extends Query {
     // }
   }
 
-  aggregate() {
-    return new Aggregation(this._db, this._coll)
+  aggregate(rawPipeline : object[] = []) {
+    return new Aggregation(this._db, this._coll, (this._apiOptions.raw || false) ? rawPipeline : [])
   }
 
   /**

package/src/command.ts

@@ -55,8 +55,12 @@ export const Command = {
     return new QueryCommand(QUERY_COMMANDS_LITERAL.SIZE, [val])
   },
 
-  mod(val: number[]) {
-    return new QueryCommand(QUERY_COMMANDS_LITERAL.MOD, [val])
+  mod() {
+    if (arguments.length == 1)
+      return new QueryCommand(QUERY_COMMANDS_LITERAL.MOD, [arguments[0]])
+    if (arguments.length == 2)
+      return new QueryCommand(QUERY_COMMANDS_LITERAL.MOD, [[arguments[0], arguments[1]]])
+    return new QueryCommand(QUERY_COMMANDS_LITERAL.MOD, arguments)
   },
 
   geoNear(val: any) {
@@ -190,11 +194,11 @@ export const Command = {
     values:
       | string
       | {
-          search: string
-          language?: string
-          caseSensitive?: boolean
-          diacriticSensitive: boolean
-        }
+        search: string
+        language?: string
+        caseSensitive?: boolean
+        diacriticSensitive: boolean
+      }
   ) {
     if (isString(values)) {
       return {

package/src/document.ts

@@ -245,7 +245,7 @@ export class DocumentReference {
     const param = {
       collectionName: this._coll,
       transactionId: this._transactionId,
-      data: UpdateSerializer.encodeEJSON(data),
+      data: UpdateSerializer.encodeEJSON(data, this._apiOptions.raw || false),
       query,
       queryType: QueryType.DOC,
       multi: false,

package/src/helper/symbol.ts

@@ -17,3 +17,5 @@ export const SYMBOL_GEO_MULTI_POLYGON = InternalSymbol.for('SYMBOL_GEO_MULTI_POL
 export const SYMBOL_SERVER_DATE = InternalSymbol.for('SERVER_DATE')
 
 export const SYMBOL_REGEXP = InternalSymbol.for('REGEXP')
+
+export const SYMBOL_OBJECTID = InternalSymbol.for('OBJECTID')

package/src/index.ts

@@ -5,6 +5,7 @@ import { Command } from './command'
 import { ServerDateConstructor } from './serverDate/index'
 import { RegExpConstructor } from './regexp/index'
 import { startTransaction, runTransaction } from './transaction/index'
+import { ObjectIdConstructor } from './ObjectId/index'
 
 /**
  * 地理位置类型
@@ -59,6 +60,8 @@ export class Db {
 
   serverDate: any
 
+  ObjectId: any
+
   startTransaction: any
 
   runTransaction: any
@@ -95,6 +98,7 @@ export class Db {
     this.serverDate = ServerDateConstructor
     this.command = Command
     this.RegExp = RegExpConstructor
+    this.ObjectId = ObjectIdConstructor
     this.startTransaction = startTransaction
     this.runTransaction = runTransaction
   }

package/src/query.ts

@@ -25,6 +25,7 @@ interface GetRes {
 
 interface BaseOption {
   timeout?: number // 接口调用超时设置
+  raw?: boolean // 原生语句查询
 }
 
 export interface QueryOption extends BaseOption {
@@ -303,11 +304,11 @@ export class Query {
     if (keys.length && !checkFlag) {
       throw Error(ErrorCode.QueryParamValueError)
     }
-
+    
     return new Query(
       this._db,
       this._coll,
-      QuerySerializer.encodeEJSON(query),
+      QuerySerializer.encodeEJSON(query, this._apiOptions.raw || false),
       this._apiOptions,
       this._transactionId
       // this._fieldOrders,
@@ -414,7 +415,7 @@ export class Query {
       multi,
       merge: true,
       upsert: false,
-      data: UpdateSerializer.encodeEJSON(data)
+      data: UpdateSerializer.encodeEJSON(data, this._apiOptions.raw || false)
     }
 
     if (this._fieldFilters) {
@@ -545,7 +546,7 @@ export class Query {
     let param: any = {
       collectionName: this._coll,
       queryType: QueryType.WHERE,
-      data: UpdateSerializer.encodeEJSON(data)
+      data: UpdateSerializer.encodeEJSON(data, false)
     }
 
     if (this._transactionId) {

package/src/serializer/datatype.ts

@@ -1,5 +1,5 @@
 // transpile internal data type
-import { SYMBOL_GEO_POINT, SYMBOL_SERVER_DATE, SYMBOL_REGEXP } from '../helper/symbol'
+import { SYMBOL_GEO_POINT, SYMBOL_SERVER_DATE, SYMBOL_OBJECTID, SYMBOL_REGEXP } from '../helper/symbol'
 import {
   getType,
   isObject,
@@ -13,6 +13,7 @@ import { Point } from '../geo/index'
 import { ServerDate } from '../serverDate/index'
 import { RegExp } from '../regexp/index'
 import { LogicCommand } from '../commands/logic'
+import { ObjectId } from '../ObjectId/index'
 
 export type IQueryCondition = Record<string, any> | LogicCommand
 
@@ -36,6 +37,9 @@ function serializeHelper(val: any, visited: object[]): Record<string, any> {
       case SYMBOL_REGEXP: {
         return (val as RegExp).parse()
       }
+      case SYMBOL_OBJECTID: {
+        return (val as ObjectId).parse()
+      }
       default: {
         return val.toJSON ? val.toJSON() : val
       }

package/src/serializer/query.ts

@@ -24,10 +24,10 @@ export class QuerySerializer {
     return encoder.encodeQuery(query)
   }
 
-  static encodeEJSON(query: IQueryCondition | QueryCommand | LogicCommand): string {
+  static encodeEJSON(query: IQueryCondition | QueryCommand | LogicCommand, raw: boolean): string {
     const encoder = new QueryEncoder()
-
-    return stringifyByEJSON(encoder.encodeQuery(query))
+    
+    return stringifyByEJSON(raw ? query : encoder.encodeQuery(query))
   }
 }
 

package/src/serializer/update.ts

@@ -25,10 +25,10 @@ export class UpdateSerializer {
     return stringifier.encodeUpdate(query)
   }
 
-  static encodeEJSON(query: IQueryCondition | UpdateCommand): string {
+  static encodeEJSON(query: IQueryCondition | UpdateCommand, raw: boolean): string {
     const stringifier = new UpdateSerializer()
-
-    return stringifyByEJSON(stringifier.encodeUpdate(query))
+    
+    return stringifyByEJSON(raw ? query : stringifier.encodeUpdate(query))
   }
 
   encodeUpdate(query: IQueryCondition | UpdateCommand): IUpdateCondition {

package/src/validate.ts

@@ -16,7 +16,7 @@ import { CenterSphere } from './typings'
 
 import { SYMBOL_GEO_POINT } from './helper/symbol'
 
-const validOptionsKeys = ['limit', 'offset', 'projection', 'order', 'multiple', 'timeout']
+const validOptionsKeys = ['limit', 'offset', 'projection', 'order', 'multiple', 'timeout', 'raw']
 
 /**
  * 校验模块
@@ -228,6 +228,20 @@ export class Validate {
     return true
   }
 
+  /**
+   * 
+   * @static
+   * @param {StageName:{}|string} stage
+   * @returns {Boolean}
+   * @memberof Validate
+   */
+  static isValidAggregation(stage: object): Boolean {
+    if (Object.keys(stage).length !== 1) {
+      throw E({ ...ERRORS.INVALID_PARAM, message: `aggregation stage must have one key` })
+    }
+    return true
+  }
+
   /**
    *
    * @static

package/dist/commonjs/decimal128/index.d.ts

@@ -1,8 +0,0 @@
-export declare class Decimal128Type {
-    readonly decimalStr: string;
-    constructor(decimalStr?: string);
-    readonly _internalType: import("../utils/symbol").InternalSymbol;
-    parse(): any;
-    toJSON(): any;
-}
-export declare function Decimal128TypeConstructor(decimalStr: any): Decimal128Type;

package/dist/commonjs/decimal128/index.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const bson_1 = require("bson");
-const symbol_1 = require("../helper/symbol");
-class Decimal128Type {
-    constructor(decimalStr = '') {
-        if (typeof decimalStr !== 'string') {
-            throw new TypeError(`Decimal128Type 入参必须为 string!`);
-        }
-        this.decimalStr = decimalStr;
-    }
-    get _internalType() {
-        return symbol_1.SYMBOL_DECIMAL128;
-    }
-    parse() {
-        return bson_1.Decimal128.fromString(this.decimalStr);
-    }
-    toJSON() {
-        return bson_1.Decimal128.fromString(this.decimalStr);
-    }
-}
-exports.Decimal128Type = Decimal128Type;
-function Decimal128TypeConstructor(decimalStr) {
-    return new Decimal128Type(decimalStr);
-}
-exports.Decimal128TypeConstructor = Decimal128TypeConstructor;

package/dist/commonjs/lib/util.d.ts

@@ -1 +0,0 @@
-export declare const createPromiseCallback: () => any;