mongoose 6.2.2 → 6.2.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "6.2.2",
+  "version": "6.2.5",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -24,39 +24,37 @@
     "mongodb": "4.3.1",
     "mpath": "0.8.4",
     "mquery": "4.0.2",
-    "ms": "2.1.2",
-    "sift": "13.5.2"
+    "ms": "2.1.3",
+    "sift": "16.0.0"
   },
   "devDependencies": {
-    "@babel/core": "7.10.5",
-    "@babel/preset-env": "7.10.4",
-    "@typescript-eslint/eslint-plugin": "5.8.0",
-    "@typescript-eslint/parser": "5.8.0",
+    "@babel/core": "7.17.5",
+    "@babel/preset-env": "7.16.11",
+    "@typescript-eslint/eslint-plugin": "5.12.0",
+    "@typescript-eslint/parser": "5.12.0",
     "acquit": "1.x",
-    "acquit-ignore": "0.1.x",
+    "acquit-ignore": "0.2.x",
     "acquit-require": "0.1.x",
-    "babel-loader": "8.1.0",
+    "babel-loader": "8.2.3",
     "benchmark": "2.1.4",
     "bluebird": "3.7.2",
-    "cheerio": "1.0.0-rc.5",
+    "cheerio": "1.0.0-rc.10",
     "dox": "0.3.1",
-    "eslint": "8.5.0",
-    "eslint-plugin-mocha-no-only": "1.1.0",
+    "eslint": "8.9.0",
+    "eslint-plugin-mocha-no-only": "1.1.1",
     "highlight.js": "9.18.3",
     "lodash.isequal": "4.5.0",
     "lodash.isequalwith": "4.4.0",
     "marked": "2.1.3",
-    "mkdirp": "0.5.5",
-    "mocha": "9.2.0",
+    "mocha": "9.2.1",
     "moment": "2.x",
-    "mongodb-memory-server": "^8.2.0",
+    "mongodb-memory-server": "^8.3.0",
     "nyc": "^15.1.0",
     "pug": "3.0.2",
     "q": "1.5.1",
-    "rimraf": "2.6.3",
     "serve-handler": "6.1.3",
     "tsd": "0.19.1",
-    "typescript": "4.5.3",
+    "typescript": "4.5.5",
     "uuid": "8.3.2",
     "webpack": "4.44.1"
   },
@@ -118,4 +116,4 @@
       "target": "ES2017"
     }
   }
-}
+}

package/types/connection.d.ts

