implemented executeCallback

executeCallbackCommand now invokes executeCommand

Author: malikj2000

src/operations/command.ts

@@ -111,7 +111,7 @@ export abstract class CommandOperation<T> extends AbstractCallbackOperation<T> {
     server: Server,
     session: ClientSession | undefined,
     cmd: Document
-  ): Promise<any> {
+  ): Promise<Document> {
     // TODO: consider making this a non-enumerable property
     this.server = server;
 
@@ -169,46 +169,9 @@ export abstract class CommandCallbackOperation<T = any> extends CommandOperation
     cmd: Document,
     callback: Callback
   ): void {
-    this.server = server;
-
-    const options = {
-      ...this.options,
-      ...this.bsonOptions,
-      readPreference: this.readPreference,
-      session
-    };
-
-    const serverWireVersion = maxWireVersion(server);
-    const inTransaction = this.session && this.session.inTransaction();
-
-    if (this.readConcern && commandSupportsReadConcern(cmd) && !inTransaction) {
-      Object.assign(cmd, { readConcern: this.readConcern });
-    }
-
-    if (this.trySecondaryWrite && serverWireVersion < MIN_SECONDARY_WRITE_WIRE_VERSION) {
-      options.omitReadPreference = true;
-    }
-
-    if (this.writeConcern && this.hasAspect(Aspect.WRITE_OPERATION) && !inTransaction) {
-      Object.assign(cmd, { writeConcern: this.writeConcern });
-    }
-
-    if (
-      options.collation &&
-      typeof options.collation === 'object' &&
-      !this.hasAspect(Aspect.SKIP_COLLATION)
-    ) {
-      Object.assign(cmd, { collation: options.collation });
-    }
-
-    if (typeof options.maxTimeMS === 'number') {
-      cmd.maxTimeMS = options.maxTimeMS;
-    }
-
-    if (this.hasAspect(Aspect.EXPLAINABLE) && this.explain) {
-      cmd = decorateWithExplain(cmd, this.explain);
-    }
-
-    server.command(this.ns, cmd, options, callback);
+    super.executeCommand(server, session, cmd).then(
+      res => callback(undefined, res),
+      err => callback(err, undefined)
+    );
   }
 }

src/sdam/server.ts

@@ -118,11 +118,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
   pool: ConnectionPool;
   serverApi?: ServerApi;
   hello?: Document;
-  commandAsync: (
-    ns: MongoDBNamespace,
-    cmd: Document,
-    options: CommandOptions
-  ) => Promise<Document | undefined>;
+  commandAsync: (ns: MongoDBNamespace, cmd: Document, options: CommandOptions) => Promise<Document>;
   [kMonitor]: Monitor | null;
 
   /** @event */
@@ -151,7 +147,8 @@ export class Server extends TypedEventEmitter<ServerEvents> {
         ns: MongoDBNamespace,
         cmd: Document,
         options: CommandOptions,
-        callback: Callback<Document>
+        // callback type defines Document result because result is never nullish when it succeeds, otherwise promise rejects
+        callback: (error: Error | undefined, result: Document) => void
       ) => this.command(ns, cmd, options, callback as any)
     );
 

test/unit/operations/abstract_command.test.ts

@@ -31,7 +31,10 @@ class ConcreteCommand<T> extends CommandOperation<T> {
     session: ClientSession | undefined,
     callback: Callback<any>
   ) {
-    return [server, session, callback];
+    super.execute(server, session).then(
+      res => callback(undefined, res),
+      err => callback(err, undefined)
+    );
   }
 }
 
@@ -50,7 +53,7 @@ describe('class CommandOperation', () => {
       const operation = new ConcreteCommand<any>();
       const serverSpy = sinon.stub(server, 'commandAsync');
       const commandPromise = operation.executeCommand(server, undefined, { ping: 1 });
-      expect(commandPromise).to.be.instanceOf(Promise<any>);
+      expect(commandPromise).to.be.instanceOf(Promise);
       await commandPromise;
       expect(serverSpy).to.have.been.calledOnce;
     });