feat(NODE-2014): return the result of provided callback

Author: durran

src/collection.ts

@@ -86,7 +86,6 @@ import {
   Callback,
   checkCollectionName,
   DEFAULT_PK_FACTORY,
-  emitWarningOnce,
   MongoDBNamespace,
   normalizeHintField,
   resolveOptions

src/mongo_client.ts

@@ -273,7 +273,7 @@ export interface MongoClientOptions extends BSONSerializeOptions, SupportedNodeC
 }
 
 /** @public */
-export type WithSessionCallback = (session: ClientSession) => Promise<any>;
+export type WithSessionCallback<T = any> = (session: ClientSession) => Promise<T>;
 
 /** @internal */
 export interface MongoClientPrivate {
@@ -643,12 +643,12 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
    * @param options - Optional settings for the command
    * @param callback - An callback to execute with an implicitly created session
    */
-  withSession(callback: WithSessionCallback): Promise<void>;
-  withSession(options: ClientSessionOptions, callback: WithSessionCallback): Promise<void>;
-  withSession(
-    optionsOrOperation?: ClientSessionOptions | WithSessionCallback,
-    callback?: WithSessionCallback
-  ): Promise<void> {
+  withSession<T>(callback: WithSessionCallback<T>): Promise<T>;
+  withSession<T>(options: ClientSessionOptions, callback: WithSessionCallback<T>): Promise<T>;
+  withSession<T>(
+    optionsOrOperation?: ClientSessionOptions | WithSessionCallback<T>,
+    callback?: WithSessionCallback<T>
+  ): Promise<T> {
     const options = {
       // Always define an owner
       owner: Symbol(),
@@ -666,15 +666,17 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
     const session = this.startSession(options);
 
     return maybeCallback(async () => {
+      let value;
       try {
-        await withSessionCallback(session);
+        value = await withSessionCallback(session);
       } finally {
         try {
           await session.endSession();
         } catch {
           // We are not concerned with errors from endSession()
         }
       }
+      return value;
     }, null);
   }
 

src/sessions.ts

@@ -61,7 +61,7 @@ export interface ClientSessionOptions {
 }
 
 /** @public */
-export type WithTransactionCallback<T = void> = (session: ClientSession) => Promise<T>;
+export type WithTransactionCallback<T = any> = (session: ClientSession) => Promise<T>;
 
 /** @public */
 export type ClientSessionEvents = {
@@ -470,10 +470,7 @@ export class ClientSession extends TypedEventEmitter<ClientSessionEvents> {
    * @param options - optional settings for the transaction
    * @returns A raw command response or undefined
    */
-  withTransaction<T = void>(
-    fn: WithTransactionCallback<T>,
-    options?: TransactionOptions
-  ): Promise<Document | undefined> {
+  withTransaction<T>(fn: WithTransactionCallback<T>, options?: TransactionOptions): Promise<T> {
     const startTime = now();
     return attemptTransaction(this, startTime, fn, options);
   }
@@ -615,12 +612,14 @@ function attemptTransaction<TSchema>(
   }
 
   return promise.then(
-    () => {
+    value => {
       if (userExplicitlyEndedTransaction(session)) {
-        return;
+        return value;
       }
 
-      return attemptTransactionCommit(session, startTime, fn, options);
+      return attemptTransactionCommit(session, startTime, fn, options).then(() => {
+        return value;
+      });
     },
     err => {
       function maybeRetryOrThrow(err: MongoError): Promise<any> {

test/integration/transactions/transactions.test.ts

@@ -90,19 +90,19 @@ describe('Transactions', function () {
           expect(withTransactionResult).to.be.undefined;
         });
 
-        it('should return raw command when transaction is successfully committed', async () => {
+        it('should return callback return value when transaction is successfully committed', async () => {
           const session = client.startSession();
 
           const withTransactionResult = await session
             .withTransaction(async session => {
               await collection.insertOne({ a: 1 }, { session });
-              await collection.findOne({ a: 1 }, { session });
+              return await collection.findOne({ a: 1 }, { session });
             })
             .finally(async () => await session.endSession());
 
           expect(withTransactionResult).to.exist;
           expect(withTransactionResult).to.be.an('object');
-          expect(withTransactionResult).to.have.property('ok', 1);
+          expect(withTransactionResult).to.have.property('a', 1);
         });
 
         it('should throw when transaction is aborted due to an error', async () => {

test/unit/mongo_client.test.js

@@ -873,3 +873,25 @@ describe('MongoOptions', function () {
     });
   });
 });
+
+describe('MongoClient', function () {
+  describe('#withSession', function () {
+    const client = new MongoClient('mongodb://localhost:27017');
+
+    context('when the callback returns a value', function () {
+      it('returns the value in the promise', async function () {
+        const value = await client.withSession(async () => {
+          return 'test';
+        });
+        expect(value).to.equal('test');
+      });
+    });
+
+    context('when the callback does not return a value', function () {
+      it('does not return a value in the promise', async function () {
+        const value = await client.withSession(async () => {});
+        expect(value).to.equal(undefined);
+      });
+    });
+  });
+});

test/unit/sessions.test.js

@@ -32,6 +32,24 @@ describe('Sessions - unit', function () {
       });
     });
 
+    describe('#withTransaction', function () {
+      context('when the callback returns a value', function () {
+        it('returns the value in the promise', async function () {
+          const value = await session.withTransaction(async () => {
+            return 'test';
+          });
+          expect(value).to.equal('test');
+        });
+      });
+
+      context('when the callback does not return a value', function () {
+        it('does not return a value in the promise', async function () {
+          const value = await session.withTransaction(async () => {});
+          expect(value).to.equal(undefined);
+        });
+      });
+    });
+
     describe('advanceClusterTime()', () => {
       it('should throw an error if the input cluster time is not an object', function () {
         const invalidInputs = [undefined, null, 3, 'a'];