@@ -0,0 +1,212 @@
+import mongodb = require('mongodb');
+import events = require('events');
+
+declare module 'mongoose' {
+
+    /**
+     * Connection ready state
+     *
+     * - 0 = disconnected
+     * - 1 = connected
+     * - 2 = connecting
+     * - 3 = disconnecting
+     * - 99 = uninitialized
+     */
+    export enum ConnectionStates {
+        disconnected = 0,
+        connected = 1,
+        connecting = 2,
+        disconnecting = 3,
+        uninitialized = 99,
+    }
+
+    /** Expose connection states for user-land */
+    export const STATES: typeof ConnectionStates;
+
+    interface ConnectOptions extends mongodb.MongoClientOptions {
+        /** Set to false to [disable buffering](http://mongoosejs.com/docs/faq.html#callback_never_executes) on all models associated with this connection. */
+        bufferCommands?: boolean;
+        /** The name of the database you want to use. If not provided, Mongoose uses the database name from connection string. */
+        dbName?: string;
+        /** username for authentication, equivalent to `options.auth.user`. Maintained for backwards compatibility. */
+        user?: string;
+        /** password for authentication, equivalent to `options.auth.password`. Maintained for backwards compatibility. */
+        pass?: string;
+        /** Set to false to disable automatic index creation for all models associated with this connection. */
+        autoIndex?: boolean;
+        /** Set to `true` to make Mongoose automatically call `createCollection()` on every model created on this connection. */
+        autoCreate?: boolean;
+    }
+
+    class Connection extends events.EventEmitter {
+      /** Returns a promise that resolves when this connection successfully connects to MongoDB */
+      asPromise(): Promise<this>;
+
+      /** Closes the connection */
+      close(force: boolean, callback: CallbackWithoutResult): void;
+      close(callback: CallbackWithoutResult): void;
+      close(force?: boolean): Promise<void>;
+
+      /** Retrieves a collection, creating it if not cached. */
+      collection<T extends AnyObject = AnyObject>(name: string, options?: mongodb.CreateCollectionOptions): Collection<T>;
+
+      /** A hash of the collections associated with this connection */
+      readonly collections: { [index: string]: Collection };
+
+      /** A hash of the global options that are associated with this connection */
+      readonly config: any;
+
+      /** The mongodb.Db instance, set when the connection is opened */
+      readonly db: mongodb.Db;
+
+      /**
+       * Helper for `createCollection()`. Will explicitly create the given collection
+       * with specified options. Used to create [capped collections](https://docs.mongodb.com/manual/core/capped-collections/)
+       * and [views](https://docs.mongodb.com/manual/core/views/) from mongoose.
+       */
+      createCollection<T extends AnyObject = AnyObject>(name: string, options: mongodb.CreateCollectionOptions, callback: Callback<mongodb.Collection<T>>): void;
+      createCollection<T extends AnyObject = AnyObject>(name: string, callback: Callback<mongodb.Collection<T>>): void;
+      createCollection<T extends AnyObject = AnyObject>(name: string, options?: mongodb.CreateCollectionOptions): Promise<mongodb.Collection<T>>;
+
+      /**
+       * Removes the model named `name` from this connection, if it exists. You can
+       * use this function to clean up any models you created in your tests to
+       * prevent OverwriteModelErrors.
+       */
+      deleteModel(name: string): this;
+
+      /**
+       * Helper for `dropCollection()`. Will delete the given collection, including
+       * all documents and indexes.
+       */
+      dropCollection(collection: string, callback: CallbackWithoutResult): void;
+      dropCollection(collection: string): Promise<void>;
+
+      /**
+       * Helper for `dropDatabase()`. Deletes the given database, including all
+       * collections, documents, and indexes.
+       */
+      dropDatabase(callback: CallbackWithoutResult): void;
+      dropDatabase(): Promise<void>;
+
+      /** Gets the value of the option `key`. */
+      get(key: string): any;
+
+      /**
+       * Returns the [MongoDB driver `MongoClient`](http://mongodb.github.io/node-mongodb-native/3.5/api/MongoClient.html) instance
+       * that this connection uses to talk to MongoDB.
+       */
+      getClient(): mongodb.MongoClient;
+
+      /**
+       * The host name portion of the URI. If multiple hosts, such as a replica set,
+       * this will contain the first host name in the URI
+       */
+      readonly host: string;
+
+      /**
+       * A number identifier for this connection. Used for debugging when
+       * you have [multiple connections](/docs/connections.html#multiple_connections).
+       */
+      readonly id: number;
+
+      /**
+       * A [POJO](https://masteringjs.io/tutorials/fundamentals/pojo) containing
+       * a map from model names to models. Contains all models that have been
+       * added to this connection using [`Connection#model()`](/docs/api/connection.html#connection_Connection-model).
+       */
+      readonly models: Readonly<{ [index: string]: Model<any> }>;
+
+      /** Defines or retrieves a model. */
+      model<T, U, TQueryHelpers = {}>(
+            name: string,
+            schema?: Schema<T, U, TQueryHelpers>,
+            collection?: string,
+            options?: CompileModelOptions
+        ): U;
+      model<T>(name: string, schema?: Schema<T>, collection?: string, options?: CompileModelOptions): Model<T>;
+
+      /** Returns an array of model names created on this connection. */
+      modelNames(): Array<string>;
+
+      /** The name of the database this connection points to. */
+      readonly name: string;
+
+      /** Opens the connection with a URI using `MongoClient.connect()`. */
+      openUri(uri: string, options: ConnectOptions, callback: Callback<Connection>): Connection;
+      openUri(uri: string, callback: Callback<Connection>): Connection;
+      openUri(uri: string, options?: ConnectOptions): Promise<Connection>;
+
+      /** The password specified in the URI */
+      readonly pass: string;
+
+      /**
+       * The port portion of the URI. If multiple hosts, such as a replica set,
+       * this will contain the port from the first host name in the URI.
+       */
+      readonly port: number;
+
+      /** Declares a plugin executed on all schemas you pass to `conn.model()` */
+      plugin<S extends Schema = Schema, O = AnyObject>(fn: (schema: S, opts?: any) => void, opts?: O): Connection;
+
+      /** The plugins that will be applied to all models created on this connection. */
+      plugins: Array<any>;
+
+      /**
+       * Connection ready state
+       *
+       * - 0 = disconnected
+       * - 1 = connected
+       * - 2 = connecting
+       * - 3 = disconnecting
+       * - 99 = uninitialized
+       */
+      readonly readyState: ConnectionStates;
+
+      /** Sets the value of the option `key`. */
+      set(key: string, value: any): any;
+
+      /**
+       * Set the [MongoDB driver `MongoClient`](http://mongodb.github.io/node-mongodb-native/3.5/api/MongoClient.html) instance
+       * that this connection uses to talk to MongoDB. This is useful if you already have a MongoClient instance, and want to
+       * reuse it.
+       */
+      setClient(client: mongodb.MongoClient): this;
+
+      /**
+       * _Requires MongoDB >= 3.6.0._ Starts a [MongoDB session](https://docs.mongodb.com/manual/release-notes/3.6/#client-sessions)
+       * for benefits like causal consistency, [retryable writes](https://docs.mongodb.com/manual/core/retryable-writes/),
+       * and [transactions](http://thecodebarbarian.com/a-node-js-perspective-on-mongodb-4-transactions.html).
+       */
+      startSession(options: mongodb.ClientSessionOptions | undefined | null, callback: Callback<mongodb.ClientSession>): void;
+      startSession(callback: Callback<mongodb.ClientSession>): void;
+      startSession(options?: mongodb.ClientSessionOptions): Promise<mongodb.ClientSession>;
+
+      /**
+       * Makes the indexes in MongoDB match the indexes defined in every model's
+       * schema. This function will drop any indexes that are not defined in
+       * the model's schema except the `_id` index, and build any indexes that
+       * are in your schema but not in MongoDB.
+       */
+      syncIndexes(options: SyncIndexesOptions | undefined | null, callback: Callback<ConnectionSyncIndexesResult>): void;
+      syncIndexes(options?: SyncIndexesOptions): Promise<ConnectionSyncIndexesResult>;
+
+      /**
+       * _Requires MongoDB >= 3.6.0._ Executes the wrapped async function
+       * in a transaction. Mongoose will commit the transaction if the
+       * 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>;
+
+      /** Switches to a different database using the same connection pool. */
+      useDb(name: string, options?: { useCache?: boolean, noListener?: boolean }): Connection;
+
+      /** The username specified in the URI */
+      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>;
+    }
+
+}

