@cloudbase/database 0.9.18-next → 0.9.20

package/.trunk/configs/.markdownlint.yaml

@@ -0,0 +1,10 @@
+# Autoformatter friendly markdownlint config (all formatting rules disabled)
+default: true
+blank_lines: false
+bullet: false
+html: false
+indentation: false
+line_length: false
+spaces: false
+url: false
+whitespace: false

package/.trunk/trunk.yaml

@@ -0,0 +1,26 @@
+version: 0.1
+cli:
+  version: 1.4.1
+plugins:
+  sources:
+    - id: trunk
+      ref: v0.0.10
+      uri: https://github.com/trunk-io/plugins
+lint:
+  enabled:
+    - eslint@8.33.0
+    - markdownlint@0.33.0
+    - git-diff-check
+    - gitleaks@8.15.3
+    - prettier@2.8.4
+runtimes:
+  enabled:
+    - go@1.18.3
+    - node@18.12.1
+actions:
+  disabled:
+    - trunk-announce
+    - trunk-check-pre-push
+    - trunk-fmt-pre-commit
+  enabled:
+    - trunk-upgrade-available

package/README.md

@@ -15,7 +15,7 @@ yarn add @cloudbase/database
 
 ## 使用
 
-使用 `@cloudbase/database` 时，需要提供发送请求的类 `reqClass`。 
+使用 `@cloudbase/database` 时，需要提供发送请求的类 `reqClass`。
 
 ```js
 // index.js
@@ -38,23 +38,23 @@ class Tcb {
 // request.js
 
 // 进一步处理，鉴权等...
-const requestHandler = require('requestHandler');
+const requestHandler = require('requestHandler')
 
 class Request {
   constructor(config) {
-    this.config = config;
+    this.config = config
   }
 
   async send(action, data) {
     const params = Object.assign({}, data, {
       action
-    });
+    })
 
     const slowQueryWarning = setTimeout(() => {
       console.warn(
         'Database operation is longer than 3s. Please check query performance and your network environment.'
-      );
-    }, 3000);
+      )
+    }, 3000)
 
     try {
       return await requestHandler({
@@ -65,14 +65,14 @@ class Request {
         headers: {
           'content-type': 'application/json'
         }
-      });
+      })
     } finally {
-      clearTimeout(slowQueryWarning);
+      clearTimeout(slowQueryWarning)
     }
   }
 }
 
-module.exports = Request;
+module.exports = Request
 ```
 
 请求数据样例
@@ -94,4 +94,26 @@ module.exports = Request;
   },
   "json": true
 }
-```
+```
+
+## 开发指南
+
+### 注意
+
+当前 database 库是通过分支来控制了两个不同的版本，主干版提供给@cloudbase/js-sdk 库使用，feature/support_db_2.0 分支提供给@cloudbase/node-sdk 库使用。
+
+两个分支区别：
+support_db_2.0 分支进行了数据库接口的升级，将原有的 json 协议转换为 mongo 支持的 bson 协议处理，目的是解决旧接口存在的问题，描述如下
+
+- 日期对象 是走约定协议处理，即转换为 {$date: timestamp}，这种方式应摒弃(EJSON 协议可解决)
+- 无法支持 null, NaN 等特殊类型处理(EJSON 协议可解决)
+- serverDate 这种自定义类型的实现，是继续保留 还是摒弃
+- 接口实现混杂，普通 CRUD 接口均走 flexdb，而聚合，事务又用 runcommand 方式
+- 原插入文档接口返回 docId 形式混杂
+
+目前仅针对服务端 sdk @cloudbase/node-sdk 完成了升级，而客户端 sdk @cloudbase/js-sdk 以及 小程序端 SDK 仍保留为旧接口形式。
+
+### 开发及发布事项
+
+1. 数据库接口的改动务必补充测试用例验证
+2. 发布时，约定 feature/support_db_2.0 分支上发布正式版（for @cloudbase/node-sdk）使用，master 分支上发布 beta 版 (for @cloudbase/js-sdk)使用。两 sdk 均通过锁版本方式依赖该库，不会受自动更新依赖影响。

package/dist/commonjs/aggregate.js

