feat(shell-api): provide bulk.find().delete() instead of .remove() MONGOSH-752

packages/i18n/src/locales/en_US.ts

@@ -1979,6 +1979,16 @@ const translations: Catalog = {
               description: 'Adds an removeOne to the bulk operation.',
               example: 'bulkOp.find(...).removeOne()',
             },
+            'delete': {
+              link: 'https://docs.mongodb.com/manual/reference/method/Bulk.find.delete/',
+              description: 'Adds an delete to the bulk operation.',
+              example: 'bulkOp.find(...).delete()',
+            },
+            'deleteOne': {
+              link: 'https://docs.mongodb.com/manual/reference/method/Bulk.find.deleteOne/',
+              description: 'Adds an deleteOne to the bulk operation.',
+              example: 'bulkOp.find(...).deleteOne()',
+            },
             'replaceOne': {
               link: 'https://docs.mongodb.com/manual/reference/method/Bulk.find.replaceOne/',
               description: 'Adds an replaceOne to the bulk operation.',

packages/shell-api/src/bulk.spec.ts

@@ -280,39 +280,73 @@ describe('Bulk API', () => {
 
       });
       describe('remove', () => {
-        it('calls serviceProviderBulkOp.remove and returns parent', () => {
+        it('calls serviceProviderBulkOp.delete and returns parent', () => {
           bulkFindOp.remove();
-          expect(innerStub.remove).to.have.been.calledWith();
+          expect(innerStub.delete).to.have.been.calledWith();
           expect(bulk._batchCounts.nRemoveOps).to.equal(1);
         });
 
         it('returns self', () => {
           expect(bulkFindOp.remove()).to.equal(bulk);
         });
 
-        it('throws if serviceProviderBulkOp.remove throws', async() => {
+        it('throws if serviceProviderBulkOp.delete throws', async() => {
           const expectedError = new Error();
-          innerStub.remove.throws(expectedError);
+          innerStub.delete.throws(expectedError);
           expect(() => bulkFindOp.remove()).to.throw(expectedError);
         });
       });
       describe('removeOne', () => {
-        it('calls serviceProviderBulkOp.removeOne and returns parent', () => {
+        it('calls serviceProviderBulkOp.deleteOne and returns parent', () => {
           bulkFindOp.removeOne();
-          expect(innerStub.removeOne).to.have.been.calledWith();
+          expect(innerStub.deleteOne).to.have.been.calledWith();
           expect(bulk._batchCounts.nRemoveOps).to.equal(1);
         });
 
         it('returns self', () => {
-          expect(bulkFindOp.removeOne()).to.equal(bulk);
+          expect(bulkFindOp.deleteOne()).to.equal(bulk);
         });
 
-        it('throws if serviceProviderBulkOp.removeOne throws', async() => {
+        it('throws if serviceProviderBulkOp.deleteOne throws', async() => {
           const expectedError = new Error();
-          innerStub.removeOne.throws(expectedError);
+          innerStub.deleteOne.throws(expectedError);
           expect(() => bulkFindOp.removeOne()).to.throw(expectedError);
         });
       });
+      describe('delete', () => {
+        it('calls serviceProviderBulkOp.delete and returns parent', () => {
+          bulkFindOp.delete();
+          expect(innerStub.delete).to.have.been.calledWith();
+          expect(bulk._batchCounts.nRemoveOps).to.equal(1);
+        });
+
+        it('returns self', () => {
+          expect(bulkFindOp.delete()).to.equal(bulk);
+        });
+
+        it('throws if serviceProviderBulkOp.delete throws', async() => {
+          const expectedError = new Error();
+          innerStub.delete.throws(expectedError);
+          expect(() => bulkFindOp.delete()).to.throw(expectedError);
+        });
+      });
+      describe('deleteOne', () => {
+        it('calls serviceProviderBulkOp.deleteOne and returns parent', () => {
+          bulkFindOp.deleteOne();
+          expect(innerStub.deleteOne).to.have.been.calledWith();
+          expect(bulk._batchCounts.nRemoveOps).to.equal(1);
+        });
+
+        it('returns self', () => {
+          expect(bulkFindOp.deleteOne()).to.equal(bulk);
+        });
+
+        it('throws if serviceProviderBulkOp.deleteOne throws', async() => {
+          const expectedError = new Error();
+          innerStub.deleteOne.throws(expectedError);
+          expect(() => bulkFindOp.deleteOne()).to.throw(expectedError);
+        });
+      });
       describe('upsert', () => {
         it('calls serviceProviderBulkOp.upsert and returns parent', () => {
           bulkFindOp.upsert();

packages/shell-api/src/bulk.ts

@@ -1,4 +1,4 @@
-import { hasAsyncChild, returnsPromise, ShellApiClass, shellApiClassDefault, returnType } from './decorators';
+import { hasAsyncChild, returnsPromise, ShellApiClass, shellApiClassDefault, returnType, deprecated } from './decorators';
 import Mongo from './mongo';
 import { CommonErrors, MongoshInvalidInputError, MongoshUnimplementedError } from '@mongosh/errors';
 import {
@@ -55,19 +55,31 @@ export class BulkFindOp extends ShellApiClass {
   }
 
   @returnType('Bulk')
-  remove(): Bulk {
+  delete(): Bulk {
     this._parentBulk._batchCounts.nRemoveOps++;
-    this._serviceProviderBulkFindOp.remove();
+    this._serviceProviderBulkFindOp.delete();
     return this._parentBulk;
   }
 
   @returnType('Bulk')
-  removeOne(): Bulk {
+  deleteOne(): Bulk {
     this._parentBulk._batchCounts.nRemoveOps++;
-    this._serviceProviderBulkFindOp.removeOne();
+    this._serviceProviderBulkFindOp.deleteOne();
     return this._parentBulk;
   }
 
+  @returnType('Bulk')
+  @deprecated
+  remove(): Bulk {
+    return this.delete();
+  }
+
+  @returnType('Bulk')
+  @deprecated
+  removeOne(): Bulk {
+    return this.deleteOne();
+  }
+
   @returnType('Bulk')
   replaceOne(replacement: Document): Bulk {
     this._parentBulk._batchCounts.nUpdateOps++;