findAndModify

Author: baileympearson

src/operations/find_and_modify.ts

@@ -1,14 +1,14 @@
+import { type Connection } from '..';
 import type { Document } from '../bson';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import type { Collection } from '../collection';
 import { MongoCompatibilityError, MongoInvalidArgumentError } from '../error';
 import { ReadPreference } from '../read_preference';
-import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
 import { formatSort, type Sort, type SortForCmd } from '../sort';
-import { type TimeoutContext } from '../timeout';
-import { decorateWithCollation, hasAtomicOperators, maxWireVersion } from '../utils';
+import { hasAtomicOperators, maxWireVersion } from '../utils';
 import { type WriteConcern, type WriteConcernSettings } from '../write_concern';
-import { CommandOperation, type CommandOperationOptions } from './command';
+import { type CommandOperationOptions, ModernizedCommandOperation } from './command';
 import { Aspect, defineAspects } from './operation';
 
 /** @public */
@@ -120,12 +120,12 @@ function configureFindAndModifyCmdBaseUpdateOpts(
 }
 
 /** @internal */
-export class FindAndModifyOperation extends CommandOperation<Document> {
+export class FindAndModifyOperation extends ModernizedCommandOperation<Document> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
+
   override options: FindOneAndReplaceOptions | FindOneAndUpdateOptions | FindOneAndDeleteOptions;
-  cmdBase: FindAndModifyCmdBase;
   collection: Collection;
   query: Document;
-  doc?: Document;
 
   constructor(
     collection: Collection,
@@ -134,87 +134,84 @@ export class FindAndModifyOperation extends CommandOperation<Document> {
   ) {
     super(collection, options);
     this.options = options ?? {};
-    this.cmdBase = {
+
+    options.includeResultMetadata ??= false;
+
+    // force primary read preference
+    this.readPreference = ReadPreference.primary;
+
+    this.collection = collection;
+    this.query = query;
+  }
+
+  override get commandName() {
+    return 'findAndModify' as const;
+  }
+
+  override buildCommandDocument(
+    connection: Connection,
+    _session?: ClientSession
+  ): FindAndModifyCmdBase {
+    const coll = this.collection;
+    const query = this.query;
+    const options = this.options;
+
+    // Create findAndModify command object
+    const command: FindAndModifyCmdBase & Document = {
+      findAndModify: coll.collectionName,
+      query: query,
       remove: false,
       new: false,
       upsert: false
     };
 
-    options.includeResultMetadata ??= false;
-
     const sort = formatSort(options.sort);
     if (sort) {
-      this.cmdBase.sort = sort;
+      command.sort = sort;
     }
 
     if (options.projection) {
-      this.cmdBase.fields = options.projection;
+      command.fields = options.projection;
     }
 
     if (options.maxTimeMS) {
-      this.cmdBase.maxTimeMS = options.maxTimeMS;
+      command.maxTimeMS = options.maxTimeMS;
     }
 
     // Decorate the findAndModify command with the write Concern
     if (options.writeConcern) {
-      this.cmdBase.writeConcern = options.writeConcern;
+      command.writeConcern = options.writeConcern;
     }
 
     if (options.let) {
-      this.cmdBase.let = options.let;
+      command.let = options.let;
     }
 
     // we check for undefined specifically here to allow falsy values
     // eslint-disable-next-line no-restricted-syntax
     if (options.comment !== undefined) {
-      this.cmdBase.comment = options.comment;
+      command.comment = options.comment;
     }
 
-    // force primary read preference
-    this.readPreference = ReadPreference.primary;
-
-    this.collection = collection;
-    this.query = query;
-  }
-
-  override get commandName() {
-    return 'findAndModify' as const;
-  }
-
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<Document> {
-    const coll = this.collection;
-    const query = this.query;
-    const options = { ...this.options, ...this.bsonOptions };
-
-    // Create findAndModify command object
-    const cmd: Document = {
-      findAndModify: coll.collectionName,
-      query: query,
-      ...this.cmdBase
-    };
-
-    decorateWithCollation(cmd, coll, options);
-
     if (options.hint) {
       // TODO: once this method becomes a CommandOperation we will have the server
       // in place to check.
       const unacknowledgedWrite = this.writeConcern?.w === 0;
-      if (unacknowledgedWrite || maxWireVersion(server) < 8) {
+      if (unacknowledgedWrite || maxWireVersion(connection) < 8) {
         throw new MongoCompatibilityError(
           'The current topology does not support a hint on findAndModify commands'
         );
       }
 
-      cmd.hint = options.hint;
+      command.hint = options.hint;
     }
 
-    // Execute the command
-    const result = await super.executeCommand(server, session, cmd, timeoutContext);
-    return options.includeResultMetadata ? result : (result.value ?? null);
+    return command;
+  }
+
+  override handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): Document {
+    const result = super.handleOk(response);
+    return this.options.includeResultMetadata ? result : (result.value ?? null);
   }
 }
 
@@ -227,12 +224,21 @@ export class FindOneAndDeleteOperation extends FindAndModifyOperation {
     }
 
     super(collection, filter, options);
-    this.cmdBase.remove = true;
+  }
+
+  override buildCommandDocument(
+    connection: Connection,
+    session?: ClientSession
+  ): FindAndModifyCmdBase {
+    const command = super.buildCommandDocument(connection, session);
+    command.remove = true;
+    return command;
   }
 }
 
 /** @internal */
 export class FindOneAndReplaceOperation extends FindAndModifyOperation {
+  private replacement: Document;
   constructor(
     collection: Collection,
     filter: Document,
@@ -250,15 +256,27 @@ export class FindOneAndReplaceOperation extends FindAndModifyOperation {
     if (hasAtomicOperators(replacement)) {
       throw new MongoInvalidArgumentError('Replacement document must not contain atomic operators');
     }
-
     super(collection, filter, options);
-    this.cmdBase.update = replacement;
-    configureFindAndModifyCmdBaseUpdateOpts(this.cmdBase, options);
+
+    this.replacement = replacement;
+  }
+
+  override buildCommandDocument(
+    connection: Connection,
+    session?: ClientSession
+  ): FindAndModifyCmdBase {
+    const command = super.buildCommandDocument(connection, session);
+    command.update = this.replacement;
+    configureFindAndModifyCmdBaseUpdateOpts(command, this.options);
+    return command;
   }
 }
 
 /** @internal */
 export class FindOneAndUpdateOperation extends FindAndModifyOperation {
+  private update: Document;
+  override options: FindOneAndUpdateOptions;
+
   constructor(
     collection: Collection,
     filter: Document,
@@ -278,12 +296,21 @@ export class FindOneAndUpdateOperation extends FindAndModifyOperation {
     }
 
     super(collection, filter, options);
-    this.cmdBase.update = update;
-    configureFindAndModifyCmdBaseUpdateOpts(this.cmdBase, options);
+    this.update = update;
+    this.options = options;
+  }
 
-    if (options.arrayFilters) {
-      this.cmdBase.arrayFilters = options.arrayFilters;
+  override buildCommandDocument(
+    connection: Connection,
+    session?: ClientSession
+  ): FindAndModifyCmdBase {
+    const command = super.buildCommandDocument(connection, session);
+    command.update = this.update;
+    configureFindAndModifyCmdBaseUpdateOpts(command, this.options);
+    if (this.options.arrayFilters) {
+      command.arrayFilters = this.options.arrayFilters;
     }
+    return command;
   }
 }