mongoose 6.2.9 → 6.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "6.2.9",
+  "version": "6.3.0",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -21,7 +21,7 @@
   "dependencies": {
     "bson": "^4.2.2",
     "kareem": "2.3.5",
-    "mongodb": "4.3.1",
+    "mongodb": "4.5.0",
     "mpath": "0.8.4",
     "mquery": "4.0.2",
     "ms": "2.1.3",
@@ -30,47 +30,53 @@
   "devDependencies": {
     "@babel/core": "7.17.8",
     "@babel/preset-env": "7.16.11",
-    "@typescript-eslint/eslint-plugin": "5.16.0",
-    "@typescript-eslint/parser": "5.16.0",
-    "acquit": "1.x",
-    "acquit-ignore": "0.2.x",
-    "acquit-require": "0.1.x",
+    "@typescript-eslint/eslint-plugin": "5.17.0",
+    "@typescript-eslint/parser": "5.17.0",
+    "acquit": "1.2.1",
+    "acquit-ignore": "0.2.0",
+    "acquit-require": "0.1.1",
+    "assert-browserify": "npm:assert@^2.0.0",
     "axios": "0.26.1",
     "babel-loader": "8.2.4",
     "benchmark": "2.1.4",
     "bluebird": "3.7.2",
     "cheerio": "1.0.0-rc.10",
+    "crypto-browserify": "3.12.0",
     "dox": "0.3.1",
-    "eslint": "8.11.0",
+    "eslint": "8.12.0",
     "eslint-plugin-mocha-no-only": "1.1.1",
-    "highlight.js": "9.18.3",
+    "highlight.js": "11.5.0",
     "lodash.isequal": "4.5.0",
     "lodash.isequalwith": "4.4.0",
     "marked": "4.0.12",
     "mocha": "9.2.2",
     "moment": "2.x",
-    "mongodb-memory-server": "^8.3.0",
-    "nyc": "^15.1.0",
+    "mongodb-memory-server": "8.3.0",
+    "nyc": "15.1.0",
     "pug": "3.0.2",
     "q": "1.5.1",
     "serve-handler": "6.1.3",
+    "sinon": "13.0.0",
+    "stream-browserify": "3.0.0",
     "tsd": "0.19.1",
     "typescript": "4.6.3",
     "uuid": "8.3.2",
-    "webpack": "4.44.1"
+    "webpack": "5.70.0"
   },
   "directories": {
     "lib": "./lib/mongoose"
   },
   "scripts": {
     "lint": "eslint .",
+    "lint-js": "eslint . --ext .js",
+    "lint-ts": "eslint . --ext .ts",
     "build-browser": "node build-browser.js",
     "prepublishOnly": "npm run build-browser",
     "release": "git pull && git push origin master --tags && npm publish",
     "release-legacy": "git pull origin 5.x && git push origin 5.x --tags && npm publish --tag legacy",
     "mongo": "node ./tools/repl.js",
     "test": "mocha --exit ./test/*.test.js",
-    "test-tsd": "tsd",
+    "test-tsd": "node ./test/types/check-types-filename && tsd",
     "tdd": "mocha ./test/*.test.js ./test/typescript/main.test.js --inspect --watch --recursive --watch-files ./**/*.js",
     "test-coverage": "nyc --reporter=html --reporter=text npm test"
   },

package/tools/repl.js

@@ -17,7 +17,8 @@ async function run() {
       // Set the expiry job in MongoDB to run every second
       {
         port: 27017,
-        args: ['--setParameter', 'ttlMonitorSleepSecs=1'] }
+        args: ['--setParameter', 'ttlMonitorSleepSecs=1']
+      }
     ],
     dbName: 'mongoose_test',
     replSet: {

package/types/aggregate.d.ts

@@ -0,0 +1,223 @@
+import mongodb = require('mongodb');
+
+declare module 'mongoose' {
+
+  interface AggregateOptions {
+    /**
+     * If true, the MongoDB server will use the hard drive to store data during this aggregation.
+     */
+    allowDiskUse?: boolean;
+    /**
+     * Applicable only if you specify the $out or $merge aggregation stages.
+     *
+     * Enables db.collection.aggregate() to bypass document validation during the operation. This lets you insert documents that do not meet the validation requirements.
+     */
+    bypassDocumentValidation?: boolean;
+    /**
+     * The BSON-serializer will check if keys are valid
+     */
+    collation?: mongodb.CollationOptions;
+    /**
+     * Users can specify an arbitrary string to help trace the operation through the database profiler, currentOp, and logs.
+     */
+    comment?: string;
+    /**
+     *  Specifies the initial batch size for the cursor. The value of the cursor field is a document with the field batchSize.
+     */
+    cursor?: { batchSize?: number; };
+    /**
+     * Specifies to return the information on the processing of the pipeline. See Return Information on Aggregation Pipeline Operation for an example.
+     *
+     * Not available in multi-document transactions.
+     */
+    explain?: mongodb.ExplainVerbosityLike;
+    /**
+     * The index to use for the aggregation. The index is on the initial collection/view against which the aggregation is run.
+     */
+    hint?: string | AnyObject;
+    /**
+     * Specifies a document with a list of variables. This allows you to improve command readability by separating the variables from the query text.
+     */
+    let?: AnyObject;
+    /**
+     * Specifies a time limit in milliseconds for processing operations on a cursor. If you do not specify a value for maxTimeMS, operations will not time out. A value of 0 explicitly specifies the default unbounded behavior.
+     *
+     * @see https://docs.mongodb.com/manual/reference/operator/meta/maxTimeMS/
+     */
+    maxTimeMS?: number;
+    /**
+     * Return BSON filled buffers from operations.
+     */
+    raw?: boolean;
+    /**
+     * Specifies the read concern.
+     */
+    readConcern?: mongodb.ReadConcernLike;
+    /**
+     * The preferred read preference.
+     */
+    readPreference?: mongodb.ReadPreferenceLike;
+    /** The ClientSession for this aggregation */
+    session?: mongodb.ClientSession;
+    /**
+     * Specifies the write concern.
+     */
+    writeConcern?: mongodb.WriteConcern;
+    [key: string]: any;
+  }
+
+  class Aggregate<R> {
+    /**
+     * Returns an asyncIterator for use with [`for/await/of` loops](https://thecodebarbarian.com/getting-started-with-async-iterators-in-node-js
+     * You do not need to call this function explicitly, the JavaScript runtime
+     * will call it for you.
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<Unpacked<R>>;
+
+    options: AggregateOptions;
+
+    /**
+     * Sets an option on this aggregation. This function will be deprecated in a
+     * future release.
+     *
+     * @deprecated
+     */
+    addCursorFlag(flag: CursorFlag, value: boolean): this;
+
+    /**
+     * Appends a new $addFields operator to this aggregate pipeline.
+     * Requires MongoDB v3.4+ to work
+     */
+    addFields(arg: PipelineStage.AddFields['$addFields']): this;
+
+    /** Sets the allowDiskUse option for the aggregation query (ignored for < 2.6.0) */
+    allowDiskUse(value: boolean): this;
+
+    /** Appends new operators to this aggregate pipeline */
+    append(...args: PipelineStage[]): this;
+
+    /**
+     * Executes the query returning a `Promise` which will be
+     * resolved with either the doc(s) or rejected with the error.
+     * Like [`.then()`](#query_Query-then), but only takes a rejection handler.
+     */
+    catch: Promise<R>['catch'];
+
+    /** Set the collation. */
+    collation(options: mongodb.CollationOptions): this;
+
+    /** Appends a new $count operator to this aggregate pipeline. */
+    count(fieldName: PipelineStage.Count['$count']): this;
+
+    /**
+     * Sets the cursor option for the aggregation query (ignored for < 2.6.0).
+     */
+    cursor<DocType = any>(options?: Record<string, unknown>): Cursor<DocType>;
+
+    /** Executes the aggregate pipeline on the currently bound Model. */
+    exec(callback: Callback<R>): void;
+    exec(): Promise<R>;
+
+    /** Execute the aggregation with explain */
+    explain(verbosity: mongodb.ExplainVerbosityLike, callback: Callback<AnyObject>): void;
+    explain(verbosity: mongodb.ExplainVerbosityLike): Promise<AnyObject>;
+    explain(callback: Callback<AnyObject>): void;
+    explain(): Promise<AnyObject>;
+
+    /** Combines multiple aggregation pipelines. */
+    facet(options: PipelineStage.Facet['$facet']): this;
+
+    /** Appends new custom $graphLookup operator(s) to this aggregate pipeline, performing a recursive search on a collection. */
+    graphLookup(options: PipelineStage.GraphLookup['$graphLookup']): this;
+
+    /** Appends new custom $group operator to this aggregate pipeline. */
+    group(arg: PipelineStage.Group['$group']): this;
+
+    /** Sets the hint option for the aggregation query (ignored for < 3.6.0) */
+    hint(value: Record<string, unknown> | string): this;
+
+    /**
+     * Appends a new $limit operator to this aggregate pipeline.
+     * @param num maximum number of records to pass to the next stage
+     */
+    limit(num: PipelineStage.Limit['$limit']): this;
+
+    /** Appends new custom $lookup operator to this aggregate pipeline. */
+    lookup(options: PipelineStage.Lookup['$lookup']): this;
+
+    /**
+     * Appends a new custom $match operator to this aggregate pipeline.
+     * @param arg $match operator contents
+     */
+    match(arg: PipelineStage.Match['$match']): this;
+
+    /**
+     * Binds this aggregate to a model.
+     * @param model the model to which the aggregate is to be bound
+     */
+    model(model: Model<any>): this;
+
+    /**
+     * Append a new $near operator to this aggregation pipeline
+     * @param arg $near operator contents
+     */
+    near(arg: { near?: number[]; distanceField: string; maxDistance?: number; query?: Record<string, any>; includeLocs?: string; num?: number; uniqueDocs?: boolean }): this;
+
+    /** Returns the current pipeline */
+    pipeline(): PipelineStage[];
+
+    /** Appends a new $project operator to this aggregate pipeline. */
+    project(arg: PipelineStage.Project['$project']): this;
+
+    /** Sets the readPreference option for the aggregation query. */
+    read(pref: mongodb.ReadPreferenceLike): this;
+
+    /** Sets the readConcern level for the aggregation query. */
+    readConcern(level: string): this;
+
+    /** Appends a new $redact operator to this aggregate pipeline. */
+    redact(expression: PipelineStage.Redact['$redact'], thenExpr: '$$DESCEND' | '$$PRUNE' | '$$KEEP' | AnyObject, elseExpr: '$$DESCEND' | '$$PRUNE' | '$$KEEP' | AnyObject): this;
+
+    /** Appends a new $replaceRoot operator to this aggregate pipeline. */
+    replaceRoot(newRoot: PipelineStage.ReplaceRoot['$replaceRoot']['newRoot'] | string): this;
+
+    /**
+     * Helper for [Atlas Text Search](https://docs.atlas.mongodb.com/reference/atlas-search/tutorial/)'s
+     * `$search` stage.
+     */
+    search(options: PipelineStage.Search['$search']): this;
+
+    /** Lets you set arbitrary options, for middlewares or plugins. */
+    option(value: AggregateOptions): this;
+
+    /** Appends new custom $sample operator to this aggregate pipeline. */
+    sample(arg: PipelineStage.Sample['$sample']['size']): this;
+
+    /** Sets the session for this aggregation. Useful for [transactions](/docs/transactions.html). */
+    session(session: mongodb.ClientSession | null): this;
+
+    /**
+     * Appends a new $skip operator to this aggregate pipeline.
+     * @param num number of records to skip before next stage
+     */
+    skip(num: PipelineStage.Skip['$skip']): this;
+
+    /** Appends a new $sort operator to this aggregate pipeline. */
+    sort(arg: string | Record<string, SortValues> | PipelineStage.Sort['$sort']): this;
+
+    /** Provides promise for aggregate. */
+    then: Promise<R>['then'];
+
+    /**
+     * Appends a new $sortByCount operator to this aggregate pipeline. Accepts either a string field name
+     * or a pipeline object.
+     */
+    sortByCount(arg: string | PipelineStage.SortByCount['$sortByCount']): this;
+
+    /** Appends new $unionWith operator to this aggregate pipeline. */
+    unionWith(options: PipelineStage.UnionWith['$unionWith']): this;
+
+    /** Appends new custom $unwind operator(s) to this aggregate pipeline. */
+    unwind(...args: PipelineStage.Unwind['$unwind'][]): this;
+  }
+}

package/types/cursor.d.ts

@@ -3,6 +3,12 @@ import stream = require('stream');
 declare module 'mongoose' {
   type CursorFlag = 'tailable' | 'oplogReplay' | 'noCursorTimeout' | 'awaitData' | 'partial';
 
+  interface EachAsyncOptions {
+    parallel?: number;
+    batchSize?: number;
+    continueOnError?: boolean;
+  }
+
   class Cursor<DocType = any, Options = never> extends stream.Readable {
     [Symbol.asyncIterator](): AsyncIterableIterator<DocType>;
 
@@ -25,10 +31,10 @@ declare module 'mongoose' {
      * will wait for the promise to resolve before iterating on to the next one.
      * Returns a promise that resolves when done.
      */
-    eachAsync(fn: (doc: DocType[]) => any, options: { parallel?: number, batchSize: number }, callback: CallbackWithoutResult): void;
-    eachAsync(fn: (doc: DocType) => any, options: { parallel?: number }, callback: CallbackWithoutResult): void;
-    eachAsync(fn: (doc: DocType[]) => any, options: { parallel?: number, batchSize: number }): Promise<void>;
-    eachAsync(fn: (doc: DocType) => any, options?: { parallel?: number }): Promise<void>;
+    eachAsync(fn: (doc: DocType[]) => any, options: EachAsyncOptions & { batchSize: number }, callback: CallbackWithoutResult): void;
+    eachAsync(fn: (doc: DocType) => any, options: EachAsyncOptions, callback: CallbackWithoutResult): void;
+    eachAsync(fn: (doc: DocType[]) => any, options: EachAsyncOptions & { batchSize: number }): Promise<void>;
+    eachAsync(fn: (doc: DocType) => any, options?: EachAsyncOptions): Promise<void>;
 
     /**
      * Registers a transform function which subsequently maps documents retrieved