@@ -39,6 +39,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var index_1 = require("./index");
 var bson_1 = require("bson");
 var query_1 = require("./serializer/query");
+var geo_1 = require("./geo");
 var Aggregation = (function () {
     function Aggregation(db, collectionName) {
         this._stages = [];
@@ -106,6 +107,15 @@ var Aggregation = (function () {
         return this._pipe('count', param);
     };
     Aggregation.prototype.geoNear = function (param) {
+        if (param.query) {
+            param.query = query_1.QuerySerializer.encode(param.query);
+        }
+        if (param.distanceMultiplier && typeof (param.distanceMultiplier) === 'number') {
+            param.distanceMultiplier = param.distanceMultiplier;
+        }
+        if (param.near) {
+            param.near = new geo_1.Point(param.near.longitude, param.near.latitude).toJSON();
+        }
         return this._pipe('geoNear', param);
     };
     Aggregation.prototype.group = function (param) {

package/dist/commonjs/document.js

@@ -224,10 +224,7 @@ var DocumentReference = (function () {
                 var documents = util_2.Util.formatResDocumentData(res.data.list);
                 callback(0, {
                     data: documents,
-                    requestId: res.requestId,
-                    total: res.TotalCount,
-                    limit: res.Limit,
-                    offset: res.Offset
+                    requestId: res.requestId
                 });
             }
         })

package/dist/commonjs/query.js

@@ -81,12 +81,12 @@ var Query = (function () {
                     data: documents,
                     requestId: res.requestId
                 };
-                if (res.TotalCount)
-                    result.total = res.TotalCount;
-                if (res.Limit)
-                    result.limit = res.Limit;
-                if (res.Offset)
-                    result.offset = res.Offset;
+                if (res.total)
+                    result.total = res.total;
+                if (res.limit)
+                    result.limit = res.limit;
+                if (res.offset)
+                    result.offset = res.offset;
                 callback(0, result);
             }
         })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudbase/database",
-  "version": "0.9.18-next",
+  "version": "0.9.20",
   "description": "database for (node.)js sdk ",
   "main": "dist/commonjs/index.js",
   "module": "dist/esm/index.js",
@@ -11,8 +11,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": "npx tsc -p tsconfig.json && npx tsc -p tsconfig.esm.json"
   },
   "author": "",
   "license": "ISC",

package/src/aggregate.ts

@@ -1,6 +1,7 @@
 import { Db } from './index'
 import { EJSON } from 'bson'
 import { QuerySerializer } from './serializer/query'
+import { Point } from './geo'
 export default class Aggregation {
   _db: any
   _request: any
@@ -70,6 +71,16 @@ export default class Aggregation {
   }
 
   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)
   }
 

package/src/document.ts

@@ -301,10 +301,7 @@ export class DocumentReference {
           const documents = Util.formatResDocumentData(res.data.list)
           callback(0, {
             data: documents,
-            requestId: res.requestId,
-            total: res.TotalCount,
-            limit: res.Limit,
-            offset: res.Offset
+            requestId: res.requestId
           })
         }
       })

package/src/query.ts

@@ -204,9 +204,9 @@ export class Query {
             data: documents,
             requestId: res.requestId
           }