package/types/cursor.ts

@@ -0,0 +1,48 @@
+import stream = require('stream');
+
+declare module 'mongoose' {
+  type CursorFlag = 'tailable' | 'oplogReplay' | 'noCursorTimeout' | 'awaitData' | 'partial';
+
+  class Cursor<DocType = any, Options = never> extends stream.Readable {
+    [Symbol.asyncIterator](): AsyncIterableIterator<DocType>;
+
+    /**
+     * Adds a [cursor flag](http://mongodb.github.io/node-mongodb-native/2.2/api/Cursor.html#addCursorFlag).
+     * Useful for setting the `noCursorTimeout` and `tailable` flags.
+     */
+    addCursorFlag(flag: CursorFlag, value: boolean): this;
+
+    /**
+     * Marks this cursor as closed. Will stop streaming and subsequent calls to
+     * `next()` will error.
+     */
+    close(callback: CallbackWithoutResult): void;
+    close(): Promise<void>;
+
+    /**
+     * Execute `fn` for every document(s) in the cursor. If batchSize is provided
+     * `fn` will be executed for each batch of documents. If `fn` returns a promise,
+     * 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>;
+
+    /**
+     * Registers a transform function which subsequently maps documents retrieved
+     * via the streams interface or `.next()`
+     */
+    map<ResultType>(fn: (res: DocType) => ResultType): Cursor<ResultType, Options>;
+
+    /**
+     * Get the next document from this cursor. Will return `null` when there are
+     * no documents left.
+     */
+    next(callback: Callback<DocType | null>): void;
+    next(): Promise<DocType>;
+
+    options: Options;
+  }
+}

package/types/error.d.ts

@@ -0,0 +1,129 @@
+import mongodb = require('mongodb');
+
+declare module 'mongoose' {
+
+    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>);
+      }
+    }
+  }