fix(shell-api): use readPref for runCommand if explicitly set MONGOSH-508

If `readPreference` has been explicitly set, either through
a) the connection string or b) by using `setReadPref()`,
then pass it for `db.runCommand()` as well.

The reason we’re not always using it is that the driver will
report it back to use as `primary` by default, which would then
break `db.runCommand()` for almost all calls when we’re connected
to a secondary.

As part of this, update the default `Mongo` instance to also
report the connection string, like a programmatically created `Mongo`
instance would (and like it worked in the old shell).

Also addresses MONGOSH-557.

Refs: https://docs.google.com/document/d/10FTlhliWtg_XquUGbEmZQ7ccUiImMLlBT5Qlm2O1ZxI/edit?pli=1

Author: addaleax

packages/cli-repl/test/e2e-direct.spec.ts

@@ -69,6 +69,31 @@ describe('e2e direct connection', () => {
           shell.assertContainsOutput(`me: '${await rs1.hostport()}'`);
           shell.assertContainsOutput(`setName: '${replSetId}'`);
         });
+
+        it('fails to list collections without explicit readPreference', async() => {
+          const shell = TestShell.start({ args: [`${await rs1.connectionString()}`] });
+          await shell.waitForPrompt();
+          await shell.executeLine('use admin');
+          await shell.executeLine('db.runCommand({ listCollections: 1 })');
+          shell.assertContainsError('MongoError: not master');
+        });
+
+        it('lists collections when readPreference is in the connection string', async() => {
+          const shell = TestShell.start({ args: [`${await rs1.connectionString()}?readPreference=secondaryPreferred`] });
+          await shell.waitForPrompt();
+          await shell.executeLine('use admin');
+          await shell.executeLine('db.runCommand({ listCollections: 1 })');
+          shell.assertContainsOutput("name: 'system.version'");
+        });
+
+        it('lists collections when readPreference is set via Mongo', async() => {
+          const shell = TestShell.start({ args: [`${await rs1.connectionString()}`] });
+          await shell.waitForPrompt();
+          await shell.executeLine('use admin');
+          await shell.executeLine('db.getMongo().setReadPref("secondaryPreferred")');
+          await shell.executeLine('db.runCommand({ listCollections: 1 })');
+          shell.assertContainsOutput("name: 'system.version'");
+        });
       });
 
       context('connecting to primary', () => {

packages/service-provider-core/src/admin.ts

@@ -47,6 +47,11 @@ export default interface Admin {
    */
   getNewConnection(uri: string, options: MongoClientOptions): Promise<any>; // returns the ServiceProvider instance
 
+  /**
+   * Return the URI for the current connection, if this ServiceProvider is connected.
+   */
+  getURI(): string | undefined;
+
   /**
    * Return connection info
    */

packages/service-provider-server/src/cli-service-provider.integration.spec.ts

@@ -686,4 +686,10 @@ describe('CliServiceProvider [integration]', function() {
       expect(serviceProvider.driverMetadata.driver.name).to.equal('nodejs');
     });
   });
+
+  describe('#getURI', () => {
+    it('returns the current URI', () => {
+      expect(serviceProvider.getURI()).to.equal(connectionString + '/');
+    });
+  });
 });

packages/service-provider-server/src/cli-service-provider.ts

@@ -1156,6 +1156,10 @@ class CliServiceProvider extends ServiceProviderCore implements ServiceProvider
   getRawClient(): MongoClient {
     return this.mongoClient;
   }
+
+  getURI(): string | undefined {
+    return this.uri?.href;
+  }
 }
 
 export default CliServiceProvider;

packages/shell-api/src/database.ts

