remove session setter from operation

Author: mbroadst

src/operations/execute_operation.ts

@@ -1,5 +1,5 @@
 import { ReadPreference } from '../read_preference';
-import { MongoError, isRetryableError, AnyError } from '../error';
+import { MongoError, isRetryableError } from '../error';
 import { Aspect, AbstractOperation } from './operation';
 import { maxWireVersion, maybePromise, Callback } from '../utils';
 import { ServerType } from '../sdam/common';
@@ -76,31 +76,28 @@ export function executeOperation<
 
   // The driver sessions spec mandates that we implicitly create sessions for operations
   // that are not explicitly provided with a session.
-  let session: ClientSession;
+  let session = operation.session;
   let owner: symbol;
   if (topology.hasSessionSupport()) {
-    if (operation.session == null) {
+    if (session == null) {
       owner = Symbol();
       session = topology.startSession({ owner, explicit: false });
-      operation.session = session;
     } else if (operation.session.hasEnded) {
       throw new MongoError('Use of expired sessions is not permitted');
     }
   }
 
   return maybePromise(callback, cb => {
-    function executeCallback(err?: AnyError, result?: TResult) {
-      if (session && session.owner === owner) {
-        return session.endSession(err2 => cb(err2 || err, result));
-      }
-
-      cb(err, result);
-    }
-
     try {
-      executeWithServerSelection(topology, operation, executeCallback);
+      executeWithServerSelection(topology, session, operation, (err, result) => {
+        if (session && session.owner && session.owner === owner) {
+          return session.endSession(err2 => cb(err2 || err, result));
+        }
+
+        cb(err, result);
+      });
     } catch (e) {
-      if (session && session.owner === owner) {
+      if (session && session.owner && session.owner === owner) {
         session.endSession();
       }
 
@@ -113,8 +110,12 @@ function supportsRetryableReads(server: Server) {
   return maxWireVersion(server) >= 6;
 }
 
-function executeWithServerSelection(topology: Topology, operation: any, callback: Callback) {
-  const session = operation.session;
+function executeWithServerSelection(
+  topology: Topology,
+  session: ClientSession,
+  operation: any,
+  callback: Callback
+) {
   const readPreference = operation.readPreference || ReadPreference.primary;
   const inTransaction = session && session.inTransaction();
 
@@ -196,17 +197,15 @@ function executeWithServerSelection(topology: Topology, operation: any, callback
       return;
     }
 
-    if (operation.hasAspect(Aspect.RETRYABLE)) {
+    if (session && operation.hasAspect(Aspect.RETRYABLE)) {
       const willRetryRead =
         topology.s.options.retryReads !== false &&
-        operation.session &&
         !inTransaction &&
         supportsRetryableReads(server) &&
         operation.canRetryRead;
 
       const willRetryWrite =
         topology.s.options.retryWrites === true &&
-        operation.session &&
         !inTransaction &&
         supportsRetryableWrites(server) &&
         operation.canRetryWrite;
@@ -217,7 +216,7 @@ function executeWithServerSelection(topology: Topology, operation: any, callback
       if ((hasReadAspect && willRetryRead) || (hasWriteAspect && willRetryWrite)) {
         if (hasWriteAspect && willRetryWrite) {
           operation.options.willRetryWrite = true;
-          operation.session.incrementTransactionNumber();
+          session.incrementTransactionNumber();
         }
 
         operation.execute(server, session, callbackWithRetry);

src/operations/operation.ts

@@ -73,10 +73,6 @@ export abstract class AbstractOperation<T> {
     return ctor.aspects.has(aspect);
   }
 
-  set session(session: ClientSession) {
-    this[kSession] = session;
-  }
-
   get session(): ClientSession {
     return this[kSession];
   }