mongoose 6.2.11 → 6.3.2

package/lib/validoptions.js

@@ -6,6 +6,7 @@
 'use strict';
 
 const VALID_OPTIONS = Object.freeze([
+  'allowDiskUse',
   'applyPluginsToChildSchemas',
   'applyPluginsToDiscriminators',
   'autoCreate',

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "6.2.11",
+  "version": "6.3.2",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -19,45 +19,50 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "bson": "^4.2.2",
+    "bson": "^4.6.2",
     "kareem": "2.3.5",
-    "mongodb": "4.3.1",
-    "mpath": "0.8.4",
+    "mongodb": "4.5.0",
+    "mpath": "0.9.0",
     "mquery": "4.0.2",
     "ms": "2.1.3",
     "sift": "16.0.0"
   },
   "devDependencies": {
-    "@babel/core": "7.17.8",
-    "@babel/preset-env": "7.16.11",
-    "@typescript-eslint/eslint-plugin": "5.17.0",
-    "@typescript-eslint/parser": "5.17.0",
+    "@babel/core": "7.17.10",
+    "@babel/preset-env": "7.17.10",
+    "@typescript-eslint/eslint-plugin": "5.21.0",
+    "@typescript-eslint/parser": "5.21.0",
     "acquit": "1.2.1",
     "acquit-ignore": "0.2.0",
     "acquit-require": "0.1.1",
-    "axios": "0.26.1",
-    "babel-loader": "8.2.4",
+    "assert-browserify": "2.0.0",
+    "axios": "0.27.2",
+    "babel-loader": "8.2.5",
     "benchmark": "2.1.4",
     "bluebird": "3.7.2",
+    "buffer": "6.0.3",
     "cheerio": "1.0.0-rc.10",
+    "crypto-browserify": "3.12.0",
     "dox": "0.3.1",
-    "eslint": "8.12.0",
+    "eslint": "8.14.0",
     "eslint-plugin-mocha-no-only": "1.1.1",
-    "highlight.js": "11.5.0",
+    "highlight.js": "11.5.1",
     "lodash.isequal": "4.5.0",
     "lodash.isequalwith": "4.4.0",
-    "marked": "4.0.12",
-    "mocha": "9.2.2",
+    "marked": "4.0.14",
+    "mocha": "10.0.0",
     "moment": "2.x",
-    "mongodb-memory-server": "^8.3.0",
-    "nyc": "^15.1.0",
+    "mongodb-memory-server": "8.5.2",
+    "nyc": "15.1.0",
     "pug": "3.0.2",
     "q": "1.5.1",
     "serve-handler": "6.1.3",
+    "sinon": "13.0.2",
+    "stream-browserify": "3.0.0",
     "tsd": "0.20.0",
-    "typescript": "4.6.3",
+    "typescript": "4.6.4",
     "uuid": "8.3.2",
-    "webpack": "4.44.1"
+    "webpack": "5.72.0"
   },
   "directories": {
     "lib": "./lib/mongoose"
@@ -72,6 +77,7 @@
     "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-rs": "START_REPLICA_SET=1 mocha --timeout 30000 --exit ./test/*.test.js",
     "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"
@@ -115,6 +121,7 @@
       "allowSyntheticDefaultImports": true,
       "strictPropertyInitialization": false,
       "noImplicitAny": false,
+      "strictNullChecks": true,
       "module": "commonjs",
       "target": "ES2017"
     }

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

@@ -1,8 +1,8 @@
 {
   "compilerOptions": {
+    "strictNullChecks": true,
     "paths": {
       "mongoose" : ["./types/index.d.ts"]
     }
-  },
-  "strictNullChecks": true
+  }
 }

package/types/aggregate.d.ts