-          if (res.TotalCount) result.total = res.TotalCount
-          if (res.Limit) result.limit = res.Limit
-          if (res.Offset) result.offset = res.Offset
+          if (res.total) result.total = res.total
+          if (res.limit) result.limit = res.limit
+          if (res.offset) result.offset = res.offset
           callback(0, result)
         }
       })

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);
-    end(): Promise<any>;
-    unwrap(): any[];
-    done(): {
-        [x: number]: any;
-    }[];
-    _pipe(stage: any, param: any): 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,144 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-import { Db } from './index';
-import { EJSON } from 'bson';
-import { QuerySerializer } from './serializer/query';
-var Aggregation = (function () {
-    function Aggregation(db, collectionName) {
-        this._stages = [];
-        if (db && collectionName) {
-            this._db = db;
-            this._request = new Db.reqClass(this._db.config);
-            this._collectionName = collectionName;
-        }
-    }
-    Aggregation.prototype.end = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var result;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this._collectionName || !this._db) {
-                            throw new Error('Aggregation pipeline cannot send request');
-                        }
-                        return [4, this._request.send('database.aggregate', {
-                                collectionName: this._collectionName,
-                                stages: this._stages
-                            })];
-                    case 1:
-                        result = _a.sent();
-                        if (result && result.data && result.data.list) {
-                            return [2, {
-                                    requestId: result.requestId,
-                                    data: JSON.parse(result.data.list).map(EJSON.parse)
-                                }];
-                        }
-                        return [2, result];
-                }
-            });
-        });
-    };
-    Aggregation.prototype.unwrap = function () {
-        return this._stages;
-    };
-    Aggregation.prototype.done = function () {
-        return this._stages.map(function (_a) {
-            var _b;
-            var stageKey = _a.stageKey, stageValue = _a.stageValue;
-            return _b = {},
-                _b[stageKey] = JSON.parse(stageValue),
-                _b;
-        });
-    };
-    Aggregation.prototype._pipe = function (stage, param) {
-        this._stages.push({
-            stageKey: "$" + stage,
-            stageValue: JSON.stringify(param)
-        });
-        return this;
-    };
-    Aggregation.prototype.addFields = function (param) {
-        return this._pipe('addFields', param);
-    };
-    Aggregation.prototype.bucket = function (param) {
-        return this._pipe('bucket', param);
-    };
-    Aggregation.prototype.bucketAuto = function (param) {
-        return this._pipe('bucketAuto', param);
-    };
-    Aggregation.prototype.count = function (param) {
-        return this._pipe('count', param);
-    };
-    Aggregation.prototype.geoNear = function (param) {
-        return this._pipe('geoNear', param);
-    };
-    Aggregation.prototype.group = function (param) {
-        return this._pipe('group', param);
-    };
-    Aggregation.prototype.limit = function (param) {
-        return this._pipe('limit', param);
-    };
-    Aggregation.prototype.match = function (param) {
-        return this._pipe('match', QuerySerializer.encode(param));
-    };
-    Aggregation.prototype.project = function (param) {
-        return this._pipe('project', param);
-    };
-    Aggregation.prototype.lookup = function (param) {
-        return this._pipe('lookup', param);
-    };
-    Aggregation.prototype.replaceRoot = function (param) {
-        return this._pipe('replaceRoot', param);
-    };
-    Aggregation.prototype.sample = function (param) {
-        return this._pipe('sample', param);
-    };
-    Aggregation.prototype.skip = function (param) {
-        return this._pipe('skip', param);
-    };
-    Aggregation.prototype.sort = function (param) {
-        return this._pipe('sort', param);
-    };
-    Aggregation.prototype.sortByCount = function (param) {
-        return this._pipe('sortByCount', param);
-    };
-    Aggregation.prototype.unwind = function (param) {
-        return this._pipe('unwind', param);
-    };
-    return Aggregation;
-}());
-export default Aggregation;

package/dist/esm/collection.d.ts

@@ -1,9 +0,0 @@
-import { DocumentReference } from './document';
-import { Query } from './query';
-import Aggregation from './aggregate';
-export declare class CollectionReference extends Query {
-    readonly name: string;
-    doc(docID?: string | number): DocumentReference;
-    add(data: Object, callback?: any): Promise<any>;
-    aggregate(): Aggregation;
-}

package/dist/esm/collection.js

