remove options type from AbstractOperation

Author: mbroadst

src/operations/bulk_write.ts

@@ -10,7 +10,8 @@ import type {
 import type { Server } from '../sdam/server';
 
 /** @internal */
-export class BulkWriteOperation extends AbstractOperation<BulkWriteOptions, BulkWriteResult> {
+export class BulkWriteOperation extends AbstractOperation<BulkWriteResult> {
+  options: BulkWriteOptions;
   collection: Collection;
   operations: AnyBulkWriteOperation[];
 
@@ -20,7 +21,7 @@ export class BulkWriteOperation extends AbstractOperation<BulkWriteOptions, Bulk
     options: BulkWriteOptions
   ) {
     super(options);
-
+    this.options = options;
     this.collection = collection;
     this.operations = operations;
   }

src/operations/collections.ts

@@ -12,12 +12,13 @@ export interface CollectionsOptions extends OperationOptions {
 }
 
 /** @internal */
-export class CollectionsOperation extends AbstractOperation<CollectionsOptions, Collection[]> {
+export class CollectionsOperation extends AbstractOperation<Collection[]> {
+  options: CollectionsOptions;
   db: Db;
 
   constructor(db: Db, options: CollectionsOptions) {
     super(options);
-
+    this.options = options;
     this.db = db;
   }
 

src/operations/delete.ts

@@ -6,8 +6,8 @@ import type { Callback, MongoDBNamespace } from '../utils';
 import type { Document } from '../bson';
 import type { Server } from '../sdam/server';
 import type { Collection } from '../collection';
-import type { WriteCommandOptions } from '../cmap/wire_protocol/write_command';
 import type { Connection } from '../cmap/connection';
+import type { WriteCommandOptions } from '../cmap/wire_protocol/write_command';
 
 /** @public */
 export interface DeleteOptions extends CommandOperationOptions {
@@ -28,11 +28,13 @@ export interface DeleteResult {
 }
 
 /** @internal */
-export class DeleteOperation extends AbstractOperation<DeleteOptions, Document> {
+export class DeleteOperation extends AbstractOperation<Document> {
+  options: DeleteOptions;
   operations: Document[];
 
   constructor(ns: MongoDBNamespace, ops: Document[], options: DeleteOptions) {
     super(options);
+    this.options = options;
     this.ns = ns;
     this.operations = ops;
   }

src/operations/execute_operation.ts

@@ -1,6 +1,6 @@
 import { ReadPreference } from '../read_preference';
 import { MongoError, isRetryableError, AnyError } from '../error';
-import { Aspect, AbstractOperation, OperationOptions } from './operation';
+import { Aspect, AbstractOperation } from './operation';
 import { maxWireVersion, maybePromise, Callback } from '../utils';
 import { ServerType } from '../sdam/common';
 import type { Server } from '../sdam/server';
@@ -12,13 +12,7 @@ const MMAPv1_RETRY_WRITES_ERROR_CODE = 20;
 const MMAPv1_RETRY_WRITES_ERROR_MESSAGE =
   'This MongoDB deployment does not support retryable writes. Please add retryWrites=false to your connection string.';
 
-type ResultTypeFromOperation<TOperation> = TOperation extends AbstractOperation<
-  OperationOptions,
-  infer K
->
-  ? K
-  : never;
-type OptionsFromOperation<TOperation> = TOperation extends AbstractOperation<infer K, unknown>
+type ResultTypeFromOperation<TOperation> = TOperation extends AbstractOperation<infer K>
   ? K
   : never;
 
@@ -48,23 +42,19 @@ export interface ExecutionResult {
  * @param callback - The command result callback
  */
 export function executeOperation<
-  T extends AbstractOperation<TOptions, TResult>,
-  TOptions = OptionsFromOperation<T>,
+  T extends AbstractOperation<TResult>,
   TResult = ResultTypeFromOperation<T>
 >(topology: Topology, operation: T): Promise<TResult>;
 export function executeOperation<
-  T extends AbstractOperation<TOptions, TResult>,
-  TOptions = OptionsFromOperation<T>,
+  T extends AbstractOperation<TResult>,
   TResult = ResultTypeFromOperation<T>
 >(topology: Topology, operation: T, callback: Callback<TResult>): void;
 export function executeOperation<
-  T extends AbstractOperation<TOptions, TResult>,
-  TOptions = OptionsFromOperation<T>,
+  T extends AbstractOperation<TResult>,
   TResult = ResultTypeFromOperation<T>
 >(topology: Topology, operation: T, callback?: Callback<TResult>): Promise<TResult> | void;
 export function executeOperation<
-  T extends AbstractOperation<TOptions, TResult>,
-  TOptions = OptionsFromOperation<T>,
+  T extends AbstractOperation<TResult>,
   TResult = ResultTypeFromOperation<T>
 >(topology: Topology, operation: T, callback?: Callback<TResult>): Promise<TResult> | void {
   if (!(operation instanceof AbstractOperation)) {
@@ -79,7 +69,7 @@ export function executeOperation<
           return;
         }
 
-        executeOperation<T, TOptions, TResult>(topology, operation, cb);
+        executeOperation<T, TResult>(topology, operation, cb);
       });
     });
   }

src/operations/indexes.ts

@@ -126,12 +126,13 @@ function makeIndexSpec(indexSpec: IndexSpecification, options: any): IndexDescri
 }
 
 /** @internal */
-export class IndexesOperation extends AbstractOperation<IndexInformationOptions, Document> {
+export class IndexesOperation extends AbstractOperation<Document> {
+  options: IndexInformationOptions;
   collection: Collection;
 
   constructor(collection: Collection, options: IndexInformationOptions) {
     super(options);
-
+    this.options = options;
     this.collection = collection;
   }
 
@@ -401,7 +402,8 @@ export class ListIndexesCursor extends AbstractCursor {
 }
 
 /** @internal */
-export class IndexExistsOperation extends AbstractOperation<IndexInformationOptions, boolean> {
+export class IndexExistsOperation extends AbstractOperation<boolean> {
+  options: IndexInformationOptions;
   collection: Collection;
   indexes: string | string[];
 
@@ -411,7 +413,7 @@ export class IndexExistsOperation extends AbstractOperation<IndexInformationOpti
     options: IndexInformationOptions
   ) {
     super(options);
-
+    this.options = options;
     this.collection = collection;
     this.indexes = indexes;
   }
@@ -440,13 +442,14 @@ export class IndexExistsOperation extends AbstractOperation<IndexInformationOpti
 }
 
 /** @internal */
-export class IndexInformationOperation extends AbstractOperation<IndexInformationOptions, Document> {
+export class IndexInformationOperation extends AbstractOperation<Document> {
+  options: IndexInformationOptions;
   db: Db;
   name: string;
 
   constructor(db: Db, name: string, options?: IndexInformationOptions) {
     super(options);
-
+    this.options = options || {};
     this.db = db;
     this.name = name;
   }

src/operations/insert.ts

@@ -12,11 +12,13 @@ import type { BulkWriteOptions } from '../bulk/common';
 import type { WriteConcernOptions } from '../write_concern';
 
 /** @internal */
-export class InsertOperation extends AbstractOperation<BulkWriteOptions, Document> {
+export class InsertOperation extends AbstractOperation<Document> {
+  options: BulkWriteOptions;
   operations: Document[];
 
   constructor(ns: MongoDBNamespace, ops: Document[], options: BulkWriteOptions) {
     super(options);
+    this.options = options;
     this.ns = ns;
     this.operations = ops;
   }

src/operations/insert_many.ts

@@ -21,13 +21,14 @@ export interface InsertManyResult {
 }
 
 /** @internal */
-export class InsertManyOperation extends AbstractOperation<BulkWriteOptions, InsertManyResult> {
+export class InsertManyOperation extends AbstractOperation<InsertManyResult> {
+  options: BulkWriteOptions;
   collection: Collection;
   docs: Document[];
 
   constructor(collection: Collection, docs: Document[], options: BulkWriteOptions) {
     super(options);
-
+    this.options = options;
     this.collection = collection;
     this.docs = docs;
   }

src/operations/is_capped.ts

@@ -5,11 +5,13 @@ import type { Server } from '../sdam/server';
 import { MongoError } from '..';
 
 /** @internal */
-export class IsCappedOperation extends AbstractOperation<OperationOptions, boolean> {
+export class IsCappedOperation extends AbstractOperation<boolean> {
+  options: OperationOptions;
   collection: Collection;
 
   constructor(collection: Collection, options: OperationOptions) {
     super(options);
+    this.options = options;
     this.collection = collection;
   }
 

src/operations/operation.ts

@@ -28,18 +28,16 @@ export interface OperationOptions extends BSONSerializeOptions {
   readPreference?: ReadPreferenceLike;
 }
 
+const kSession = Symbol('session');
+
 /**
  * This class acts as a parent class for any operation and is responsible for setting this.options,
  * as well as setting and getting a session.
  * Additionally, this class implements `hasAspect`, which determines whether an operation has
  * a specific aspect.
  * @internal
  */
-export abstract class AbstractOperation<
-  T extends OperationOptions = OperationOptions,
-  TResult = Document
-> {
-  options: T;
+export abstract class AbstractOperation<T = Document> {
   ns!: MongoDBNamespace;
   cmd!: Document;
   readPreference: ReadPreference;
@@ -49,21 +47,18 @@ export abstract class AbstractOperation<
   // BSON serialization options
   bsonOptions?: BSONSerializeOptions;
 
-  constructor(options: T = {} as T) {
-    this.options = Object.assign({}, options);
+  [kSession]: ClientSession;
 
+  constructor(options: OperationOptions = {}) {
     this.readPreference = this.hasAspect(Aspect.WRITE_OPERATION)
       ? ReadPreference.primary
       : ReadPreference.fromOptions(options) ?? ReadPreference.primary;
-    // TODO: A lot of our code depends on having the read preference in the options. This should
-    //       go away, but also requires massive test rewrites.
-    this.options.readPreference = this.readPreference;
 
     // Pull the BSON serialize options from the already-resolved options
     this.bsonOptions = resolveBSONOptions(options);
   }
 
-  abstract execute(server: Server, callback: Callback<TResult>): void;
+  abstract execute(server: Server, callback: Callback<T>): void;
 
   hasAspect(aspect: symbol): boolean {
     const ctor = this.constructor as OperationConstructor;
@@ -75,19 +70,15 @@ export abstract class AbstractOperation<
   }
 
   set session(session: ClientSession) {
-    Object.assign(this.options, { session });
+    this[kSession] = session;
   }
 
   get session(): ClientSession {
-    // NOTE: Using the bang operator here because we know there is always a
-    //       session, explicit or implicit. We should disambiguate the session
-    //       from the options and set it as an explicit field
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    return this.options.session!;
+    return this[kSession];
   }
 
   clearSession(): void {
-    delete this.options.session;
+    // this[kSession] = undefined;
   }
 
   get canRetryRead(): boolean {

src/operations/options_operation.ts

@@ -6,12 +6,13 @@ import type { Collection } from '../collection';
 import type { Server } from '../sdam/server';
 
 /** @internal */
-export class OptionsOperation extends AbstractOperation<OperationOptions, Document> {
+export class OptionsOperation extends AbstractOperation<Document> {
+  options: OperationOptions;
   collection: Collection;
 
   constructor(collection: Collection, options: OperationOptions) {
     super(options);
-
+    this.options = options;
     this.collection = collection;
   }
 

src/operations/update.ts

@@ -41,11 +41,13 @@ export interface UpdateResult {
 }
 
 /** @internal */
-export class UpdateOperation extends AbstractOperation<UpdateOptions, Document> {
+export class UpdateOperation extends AbstractOperation<Document> {
+  options: UpdateOptions;
   operations: Document[];
 
   constructor(ns: MongoDBNamespace, ops: Document[], options: UpdateOptions) {
     super(options);
+    this.options = options;
     this.ns = ns;
     this.operations = ops;
   }