@@ -1,6 +1,5 @@
-import mongodb = require('mongodb');
-
 declare module 'mongoose' {
+  import mongodb = require('mongodb');
 
   interface AggregateOptions {
     /**

package/types/connection.d.ts

@@ -1,7 +1,6 @@
-import mongodb = require('mongodb');
-import events = require('events');
-
 declare module 'mongoose' {
+  import mongodb = require('mongodb');
+  import events = require('events');
 
   /**
      * Connection ready state
@@ -197,7 +196,7 @@ declare module 'mongoose' {
        * async function executes successfully and attempt to retry if
        * there was a retryable error.
        */
-    transaction<U = any>(fn: (session: mongodb.ClientSession) => Promise<U>): Promise<U>;
+    transaction(fn: (session: mongodb.ClientSession) => Promise<any>): Promise<void>;
 
     /** Switches to a different database using the same connection pool. */
     useDb(name: string, options?: { useCache?: boolean, noListener?: boolean }): Connection;
@@ -206,7 +205,7 @@ declare module 'mongoose' {
     readonly user: string;
 
     /** Watches the entire underlying database for changes. Similar to [`Model.watch()`](/docs/api/model.html#model_Model.watch). */
-    watch<ResultType = any>(pipeline?: Array<any>, options?: mongodb.ChangeStreamOptions): mongodb.ChangeStream<ResultType>;
+    watch<ResultType extends mongodb.Document = any>(pipeline?: Array<any>, options?: mongodb.ChangeStreamOptions): mongodb.ChangeStream<ResultType>;
   }
 
 }

package/types/cursor.d.ts

@@ -1,8 +1,15 @@
-import stream = require('stream');
-
 declare module 'mongoose' {
+
+  import stream = require('stream');
+
   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 +32,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

package/types/document.d.ts

@@ -1,10 +1,15 @@
-import mongodb = require('mongodb');
-
 declare module 'mongoose' {
+  import mongodb = require('mongodb');
 
   /** A list of paths to skip. If set, Mongoose will validate every modified path that is not in this list. */
   type pathsToSkip = string[] | string;
 
+  /**
+   * Generic types for Document:
+   * *  T - the type of _id
+   * *  TQueryHelpers - Object with any helpers that should be mixed into the Query type
+   * *  DocType - the type of the actual Document created
+   */
   class Document<T = any, TQueryHelpers = any, DocType = any> {
     constructor(doc?: any);
 
@@ -49,6 +54,9 @@ declare module 'mongoose' {
     /** Marks a path as valid, removing existing validation errors. */
     $markValid(path: string): void;
 
+    /** Returns the model with the given name on this document's associated connection. */
+    $model<ModelType = Model<unknown>>(name: string): ModelType;
+
     /**
      * A string containing the current operation that Mongoose is executing
      * on this document. Can be `null`, `'save'`, `'validate'`, or `'remove'`.
@@ -169,9 +177,6 @@ declare module 'mongoose' {
     /** The name of the model */
     modelName: string;
 
-    /** Returns the model with the given name on this document's associated connection. */
-    model<ModelType = Model<unknown>>(name: string): ModelType;
-
     /**
      * Overwrite all values in this document with the values of `obj`, except
      * for immutable properties. Behaves similarly to `set()`, except for it
@@ -186,10 +191,10 @@ declare module 'mongoose' {
     $parent(): Document | undefined;
 
     /** Populates document references. */
-    populate<Paths = {}>(path: string | PopulateOptions | (string | PopulateOptions)[], callback: Callback<this & Paths>): void;
-    populate<Paths = {}>(path: string, names: string, callback: Callback<this & Paths>): void;
-    populate<Paths = {}>(path: string, names: string): Promise<this & Paths>;
     populate<Paths = {}>(path: string | PopulateOptions | (string | PopulateOptions)[]): Promise<this & Paths>;
+    populate<Paths = {}>(path: string | PopulateOptions | (string | PopulateOptions)[], callback: Callback<this & Paths>): void;
+    populate<Paths = {}>(path: string, select?: string | AnyObject, model?: Model<unknown>, match?: AnyObject, options?: PopulateOptions): Promise<this & Paths>;
+    populate<Paths = {}>(path: string, select?: string | AnyObject, model?: Model<unknown>, match?: AnyObject, options?: PopulateOptions, callback?: Callback<this & Paths>): void;
 
     /** Gets _id(s) used during population of the given `path`. If the path was not populated, returns `undefined`. */
     populated(path: string): any;
@@ -216,13 +221,11 @@ declare module 'mongoose' {
     set(value: any): this;
 
     /** The return value of this method is used in calls to JSON.stringify(doc). */
-    toJSON(options: ToObjectOptions & { flattenMaps: false }): LeanDocument<this>;
-    toJSON(options?: ToObjectOptions): FlattenMaps<LeanDocument<this>>;
-    toJSON<T = FlattenMaps<DocType>>(options?: ToObjectOptions): T;
+    toJSON<T = DocType>(options?: ToObjectOptions & { flattenMaps?: true }): FlattenMaps<LeanDocument<T>>;
+    toJSON<T = DocType>(options: ToObjectOptions & { flattenMaps: false }): LeanDocument<T>;
 
     /** Converts this document into a plain-old JavaScript object ([POJO](https://masteringjs.io/tutorials/fundamentals/pojo)). */
-    toObject(options?: ToObjectOptions): LeanDocument<this>;
-    toObject<T = DocType>(options?: ToObjectOptions): T;
+    toObject<T = DocType>(options?: ToObjectOptions): LeanDocument<T>;
 
     /** Clears the modified state on the specified path. */
     unmarkModified(path: string): void;
@@ -242,6 +245,6 @@ declare module 'mongoose' {
 
     /** Executes registered validation rules (skipping asynchronous validators) for this document. */
     validateSync(options: { pathsToSkip?: pathsToSkip, [k: string]: any }): Error.ValidationError | null;
-    validateSync(pathsToValidate?: Array<string>, options?: AnyObject): Error.ValidationError | null;
+    validateSync(pathsToValidate?: pathsToValidate, options?: AnyObject): Error.ValidationError | null;
   }
 }

package/types/error.d.ts

@@ -1,129 +1,129 @@
-import mongodb = require('mongodb');
+declare class NativeError extends global.Error { }
 
 declare module 'mongoose' {
+  import mongodb = require('mongodb');
 
-  class NativeError extends global.Error { }
-    type CallbackError = NativeError | null;
-
-    class MongooseError extends global.Error {
-      constructor(msg: string);
-
-      /** The type of error. "MongooseError" for generic errors. */
-      name: string;
-
-      static messages: any;
-
-      static Messages: any;
-    }
-
-    namespace Error {
-      export class CastError extends MongooseError {
-        name: 'CastError';
-        stringValue: string;
-        kind: string;
-        value: any;
-        path: string;
-        reason?: NativeError | null;
-        model?: any;
-
-        constructor(type: string, value: any, path: string, reason?: NativeError, schemaType?: SchemaType);
-      }
-      export class SyncIndexesError extends MongooseError {
-        name: 'SyncIndexesError';
-        errors?: Record<string, mongodb.MongoServerError>;
-
-        constructor(type: string, value: any, path: string, reason?: NativeError, schemaType?: SchemaType);
-      }
-
-      export class DisconnectedError extends MongooseError {
-        name: 'DisconnectedError';
-      }
-
-      export class DivergentArrayError extends MongooseError {
-        name: 'DivergentArrayError';
-      }
-
-      export class MissingSchemaError extends MongooseError {
-        name: 'MissingSchemaError';
-      }
-
-      export class DocumentNotFoundError extends MongooseError {
-        name: 'DocumentNotFoundError';
-        result: any;
-        numAffected: number;
-        filter: any;
-        query: any;
-      }
-
-      export class ObjectExpectedError extends MongooseError {
-        name: 'ObjectExpectedError';
-        path: string;
-      }
-
-      export class ObjectParameterError extends MongooseError {
-        name: 'ObjectParameterError';
-      }
-
-      export class OverwriteModelError extends MongooseError {
-        name: 'OverwriteModelError';
-      }
-
-      export class ParallelSaveError extends MongooseError {
-        name: 'ParallelSaveError';
-      }
-
-      export class ParallelValidateError extends MongooseError {
-        name: 'ParallelValidateError';
-      }
-
-      export class MongooseServerSelectionError extends MongooseError {
-        name: 'MongooseServerSelectionError';
-      }
-
-      export class StrictModeError extends MongooseError {
-        name: 'StrictModeError';
-        isImmutableError: boolean;
-        path: string;
-      }
-
-      export class ValidationError extends MongooseError {
-        name: 'ValidationError';
-
-        errors: { [path: string]: ValidatorError | CastError };
-        addError: (path: string, error: ValidatorError | CastError) => void;
-
-        constructor(instance?: MongooseError);
-      }
-
-      export class ValidatorError extends MongooseError {
-        name: 'ValidatorError';
-        properties: {
-          message: string,
-          type?: string,
-          path?: string,
-          value?: any,
-          reason?: any
-        };
-        kind: string;
-        path: string;
-        value: any;
-        reason?: MongooseError | null;
-
-        constructor(properties: {
-          message?: string,
-          type?: string,
-          path?: string,
-          value?: any,
-          reason?: any
-        });
-      }
-
-      export class VersionError extends MongooseError {
-        name: 'VersionError';
-        version: number;
-        modifiedPaths: Array<string>;
-
-        constructor(doc: Document, currentVersion: number, modifiedPaths: Array<string>);
-      }
+  type CallbackError = NativeError | null;
+
+  class MongooseError extends global.Error {
+    constructor(msg: string);
+
+    /** The type of error. "MongooseError" for generic errors. */
+    name: string;
+
+    static messages: any;
+
+    static Messages: any;
+  }
+
+  namespace Error {
+    export class CastError extends MongooseError {
+      name: 'CastError';
+      stringValue: string;
+      kind: string;
+      value: any;
+      path: string;
+      reason?: NativeError | null;
+      model?: any;
+
+      constructor(type: string, value: any, path: string, reason?: NativeError, schemaType?: SchemaType);
+    }
+    export class SyncIndexesError extends MongooseError {
+      name: 'SyncIndexesError';
+      errors?: Record<string, mongodb.MongoServerError>;
+
+      constructor(type: string, value: any, path: string, reason?: NativeError, schemaType?: SchemaType);
+    }
+
+    export class DisconnectedError extends MongooseError {
+      name: 'DisconnectedError';
+    }
+
+    export class DivergentArrayError extends MongooseError {
+      name: 'DivergentArrayError';
+    }
+
+    export class MissingSchemaError extends MongooseError {
+      name: 'MissingSchemaError';
+    }
+
+    export class DocumentNotFoundError extends MongooseError {
+      name: 'DocumentNotFoundError';
+      result: any;
+      numAffected: number;
+      filter: any;
+      query: any;
+    }
+
+    export class ObjectExpectedError extends MongooseError {
+      name: 'ObjectExpectedError';
+      path: string;
+    }
+
+    export class ObjectParameterError extends MongooseError {
+      name: 'ObjectParameterError';
+    }
+
+    export class OverwriteModelError extends MongooseError {
+      name: 'OverwriteModelError';
+    }
+
+    export class ParallelSaveError extends MongooseError {
+      name: 'ParallelSaveError';
+    }
+
+    export class ParallelValidateError extends MongooseError {
+      name: 'ParallelValidateError';
+    }
+
+    export class MongooseServerSelectionError extends MongooseError {
+      name: 'MongooseServerSelectionError';
+    }
+
+    export class StrictModeError extends MongooseError {
+      name: 'StrictModeError';
+      isImmutableError: boolean;
+      path: string;
+    }
+
+    export class ValidationError extends MongooseError {
+      name: 'ValidationError';
+
+      errors: { [path: string]: ValidatorError | CastError };
+      addError: (path: string, error: ValidatorError | CastError) => void;
+
+      constructor(instance?: MongooseError);
+    }
+
+    export class ValidatorError extends MongooseError {
+      name: 'ValidatorError';
+      properties: {
+        message: string,
+        type?: string,
+        path?: string,
+        value?: any,
+        reason?: any
+      };
+      kind: string;
+      path: string;
+      value: any;
+      reason?: MongooseError | null;
+
+      constructor(properties: {
+        message?: string,
+        type?: string,
+        path?: string,
+        value?: any,
+        reason?: any
+      });
+    }
+
+    export class VersionError extends MongooseError {
+      name: 'VersionError';
+      version: number;
+      modifiedPaths: Array<string>;
+
+      constructor(doc: Document, currentVersion: number, modifiedPaths: Array<string>);
     }
+  }
 }