nodb

Author: aherlihy

packages/cli-repl/src/cli-repl.ts

@@ -81,7 +81,7 @@ class CliRepl {
    */
   async setupRepl(driverUri: string, driverOptions: NodeOptions): Promise<void> {
     const initialServiceProvider = await this.connect(driverUri, driverOptions);
-    this.internalState = new ShellInternalState(initialServiceProvider, this.bus);
+    this.internalState = new ShellInternalState(initialServiceProvider, this.bus, this.options);
     this.shellEvaluator = new ShellEvaluator(this.internalState, this);
     await this.internalState.fetchConnectionInfo();
     this.start();
@@ -94,8 +94,10 @@ class CliRepl {
    * @param {NodeOptions} driverOptions - The driver options.
    */
   async connect(driverUri: string, driverOptions: NodeOptions): Promise<any> {
-    console.log(i18n.__(CONNECTING), '    ', clr(retractPassword(driverUri), ['bold', 'green']));
-    return await CliServiceProvider.connect(driverUri, driverOptions);
+    if (!this.options.nodb) {
+      console.log(i18n.__(CONNECTING), '    ', clr(retractPassword(driverUri), ['bold', 'green']));
+    }
+    return await CliServiceProvider.connect(driverUri, driverOptions, this.options);
   }
 
   /**

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

@@ -21,6 +21,27 @@ describe('e2e', function() {
     });
   });
 
+  describe('--nodb', () => {
+    let shell;
+    beforeEach(async() => {
+      shell = TestShell.start({ args: [ '--nodb' ] });
+      await shell.waitForPrompt();
+      shell.assertNoErrors();
+    });
+    it('db throws', async() => {
+      await shell.executeLine('db');
+      shell.assertContainsError('MongoshInvalidInputError: No connected database');
+    });
+    it('show dbs throws InvalidInput', async() => {
+      await shell.executeLine('show dbs');
+      shell.assertContainsError('MongoshInvalidInputError: No connected database');
+    });
+    it('db.coll.find() throws InvalidInput', async() => {
+      await shell.executeLine('db.coll.find()');
+      shell.assertContainsError('MongoshInvalidInputError: No connected database');
+    });
+  });
+
   describe('with connection string', () => {
     let db;
     let client;

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

@@ -42,22 +42,26 @@ class CliServiceProvider implements ServiceProvider {
    *
    * @param {String} uri - The URI.
    * @param {NodeOptions} options - The options.
+   * @param {Object} cliOptions - Options passed through CLI. Right now only being used for nodb.
    *
    * @returns {Promise} The promise with cli service provider.
    */
   static async connect(
     uri: string,
-    options: NodeOptions = {}
+    options: NodeOptions = {},
+    cliOptions: any = {}
   ): Promise<CliServiceProvider> {
     const clientOptions: any = {
       ...DEFAULT_OPTIONS,
       ...options
     };
 
-    const mongoClient = await MongoClient.connect(
-      uri,
-      clientOptions
-    );
+    const mongoClient = !cliOptions.nodb ?
+      await MongoClient.connect(
+        uri,
+        clientOptions
+      ) :
+      new MongoClient(uri, clientOptions);
 
     return new CliServiceProvider(mongoClient, uri);
   }

packages/shell-api/src/helpers.ts

@@ -51,6 +51,6 @@ export function validateExplainableVerbosity(verbosity: string): void {
 
 export function checkUndefinedUpdate(...args: any): void {
   if (args.some(a => a === undefined)) {
-    throw new MongoshInvalidInputError('Cannot pass an undefined argument to a write command');
+    throw new MongoshInvalidInputError('Cannot pass an undefined argument to a command');
   }
 }

packages/shell-api/src/no-db.spec.ts

@@ -0,0 +1,26 @@
+import { expect } from 'chai';
+import NoDatabase from './no-db';
+describe('NoDatabase', () => {
+  let nomongo;
+  let nodb;
+  beforeEach(() => {
+    nodb = new NoDatabase();
+    nomongo = nodb.mongo;
+  });
+  it('throws for show', () => {
+    try {
+      nodb.mongo.show('dbs');
+    } catch (e) {
+      return expect(e.name).to.equal('MongoshInvalidInputError');
+    }
+    expect.fail('no error thrown for NoDb.mongo.use');
+  });
+  it('throws for nomongo.use', () => {
+    try {
+      nomongo.use('test');
+    } catch (e) {
+      return expect(e.name).to.equal('MongoshInvalidInputError');
+    }
+    expect.fail('no error thrown for NoDb');
+  });
+});

packages/shell-api/src/no-db.ts

@@ -0,0 +1,27 @@
+import { MongoshInvalidInputError } from '@mongosh/errors';
+import Mongo from './mongo';
+
+export default class NoDatabase {
+  mongo: Mongo;
+  constructor() {
+    this.mongo = new NoMongo() as Mongo;
+    const proxy = new Proxy(this, {
+      get: (target, prop): any => {
+        if (prop === 'mongo') return this.mongo; // so we can create rs/sh without erroring
+        throw new MongoshInvalidInputError('No connected database');
+      }
+    });
+    return proxy;
+  }
+}
+
+class NoMongo {
+  constructor() {
+    const proxy = new Proxy(this, {
+      get: (): any => {
+        throw new MongoshInvalidInputError('No connected database');
+      }
+    });
+    return proxy;
+  }
+}

packages/shell-api/src/shell-api.spec.ts

@@ -141,6 +141,17 @@ describe('ShellApi', () => {
         expect(db.shellApiType()).to.equal('Database');
         expect(db.getMongo().uri).to.equal('uri');
       });
+      it('fails with no arg', async() => {
+        serviceProvider.platform = ReplPlatform.CLI;
+        try {
+          // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
+          // @ts-ignore
+          await internalState.shellApi.connect();
+        } catch (e) {
+          return expect(e.name).to.equal('MongoshInvalidInputError');
+        }
+        expect.fail('MongoshInvalidInputError not thrown for connect');
+      });
     });
   });
   describe('from context', () => {

packages/shell-api/src/shell-api.ts

@@ -12,6 +12,7 @@ import Mongo from './mongo';
 import Database from './database';
 import { CommandResult } from './result';
 import ShellInternalState from './shell-internal-state';
+import { checkUndefinedUpdate } from './helpers';
 import { ReplPlatform } from '@mongosh/service-provider-core';
 import { MongoshUnimplementedError } from '@mongosh/errors';
 
@@ -68,11 +69,12 @@ export default class ShellApi extends ShellApiClass {
   @returnsPromise
   @returnType('Database')
   @platforms([ ReplPlatform.CLI ] )
-  async connect(uri?, user?, pwd?): Promise<Database> {
+  async connect(uri, user?, pwd?): Promise<Database> {
+    checkUndefinedUpdate(uri);
     const options = {} as any;
     if (user) options.username = user;
     if (pwd) options.password = pwd;
-    const mongo = await this.Mongo(uri, { auth: options });
+    const mongo = await this.Mongo(uri, Object.keys(options).length ? { auth: options } : {});
     return mongo.getDB('test');
   }
 

packages/shell-api/src/shell-internal-state.ts

@@ -15,6 +15,7 @@ import { Document, ServiceProvider } from '@mongosh/service-provider-core';
 import { MongoshInvalidInputError } from '@mongosh/errors';
 import AsyncWriter from '@mongosh/async-rewriter';
 import { toIgnore } from './decorators';
+import NoDatabase from './no-db';
 
 /**
  * Anything to do with the internal shell state is stored here.
@@ -30,21 +31,31 @@ export default class ShellInternalState {
   public context: any;
   public mongos: Mongo[];
   public shellApi: ShellApi;
-  constructor(initialServiceProvider: ServiceProvider, messageBus: any = new EventEmitter()) {
+  public cliOptions: any;
+  constructor(initialServiceProvider: ServiceProvider, messageBus: any = new EventEmitter(), cliOptions: any = {}) {
     this.initialServiceProvider = initialServiceProvider;
     this.messageBus = messageBus;
     this.asyncWriter = new AsyncWriter(signatures);
     this.shellApi = new ShellApi(this);
-    const mongo = new Mongo(this);
+    this.mongos = [];
+    this.connectionInfo = { buildInfo: {} };
+    if (!cliOptions.nodb) {
+      const mongo = new Mongo(this);
+      this.mongos.push(mongo);
+      this.currentDb = mongo.getDB('test'); // TODO: set to CLI arg
+    } else {
+      this.currentDb = new NoDatabase() as Database;
+    }
     this.currentCursor = null;
-    this.currentDb = mongo.getDB('test'); // TODO: set to CLI arg
     this.context = {};
-    this.mongos = [ mongo ];
+    this.cliOptions = cliOptions;
   }
 
   async fetchConnectionInfo(): Promise<void> {
-    this.connectionInfo = await this.currentDb.mongo.serviceProvider.getConnectionInfo();
-    this.messageBus.emit('mongosh:connect', this.connectionInfo.extraInfo);
+    if (!this.cliOptions.nodb) {
+      this.connectionInfo = await this.currentDb.mongo.serviceProvider.getConnectionInfo();
+      this.messageBus.emit('mongosh:connect', this.connectionInfo.extraInfo);
+    }
   }
 
   async close(p): Promise<void> {
@@ -95,6 +106,7 @@ export default class ShellInternalState {
     contextObject.help = this.shellApi.help;
     contextObject.printjson = contextObject.print;
     Object.assign(contextObject, ShellBson);
+
     contextObject.rs = new ReplicaSet(this.currentDb.mongo);
     contextObject.sh = new Shard(this.currentDb.mongo);