refactor(collection): do not use resultMutator for insertMany

Fixes NODE-1895

Author: kvwalker

lib/collection.js

@@ -45,12 +45,12 @@ const group = require('./operations/collection_ops').group;
 const indexes = require('./operations/collection_ops').indexes;
 const indexExists = require('./operations/collection_ops').indexExists;
 const indexInformation = require('./operations/collection_ops').indexInformation;
+const insertMany = require('./operations/collection_ops').insertMany;
 const insertOne = require('./operations/collection_ops').insertOne;
 const isCapped = require('./operations/collection_ops').isCapped;
 const mapReduce = require('./operations/collection_ops').mapReduce;
 const optionsOp = require('./operations/collection_ops').optionsOp;
 const parallelCollectionScan = require('./operations/collection_ops').parallelCollectionScan;
-const prepareDocs = require('./operations/collection_ops').prepareDocs;
 const reIndex = require('./operations/collection_ops').reIndex;
 const removeDocuments = require('./operations/collection_ops').removeDocuments;
 const rename = require('./operations/collection_ops').rename;
@@ -463,21 +463,6 @@ Collection.prototype.insertOne = function(doc, options, callback) {
   return executeOperation(this.s.topology, insertOne, [this, doc, options, callback]);
 };
 
-function mapInsertManyResults(docs, r) {
-  const finalResult = {
-    result: { ok: 1, n: r.insertedCount },
-    ops: docs,
-    insertedCount: r.insertedCount,
-    insertedIds: r.insertedIds
-  };
-
-  if (r.getLastOp()) {
-    finalResult.result.opTime = r.getLastOp();
-  }
-
-  return finalResult;
-}
-
 /**
  * Inserts an array of documents into MongoDB. If documents passed in do not contain the **_id** field,
  * one will be added to each of the documents missing it by the driver, mutating the document. This behavior
@@ -501,33 +486,7 @@ Collection.prototype.insertMany = function(docs, options, callback) {
   if (typeof options === 'function') (callback = options), (options = {});
   options = options ? Object.assign({}, options) : { ordered: true };
 
-  if (!Array.isArray(docs) && typeof callback === 'function') {
-    return callback(
-      MongoError.create({ message: 'docs parameter must be an array of documents', driver: true })
-    );
-  } else if (!Array.isArray(docs)) {
-    return new this.s.promiseLibrary((resolve, reject) => {
-      reject(
-        MongoError.create({ message: 'docs parameter must be an array of documents', driver: true })
-      );
-    });
-  }
-
-  // If keep going set unordered
-  options['serializeFunctions'] = options['serializeFunctions'] || this.s.serializeFunctions;
-
-  docs = prepareDocs(this, docs, options);
-
-  // Generate the bulk write operations
-  const operations = [
-    {
-      insertMany: docs
-    }
-  ];
-
-  return executeOperation(this.s.topology, bulkWrite, [this, operations, options, callback], {
-    resultMutator: result => mapInsertManyResults(docs, result)
-  });
+  return executeOperation(this.s.topology, insertMany, [this, docs, options, callback]);
 };
 
 /**

lib/operations/collection_ops.js

@@ -892,6 +892,57 @@ function insertOne(coll, doc, options, callback) {
   });
 }
 
+/**
+ * Inserts an array of documents into MongoDB. If documents passed in do not contain the **_id** field,
+ * one will be added to each of the documents missing it by the driver, mutating the document. This behavior
+ * can be overridden by setting the **forceServerObjectId** flag.
+ *
+ * @method
+ * @param {Collection} a Collection instance.
+ * @param {object[]} docs Documents to insert.
+ * @param {number} [options] Optional settings. See Collection.prototype.insertMany for a list of options.
+ * @param {Collection~insertWriteOpCallback} [callback] The command result callback
+ */
+function insertMany(coll, docs, options, callback) {
+  if (!Array.isArray(docs)) {
+    return callback(
+      MongoError.create({ message: 'docs parameter must be an array of documents', driver: true })
+    );
+  }
+
+  // If keep going set unordered
+  options['serializeFunctions'] = options['serializeFunctions'] || coll.s.serializeFunctions;
+
+  docs = prepareDocs(coll, docs, options);
+
+  // Generate the bulk write operations
+  const operations = [
+    {
+      insertMany: docs
+    }
+  ];
+
+  bulkWrite(coll, operations, options, (err, result) => {
+    if (err) return callback(err, null);
+    callback(null, mapInsertManyResults(docs, result));
+  });
+}
+
+function mapInsertManyResults(docs, r) {
+  const finalResult = {
+    result: { ok: 1, n: r.insertedCount },
+    ops: docs,
+    insertedCount: r.insertedCount,
+    insertedIds: r.insertedIds
+  };
+
+  if (r.getLastOp()) {
+    finalResult.result.opTime = r.getLastOp();
+  }
+
+  return finalResult;
+}
+
 /**
  * Determine whether the collection is a capped collection.
  *
@@ -1476,6 +1527,7 @@ module.exports = {
   indexes,
   indexExists,
   indexInformation,
+  insertMany,
   insertOne,
   isCapped,
   mapReduce,

lib/utils.js

@@ -360,7 +360,6 @@ var mergeOptionsAndWriteConcern = function(targetOptions, sourceOptions, keys, m
  * @param {function} operation The operation to execute
  * @param {array} args Arguments to apply the provided operation
  * @param {object} [options] Options that modify the behavior of the method
- * @param {function]} [options.resultMutator] Allows for the result of the operation to be changed for custom return types
  */
 const executeOperation = (topology, operation, args, options) => {
   if (topology == null) {
@@ -373,7 +372,6 @@ const executeOperation = (topology, operation, args, options) => {
 
   options = options || {};
   const Promise = topology.s.promiseLibrary;
-  let resultMutator = options.resultMutator;
   let callback = args[args.length - 1];
 
   // The driver sessions spec mandates that we implicitly create sessions for operations
@@ -397,12 +395,10 @@ const executeOperation = (topology, operation, args, options) => {
         session.endSession(() => {
           delete opOptions.session;
           if (err) return reject(err);
-          if (resultMutator) return resolve(resultMutator(result));
           resolve(result);
         });
       } else {
         if (err) return reject(err);
-        if (resultMutator) return resolve(resultMutator(result));
         resolve(result);
       }
     };