refactor(NODE-7083): index operations to modernized operation

Author: durran

src/operations/indexes.ts

@@ -1,5 +1,6 @@
 import type { Document } from '../bson';
-import { CursorResponse } from '../cmap/wire_protocol/responses';
+import { type Connection } from '../cmap/connection';
+import { CursorResponse, MongoDBResponse } from '../cmap/wire_protocol/responses';
 import type { Collection } from '../collection';
 import { type AbstractCursorOptions } from '../cursor/abstract_cursor';
 import { MongoCompatibilityError } from '../error';
@@ -12,6 +13,7 @@ import {
   type CollationOptions,
   CommandOperation,
   type CommandOperationOptions,
+  ModernizedCommandOperation,
   type OperationParent
 } from './command';
 import { Aspect, defineAspects } from './operation';
@@ -244,7 +246,8 @@ type ResolvedIndexDescription = Omit<IndexDescription, 'key' | 'version'> & {
 };
 
 /** @internal */
-export class CreateIndexesOperation extends CommandOperation<string[]> {
+export class CreateIndexesOperation extends ModernizedCommandOperation<string[]> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: CreateIndexesOptions;
   collectionName: string;
   indexes: ReadonlyArray<ResolvedIndexDescription>;
@@ -258,6 +261,8 @@ export class CreateIndexesOperation extends CommandOperation<string[]> {
     super(parent, options);
 
     this.options = options ?? {};
+    // collation is set on each index, it should not be defined at the root
+    this.options.collation = undefined;
     this.collectionName = collectionName;
     this.indexes = indexes.map((userIndex: IndexDescription): ResolvedIndexDescription => {
       // Ensure the key is a Map to preserve index key ordering
@@ -271,6 +276,7 @@ export class CreateIndexesOperation extends CommandOperation<string[]> {
         key
       };
     });
+    this.ns = parent.s.namespace;
   }
 
   static fromIndexDescriptionArray(
@@ -297,15 +303,11 @@ export class CreateIndexesOperation extends CommandOperation<string[]> {
     return 'createIndexes';
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<string[]> {
+  override buildCommandDocument(connection: Connection): Document {
     const options = this.options;
     const indexes = this.indexes;
 
-    const serverWireVersion = maxWireVersion(server);
+    const serverWireVersion = maxWireVersion(connection);
 
     const cmd: Document = { createIndexes: this.collectionName, indexes };
 
@@ -317,13 +319,11 @@ export class CreateIndexesOperation extends CommandOperation<string[]> {
       }
       cmd.commitQuorum = options.commitQuorum;
     }
+    return cmd;
+  }
 
-    // collation is set on each index, it should not be defined at the root
-    this.options.collation = undefined;
-
-    await super.executeCommand(server, session, cmd, timeoutContext);
-
-    const indexNames = indexes.map(index => index.name || '');
+  override handleOk(_response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): string[] {
+    const indexNames = this.indexes.map(index => index.name || '');
     return indexNames;
   }
 }
@@ -332,7 +332,8 @@ export class CreateIndexesOperation extends CommandOperation<string[]> {
 export type DropIndexesOptions = CommandOperationOptions;
 
 /** @internal */
-export class DropIndexOperation extends CommandOperation<Document> {
+export class DropIndexOperation extends ModernizedCommandOperation<Document> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: DropIndexesOptions;
   collection: Collection;
   indexName: string;
@@ -343,19 +344,15 @@ export class DropIndexOperation extends CommandOperation<Document> {
     this.options = options ?? {};
     this.collection = collection;
     this.indexName = indexName;
+    this.ns = collection.fullNamespace;
   }
 
   override get commandName() {
     return 'dropIndexes' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<Document> {
-    const cmd = { dropIndexes: this.collection.collectionName, index: this.indexName };
-    return await super.executeCommand(server, session, cmd, timeoutContext);
+  override buildCommandDocument(_connection: Connection): Document {
+    return { dropIndexes: this.collection.collectionName, index: this.indexName };
   }
 }
 

src/operations/search_indexes/create.ts

@@ -1,9 +1,11 @@
-import type { Document } from '../../bson';
+import { BSONType, type Document } from '../../bson';
+import { type Connection } from '../../cmap/connection';
+import { MongoDBResponse } from '../../cmap/wire_protocol/responses';
 import type { Collection } from '../../collection';
-import type { Server } from '../../sdam/server';
+import type { ServerCommandOptions } from '../../sdam/server';
 import type { ClientSession } from '../../sessions';
 import { type TimeoutContext } from '../../timeout';
-import { AbstractOperation } from '../operation';
+import { ModernizedOperation } from '../operation';
 
 /**
  * @public
@@ -20,37 +22,37 @@ export interface SearchIndexDescription extends Document {
 }
 
 /** @internal */
-export class CreateSearchIndexesOperation extends AbstractOperation<string[]> {
+export class CreateSearchIndexesOperation extends ModernizedOperation<string[]> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   private readonly collection: Collection;
   private readonly descriptions: ReadonlyArray<SearchIndexDescription>;
 
   constructor(collection: Collection, descriptions: ReadonlyArray<SearchIndexDescription>) {
     super();
     this.collection = collection;
     this.descriptions = descriptions;
+    this.ns = collection.fullNamespace;
   }
 
   override get commandName() {
     return 'createSearchIndexes' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<string[]> {
+  override buildCommand(_connection: Connection, _session?: ClientSession): Document {
     const namespace = this.collection.fullNamespace;
-    const command = {
+    return {
       createSearchIndexes: namespace.collection,
       indexes: this.descriptions
     };
+  }
 
-    const res = await server.command(namespace, command, {
-      session,
-      timeoutContext
-    });
+  override handleOk(response: MongoDBResponse): string[] {
+    const indexesCreated = response.get('indexesCreated', BSONType.array, true);
+    const doc = indexesCreated.toObject();
+    return Object.entries(doc).map(([_key, val]) => val.name);
+  }
 
-    const indexesCreated: Array<{ name: string }> = res?.indexesCreated ?? [];
-    return indexesCreated.map(({ name }) => name);
+  override buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions {
+    return { session: this.session, timeoutContext };
   }
 }

src/operations/search_indexes/update.ts

@@ -1,12 +1,15 @@
 import type { Document } from '../../bson';
+import { type Connection } from '../../cmap/connection';
+import { MongoDBResponse } from '../../cmap/wire_protocol/responses';
 import type { Collection } from '../../collection';
-import type { Server } from '../../sdam/server';
+import type { ServerCommandOptions } from '../../sdam/server';
 import type { ClientSession } from '../../sessions';
 import { type TimeoutContext } from '../../timeout';
-import { AbstractOperation } from '../operation';
+import { ModernizedOperation } from '../operation';
 
 /** @internal */
-export class UpdateSearchIndexOperation extends AbstractOperation<void> {
+export class UpdateSearchIndexOperation extends ModernizedOperation<void> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   private readonly collection: Collection;
   private readonly name: string;
   private readonly definition: Document;
@@ -16,25 +19,27 @@ export class UpdateSearchIndexOperation extends AbstractOperation<void> {
     this.collection = collection;
     this.name = name;
     this.definition = definition;
+    this.ns = collection.fullNamespace;
   }
 
   override get commandName() {
     return 'updateSearchIndex' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<void> {
+  override buildCommand(_connection: Connection, _session?: ClientSession): Document {
     const namespace = this.collection.fullNamespace;
-    const command = {
+    return {
       updateSearchIndex: namespace.collection,
       name: this.name,
       definition: this.definition
     };
+  }
+
+  override handleOk(_response: MongoDBResponse): void {
+    // no response.
+  }
 
-    await server.command(namespace, command, { session, timeoutContext });
-    return;
+  override buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions {
+    return { session: this.session, timeoutContext };
   }
 }