@@ -1,44 +0,0 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-import { DocumentReference } from './document';
-import { Query } from './query';
-import Aggregation from './aggregate';
-var CollectionReference = (function (_super) {
-    __extends(CollectionReference, _super);
-    function CollectionReference(db, coll) {
-        return _super.call(this, db, coll) || this;
-    }
-    Object.defineProperty(CollectionReference.prototype, "name", {
-        get: function () {
-            return this._coll;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    CollectionReference.prototype.doc = function (docID) {
-        if (typeof docID !== 'string' && typeof docID !== 'number') {
-            throw new Error('docId必须为字符串或数字');
-        }
-        return new DocumentReference(this._db, this._coll, docID);
-    };
-    CollectionReference.prototype.add = function (data, callback) {
-        var docRef = new DocumentReference(this._db, this._coll, undefined);
-        return docRef.create(data, callback);
-    };
-    CollectionReference.prototype.aggregate = function () {
-        return new Aggregation(this._db, this._coll);
-    };
-    return CollectionReference;
-}(Query));
-export { CollectionReference };

package/dist/esm/command.d.ts

@@ -1,175 +0,0 @@
-import { QueryCommand } from './commands/query';
-import { LogicCommand } from './commands/logic';
-import { UpdateCommand } from './commands/update';
-import Aggregation from './aggregate';
-export declare type IQueryCondition = Record<string, any> | LogicCommand;
-export declare const Command: {
-    eq(val: any): QueryCommand;
-    neq(val: any): QueryCommand;
-    lt(val: any): QueryCommand;
-    lte(val: any): QueryCommand;
-    gt(val: any): QueryCommand;
-    gte(val: any): QueryCommand;
-    in(val: any): QueryCommand;
-    nin(val: any): QueryCommand;
-    all(val: any): QueryCommand;
-    elemMatch(val: any): QueryCommand;
-    exists(val: boolean): QueryCommand;
-    size(val: number): QueryCommand;
-    mod(val: number[]): QueryCommand;
-    geoNear(val: any): QueryCommand;
-    geoWithin(val: any): QueryCommand;
-    geoIntersects(val: any): QueryCommand;
-    and(...__expressions__: import("./serializer/datatype").IQueryCondition[]): LogicCommand;
-    nor(...__expressions__: import("./serializer/datatype").IQueryCondition[]): LogicCommand;
-    or(...__expressions__: import("./serializer/datatype").IQueryCondition[]): LogicCommand;
-    not(...__expressions__: import("./serializer/datatype").IQueryCondition[]): LogicCommand;
-    set(val: any): UpdateCommand;
-    remove(): UpdateCommand;
-    inc(val: number): UpdateCommand;
-    mul(val: number): UpdateCommand;
-    push(...args: any[]): UpdateCommand;
-    pull(values: any): UpdateCommand;
-    pullAll(values: any): UpdateCommand;
-    pop(): UpdateCommand;
-    shift(): UpdateCommand;
-    unshift(...__values__: any[]): UpdateCommand;
-    addToSet(values: any): UpdateCommand;
-    rename(values: any): UpdateCommand;
-    bit(values: any): UpdateCommand;
-    max(values: any): UpdateCommand;
-    min(values: any): UpdateCommand;
-    expr(values: AggregationOperator): {
-        $expr: AggregationOperator;
-    };
-    jsonSchema(schema: any): {
-        $jsonSchema: any;
-    };
-    text(values: string | {
-        search: string;
-        language?: string;
-        caseSensitive?: boolean;
-        diacriticSensitive: boolean;
-    }): {
-        $search: {
-            (regexp: string | RegExp): number;
-            (searcher: {
-                [Symbol.search](string: string): number;
-            }): number;
-        };
-        $language?: undefined;
-        $caseSensitive?: undefined;
-        $diacriticSensitive?: undefined;
-    } | {
-        $search: string;
-        $language: string;
-        $caseSensitive: boolean;
-        $diacriticSensitive: boolean;
-    };
-    aggregate: {
-        pipeline(): Aggregation;
-        abs: (param: any) => AggregationOperator;
-        add: (param: any) => AggregationOperator;
-        ceil: (param: any) => AggregationOperator;
-        divide: (param: any) => AggregationOperator;
-        exp: (param: any) => AggregationOperator;
-        floor: (param: any) => AggregationOperator;
-        ln: (param: any) => AggregationOperator;
-        log: (param: any) => AggregationOperator;
-        log10: (param: any) => AggregationOperator;
-        mod: (param: any) => AggregationOperator;
-        multiply: (param: any) => AggregationOperator;
-        pow: (param: any) => AggregationOperator;
-        sqrt: (param: any) => AggregationOperator;
-        subtract: (param: any) => AggregationOperator;
-        trunc: (param: any) => AggregationOperator;
-        arrayElemAt: (param: any) => AggregationOperator;
-        arrayToObject: (param: any) => AggregationOperator;
-        concatArrays: (param: any) => AggregationOperator;
-        filter: (param: any) => AggregationOperator;
-        in: (param: any) => AggregationOperator;
-        indexOfArray: (param: any) => AggregationOperator;
-        isArray: (param: any) => AggregationOperator;
-        map: (param: any) => AggregationOperator;
-        range: (param: any) => AggregationOperator;
-        reduce: (param: any) => AggregationOperator;
-        reverseArray: (param: any) => AggregationOperator;
-        size: (param: any) => AggregationOperator;
-        slice: (param: any) => AggregationOperator;
-        zip: (param: any) => AggregationOperator;
-        and: (param: any) => AggregationOperator;
-        not: (param: any) => AggregationOperator;
-        or: (param: any) => AggregationOperator;
-        cmp: (param: any) => AggregationOperator;
-        eq: (param: any) => AggregationOperator;
-        gt: (param: any) => AggregationOperator;
-        gte: (param: any) => AggregationOperator;
-        lt: (param: any) => AggregationOperator;
-        lte: (param: any) => AggregationOperator;
-        neq: (param: any) => AggregationOperator;
-        cond: (param: any) => AggregationOperator;
-        ifNull: (param: any) => AggregationOperator;
-        switch: (param: any) => AggregationOperator;
-        dateFromParts: (param: any) => AggregationOperator;
-        dateFromString: (param: any) => AggregationOperator;
-        dayOfMonth: (param: any) => AggregationOperator;
-        dayOfWeek: (param: any) => AggregationOperator;
-        dayOfYear: (param: any) => AggregationOperator;
-        isoDayOfWeek: (param: any) => AggregationOperator;
-        isoWeek: (param: any) => AggregationOperator;
-        isoWeekYear: (param: any) => AggregationOperator;
-        millisecond: (param: any) => AggregationOperator;
-        minute: (param: any) => AggregationOperator;
-        month: (param: any) => AggregationOperator;
-        second: (param: any) => AggregationOperator;
-        hour: (param: any) => AggregationOperator;
-        week: (param: any) => AggregationOperator;
-        year: (param: any) => AggregationOperator;
-        literal: (param: any) => AggregationOperator;
-        mergeObjects: (param: any) => AggregationOperator;
-        objectToArray: (param: any) => AggregationOperator;
-        allElementsTrue: (param: any) => AggregationOperator;
-        anyElementTrue: (param: any) => AggregationOperator;
-        setDifference: (param: any) => AggregationOperator;
-        setEquals: (param: any) => AggregationOperator;
-        setIntersection: (param: any) => AggregationOperator;
-        setIsSubset: (param: any) => AggregationOperator;
-        setUnion: (param: any) => AggregationOperator;
-        concat: (param: any) => AggregationOperator;
-        dateToString: (param: any) => AggregationOperator;
-        indexOfBytes: (param: any) => AggregationOperator;
-        indexOfCP: (param: any) => AggregationOperator;
-        split: (param: any) => AggregationOperator;
-        strLenBytes: (param: any) => AggregationOperator;
-        strLenCP: (param: any) => AggregationOperator;
-        strcasecmp: (param: any) => AggregationOperator;
-        substr: (param: any) => AggregationOperator;
-        substrBytes: (param: any) => AggregationOperator;
-        substrCP: (param: any) => AggregationOperator;
-        toLower: (param: any) => AggregationOperator;
-        toUpper: (param: any) => AggregationOperator;
-        meta: (param: any) => AggregationOperator;
-        addToSet: (param: any) => AggregationOperator;
-        avg: (param: any) => AggregationOperator;
-        first: (param: any) => AggregationOperator;
-        last: (param: any) => AggregationOperator;
-        max: (param: any) => AggregationOperator;
-        min: (param: any) => AggregationOperator;
-        push: (param: any) => AggregationOperator;
-        stdDevPop: (param: any) => AggregationOperator;
-        stdDevSamp: (param: any) => AggregationOperator;
-        sum: (param: any) => AggregationOperator;
-        let: (param: any) => AggregationOperator;
-    };
-    project: {
-        slice: (param: any) => ProjectionOperator;
-        elemMatch: (param: any) => ProjectionOperator;
-    };
-};
-declare class AggregationOperator {
-    constructor(name: any, param: any);
-}
-declare class ProjectionOperator {
-    constructor(name: any, param: any);
-}
-export default Command;