@@ -28,7 +28,8 @@ import type {
   CommandOperationOptions,
   CreateCollectionOptions,
   Document,
-  WriteConcern
+  WriteConcern,
+  ListCollectionsOptions
 } from '@mongosh/service-provider-core';
 import { AggregationCursor, CommandResult } from './index';
 import {
@@ -116,27 +117,27 @@ export default class Database extends ShellApiClass {
 
   // Private helpers to avoid sending telemetry events for internal calls. Public so rs/sh can use them
 
-  public async _runCommand(cmd: Document, options = {}): Promise<Document> {
+  public async _runCommand(cmd: Document, options: CommandOperationOptions = {}): Promise<Document> {
     return this._mongo._serviceProvider.runCommandWithCheck(
       this._name,
       cmd,
-      { ...this._baseOptions, ...options }
+      { ...this._mongo._getExplicitlyRequestedReadPref(), ...this._baseOptions, ...options }
     );
   }
 
-  public async _runAdminCommand(cmd: Document, options = {}): Promise<Document> {
+  public async _runAdminCommand(cmd: Document, options: CommandOperationOptions = {}): Promise<Document> {
     return this._mongo._serviceProvider.runCommandWithCheck(
       ADMIN_DB,
       cmd,
-      { ...this._baseOptions, ...options }
+      { ...this._mongo._getExplicitlyRequestedReadPref(), ...this._baseOptions, ...options }
     );
   }
 
-  private async _listCollections(filter: Document, options: Document): Promise<Document[]> {
+  private async _listCollections(filter: Document, options: ListCollectionsOptions): Promise<Document[]> {
     return await this._mongo._serviceProvider.listCollections(
       this._name,
       filter,
-      { ...this._baseOptions, ...options }
+      { ...this._mongo._getExplicitlyRequestedReadPref(), ...this._baseOptions, ...options }
     ) || [];
   }
 
@@ -216,7 +217,7 @@ export default class Database extends ShellApiClass {
    */
   @returnsPromise
   @serverVersions(['3.0.0', ServerVersions.latest])
-  async getCollectionInfos(filter: Document = {}, options: Document = {}): Promise<Document[]> {
+  async getCollectionInfos(filter: Document = {}, options: ListCollectionsOptions = {}): Promise<Document[]> {
     this._emitDatabaseApiCall('getCollectionInfos', { filter, options });
     return await this._listCollections(
       filter,

packages/shell-api/src/mongo.ts

@@ -59,17 +59,23 @@ export default class Mongo extends ShellApiClass {
   public _fleOptions: SPAutoEncryption | undefined;
   private _keyVault: KeyVault | undefined; // need to keep it around so that the ShellApi ClientEncryption class can access it
   private _clientEncryption: ClientEncryption | undefined;
+  private _readPreferenceWasExplicitlyRequested = false;
 
   constructor(
     internalState: ShellInternalState,
-    uri = 'mongodb://localhost/',
+    uri?: string,
     fleOptions?: ClientSideFieldLevelEncryptionOptions
   ) {
     super();
     this._internalState = internalState;
     this._databases = {};
-    this._uri = generateUri({ _: [uri] });
     this._serviceProvider = this._internalState.initialServiceProvider;
+    if (typeof uri === 'string') {
+      this._uri = generateUri({ _: [uri] });
+    } else {
+      this._uri = this._serviceProvider?.getURI?.() ?? generateUri({ _: ['mongodb://localhost/'] });
+    }
+    this._readPreferenceWasExplicitlyRequested = /\breadPreference=/.test(this._uri);
     if (fleOptions) {
       this._fleOptions = processFLEOptions(fleOptions, this._serviceProvider);
       const { mongocryptdSpawnPath } = this._internalState;
@@ -203,6 +209,12 @@ export default class Mongo extends ShellApiClass {
     return this._serviceProvider.getReadPreference();
   }
 
+  _getExplicitlyRequestedReadPref(): { readPreference: ReadPreference } | undefined {
+    return this._readPreferenceWasExplicitlyRequested ?
+      { readPreference: this.getReadPref() } :
+      undefined;
+  }
+
   getReadConcern(): string | undefined {
     try {
       const rc = this._serviceProvider.getReadConcern();
@@ -217,6 +229,7 @@ export default class Mongo extends ShellApiClass {
     await this._serviceProvider.resetConnectionOptions({
       readPreference: { mode: mode, tagSet: tagSet, hedgeOptions: hedgeOptions }
     });
+    this._readPreferenceWasExplicitlyRequested = true;
   }
 
   @returnsPromise