mongoose 9.0.1 → 9.0.2

package/lib/document.js

@@ -648,6 +648,10 @@ Document.prototype.init = function(doc, opts, fn) {
     opts = null;
   }
 
+  if (doc == null) {
+    throw new ObjectParameterError(doc, 'doc', 'init');
+  }
+
   this.$__init(doc, opts);
 
   if (fn) {
@@ -677,6 +681,9 @@ Document.prototype.$init = function() {
  */
 
 Document.prototype.$__init = function(doc, opts) {
+  if (doc == null) {
+    throw new ObjectParameterError(doc, 'doc', 'init');
+  }
   this.$isNew = false;
   opts = opts || {};
 
@@ -5174,7 +5181,7 @@ function operand(self, where, delta, data, val, op) {
     if (/\.\d+\.|\.\d+$/.test(data.path)) {
       self.$__.version = VERSION_ALL;
     } else {
-      self.$__.version = VERSION_INC;
+      self.$__.version |= VERSION_INC;
     }
   } else if (/^\$p/.test(op)) {
     // potentially changing array positions
@@ -5185,7 +5192,7 @@ function operand(self, where, delta, data, val, op) {
   } else if (/\.\d+\.|\.\d+$/.test(data.path)) {
     // now handling $set, $unset
     // subpath of array
-    self.$__.version = VERSION_WHERE;
+    self.$__.version |= VERSION_WHERE;
   }
 }
 

package/lib/drivers/node-mongodb-native/collection.js

@@ -80,12 +80,6 @@ NativeCollection.prototype._getCollection = function _getCollection() {
   return null;
 };
 
-/*!
- * ignore
- */
-
-const syncCollectionMethods = { watch: true, find: true, aggregate: true };
-
 /**
  * Copy the collection methods and make them subject to queues
  * @param {Number|String} I
@@ -107,7 +101,6 @@ function iter(i) {
       _this.conn.options &&
       _this.conn.options.debug;
     const debug = connectionDebug == null ? globalDebug : connectionDebug;
-    const lastArg = arguments[arguments.length - 1];
     const opId = new ObjectId();
 
     // If user force closed, queueing will hang forever. See #5664
@@ -122,9 +115,8 @@ function iter(i) {
       }
     }
 
-    let _args = args;
-    let callback = null;
     let timeout = null;
+    let waitForBufferPromise = null;
     if (this._shouldBufferCommands() && this.buffer) {
       this.conn.emit('buffer', {
         _id: opId,
@@ -134,78 +126,28 @@ function iter(i) {
         args: args
       });
 
-      let callback;
-      let _args = args;
-      let promise = null;
-      if (syncCollectionMethods[i] && typeof lastArg === 'function') {
-        this.addQueue(i, _args);
-        callback = lastArg;
-      } else if (syncCollectionMethods[i]) {
-        promise = new this.Promise((resolve, reject) => {
-          callback = function collectionOperationCallback(err, res) {
-            if (timeout != null) {
-              clearTimeout(timeout);
-            }
-            if (err != null) {
-              return reject(err);
-            }
-            resolve(res);
-          };
-          _args = args.concat([callback]);
-          this.addQueue(i, _args);
-        });
-      } else if (typeof lastArg === 'function') {
-        callback = function collectionOperationCallback() {
-          if (timeout != null) {
-            clearTimeout(timeout);
-          }
-          return lastArg.apply(this, arguments);
-        };
-        _args = args.slice(0, args.length - 1).concat([callback]);
-      } else {
-        promise = new Promise((resolve, reject) => {
-          callback = function collectionOperationCallback(err, res) {
-            if (timeout != null) {
-              clearTimeout(timeout);
-            }
-            if (err != null) {
-              return reject(err);
-            }
-            resolve(res);
-          };
-          _args = args.concat([callback]);
-          this.addQueue(i, _args);
-        });
-      }
-
       const bufferTimeoutMS = this._getBufferTimeoutMS();
-      timeout = setTimeout(() => {
-        const removed = this.removeQueue(i, _args);
-        if (removed) {
-          const message = 'Operation `' + this.name + '.' + i + '()` buffering timed out after ' +
-            bufferTimeoutMS + 'ms';
-          const err = new MongooseError(message);
-          this.conn.emit('buffer-end', { _id: opId, modelName: _this.modelName, collectionName: _this.name, method: i, error: err });
-          callback(err);
-        }
-      }, bufferTimeoutMS);
-
-      if (!syncCollectionMethods[i] && typeof lastArg === 'function') {
-        this.addQueue(i, _args);
-        return;
-      }
+      waitForBufferPromise = new Promise((resolve, reject) => {
+        this.addQueue(resolve);
+
+        timeout = setTimeout(() => {
+          const removed = this.removeQueue(resolve);
+          if (removed) {
+            const message = 'Operation `' + this.name + '.' + i + '()` buffering timed out after ' +
+              bufferTimeoutMS + 'ms';
+            const err = new MongooseError(message);
+            this.conn.emit('buffer-end', { _id: opId, modelName: _this.modelName, collectionName: _this.name, method: i, error: err });
+            reject(err);
+          }
+        }, bufferTimeoutMS);
+      });
 
-      return promise;
-    } else if (!syncCollectionMethods[i] && typeof lastArg === 'function') {
-      callback = function collectionOperationCallback(err, res) {
-        if (err != null) {
-          _this.conn.emit('operation-end', { _id: opId, modelName: _this.modelName, collectionName: _this.name, method: i, error: err });
-        } else {
-          _this.conn.emit('operation-end', { _id: opId, modelName: _this.modelName, collectionName: _this.name, method: i, result: res });
+      return waitForBufferPromise.then(() => {
+        if (timeout) {
+          clearTimeout(timeout);
         }
-        return lastArg.apply(this, arguments);
-      };
-      _args = args.slice(0, args.length - 1).concat([callback]);
+        return this[i].apply(this, args);
+      });
     }
 
     if (debug) {
@@ -227,7 +169,7 @@ function iter(i) {
       }
     }
 
-    this.conn.emit('operation-start', { _id: opId, modelName: _this.modelName, collectionName: this.name, method: i, params: _args });
+    this.conn.emit('operation-start', { _id: opId, modelName: _this.modelName, collectionName: this.name, method: i, params: args });
 
     try {
       if (collection == null) {
@@ -237,60 +179,37 @@ function iter(i) {
         throw new MongooseError(message);
       }
 
-      if (syncCollectionMethods[i] && typeof lastArg === 'function') {
-        const result = collection[i].apply(collection, _args.slice(0, _args.length - 1));
-        if (timeout != null) {
-          clearTimeout(timeout);
-        }
-        this.conn.emit('operation-end', { _id: opId, modelName: _this.modelName, collectionName: this.name, method: i, result });
-        return lastArg.call(this, null, result);
-      }
-
-      const ret = collection[i].apply(collection, _args);
+      const ret = collection[i].apply(collection, args);
       if (ret != null && typeof ret.then === 'function') {
         return ret.then(
           result => {
             if (timeout != null) {
               clearTimeout(timeout);
             }
-            if (typeof lastArg === 'function') {
-              lastArg(null, result);
-            } else {
-              this.conn.emit('operation-end', { _id: opId, modelName: _this.modelName, collectionName: this.name, method: i, result });
-            }
+            this.conn.emit('operation-end', { _id: opId, modelName: _this.modelName, collectionName: this.name, method: i, result });
             return result;
           },
           error => {
             if (timeout != null) {
               clearTimeout(timeout);
             }
-            if (typeof lastArg === 'function') {
-              lastArg(error);
-              return;
-            } else {
-              this.conn.emit('operation-end', { _id: opId, modelName: _this.modelName, collectionName: this.name, method: i, error });
-            }
+            this.conn.emit('operation-end', { _id: opId, modelName: _this.modelName, collectionName: this.name, method: i, error });
             throw error;
           }
         );
       }
+
+      this.conn.emit('operation-end', { _id: opId, modelName: _this.modelName, collectionName: this.name, method: i, result: ret });
       if (timeout != null) {
         clearTimeout(timeout);
       }
       return ret;
     } catch (error) {
-      // Collection operation may throw because of max bson size, catch it here
-      // See gh-3906
       if (timeout != null) {
         clearTimeout(timeout);
       }
-      if (typeof lastArg === 'function') {
-        return lastArg(error);
-      } else {
-        this.conn.emit('operation-end', { _id: opId, modelName: _this.modelName, collectionName: this.name, method: i, error: error });
-
-        throw error;
-      }
+      this.conn.emit('operation-end', { _id: opId, modelName: _this.modelName, collectionName: this.name, method: i, error: error });
+      throw error;
     }
   };
 }

package/lib/model.js

@@ -3248,12 +3248,14 @@ function _setIsNew(doc, val) {
  * @param {Object} [ops.updateOne.update] An object containing [update operators](https://www.mongodb.com/docs/manual/reference/operator/update/)
  * @param {Boolean} [ops.updateOne.upsert=false] If true, insert a doc if none match
  * @param {Boolean} [ops.updateOne.timestamps=true] If false, do not apply [timestamps](https://mongoosejs.com/docs/guide.html#timestamps) to the operation
+ * @param {Boolean} [ops.updateOne.overwriteImmutable=false] Mongoose removes updated immutable properties from `update` by default (excluding $setOnInsert). Set `overwriteImmutable` to `true` to allow updating immutable properties using other update operators.
  * @param {Object} [ops.updateOne.collation] The [MongoDB collation](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-34-collations) to use
  * @param {Array} [ops.updateOne.arrayFilters] The [array filters](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-36-array-filters.html) used in `update`
  * @param {Object} [ops.updateMany.filter] Update all the documents that match this filter
  * @param {Object} [ops.updateMany.update] An object containing [update operators](https://www.mongodb.com/docs/manual/reference/operator/update/)
  * @param {Boolean} [ops.updateMany.upsert=false] If true, insert a doc if no documents match `filter`
  * @param {Boolean} [ops.updateMany.timestamps=true] If false, do not apply [timestamps](https://mongoosejs.com/docs/guide.html#timestamps) to the operation
+ * @param {Boolean} [ops.updateMany.overwriteImmutable=false] Mongoose removes updated immutable properties from `update` by default (excluding $setOnInsert). Set `overwriteImmutable` to `true` to allow updating immutable properties using other update operators.
  * @param {Object} [ops.updateMany.collation] The [MongoDB collation](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-34-collations) to use
  * @param {Array} [ops.updateMany.arrayFilters] The [array filters](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-36-array-filters.html) used in `update`
  * @param {Object} [ops.deleteOne.filter] Delete the first document that matches this filter
@@ -3286,12 +3288,15 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
   }
   options = options || {};
 
-  [ops, options] = await this.hooks.execPre('bulkWrite', this, [ops, options]).catch(err => {
+  try {
+    [ops, options] = await this.hooks.execPre('bulkWrite', this, [ops, options]);
+  } catch (err) {
     if (err instanceof Kareem.skipWrappedFunction) {
-      return [err];
+      ops = err;
+    } else {
+      await this.hooks.execPost('bulkWrite', this, [null], { error: err });
     }
-    throw err;
-  });
+  }
 
   if (ops instanceof Kareem.skipWrappedFunction) {
     return ops.args[0];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "9.0.1",
+  "version": "9.0.2",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -102,6 +102,7 @@
     "tdd": "mocha --watch --inspect --recursive ./test/*.test.js --watch-files lib/**/*.js test/**/*.js",
     "test-coverage": "nyc --reporter=html --reporter=text npm test",
     "ts-benchmark": "cd ./benchmarks/typescript/simple && npm install && npm run benchmark | node ../../../scripts/tsc-diagnostics-check",
+    "ts-benchmark:local": "node ./scripts/create-tarball && cd ./benchmarks/typescript/simple && rm -rf ./node_modules && npm install && npm run benchmark | node ../../../scripts/tsc-diagnostics-check",
     "attest-benchmark": "node ./benchmarks/typescript/infer.bench.mts"
   },
   "main": "./index.js",

package/types/index.d.ts

@@ -345,7 +345,8 @@ declare module 'mongoose' {
         TSchemaOptions extends { methods: infer M } ? M : {},
         TSchemaOptions extends { query: any } ? TSchemaOptions['query'] : {},
         TSchemaOptions extends { virtuals: any } ? TSchemaOptions['virtuals'] : {},
-        RawDocType
+        RawDocType,
+        ResolveSchemaOptions<TSchemaOptions>
       >
     >(def: TSchemaDefinition): Schema<
       RawDocType,
@@ -374,7 +375,14 @@ declare module 'mongoose' {
         InferRawDocType<TSchemaDefinition, ResolveSchemaOptions<TSchemaOptions>>,
         ResolveSchemaOptions<TSchemaOptions>
       >,
-      THydratedDocumentType extends AnyObject = HydratedDocument<InferHydratedDocType<TSchemaDefinition, ResolveSchemaOptions<TSchemaOptions>>>
+      THydratedDocumentType extends AnyObject = HydratedDocument<
+        InferHydratedDocType<TSchemaDefinition, ResolveSchemaOptions<TSchemaOptions>>,
+        TSchemaOptions extends { methods: infer M } ? M : {},
+        TSchemaOptions extends { query: any } ? TSchemaOptions['query'] : {},
+        TSchemaOptions extends { virtuals: any } ? TSchemaOptions['virtuals'] : {},
+        RawDocType,
+        ResolveSchemaOptions<TSchemaOptions>
+      >
     >(def: TSchemaDefinition, options: TSchemaOptions): Schema<
       RawDocType,
       Model<RawDocType, any, any, any>,
@@ -623,8 +631,7 @@ declare module 'mongoose' {
 
     /** Adds static "class" methods to Models compiled from this schema. */
     static<K extends keyof TStaticMethods>(name: K, fn: TStaticMethods[K]): this;
-    static(obj: { [F in keyof TStaticMethods]: TStaticMethods[F] }): this;
-    static(obj: { [F in keyof TStaticMethods]: TStaticMethods[F] } & { [name: string]: (this: TModelType, ...args: any[]) => any }): this;
+    static(obj: Partial<TStaticMethods> & { [name: string]: (this: TModelType, ...args: any[]) => any }): this;
     static(name: string, fn: (this: TModelType, ...args: any[]) => any): this;
 
     /** Object of currently defined statics on this schema. */

package/types/inferrawdoctype.d.ts

@@ -12,18 +12,24 @@ declare module 'mongoose' {
     ? ObtainSchemaGeneric<TSchema, 'EnforcedDocType'>
     : FlattenMaps<SubdocsToPOJOs<ObtainSchemaGeneric<TSchema, 'DocType'>>>;
 
-  export type InferRawDocType<
+  export type InferRawDocTypeWithout_id<
     SchemaDefinition,
     TSchemaOptions extends Record<any, any> = DefaultSchemaOptions,
     TTransformOptions = { bufferToBinary: false }
-  > = Require_id<ApplySchemaOptions<{
+  > = ApplySchemaOptions<{
     [
     K in keyof (RequiredPaths<SchemaDefinition, TSchemaOptions['typeKey']> &
     OptionalPaths<SchemaDefinition, TSchemaOptions['typeKey']>)
     ]: IsPathRequired<SchemaDefinition[K], TSchemaOptions['typeKey']> extends true
       ? ObtainRawDocumentPathType<SchemaDefinition[K], TSchemaOptions['typeKey'], TTransformOptions>
       : ObtainRawDocumentPathType<SchemaDefinition[K], TSchemaOptions['typeKey'], TTransformOptions> | null;
-  }, TSchemaOptions>>;
+  }, TSchemaOptions>;
+
+  export type InferRawDocType<
+    SchemaDefinition,
+    TSchemaOptions extends Record<any, any> = DefaultSchemaOptions,
+    TTransformOptions = { bufferToBinary: false }
+  > = Require_id<InferRawDocTypeWithout_id<SchemaDefinition, TSchemaOptions, TTransformOptions>>;
 
   /**
    * @summary Allows users to optionally choose their own type for a schema field for stronger typing.

package/types/inferschematype.d.ts

@@ -100,10 +100,10 @@ declare module 'mongoose' {
       {
         EnforcedDocType: EnforcedDocType;
         M: M;
-        TInstanceMethods: TInstanceMethods;
-        TQueryHelpers: TQueryHelpers;
-        TVirtuals: AddDefaultId<DocType, TVirtuals, TSchemaOptions>;
-        TStaticMethods: TStaticMethods;
+        TInstanceMethods: IfEquals<TInstanceMethods, {}, TSchemaOptions extends { methods: infer M } ? M : {}, TInstanceMethods>;
+        TQueryHelpers: IfEquals<TQueryHelpers, {}, TSchemaOptions extends { query: infer Q } ? Q : {}, TQueryHelpers>;
+        TVirtuals: AddDefaultId<DocType, IfEquals<TVirtuals, {}, TSchemaOptions extends { virtuals: infer V } ? V : {}, TVirtuals>, TSchemaOptions>;
+        TStaticMethods: IfEquals<TStaticMethods, {}, TSchemaOptions extends { statics: infer S } ? S : {}, TStaticMethods>;
         TSchemaOptions: TSchemaOptions;
         DocType: DocType;
         THydratedDocumentType: THydratedDocumentType;
@@ -136,11 +136,6 @@ declare module 'mongoose' {
     : T;
 }
 
-type IsPathDefaultUndefined<PathType> =
-  PathType extends { default: undefined } ? true
-  : PathType extends { default: (...args: any[]) => undefined } ? true
-  : false;
-
 type RequiredPropertyDefinition =
   | {
       required: true | string | [true, string | undefined] | { isRequired: true };
@@ -159,16 +154,17 @@ type IsPathRequired<P, TypeKey extends string = DefaultTypeKey> =
     P extends { required: false } ?
       false
     : true
-  : P extends Record<TypeKey, ArrayConstructor | any[]> ?
-    IsPathDefaultUndefined<P> extends true ?
-      false
-    : true
-  : P extends Record<TypeKey, any> ?
-    P extends { default: any } ?
-      IfEquals<P['default'], undefined, false, true>
-    : false
+  : P extends { default: undefined | null | ((...args: any[]) => undefined) | ((...args: any[]) => null) } ? false
+  : P extends { default: any } ? true
+  : P extends Record<TypeKey, ArrayConstructor | any[]> ? true
   : false;
 
+// Internal type used to efficiently check for never or any types
+// can be efficiently checked like:
+// `[T] extends [neverOrAny] ? T : ...`
+// to avoid edge cases
+type neverOrAny = ' ~neverOrAny~';
+
 /**
  * @summary A Utility to obtain schema's required path keys.
  * @param {T} T A generic refers to document definition.
@@ -251,6 +247,7 @@ type UnionToType<T extends readonly any[]> = T[number] extends infer U
 
 type IsSchemaTypeFromBuiltinClass<T> =
   T extends typeof String ? true
+  : unknown extends Buffer ? false
   : T extends typeof Number ? true
   : T extends typeof Boolean ? true
   : T extends typeof Buffer ? true
@@ -268,7 +265,6 @@ type IsSchemaTypeFromBuiltinClass<T> =
   : T extends NativeDate ? true
   : T extends typeof Schema.Types.Mixed ? true
   : T extends Types.UUID ? true
-  : unknown extends Buffer ? false
   : T extends Buffer ? true
   : false;
 
@@ -284,12 +280,10 @@ type ResolvePathType<
   Options extends SchemaTypeOptions<PathValueType> = {},
   TypeKey extends string = DefaultSchemaOptions['typeKey'],
   TypeHint = never
-> = IfEquals<
-  TypeHint,
-  never,
-  PathValueType extends Schema ? InferSchemaType<PathValueType>
+> = [TypeHint] extends [never]
+  ? PathValueType extends Schema ? InferSchemaType<PathValueType>
   : PathValueType extends AnyArray<infer Item> ?
-    IfEquals<Item, never> extends true
+    [Item] extends [never]
       ? any[]
       : Item extends Schema ?
         // If Item is a schema, infer its type.
@@ -328,7 +322,7 @@ type ResolvePathType<
     : never
   : PathValueType extends ArrayConstructor ? any[]
   : PathValueType extends typeof Schema.Types.Mixed ? any
-  : IfEquals<PathValueType, ObjectConstructor> extends true ? any
+  : PathValueType extends ObjectConstructor ? any
   : IfEquals<PathValueType, {}> extends true ? any
   : PathValueType extends typeof SchemaType ? PathValueType['prototype']
   : PathValueType extends Record<string, any> ?
@@ -339,6 +333,5 @@ type ResolvePathType<
         typeKey: TypeKey;
       }
     >
-  : unknown,
-  TypeHint
->;
+  : unknown
+  : TypeHint;

package/types/query.d.ts

@@ -20,7 +20,7 @@ declare module 'mongoose' {
 
   export type ApplyBasicQueryCasting<T> = QueryTypeCasting<T> | QueryTypeCasting<T[]> | (T extends (infer U)[] ? QueryTypeCasting<U> : T) | null;
 
-  type _QueryFilter<T> = ({ [P in keyof T]?: mongodb.Condition<ApplyBasicQueryCasting<T[P]>>; } & mongodb.RootFilterOperators<{ [P in keyof T]?: ApplyBasicQueryCasting<T[P]>; }>);
+  type _QueryFilter<T> = ({ [P in keyof T]?: mongodb.Condition<ApplyBasicQueryCasting<T[P]>>; } & mongodb.RootFilterOperators<{ [P in keyof mongodb.WithId<T>]?: ApplyBasicQueryCasting<mongodb.WithId<T>[P]>; }>);
   type QueryFilter<T> = IsItRecordAndNotAny<T> extends true ? _QueryFilter<WithLevel1NestedPaths<T>> : _QueryFilter<Record<string, any>>;
 
   type MongooseBaseQueryOptionKeys =

package/types/utility.d.ts

@@ -146,7 +146,7 @@ declare module 'mongoose' {
    * @param {T} T Function type to extract 'this' parameter from.
    * @param {F} F Fallback type to return if 'this' parameter does not exist.
    */
-  type ThisParameter<T, F> = T extends { (this: infer This): void } ? This : F;
+  type ThisParameter<T, F> = T extends { (this: infer This, ...args: never): void } ? This : F;
 
   /**
    * @summary Decorates all functions in an object with 'this' parameter.

package/types/virtuals.d.ts

@@ -8,7 +8,7 @@ declare module 'mongoose' {
   type TVirtualPathFN<DocType = {}, PathType = unknown, TInstanceMethods = {}, TReturn = unknown> =
     <T = HydratedDocument<DocType, TInstanceMethods>>(this: Document<any, any, DocType> & DocType, value: PathType, virtual: VirtualType<T>, doc: Document<any, any, DocType> & DocType) => TReturn;
 
-    type SchemaOptionsVirtualsPropertyType<DocType = any, VirtualPaths = Record<any, unknown>, TInstanceMethods = {}> = {
-      [K in keyof VirtualPaths]: VirtualPathFunctions<IsItRecordAndNotAny<DocType> extends true ? DocType : any, VirtualPaths[K], TInstanceMethods>
-    };
+  type SchemaOptionsVirtualsPropertyType<DocType = any, VirtualPaths = Record<any, unknown>, TInstanceMethods = {}> = {
+    [K in keyof VirtualPaths]: VirtualPathFunctions<IsItRecordAndNotAny<DocType> extends true ? DocType : any, VirtualPaths[K], TInstanceMethods>
+  };
 }