fix(NODE-3565): Error for insertMany with partially empty array is unhelpful

src/bulk/common.ts

@@ -1133,6 +1133,9 @@ export abstract class BulkOperationBase {
 
   /** Specifies a raw operation to perform in the bulk write. */
   raw(op: AnyBulkWriteOperation): this {
+    if (op == null || typeof op !== 'object') {
+      throw new MongoInvalidArgumentError('Operation must be an object with an operation key');
+    }
     if ('insertOne' in op) {
       const forceServerObjectId = shouldForceServerObjectId(this);
       if (op.insertOne && op.insertOne.document == null) {

src/operations/insert.ts

@@ -136,7 +136,14 @@ export class InsertManyOperation extends AbstractOperation<InsertManyResult> {
     );
 
     bulkWriteOperation.execute(server, session, (err, res) => {
-      if (err || res == null) return callback(err);
+      if (err || res == null) {
+        if (err && err.message === 'Operation must be an object with an operation key') {
+          err = new MongoInvalidArgumentError(
+            'Argument "docs" is a sparse array containing element(s) that are null or undefined'
+          );
+        }
+        return callback(err);
+      }
       callback(undefined, {
         acknowledged: writeConcern?.w !== 0 ?? true,
         insertedCount: res.insertedCount,

test/integration/crud/bulk.test.js

@@ -7,7 +7,12 @@ const {
   ignoreNsNotFound,
   assert: test
 } = require('../shared');
-const { Long, MongoBatchReExecutionError, MongoDriverError } = require('../../../src');
+const {
+  Long,
+  MongoBatchReExecutionError,
+  MongoDriverError,
+  MongoInvalidArgumentError
+} = require('../../../src');
 const crypto = require('crypto');
 const chai = require('chai');
 
@@ -22,6 +27,86 @@ describe('Bulk', function () {
   before(function () {
     return setupDatabase(this.configuration);
   });
+  describe('BulkOperationBase', () => {
+    describe('#raw', function () {
+      let client;
+      beforeEach(async function () {
+        client = this.configuration.newClient();
+        await client.connect();
+      });
+      afterEach(async function () {
+        await client.close();
+      });
+      context('when called with an undefined operation', function () {
+        it('should throw a MongoInvalidArgument error ', async function () {
+          const bulkOp = client.db('test').collection('test').initializeUnorderedBulkOp();
+          expect(() => bulkOp.raw(undefined)).to.throw(MongoInvalidArgumentError);
+          expect(() => bulkOp.raw(true)).to.throw(MongoInvalidArgumentError);
+          expect(() => bulkOp.raw(3)).to.throw(MongoInvalidArgumentError);
+        });
+
+        it('should throw an error with the specifc message: "Operation must be an object with an operation key"', async function () {
+          const bulkOp = client.db('test').collection('test').initializeUnorderedBulkOp();
+          try {
+            bulkOp.raw(undefined);
+            expect.fail(
+              'Expected passing argument of "undefined" to .raw to throw error, failed to throw error'
+            );
+          } catch (error) {
+            expect(error.message).to.equal('Operation must be an object with an operation key');
+          }
+        });
+      });
+
+      context('when called with a valid operation', function () {
+        it('should not throw a MongoInvalidArgument error', async function () {
+          try {
+            client.db('test').collection('test').initializeUnorderedBulkOp().raw({ insertOne: {} });
+          } catch (error) {
+            expect(error).not.to.exist;
+          }
+        });
+      });
+    });
+  });
+
+  describe('Db.collection', function () {
+    describe('#insertMany', function () {
+      let client;
+      beforeEach(async function () {
+        client = this.configuration.newClient();
+        await client.connect();
+      });
+      afterEach(async function () {
+        await client.close();
+      });
+      context('when passed an invalid docs argument', function () {
+        it('insertMany should throw a MongoInvalidArgument error when called with a invalid operation', async function () {
+          try {
+            const docs = [];
+            docs[1] = { color: 'red' };
+            await client.db('test').collection('test').insertMany(docs);
+            expect.fail('Expected insertMany to throw error, failed to throw error');
+          } catch (error) {
+            expect(error).to.be.instanceOf(MongoInvalidArgumentError);
+          }
+        });
+      });
+      context('when passed a valid document list', function () {
+        it('insertMany should not throw a MongoInvalidArgument error when called with a valid operation', async function () {
+          try {
+            let result = await client
+              .db('test')
+              .collection('test')
+              .insertMany([{ color: 'blue' }]);
+            expect(result).to.exist;
+          } catch (error) {
+            expect(error).not.to.exist;
+          }
+        });
+      });
+    });
+  });
 
   context('promise tests', () => {
     it('Should correctly execute unordered bulk operation in promise form', function (done) {