mongoose 8.10.1 → 8.10.2

package/lib/connection.js

@@ -23,6 +23,7 @@ const CreateCollectionsError = require('./error/createCollectionsError');
 const castBulkWrite = require('./helpers/model/castBulkWrite');
 const { modelSymbol } = require('./helpers/symbols');
 const isPromise = require('./helpers/isPromise');
+const decorateBulkWriteResult = require('./helpers/model/decorateBulkWriteResult');
 
 const arrayAtomicsSymbol = require('./helpers/symbols').arrayAtomicsSymbol;
 const sessionNewDocuments = require('./helpers/symbols').sessionNewDocuments;
@@ -559,7 +560,9 @@ Connection.prototype.bulkWrite = async function bulkWrite(ops, options) {
           'bulkWrite'
         );
       }
-      return getDefaultBulkwriteResult();
+      const BulkWriteResult = this.base.driver.get().BulkWriteResult;
+      const res = new BulkWriteResult(getDefaultBulkwriteResult(), false);
+      return decorateBulkWriteResult(res, validationErrors, results);
     }
 
     let error;
@@ -567,16 +570,17 @@ Connection.prototype.bulkWrite = async function bulkWrite(ops, options) {
       then(res => ([res, null])).
       catch(err => ([null, err]));
 
+    for (let i = 0; i < validOpIndexes.length; ++i) {
+      results[validOpIndexes[i]] = null;
+    }
     if (error) {
       if (validationErrors.length > 0) {
+        decorateBulkWriteResult(error, validationErrors, results);
         error.mongoose = error.mongoose || {};
         error.mongoose.validationErrors = validationErrors;
       }
     }
 
-    for (let i = 0; i < validOpIndexes.length; ++i) {
-      results[validOpIndexes[i]] = null;
-    }
     if (validationErrors.length > 0) {
       if (options.throwOnValidationError) {
         throw new MongooseBulkWriteError(
@@ -586,9 +590,7 @@ Connection.prototype.bulkWrite = async function bulkWrite(ops, options) {
           'bulkWrite'
         );
       } else {
-        res.mongoose = res.mongoose || {};
-        res.mongoose.validationErrors = validationErrors;
-        res.mongoose.results = results;
+        decorateBulkWriteResult(res, validationErrors, results);
       }
     }
   }

package/lib/drivers/browser/index.js

@@ -10,3 +10,4 @@ exports.Collection = function() {
 exports.Connection = function() {
   throw new Error('Cannot create a connection from browser library');
 };
+exports.BulkWriteResult = function() {};

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

@@ -0,0 +1,5 @@
+'use strict';
+
+const BulkWriteResult = require('mongodb/lib/bulk/common').BulkWriteResult;
+
+module.exports = BulkWriteResult;

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

@@ -13,6 +13,8 @@ const internalToObjectOptions = require('../../options').internalToObjectOptions
 const stream = require('stream');
 const util = require('util');
 
+const formatToObjectOptions = Object.freeze({ ...internalToObjectOptions, copyTrustedSymbol: false });
+
 /**
  * A [node-mongodb-native](https://github.com/mongodb/node-mongodb-native) collection implementation.
  *
@@ -384,7 +386,9 @@ function format(obj, sub, color, shell) {
   }
 
   const clone = require('../../helpers/clone');
-  let x = clone(obj, internalToObjectOptions);
+  // `sub` indicates `format()` was called recursively, so skip cloning because we already
+  // did a deep clone on the top-level object.
+  let x = sub ? obj : clone(obj, formatToObjectOptions);
   const constructorName = getConstructorName(x);
 
   if (constructorName === 'Binary') {

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

@@ -4,5 +4,6 @@
 
 'use strict';
 
+exports.BulkWriteResult = require('./bulkWriteResult');
 exports.Collection = require('./collection');
 exports.Connection = require('./connection');

package/lib/helpers/clone.js

@@ -147,7 +147,7 @@ function cloneObject(obj, options, isArrayChild) {
   } else if (seen) {
     seen.set(obj, ret);
   }
-  if (trustedSymbol in obj) {
+  if (trustedSymbol in obj && options?.copyTrustedSymbol !== false) {
     ret[trustedSymbol] = obj[trustedSymbol];
   }
 

package/lib/helpers/getDefaultBulkwriteResult.js

@@ -1,26 +1,17 @@
 'use strict';
+
 function getDefaultBulkwriteResult() {
   return {
-    result: {
-      ok: 1,
-      writeErrors: [],
-      writeConcernErrors: [],
-      insertedIds: [],
-      nInserted: 0,
-      nUpserted: 0,
-      nMatched: 0,
-      nModified: 0,
-      nRemoved: 0,
-      upserted: []
-    },
-    insertedCount: 0,
-    matchedCount: 0,
-    modifiedCount: 0,
-    deletedCount: 0,
-    upsertedCount: 0,
-    upsertedIds: {},
-    insertedIds: {},
-    n: 0
+    ok: 1,
+    nInserted: 0,
+    nUpserted: 0,
+    nMatched: 0,
+    nModified: 0,
+    nRemoved: 0,
+    upserted: [],
+    writeErrors: [],
+    insertedIds: [],
+    writeConcernErrors: []
   };
 }
 

package/lib/helpers/model/decorateBulkWriteResult.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = function decorateBulkWriteResult(resultOrError, validationErrors, results) {
+  resultOrError.mongoose = resultOrError.mongoose || {};
+  resultOrError.mongoose.validationErrors = validationErrors;
+  resultOrError.mongoose.results = results;
+  return resultOrError;
+};

package/lib/model.js

@@ -10,7 +10,6 @@ const Document = require('./document');
 const DocumentNotFoundError = require('./error/notFound');
 const EventEmitter = require('events').EventEmitter;
 const Kareem = require('kareem');
-const { MongoBulkWriteError } = require('mongodb');
 const MongooseBulkWriteError = require('./error/bulkWriteError');
 const MongooseError = require('./error/index');
 const ObjectParameterError = require('./error/objectParameter');
@@ -69,6 +68,7 @@ const utils = require('./utils');
 const minimize = require('./helpers/minimize');
 const MongooseBulkSaveIncompleteError = require('./error/bulkSaveIncompleteError');
 const ObjectExpectedError = require('./error/objectExpected');
+const decorateBulkWriteResult = require('./helpers/model/decorateBulkWriteResult');
 
 const modelCollectionSymbol = Symbol('mongoose#Model#collection');
 const modelDbSymbol = Symbol('mongoose#Model#db');
@@ -3399,7 +3399,11 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
   const ordered = options.ordered == null ? true : options.ordered;
 
   if (ops.length === 0) {
-    return getDefaultBulkwriteResult();
+    const BulkWriteResult = this.base.driver.get().BulkWriteResult;
+    const bulkWriteResult = new BulkWriteResult(getDefaultBulkwriteResult(), false);
+    bulkWriteResult.n = 0;
+    decorateBulkWriteResult(bulkWriteResult, [], []);
+    return bulkWriteResult;
   }
 
   const validations = ops.map(op => castBulkWrite(this, op, options));
@@ -3470,7 +3474,11 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
           'bulkWrite'
         );
       }
-      return getDefaultBulkwriteResult();
+      const BulkWriteResult = this.base.driver.get().BulkWriteResult;
+      const bulkWriteResult = new BulkWriteResult(getDefaultBulkwriteResult(), false);
+      bulkWriteResult.result = getDefaultBulkwriteResult();
+      decorateBulkWriteResult(bulkWriteResult, validationErrors, results);
+      return bulkWriteResult;
     }
 
     let error;
@@ -3478,10 +3486,12 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
       then(res => ([res, null])).
       catch(error => ([null, error]));
 
+    for (let i = 0; i < validOpIndexes.length; ++i) {
+      results[validOpIndexes[i]] = null;
+    }
     if (error) {
       if (validationErrors.length > 0) {
-        error.mongoose = error.mongoose || {};
-        error.mongoose.validationErrors = validationErrors;
+        decorateBulkWriteResult(error, validationErrors, results);
       }
 
       await new Promise((resolve, reject) => {
@@ -3495,9 +3505,6 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
       });
     }
 
-    for (let i = 0; i < validOpIndexes.length; ++i) {
-      results[validOpIndexes[i]] = null;
-    }
     if (validationErrors.length > 0) {
       if (options.throwOnValidationError) {
         throw new MongooseBulkWriteError(
@@ -3507,9 +3514,7 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
           'bulkWrite'
         );
       } else {
-        res.mongoose = res.mongoose || {};
-        res.mongoose.validationErrors = validationErrors;
-        res.mongoose.results = results;
+        decorateBulkWriteResult(res, validationErrors, results);
       }
     }
   }
@@ -3575,7 +3580,7 @@ Model.bulkSave = async function bulkSave(documents, options) {
     (err) => ({ bulkWriteResult: null, bulkWriteError: err })
   );
   // If not a MongoBulkWriteError, treat this as all documents failed to save.
-  if (bulkWriteError != null && !(bulkWriteError instanceof MongoBulkWriteError)) {
+  if (bulkWriteError != null && bulkWriteError.name !== 'MongoBulkWriteError') {
     throw bulkWriteError;
   }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "8.10.1",
+  "version": "8.10.2",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",

package/types/index.d.ts

@@ -712,47 +712,53 @@ declare module 'mongoose' {
     [K in keyof T]: FlattenProperty<T[K]>;
   };
 
-  export type BufferToBinaryProperty<T> = T extends Buffer
-    ? mongodb.Binary
-    : T extends Types.DocumentArray<infer ItemType>
-      ? Types.DocumentArray<BufferToBinary<ItemType>>
-      : T extends Types.Subdocument<unknown, unknown, infer SubdocType>
-        ? HydratedSingleSubdocument<BufferToBinary<SubdocType>>
-        : BufferToBinary<T>;
+  export type BufferToBinaryProperty<T> = unknown extends Buffer
+    ? T
+    : T extends Buffer
+      ? mongodb.Binary
+      : T extends Types.DocumentArray<infer ItemType>
+        ? Types.DocumentArray<BufferToBinary<ItemType>>
+        : T extends Types.Subdocument<unknown, unknown, infer SubdocType>
+          ? HydratedSingleSubdocument<BufferToBinary<SubdocType>>
+          : BufferToBinary<T>;
 
   /**
    * Converts any Buffer properties into mongodb.Binary instances, which is what `lean()` returns
    */
-  export type BufferToBinary<T> = T extends Buffer
-    ? mongodb.Binary
-    : T extends Document
-      ? T
-      : T extends TreatAsPrimitives
-        ? T
-        : T extends Record<string, any>
-          ? {
-              [K in keyof T]: BufferToBinaryProperty<T[K]>
-            }
-          : T;
+   export type BufferToBinary<T> = unknown extends Buffer
+     ? T
+     : T extends Buffer
+       ? mongodb.Binary
+       : T extends Document
+         ? T
+         : T extends TreatAsPrimitives
+           ? T
+           : T extends Record<string, any>
+             ? {
+                 [K in keyof T]: BufferToBinaryProperty<T[K]>
+               }
+             : T;
 
   /**
-   * Converts any Buffer properties into { type: 'buffer', data: [1, 2, 3] } format for JSON serialization
-   */
-  export type BufferToJSON<T> = T extends Buffer
-    ? { type: 'buffer', data: number[] }
-    : T extends Document
-      ? T
-      : T extends TreatAsPrimitives
+  * Converts any Buffer properties into { type: 'buffer', data: [1, 2, 3] } format for JSON serialization
+  */
+  export type BufferToJSON<T> = unknown extends Buffer
+    ? T
+    : T extends Buffer
+      ? { type: 'buffer', data: number[] }
+      : T extends Document
         ? T
-        : T extends Record<string, any> ? {
-          [K in keyof T]: T[K] extends Buffer
-            ? { type: 'buffer', data: number[] }
-            : T[K] extends Types.DocumentArray<infer ItemType>
-                ? Types.DocumentArray<BufferToBinary<ItemType>>
-                : T[K] extends Types.Subdocument<unknown, unknown, infer SubdocType>
-                  ? HydratedSingleSubdocument<SubdocType>
-                  : BufferToBinary<T[K]>;
-        } : T;
+        : T extends TreatAsPrimitives
+          ? T
+          : T extends Record<string, any> ? {
+            [K in keyof T]: T[K] extends Buffer
+              ? { type: 'buffer', data: number[] }
+              : T[K] extends Types.DocumentArray<infer ItemType>
+                  ? Types.DocumentArray<BufferToBinary<ItemType>>
+                  : T[K] extends Types.Subdocument<unknown, unknown, infer SubdocType>
+                    ? HydratedSingleSubdocument<SubdocType>
+                    : BufferToBinary<T[K]>;
+          } : T;
 
   /**
    * Converts any ObjectId properties into strings for JSON serialization

package/types/inferschematype.d.ts

@@ -235,13 +235,17 @@ type IsSchemaTypeFromBuiltinClass<T> = T extends (typeof String)
                               ? true
                               : T extends Types.Decimal128
                                 ? true
-                                : T extends Buffer
+                                : T extends NativeDate
                                   ? true
-                                  : T extends NativeDate
+                                  : T extends (typeof Schema.Types.Mixed)
                                     ? true
-                                    : T extends (typeof Schema.Types.Mixed)
+                                    : IfEquals<T, Schema.Types.ObjectId, true, false> extends true
                                       ? true
-                                      : IfEquals<T, Schema.Types.ObjectId, true, false>;
+                                      : unknown extends Buffer
+                                        ? false
+                                        : T extends Buffer
+                                          ? true
+                                          : false;
 
 /**
  * @summary Resolve path type by returning the corresponding type.

package/types/models.d.ts

@@ -308,7 +308,7 @@ declare module 'mongoose' {
     bulkWrite<DocContents = TRawDocType>(
       writes: Array<AnyBulkWriteOperation<DocContents extends Document ? any : (DocContents extends {} ? DocContents : any)>>,
       options: MongooseBulkWriteOptions & { ordered: false }
-    ): Promise<mongodb.BulkWriteResult & { mongoose?: { validationErrors: Error[] } }>;
+    ): Promise<mongodb.BulkWriteResult & { mongoose?: { validationErrors: Error[], results: Array<Error | null> } }>;
     bulkWrite<DocContents = TRawDocType>(
       writes: Array<AnyBulkWriteOperation<DocContents extends Document ? any : (DocContents extends {} ? DocContents : any)>>,
       options?: MongooseBulkWriteOptions