SERVER-54975 Rename IDL parser classes to use CommandRequest and CommandReply suffixes

11 files changed, 140 insertions, 135 deletions

diff --git a/src/mongo/db/ops/parsed_delete.cpp b/src/mongo/db/ops/parsed_delete.cpp
index 0837f51addc..5028ccde159 100644
--- a/src/mongo/db/ops/parsed_delete.cpp
+++ b/src/mongo/db/ops/parsed_delete.cpp
@@ -90,7 +90,7 @@ Status ParsedDelete::parseQueryToCQ() {
 
     // The projection needs to be applied after the delete operation, so we do not specify a
     // projection during canonicalization.
-    auto findCommand = std::make_unique<FindCommand>(_request->getNsString());
+    auto findCommand = std::make_unique<FindCommandRequest>(_request->getNsString());
     findCommand->setFilter(_request->getQuery().getOwned());
     findCommand->setSort(_request->getSort().getOwned());
     findCommand->setCollation(_request->getCollation().getOwned());
@@ -107,7 +107,7 @@ Status ParsedDelete::parseQueryToCQ() {
     }
 
     // If the delete request has runtime constants or let parameters attached to it, pass them to
-    // the FindCommand.
+    // the FindCommandRequest.
     if (auto& runtimeConstants = _request->getLegacyRuntimeConstants())
         findCommand->setLegacyRuntimeConstants(*runtimeConstants);
     if (auto& letParams = _request->getLet())
diff --git a/src/mongo/db/ops/parsed_update.cpp b/src/mongo/db/ops/parsed_update.cpp
index fbdc4e0a43e..f36bee843fb 100644
--- a/src/mongo/db/ops/parsed_update.cpp
+++ b/src/mongo/db/ops/parsed_update.cpp
@@ -122,7 +122,7 @@ Status ParsedUpdate::parseQueryToCQ() {
 
     // The projection needs to be applied after the update operation, so we do not specify a
     // projection during canonicalization.
-    auto findCommand = std::make_unique<FindCommand>(_request->getNamespaceString());
+    auto findCommand = std::make_unique<FindCommandRequest>(_request->getNamespaceString());
     findCommand->setFilter(_request->getQuery());
     findCommand->setSort(_request->getSort());
     findCommand->setHint(_request->getHint());
@@ -150,7 +150,7 @@ Status ParsedUpdate::parseQueryToCQ() {
     }
 
     // If the update request has runtime constants or let parameters attached to it, pass them to
-    // the FindCommand.
+    // the FindCommandRequest.
     if (auto& runtimeConstants = _request->getLegacyRuntimeConstants()) {
         findCommand->setLegacyRuntimeConstants(*runtimeConstants);
     }
diff --git a/src/mongo/db/ops/write_ops.cpp b/src/mongo/db/ops/write_ops.cpp
index ae6ba44727b..8e00f19713a 100644
--- a/src/mongo/db/ops/write_ops.cpp
+++ b/src/mongo/db/ops/write_ops.cpp
@@ -43,10 +43,10 @@
 
 namespace mongo {
 
-using write_ops::Delete;
+using write_ops::DeleteCommandRequest;
 using write_ops::DeleteOpEntry;
-using write_ops::Insert;
-using write_ops::Update;
+using write_ops::InsertCommandRequest;
+using write_ops::UpdateCommandRequest;
 using write_ops::UpdateOpEntry;
 
 namespace {
@@ -58,7 +58,7 @@ void checkOpCountForCommand(const T& op, size_t numOps) {
                           << write_ops::kMaxWriteBatchSize << ". Got " << numOps << " operations.",
             numOps != 0 && numOps <= write_ops::kMaxWriteBatchSize);
 
-    if (const auto& stmtIds = op.getWriteCommandBase().getStmtIds()) {
+    if (const auto& stmtIds = op.getWriteCommandRequestBase().getStmtIds()) {
         uassert(
             ErrorCodes::InvalidLength,
             str::stream() << "Number of statement ids must match the number of batch entries. Got "
@@ -68,10 +68,10 @@ void checkOpCountForCommand(const T& op, size_t numOps) {
             stmtIds->size() == numOps);
         uassert(ErrorCodes::InvalidOptions,
                 str::stream() << "May not specify both stmtId and stmtIds in write command. Got "
-                              << BSON("stmtId" << *op.getWriteCommandBase().getStmtId() << "stmtIds"
-                                               << *stmtIds)
+                              << BSON("stmtId" << *op.getWriteCommandRequestBase().getStmtId()
+                                               << "stmtIds" << *stmtIds)
                               << ". Write command: " << redact(op.toBSON({})),
-                !op.getWriteCommandBase().getStmtId());
+                !op.getWriteCommandRequestBase().getStmtId());
     }
 }
 
@@ -114,7 +114,7 @@ repl::OpTime opTimeParser(BSONElement elem) {
                             << BSONType::bsonTimestamp << ", but found " << elem.type());
 }
 
-int32_t getStmtIdForWriteAt(const WriteCommandBase& writeCommandBase, size_t writePos) {
+int32_t getStmtIdForWriteAt(const WriteCommandRequestBase& writeCommandBase, size_t writePos) {
     const auto& stmtIds = writeCommandBase.getStmtIds();
 
     if (stmtIds) {
@@ -128,23 +128,23 @@ int32_t getStmtIdForWriteAt(const WriteCommandBase& writeCommandBase, size_t wri
 
 }  // namespace write_ops
 
-write_ops::Insert InsertOp::parse(const OpMsgRequest& request) {
-    auto insertOp = Insert::parse(IDLParserErrorContext("insert"), request);
+write_ops::InsertCommandRequest InsertOp::parse(const OpMsgRequest& request) {
+    auto insertOp = InsertCommandRequest::parse(IDLParserErrorContext("insert"), request);
 
     validate(insertOp);
     return insertOp;
 }
 
-write_ops::Insert InsertOp::parseLegacy(const Message& msgRaw) {
+write_ops::InsertCommandRequest InsertOp::parseLegacy(const Message& msgRaw) {
     DbMessage msg(msgRaw);
 
-    Insert op(NamespaceString(msg.getns()));
+    InsertCommandRequest op(NamespaceString(msg.getns()));
 
     {
-        write_ops::WriteCommandBase writeCommandBase;
+        write_ops::WriteCommandRequestBase writeCommandBase;
         writeCommandBase.setBypassDocumentValidation(false);
         writeCommandBase.setOrdered(!(msg.reservedField() & InsertOption_ContinueOnError));
-        op.setWriteCommandBase(std::move(writeCommandBase));
+        op.setWriteCommandRequestBase(std::move(writeCommandBase));
     }
 
     uassert(ErrorCodes::InvalidLength, "Need at least one object to insert", msg.moreJSObjs());
@@ -162,28 +162,28 @@ write_ops::Insert InsertOp::parseLegacy(const Message& msgRaw) {
     return op;
 }
 
-void InsertOp::validate(const write_ops::Insert& insertOp) {
+void InsertOp::validate(const write_ops::InsertCommandRequest& insertOp) {
     const auto& docs = insertOp.getDocuments();
     checkOpCountForCommand(insertOp, docs.size());
 }
 
-write_ops::Update UpdateOp::parse(const OpMsgRequest& request) {
-    auto updateOp = Update::parse(IDLParserErrorContext("update"), request);
+write_ops::UpdateCommandRequest UpdateOp::parse(const OpMsgRequest& request) {
+    auto updateOp = UpdateCommandRequest::parse(IDLParserErrorContext("update"), request);
 
     checkOpCountForCommand(updateOp, updateOp.getUpdates().size());
     return updateOp;
 }
 
-write_ops::Update UpdateOp::parseLegacy(const Message& msgRaw) {
+write_ops::UpdateCommandRequest UpdateOp::parseLegacy(const Message& msgRaw) {
     DbMessage msg(msgRaw);
 
-    Update op(NamespaceString(msg.getns()));
+    UpdateCommandRequest op(NamespaceString(msg.getns()));
 
     {
-        write_ops::WriteCommandBase writeCommandBase;
+        write_ops::WriteCommandRequestBase writeCommandBase;
         writeCommandBase.setBypassDocumentValidation(false);
         writeCommandBase.setOrdered(true);
-        op.setWriteCommandBase(std::move(writeCommandBase));
+        op.setWriteCommandRequestBase(std::move(writeCommandBase));
     }
 
     op.setUpdates([&] {
@@ -205,39 +205,40 @@ write_ops::Update UpdateOp::parseLegacy(const Message& msgRaw) {
     return op;
 }
 
-write_ops::UpdateReply UpdateOp::parseResponse(const BSONObj& obj) {
+write_ops::UpdateCommandReply UpdateOp::parseResponse(const BSONObj& obj) {
     uassertStatusOK(getStatusFromCommandResult(obj));
 
-    return write_ops::UpdateReply::parse(IDLParserErrorContext("updateReply"), obj);
+    return write_ops::UpdateCommandReply::parse(IDLParserErrorContext("updateReply"), obj);
 }
 
-void UpdateOp::validate(const Update& updateOp) {
+void UpdateOp::validate(const UpdateCommandRequest& updateOp) {
     checkOpCountForCommand(updateOp, updateOp.getUpdates().size());
 }
 
-write_ops::FindAndModifyReply FindAndModifyOp::parseResponse(const BSONObj& obj) {
+write_ops::FindAndModifyCommandReply FindAndModifyOp::parseResponse(const BSONObj& obj) {
     uassertStatusOK(getStatusFromCommandResult(obj));
 
-    return write_ops::FindAndModifyReply::parse(IDLParserErrorContext("findAndModifyReply"), obj);
+    return write_ops::FindAndModifyCommandReply::parse(IDLParserErrorContext("findAndModifyReply"),
+                                                       obj);
 }
 
-write_ops::Delete DeleteOp::parse(const OpMsgRequest& request) {
-    auto deleteOp = Delete::parse(IDLParserErrorContext("delete"), request);
+write_ops::DeleteCommandRequest DeleteOp::parse(const OpMsgRequest& request) {
+    auto deleteOp = DeleteCommandRequest::parse(IDLParserErrorContext("delete"), request);
 
     checkOpCountForCommand(deleteOp, deleteOp.getDeletes().size());
     return deleteOp;
 }
 
-write_ops::Delete DeleteOp::parseLegacy(const Message& msgRaw) {
+write_ops::DeleteCommandRequest DeleteOp::parseLegacy(const Message& msgRaw) {
     DbMessage msg(msgRaw);
 
-    Delete op(NamespaceString(msg.getns()));
+    DeleteCommandRequest op(NamespaceString(msg.getns()));
 
     {
-        write_ops::WriteCommandBase writeCommandBase;
+        write_ops::WriteCommandRequestBase writeCommandBase;
         writeCommandBase.setBypassDocumentValidation(false);
         writeCommandBase.setOrdered(true);
-        op.setWriteCommandBase(std::move(writeCommandBase));
+        op.setWriteCommandRequestBase(std::move(writeCommandBase));
     }
 
     op.setDeletes([&] {
@@ -256,7 +257,7 @@ write_ops::Delete DeleteOp::parseLegacy(const Message& msgRaw) {
     return op;
 }
 
-void DeleteOp::validate(const Delete& deleteOp) {
+void DeleteOp::validate(const DeleteCommandRequest& deleteOp) {
     checkOpCountForCommand(deleteOp, deleteOp.getDeletes().size());
 }
 
diff --git a/src/mongo/db/ops/write_ops.h b/src/mongo/db/ops/write_ops.h
index ca1c2e8f429..5fa6651bad5 100644
--- a/src/mongo/db/ops/write_ops.h
+++ b/src/mongo/db/ops/write_ops.h
@@ -37,29 +37,29 @@ namespace mongo {
 
 class InsertOp {
 public:
-    static write_ops::Insert parse(const OpMsgRequest& request);
-    static write_ops::Insert parseLegacy(const Message& msg);
-    static void validate(const write_ops::Insert& insertOp);
+    static write_ops::InsertCommandRequest parse(const OpMsgRequest& request);
+    static write_ops::InsertCommandRequest parseLegacy(const Message& msg);
+    static void validate(const write_ops::InsertCommandRequest& insertOp);
 };
 
 class UpdateOp {
 public:
-    static write_ops::Update parse(const OpMsgRequest& request);
-    static write_ops::Update parseLegacy(const Message& msg);
-    static write_ops::UpdateReply parseResponse(const BSONObj& obj);
-    static void validate(const write_ops::Update& updateOp);
+    static write_ops::UpdateCommandRequest parse(const OpMsgRequest& request);
+    static write_ops::UpdateCommandRequest parseLegacy(const Message& msg);
+    static write_ops::UpdateCommandReply parseResponse(const BSONObj& obj);
+    static void validate(const write_ops::UpdateCommandRequest& updateOp);
 };
 
 class DeleteOp {
 public:
-    static write_ops::Delete parse(const OpMsgRequest& request);
-    static write_ops::Delete parseLegacy(const Message& msg);
-    static void validate(const write_ops::Delete& deleteOp);
+    static write_ops::DeleteCommandRequest parse(const OpMsgRequest& request);
+    static write_ops::DeleteCommandRequest parseLegacy(const Message& msg);
+    static void validate(const write_ops::DeleteCommandRequest& deleteOp);
 };
 
 class FindAndModifyOp {
 public:
-    static write_ops::FindAndModifyReply parseResponse(const BSONObj& obj);
+    static write_ops::FindAndModifyCommandReply parseResponse(const BSONObj& obj);
 };
 
 namespace write_ops {
@@ -77,11 +77,11 @@ constexpr size_t insertVectorMaxBytes = 256 * 1024;
  * Retrieves the statement id for the write at the specified position in the write batch entries
  * array.
  */
-int32_t getStmtIdForWriteAt(const WriteCommandBase& writeCommandBase, size_t writePos);
+int32_t getStmtIdForWriteAt(const WriteCommandRequestBase& writeCommandBase, size_t writePos);
 
 template <class T>
 int32_t getStmtIdForWriteAt(const T& op, size_t writePos) {
-    return getStmtIdForWriteAt(op.getWriteCommandBase(), writePos);
+    return getStmtIdForWriteAt(op.getWriteCommandRequestBase(), writePos);
 }
 
 // TODO: Delete this getter once IDL supports defaults for object and array fields
diff --git a/src/mongo/db/ops/write_ops.idl b/src/mongo/db/ops/write_ops.idl
index 5a61affe924..23f22c361d6 100644
--- a/src/mongo/db/ops/write_ops.idl
+++ b/src/mongo/db/ops/write_ops.idl
@@ -66,7 +66,7 @@ types:
 
 structs:
 
-    WriteReplyBase:
+    WriteCommandReplyBase:
         description: "Contains fields that is common in all the write commands reply."
         fields:
             n:
@@ -88,11 +88,11 @@ structs:
                 type: array<object_owned>
                 optional: true
 
-    InsertReply:
+    InsertCommandReply:
         description: "Contains information related to insert command reply."
 
         chained_structs:
-            WriteReplyBase: writeReplyBase
+            WriteCommandReplyBase: writeCommandReplyBase
 
     Upserted:
         description: "Contains documents that have been upserted."
@@ -104,7 +104,7 @@ structs:
                 description: "ID of the document."
                 type: IDLAnyTypeOwned
 
-    UpdateReply:
+    UpdateCommandReply:
         description: "Contains information related to update command reply."
         strict: false
         fields:
@@ -118,15 +118,15 @@ structs:
                 default: 0
 
         chained_structs:
-            WriteReplyBase: writeReplyBase
+            WriteCommandReplyBase: writeCommandReplyBase
 
-    DeleteReply:
+    DeleteCommandReply:
         description: "Contains information related to delete command reply."
 
         chained_structs:
-            WriteReplyBase: writeReplyBase
+            WriteCommandReplyBase: writeCommandReplyBase
 
-    WriteCommandBase:
+    WriteCommandRequestBase:
         description: "Contains basic information included by all write commands"
         strict: false
         fields:
@@ -245,7 +245,7 @@ structs:
                 description: "The _id of the inserted document."
                 optional: true
 
-    FindAndModifyReply:
+    FindAndModifyCommandReply:
         description: "Parser for the response from a `findAndModify` command"
         strict: false
         fields:
@@ -263,6 +263,7 @@ commands:
     insert:
         description: "Parser for the 'insert' command."
         command_name: insert
+        cpp_name: InsertCommandRequest
         strict: true
         namespace: concatenate_with_db
         api_version: "1"
@@ -271,9 +272,9 @@ commands:
                 privilege:
                     resource_pattern: exact_namespace
                     action_type: [bypassDocumentValidation, insert]
-        reply_type: InsertReply
+        reply_type: InsertCommandReply
         chained_structs:
-            WriteCommandBase: writeCommandBase
+            WriteCommandRequestBase: writeCommandRequestBase
         fields:
             documents:
                 description: "An array of one or more documents to insert."
@@ -283,6 +284,7 @@ commands:
     update:
         description: "Parser for the 'update' command."
         command_name: update
+        cpp_name: UpdateCommandRequest
         strict: true
         namespace: concatenate_with_db
         api_version: "1"
@@ -291,9 +293,9 @@ commands:
                 privilege:
                     resource_pattern: exact_namespace
                     action_type: [bypassDocumentValidation, insert, update]
-        reply_type: UpdateReply
+        reply_type: UpdateCommandReply
         chained_structs:
-            WriteCommandBase: writeCommandBase
+            WriteCommandRequestBase: writeCommandRequestBase
         fields:
             updates:
                 description: "An array of one or more update statements to perform."
@@ -314,6 +316,7 @@ commands:
     delete:
         description: "Parser for the 'delete' command."
         command_name: delete
+        cpp_name: DeleteCommandRequest
         strict: true
         namespace: concatenate_with_db
         api_version: "1"
@@ -322,9 +325,9 @@ commands:
                 privilege:
                     resource_pattern: exact_namespace
                     action_type: [bypassDocumentValidation, remove]
-        reply_type: DeleteReply
+        reply_type: DeleteCommandReply
         chained_structs:
-            WriteCommandBase: writeCommandBase
+            WriteCommandRequestBase: writeCommandRequestBase
         fields:
             deletes:
                 description: "An array of one or more delete statements to perform."
@@ -345,7 +348,7 @@ commands:
         description: "Parser for the 'findAndModify' command."
         command_name: findAndModify
         command_alias: findandmodify
-        cpp_name: FindAndModifyCommand
+        cpp_name: FindAndModifyCommandRequest
         strict: true
         namespace: concatenate_with_db
         api_version: "1"
@@ -354,7 +357,7 @@ commands:
                 privilege:
                     resource_pattern: exact_namespace
                     action_type: [bypassDocumentValidation, find, insert, update, remove]
-        reply_type: FindAndModifyReply
+        reply_type: FindAndModifyCommandReply
         fields:
             query:
                 description: "The query that matches documents to update. Uses the same query
diff --git a/src/mongo/db/ops/write_ops_exec.cpp b/src/mongo/db/ops/write_ops_exec.cpp
index b9e3c1e6883..d36103f03e0 100644
--- a/src/mongo/db/ops/write_ops_exec.cpp
+++ b/src/mongo/db/ops/write_ops_exec.cpp
@@ -243,7 +243,7 @@ void makeCollection(OperationContext* opCtx, const NamespaceString& ns) {
 bool handleError(OperationContext* opCtx,
                  const DBException& ex,
                  const NamespaceString& nss,
-                 const write_ops::WriteCommandBase& wholeOp,
+                 const write_ops::WriteCommandRequestBase& wholeOp,
                  bool isMultiUpdate,
                  WriteResult* out) {
     LastError::get(opCtx->getClient()).setLastError(ex.code(), ex.reason());
@@ -376,7 +376,7 @@ Status checkIfTransactionOnCappedColl(OperationContext* opCtx, const CollectionP
  * Returns true if caller should try to insert more documents. Does nothing else if batch is empty.
  */
 bool insertBatchAndHandleErrors(OperationContext* opCtx,
-                                const write_ops::Insert& wholeOp,
+                                const write_ops::InsertCommandRequest& wholeOp,
                                 std::vector<InsertStatement>& batch,
                                 LastOpFixer* lastOpFixer,
                                 WriteResult* out,
@@ -440,7 +440,7 @@ bool insertBatchAndHandleErrors(OperationContext* opCtx,
             auto canContinue = handleError(opCtx,
                                            ex,
                                            wholeOp.getNamespace(),
-                                           wholeOp.getWriteCommandBase(),
+                                           wholeOp.getWriteCommandRequestBase(),
                                            false /* multiUpdate */,
                                            out);
             invariant(!canContinue);
@@ -512,7 +512,7 @@ bool insertBatchAndHandleErrors(OperationContext* opCtx,
             bool canContinue = handleError(opCtx,
                                            ex,
                                            wholeOp.getNamespace(),
-                                           wholeOp.getWriteCommandBase(),
+                                           wholeOp.getWriteCommandRequestBase(),
                                            false /* multiUpdate */,
                                            out);
 
@@ -542,7 +542,7 @@ SingleWriteResult makeWriteResultForInsertOrDeleteRetry() {
 }  // namespace
 
 WriteResult performInserts(OperationContext* opCtx,
-                           const write_ops::Insert& wholeOp,
+                           const write_ops::InsertCommandRequest& wholeOp,
                            const OperationSource& source) {
     // Insert performs its own retries, so we should only be within a WriteUnitOfWork when run in a
     // transaction.
@@ -579,7 +579,7 @@ WriteResult performInserts(OperationContext* opCtx,
     }
 
     DisableDocumentSchemaValidationIfTrue docSchemaValidationDisabler(
-        opCtx, wholeOp.getWriteCommandBase().getBypassDocumentValidation());
+        opCtx, wholeOp.getWriteCommandRequestBase().getBypassDocumentValidation());
     LastOpFixer lastOpFixer(opCtx, wholeOp.getNamespace());
 
     WriteResult out;
@@ -649,7 +649,7 @@ WriteResult performInserts(OperationContext* opCtx,
                 canContinue = handleError(opCtx,
                                           ex,
                                           wholeOp.getNamespace(),
-                                          wholeOp.getWriteCommandBase(),
+                                          wholeOp.getWriteCommandRequestBase(),
                                           false /* multiUpdate */,
                                           &out);
             }
@@ -835,7 +835,7 @@ static SingleWriteResult performSingleUpdateOpWithDupKeyRetry(
 }
 
 WriteResult performUpdates(OperationContext* opCtx,
-                           const write_ops::Update& wholeOp,
+                           const write_ops::UpdateCommandRequest& wholeOp,
                            const OperationSource& source) {
     // Update performs its own retries, so we should not be in a WriteUnitOfWork unless run in a
     // transaction.
@@ -845,7 +845,7 @@ WriteResult performUpdates(OperationContext* opCtx,
     uassertStatusOK(userAllowedWriteNS(opCtx, wholeOp.getNamespace()));
 
     DisableDocumentSchemaValidationIfTrue docSchemaValidationDisabler(
-        opCtx, wholeOp.getWriteCommandBase().getBypassDocumentValidation());
+        opCtx, wholeOp.getWriteCommandRequestBase().getBypassDocumentValidation());
     LastOpFixer lastOpFixer(opCtx, wholeOp.getNamespace());
 
     bool containsRetry = false;
@@ -904,7 +904,7 @@ WriteResult performUpdates(OperationContext* opCtx,
             const bool canContinue = handleError(opCtx,
                                                  ex,
                                                  wholeOp.getNamespace(),
-                                                 wholeOp.getWriteCommandBase(),
+                                                 wholeOp.getWriteCommandRequestBase(),
                                                  singleOp.getMulti(),
                                                  &out);
             if (!canContinue)
@@ -1006,7 +1006,8 @@ static SingleWriteResult performSingleDeleteOp(OperationContext* opCtx,
     return result;
 }
 
-WriteResult performDeletes(OperationContext* opCtx, const write_ops::Delete& wholeOp) {
+WriteResult performDeletes(OperationContext* opCtx,
+                           const write_ops::DeleteCommandRequest& wholeOp) {
     // Delete performs its own retries, so we should not be in a WriteUnitOfWork unless we are in a
     // transaction.
     auto txnParticipant = TransactionParticipant::get(opCtx);
@@ -1015,7 +1016,7 @@ WriteResult performDeletes(OperationContext* opCtx, const write_ops::Delete& who
     uassertStatusOK(userAllowedWriteNS(opCtx, wholeOp.getNamespace()));
 
     DisableDocumentSchemaValidationIfTrue docSchemaValidationDisabler(
-        opCtx, wholeOp.getWriteCommandBase().getBypassDocumentValidation());
+        opCtx, wholeOp.getWriteCommandRequestBase().getBypassDocumentValidation());
     LastOpFixer lastOpFixer(opCtx, wholeOp.getNamespace());
 
     bool containsRetry = false;
@@ -1075,7 +1076,7 @@ WriteResult performDeletes(OperationContext* opCtx, const write_ops::Delete& who
             const bool canContinue = handleError(opCtx,
                                                  ex,
                                                  wholeOp.getNamespace(),
-                                                 wholeOp.getWriteCommandBase(),
+                                                 wholeOp.getWriteCommandRequestBase(),
                                                  false /* multiUpdate */,
                                                  &out);
             if (!canContinue)
diff --git a/src/mongo/db/ops/write_ops_exec.h b/src/mongo/db/ops/write_ops_exec.h
index 87196b1345e..efe2e6663ac 100644
--- a/src/mongo/db/ops/write_ops_exec.h
+++ b/src/mongo/db/ops/write_ops_exec.h
@@ -75,12 +75,12 @@ struct WriteResult {
  * and initial sync/tenant migration oplog buffer) inserts.
  */
 WriteResult performInserts(OperationContext* opCtx,
-                           const write_ops::Insert& op,
+                           const write_ops::InsertCommandRequest& op,
                            const OperationSource& source = OperationSource::kStandard);
 WriteResult performUpdates(OperationContext* opCtx,
-                           const write_ops::Update& op,
+                           const write_ops::UpdateCommandRequest& op,
                            const OperationSource& source = OperationSource::kStandard);
-WriteResult performDeletes(OperationContext* opCtx, const write_ops::Delete& op);
+WriteResult performDeletes(OperationContext* opCtx, const write_ops::DeleteCommandRequest& op);
 
 /**
  * Populate 'opDebug' with stats describing the execution of an update operation. Illegal to call
diff --git a/src/mongo/db/ops/write_ops_parsers_test.cpp b/src/mongo/db/ops/write_ops_parsers_test.cpp
index f7f8e631f47..5dbba6205d6 100644
--- a/src/mongo/db/ops/write_ops_parsers_test.cpp
+++ b/src/mongo/db/ops/write_ops_parsers_test.cpp
@@ -48,7 +48,7 @@ TEST(CommandWriteOpsParsers, CommonFields_BypassDocumentValidation) {
         for (bool seq : {false, true}) {
             auto request = toOpMsg("foo", cmd, seq);
             auto op = InsertOp::parse(request);
-            ASSERT_EQ(op.getWriteCommandBase().getBypassDocumentValidation(),
+            ASSERT_EQ(op.getWriteCommandRequestBase().getBypassDocumentValidation(),
                       shouldBypassDocumentValidationForCommand(cmd));
         }
     }
@@ -62,7 +62,7 @@ TEST(CommandWriteOpsParsers, CommonFields_Ordered) {
         for (bool seq : {false, true}) {
             auto request = toOpMsg("foo", cmd, seq);
             auto op = InsertOp::parse(request);
-            ASSERT_EQ(op.getWriteCommandBase().getOrdered(), ordered);
+            ASSERT_EQ(op.getWriteCommandRequestBase().getOrdered(), ordered);
         }
     }
 }
@@ -213,8 +213,8 @@ TEST(CommandWriteOpsParsers, SingleInsert) {
         auto request = toOpMsg(ns.db(), cmd, seq);
         const auto op = InsertOp::parse(request);
         ASSERT_EQ(op.getNamespace().ns(), ns.ns());
-        ASSERT(!op.getWriteCommandBase().getBypassDocumentValidation());
-        ASSERT(op.getWriteCommandBase().getOrdered());
+        ASSERT(!op.getWriteCommandRequestBase().getBypassDocumentValidation());
+        ASSERT(op.getWriteCommandRequestBase().getOrdered());
         ASSERT_EQ(op.getDocuments().size(), 1u);
         ASSERT_BSONOBJ_EQ(op.getDocuments()[0], obj);
     }
@@ -238,8 +238,8 @@ TEST(CommandWriteOpsParsers, RealMultiInsert) {
         auto request = toOpMsg(ns.db(), cmd, seq);
         const auto op = InsertOp::parse(request);
         ASSERT_EQ(op.getNamespace().ns(), ns.ns());
-        ASSERT(!op.getWriteCommandBase().getBypassDocumentValidation());
-        ASSERT(op.getWriteCommandBase().getOrdered());
+        ASSERT(!op.getWriteCommandRequestBase().getBypassDocumentValidation());
+        ASSERT(op.getWriteCommandRequestBase().getOrdered());
         ASSERT_EQ(op.getDocuments().size(), 2u);
         ASSERT_BSONOBJ_EQ(op.getDocuments()[0], obj0);
         ASSERT_BSONOBJ_EQ(op.getDocuments()[1], obj1);
@@ -258,8 +258,8 @@ TEST(CommandWriteOpsParsers, MultiInsertWithStmtId) {
         auto request = toOpMsg(ns.db(), cmd, seq);
         const auto op = InsertOp::parse(request);
         ASSERT_EQ(op.getNamespace().ns(), ns.ns());
-        ASSERT(!op.getWriteCommandBase().getBypassDocumentValidation());
-        ASSERT(op.getWriteCommandBase().getOrdered());
+        ASSERT(!op.getWriteCommandRequestBase().getBypassDocumentValidation());
+        ASSERT(op.getWriteCommandRequestBase().getOrdered());
         ASSERT_EQ(op.getDocuments().size(), 2u);
         ASSERT_BSONOBJ_EQ(op.getDocuments()[0], obj0);
         ASSERT_BSONOBJ_EQ(op.getDocuments()[1], obj1);
@@ -278,8 +278,8 @@ TEST(CommandWriteOpsParsers, MultiInsertWithStmtIdsArray) {
         auto request = toOpMsg(ns.db(), cmd, seq);
         const auto op = InsertOp::parse(request);
         ASSERT_EQ(op.getNamespace().ns(), ns.ns());
-        ASSERT(!op.getWriteCommandBase().getBypassDocumentValidation());
-        ASSERT(op.getWriteCommandBase().getOrdered());
+        ASSERT(!op.getWriteCommandRequestBase().getBypassDocumentValidation());
+        ASSERT(op.getWriteCommandRequestBase().getOrdered());
         ASSERT_EQ(op.getDocuments().size(), 2u);
         ASSERT_BSONOBJ_EQ(op.getDocuments()[0], obj0);
         ASSERT_BSONOBJ_EQ(op.getDocuments()[1], obj1);
@@ -288,7 +288,7 @@ TEST(CommandWriteOpsParsers, MultiInsertWithStmtIdsArray) {
     }
 }
 
-TEST(CommandWriteOpsParsers, Update) {
+TEST(CommandWriteOpsParsers, UpdateCommandRequest) {
     const auto ns = NamespaceString("test", "foo");
     const BSONObj query = BSON("x" << 1);
     const BSONObj update = BSON("$inc" << BSON("x" << 1));
@@ -305,8 +305,8 @@ TEST(CommandWriteOpsParsers, Update) {
                 auto request = toOpMsg(ns.db(), cmd, seq);
                 auto op = UpdateOp::parse(request);
                 ASSERT_EQ(op.getNamespace().ns(), ns.ns());
-                ASSERT(!op.getWriteCommandBase().getBypassDocumentValidation());
-                ASSERT_EQ(op.getWriteCommandBase().getOrdered(), true);
+                ASSERT(!op.getWriteCommandRequestBase().getBypassDocumentValidation());
+                ASSERT_EQ(op.getWriteCommandRequestBase().getOrdered(), true);
                 ASSERT_EQ(op.getUpdates().size(), 1u);
                 ASSERT_BSONOBJ_EQ(op.getUpdates()[0].getQ(), query);
 
@@ -342,8 +342,8 @@ TEST(CommandWriteOpsParsers, UpdateWithPipeline) {
                 auto request = toOpMsg(ns.db(), cmd, seq);
                 auto op = UpdateOp::parse(request);
                 ASSERT_EQ(op.getNamespace().ns(), ns.ns());
-                ASSERT(!op.getWriteCommandBase().getBypassDocumentValidation());
-                ASSERT_EQ(op.getWriteCommandBase().getOrdered(), true);
+                ASSERT(!op.getWriteCommandRequestBase().getBypassDocumentValidation());
+                ASSERT_EQ(op.getWriteCommandRequestBase().getOrdered(), true);
                 ASSERT_EQ(op.getUpdates().size(), 1u);
                 ASSERT_BSONOBJ_EQ(op.getUpdates()[0].getQ(), query["q"].Obj());
 
@@ -375,8 +375,8 @@ TEST(CommandWriteOpsParsers, Remove) {
             auto request = toOpMsg(ns.db(), cmd, seq);
             auto op = DeleteOp::parse(request);
             ASSERT_EQ(op.getNamespace().ns(), ns.ns());
-            ASSERT(!op.getWriteCommandBase().getBypassDocumentValidation());
-            ASSERT_EQ(op.getWriteCommandBase().getOrdered(), true);
+            ASSERT(!op.getWriteCommandRequestBase().getBypassDocumentValidation());
+            ASSERT_EQ(op.getWriteCommandRequestBase().getOrdered(), true);
             ASSERT_EQ(op.getDeletes().size(), 1u);
             ASSERT_BSONOBJ_EQ(op.getDeletes()[0].getQ(), query);
             ASSERT_BSONOBJ_EQ(write_ops::collationOf(op.getDeletes()[0]), collation);
@@ -408,8 +408,8 @@ TEST(LegacyWriteOpsParsers, SingleInsert) {
             makeInsertMessage(ns, obj, continueOnError ? InsertOption_ContinueOnError : 0);
         const auto op = InsertOp::parseLegacy(message);
         ASSERT_EQ(op.getNamespace().ns(), ns);
-        ASSERT(!op.getWriteCommandBase().getBypassDocumentValidation());
-        ASSERT_EQ(!op.getWriteCommandBase().getOrdered(), continueOnError);
+        ASSERT(!op.getWriteCommandRequestBase().getBypassDocumentValidation());
+        ASSERT_EQ(!op.getWriteCommandRequestBase().getOrdered(), continueOnError);
         ASSERT_EQ(op.getDocuments().size(), 1u);
         ASSERT_BSONOBJ_EQ(op.getDocuments()[0], obj);
     }
@@ -436,15 +436,15 @@ TEST(LegacyWriteOpsParsers, RealMultiInsert) {
             ns, objs.data(), objs.size(), continueOnError ? InsertOption_ContinueOnError : 0);
         const auto op = InsertOp::parseLegacy(message);
         ASSERT_EQ(op.getNamespace().ns(), ns);
-        ASSERT(!op.getWriteCommandBase().getBypassDocumentValidation());
-        ASSERT_EQ(!op.getWriteCommandBase().getOrdered(), continueOnError);
+        ASSERT(!op.getWriteCommandRequestBase().getBypassDocumentValidation());
+        ASSERT_EQ(!op.getWriteCommandRequestBase().getOrdered(), continueOnError);
         ASSERT_EQ(op.getDocuments().size(), 2u);
         ASSERT_BSONOBJ_EQ(op.getDocuments()[0], obj0);
         ASSERT_BSONOBJ_EQ(op.getDocuments()[1], obj1);
     }
 }
 
-TEST(LegacyWriteOpsParsers, Update) {
+TEST(LegacyWriteOpsParsers, UpdateCommandRequest) {
     const std::string ns = "test.foo";
     const BSONObj query = BSON("x" << 1);
     const BSONObj update = BSON("$inc" << BSON("x" << 1));
@@ -457,8 +457,8 @@ TEST(LegacyWriteOpsParsers, Update) {
                                                  (multi ? UpdateOption_Multi : 0));
             const auto op = UpdateOp::parseLegacy(message);
             ASSERT_EQ(op.getNamespace().ns(), ns);
-            ASSERT(!op.getWriteCommandBase().getBypassDocumentValidation());
-            ASSERT_EQ(op.getWriteCommandBase().getOrdered(), true);
+            ASSERT(!op.getWriteCommandRequestBase().getBypassDocumentValidation());
+            ASSERT_EQ(op.getWriteCommandRequestBase().getOrdered(), true);
             ASSERT_EQ(op.getUpdates().size(), 1u);
             ASSERT_BSONOBJ_EQ(op.getUpdates()[0].getQ(), query);
             ASSERT_BSONOBJ_EQ(op.getUpdates()[0].getU().getUpdateClassic(), update);
@@ -485,8 +485,8 @@ TEST(LegacyWriteOpsParsers, UpdateWithArrayUpdateFieldIsParsedAsReplacementStyle
                                                  (multi ? UpdateOption_Multi : 0));
             const auto op = UpdateOp::parseLegacy(message);
             ASSERT_EQ(op.getNamespace().ns(), ns);
-            ASSERT(!op.getWriteCommandBase().getBypassDocumentValidation());
-            ASSERT_EQ(op.getWriteCommandBase().getOrdered(), true);
+            ASSERT(!op.getWriteCommandRequestBase().getBypassDocumentValidation());
+            ASSERT_EQ(op.getWriteCommandRequestBase().getOrdered(), true);
             ASSERT_EQ(op.getUpdates().size(), 1u);
             ASSERT_BSONOBJ_EQ(op.getUpdates()[0].getQ(), query);
             ASSERT(op.getUpdates()[0].getU().type() ==
@@ -505,8 +505,8 @@ TEST(LegacyWriteOpsParsers, Remove) {
         auto message = makeRemoveMessage(ns, query, (multi ? 0 : RemoveOption_JustOne));
         const auto op = DeleteOp::parseLegacy(message);
         ASSERT_EQ(op.getNamespace().ns(), ns);
-        ASSERT(!op.getWriteCommandBase().getBypassDocumentValidation());
-        ASSERT_EQ(op.getWriteCommandBase().getOrdered(), true);
+        ASSERT(!op.getWriteCommandRequestBase().getBypassDocumentValidation());
+        ASSERT_EQ(op.getWriteCommandRequestBase().getOrdered(), true);
         ASSERT_EQ(op.getDeletes().size(), 1u);
         ASSERT_BSONOBJ_EQ(op.getDeletes()[0].getQ(), query);
         ASSERT_EQ(op.getDeletes()[0].getMulti(), multi);
diff --git a/src/mongo/db/ops/write_ops_retryability.cpp b/src/mongo/db/ops/write_ops_retryability.cpp
index bf52941e959..1237cf41596 100644
--- a/src/mongo/db/ops/write_ops_retryability.cpp
+++ b/src/mongo/db/ops/write_ops_retryability.cpp
@@ -45,7 +45,7 @@ namespace {
  * In the case of nested oplog entry where the correct links are in the top level
  * oplog, oplogWithCorrectLinks can be used to specify the outer oplog.
  */
-void validateFindAndModifyRetryability(const write_ops::FindAndModifyCommand& request,
+void validateFindAndModifyRetryability(const write_ops::FindAndModifyCommandRequest& request,
                                        const repl::OplogEntry& oplogEntry,
                                        const repl::OplogEntry& oplogWithCorrectLinks) {
     auto opType = oplogEntry.getOpType();
@@ -128,14 +128,14 @@ BSONObj extractPreOrPostImage(OperationContext* opCtx, const repl::OplogEntry& o
  * previous execution of the command. In the case of nested oplog entry where the correct links
  * are in the top level oplog, oplogWithCorrectLinks can be used to specify the outer oplog.
  */
-write_ops::FindAndModifyReply parseOplogEntryForFindAndModify(
+write_ops::FindAndModifyCommandReply parseOplogEntryForFindAndModify(
     OperationContext* opCtx,
-    const write_ops::FindAndModifyCommand& request,
+    const write_ops::FindAndModifyCommandRequest& request,
     const repl::OplogEntry& oplogEntry,
     const repl::OplogEntry& oplogWithCorrectLinks) {
     validateFindAndModifyRetryability(request, oplogEntry, oplogWithCorrectLinks);
 
-    write_ops::FindAndModifyReply result;
+    write_ops::FindAndModifyCommandReply result;
     write_ops::FindAndModifyLastError lastError;
     lastError.setNumDocs(1);
 
@@ -206,9 +206,9 @@ SingleWriteResult parseOplogEntryForUpdate(const repl::OplogEntry& entry) {
     return res;
 }
 
-write_ops::FindAndModifyReply parseOplogEntryForFindAndModify(
+write_ops::FindAndModifyCommandReply parseOplogEntryForFindAndModify(
     OperationContext* opCtx,
-    const write_ops::FindAndModifyCommand& request,
+    const write_ops::FindAndModifyCommandRequest& request,
     const repl::OplogEntry& oplogEntry) {
     // Migrated op case.
     if (oplogEntry.getOpType() == repl::OpTypeEnum::kNoop) {
diff --git a/src/mongo/db/ops/write_ops_retryability.h b/src/mongo/db/ops/write_ops_retryability.h
index 5726864ddcb..dd59b412475 100644
--- a/src/mongo/db/ops/write_ops_retryability.h
+++ b/src/mongo/db/ops/write_ops_retryability.h
@@ -50,9 +50,9 @@ SingleWriteResult parseOplogEntryForUpdate(const repl::OplogEntry& entry);
  * Populates the passed-in builder with the result of a findAndModify based on the oplog entries
  * generated by the operation.
  */
-write_ops::FindAndModifyReply parseOplogEntryForFindAndModify(
+write_ops::FindAndModifyCommandReply parseOplogEntryForFindAndModify(
     OperationContext* opCtx,
-    const write_ops::FindAndModifyCommand& request,
+    const write_ops::FindAndModifyCommandRequest& request,
     const repl::OplogEntry& oplogEntry);
 
 }  // namespace mongo
diff --git a/src/mongo/db/ops/write_ops_retryability_test.cpp b/src/mongo/db/ops/write_ops_retryability_test.cpp
index 4aa7f3a4748..2d209dbfebb 100644
--- a/src/mongo/db/ops/write_ops_retryability_test.cpp
+++ b/src/mongo/db/ops/write_ops_retryability_test.cpp
@@ -99,9 +99,9 @@ void setUpTxnParticipant(OperationContext* opCtx, std::vector<int> executedStmtI
     txnPart.setCommittedStmtIdsForTest(std::move(executedStmtIds));
 }
 
-write_ops::FindAndModifyCommand makeFindAndModifyRequest(
+write_ops::FindAndModifyCommandRequest makeFindAndModifyRequest(
     NamespaceString fullNs, BSONObj query, boost::optional<write_ops::UpdateModification> update) {
-    auto request = write_ops::FindAndModifyCommand(fullNs);
+    auto request = write_ops::FindAndModifyCommandRequest(fullNs);
     request.setQuery(query);
     if (update) {
         request.setUpdate(std::move(update));
@@ -192,8 +192,8 @@ TEST_F(WriteOpsRetryability, PerformInsertsSuccess) {
     repl::UnreplicatedWritesBlock unreplicated(opCtxRaii.get());
     setUpReplication(getServiceContext());
 
-    write_ops::Insert insertOp(NamespaceString("foo.bar"));
-    insertOp.getWriteCommandBase().setOrdered(true);
+    write_ops::InsertCommandRequest insertOp(NamespaceString("foo.bar"));
+    insertOp.getWriteCommandRequestBase().setOrdered(true);
     insertOp.setDocuments({BSON("_id" << 0), BSON("_id" << 1)});
     write_ops_exec::WriteResult result = write_ops_exec::performInserts(opCtxRaii.get(), insertOp);
 
@@ -213,12 +213,12 @@ TEST_F(WriteOpsRetryability, PerformRetryableInsertsSuccess) {
     // Set up a retryable write where statements 1 and 2 have already executed.
     setUpTxnParticipant(opCtxRaii.get(), {1, 2});
 
-    write_ops::Insert insertOp(NamespaceString("foo.bar"));
-    insertOp.getWriteCommandBase().setOrdered(true);
+    write_ops::InsertCommandRequest insertOp(NamespaceString("foo.bar"));
+    insertOp.getWriteCommandRequestBase().setOrdered(true);
     // Setup documents that cannot be successfully inserted to show that the retryable logic was
     // exercised.
     insertOp.setDocuments({BSON("_id" << 0), BSON("_id" << 0)});
-    insertOp.getWriteCommandBase().setStmtIds({{1, 2}});
+    insertOp.getWriteCommandRequestBase().setStmtIds({{1, 2}});
     write_ops_exec::WriteResult result = write_ops_exec::performInserts(opCtxRaii.get(), insertOp);
 
     // Assert that both writes "succeeded". While there should have been a duplicate key error, the
@@ -240,11 +240,11 @@ TEST_F(WriteOpsRetryability, PerformRetryableInsertsWithBatchedFailure) {
     // Set up a retryable write where statement 3 has already executed.
     setUpTxnParticipant(opCtxRaii.get(), {3});
 
-    write_ops::Insert insertOp(NamespaceString("foo.bar"));
-    insertOp.getWriteCommandBase().setOrdered(false);
+    write_ops::InsertCommandRequest insertOp(NamespaceString("foo.bar"));
+    insertOp.getWriteCommandRequestBase().setOrdered(false);
     // Setup documents such that the second will fail insertion.
     insertOp.setDocuments({BSON("_id" << 0), BSON("_id" << 0), BSON("_id" << 1)});
-    insertOp.getWriteCommandBase().setStmtIds({{1, 2, 3}});
+    insertOp.getWriteCommandRequestBase().setStmtIds({{1, 2, 3}});
     write_ops_exec::WriteResult result = write_ops_exec::performInserts(opCtxRaii.get(), insertOp);
 
     // Assert that the third (already executed) write succeeds, despite the second write failing
@@ -264,8 +264,8 @@ TEST_F(WriteOpsRetryability, PerformOrderedInsertsStopsAtError) {
     repl::UnreplicatedWritesBlock unreplicated(opCtxRaii.get());
     setUpReplication(getServiceContext());
 
-    write_ops::Insert insertOp(NamespaceString("foo.bar"));
-    insertOp.getWriteCommandBase().setOrdered(true);
+    write_ops::InsertCommandRequest insertOp(NamespaceString("foo.bar"));
+    insertOp.getWriteCommandRequestBase().setOrdered(true);
     // Setup documents such that the second cannot be successfully inserted.
     insertOp.setDocuments({BSON("_id" << 0), BSON("_id" << 0), BSON("_id" << 1)});
     write_ops_exec::WriteResult result = write_ops_exec::performInserts(opCtxRaii.get(), insertOp);
@@ -285,8 +285,8 @@ TEST_F(WriteOpsRetryability, PerformOrderedInsertsStopsAtBadDoc) {
     repl::UnreplicatedWritesBlock unreplicated(opCtxRaii.get());
     setUpReplication(getServiceContext());
 
-    write_ops::Insert insertOp(NamespaceString("foo.bar"));
-    insertOp.getWriteCommandBase().setOrdered(true);
+    write_ops::InsertCommandRequest insertOp(NamespaceString("foo.bar"));
+    insertOp.getWriteCommandRequestBase().setOrdered(true);
 
     // Setup documents such that the second cannot be successfully inserted.
     auto largeBuffer = [](std::int32_t size) {
@@ -317,8 +317,8 @@ TEST_F(WriteOpsRetryability, PerformUnorderedInsertsContinuesAtBadDoc) {
     repl::UnreplicatedWritesBlock unreplicated(opCtxRaii.get());
     setUpReplication(getServiceContext());
 
-    write_ops::Insert insertOp(NamespaceString("foo.bar"));
-    insertOp.getWriteCommandBase().setOrdered(false);
+    write_ops::InsertCommandRequest insertOp(NamespaceString("foo.bar"));
+    insertOp.getWriteCommandRequestBase().setOrdered(false);
 
     // Setup documents such that the second cannot be successfully inserted.
     auto largeBuffer = [](std::int32_t size) {