MONGOSH-301 - Support raw command execution methods

Author: aherlihy

packages/browser-repl/src/components/shell-output-line.spec.tsx

@@ -153,6 +153,20 @@ describe('<ShellOutputLine />', () => {
     expect(wrapper.text()).to.include('metadata');
   });
 
+  it('renders ListCommandsResult', () => {
+    const wrapper = mount(<ShellOutputLine entry={{
+      format: 'output',
+      type: 'ListCommandsResult',
+      value: {
+        c1: { metadata: 1, help: 'help string' },
+      }
+    }}/>);
+
+    expect(wrapper.text()).to.include('help string');
+    expect(wrapper.text()).to.include('c1');
+    expect(wrapper.text()).to.include('metadata');
+  });
+
   it('renders an error', () => {
     const err = new Error('x');
     const wrapper = shallow(<ShellOutputLine entry={{ format: 'output', value: err }} />);

packages/browser-repl/src/components/shell-output-line.tsx

@@ -1,3 +1,4 @@
+/* eslint-disable complexity */
 import React, { Component } from 'react';
 import classnames from 'classnames';
 
@@ -64,6 +65,10 @@ export class ShellOutputLine extends Component<ShellOutputLineProps> {
       return <SimpleTypeOutput value={res} />;
     }
 
+    if (type === 'ListCommandsResult)') {
+      return <SimpleTypeOutput value={value} />;
+    }
+
     if (type === 'ShowCollectionsResult') {
       return <ShowCollectionsOutput value={value} />;
     }

packages/cli-repl/src/format-output.spec.ts

@@ -129,6 +129,20 @@ describe('formatOutput', () => {
     });
   });
 
+  context('when the result is ListCommandsResult', () => {
+    it('returns the formatted list', () => {
+      const output = stripAnsiColors(format({
+        value: {
+          c1: { metadata1: 1, help: 'help1' },
+          c2: { metadata2: 2, help: 'help2' }
+        },
+        type: 'ListCommandsResult'
+      }));
+
+      expect(output).to.contain('c1:  metadata1\nhelp1\n\nc2:  metadata2\nhelp2');
+    });
+  });
+
   context('when the result is Help', () => {
     it('returns help text', () => {
       const output = stripAnsiColors(format({

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

@@ -49,6 +49,10 @@ export default function formatOutput(evaluationResult: EvaluationResult): string
     return formatStats(value);
   }
 
+  if (type === 'ListCommandsResult') {
+    return formatListCommands(value);
+  }
+
   if (type === 'Error') {
     return formatError(value);
   }
@@ -81,6 +85,23 @@ function formatStats(output): string {
   }).join('\n---\n');
 }
 
+function formatListCommands(output): string {
+  const tableEntries = Object.keys(output).map(
+    (cmd) => {
+      const val = output[cmd];
+      let result = Object.keys(val).filter(k => k !== 'help').reduce((str, k) => {
+        if (val[k]) {
+          return `${str} ${clr(k, ['bold', 'white'])}`;
+        }
+        return str;
+      }, `${clr(cmd, ['bold', 'yellow'])}: `);
+      result += val.help ? `\n${clr(val.help, 'green')}` : '';
+      return result;
+    }
+  );
+  return tableEntries.join('\n\n');
+}
+
 export function formatError(error): string {
   let result = '';
   if (error.name) result += `\r${clr(error.name, ['bold', 'red'])}: `;

packages/i18n/src/locales/en_US.js

@@ -1020,6 +1020,16 @@ const translations = {
               link: 'https://docs.mongodb.com/manual/reference/method/db.getLogComponents',
               description: 'returns the db getLogComponents. uses the getParameter command',
               example: 'db.getLogComponents()'
+            },
+            listCommands: {
+              link: 'https://docs.mongodb.com/manual/reference/method/db.listCommands',
+              description: 'Calls the listCommands command',
+              example: 'db.listCommands()'
+            },
+            commandHelp: {
+              link: 'https://docs.mongodb.com/manual/reference/method/db.commandHelp',
+              description: 'returns the db commandHelp. uses the passed in command with help: true',
+              example: 'db.commandHelp(<command>)',
             }
           }
         }

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

@@ -1936,6 +1936,64 @@ describe('Database', () => {
         expect(catchedError).to.equal(expectedError);
       });
     });
+
+    describe('commandHelp', () => {
+      it('calls serviceProvider.runCommand on the database with options', async() => {
+        await database.commandHelp('listDatabases');
+
+        expect(serviceProvider.runCommand).to.have.been.calledWith(
+          database._name,
+          {
+            listDatabases: 1,
+            help: true
+          }
+        );
+      });
+
+      it('returns whatever serviceProvider.runCommand().help returns', async() => {
+        const expectedResult = { ok: 1, help: 'help string' };
+        serviceProvider.runCommand.resolves(expectedResult);
+        const result = await database.commandHelp('listDatabases');
+        expect(result).to.deep.equal('help string');
+      });
+
+      it('throws if serviceProvider.runCommand rejects', async() => {
+        const expectedError = new Error();
+        serviceProvider.runCommand.rejects(expectedError);
+        const catchedError = await database.commandHelp('listDatabases')
+          .catch(e => e);
+        expect(catchedError).to.equal(expectedError);
+      });
+    });
+
+    describe('listCommands', () => {
+      it('calls serviceProvider.runCommand on the database', async() => {
+        await database.listCommands();
+
+        expect(serviceProvider.runCommand).to.have.been.calledWith(
+          database._name,
+          {
+            listCommands: 1
+          }
+        );
+      });
+
+      it('returns ListCommandsResult', async() => {
+        const expectedResult = { ok: 1, commands: { c1: { requiresAuth: false, slaveOk: true, adminOnly: false, help: 'help string' } } };
+        serviceProvider.runCommand.resolves(expectedResult);
+        const result = await database.listCommands();
+        expect(result.value).to.deep.equal(expectedResult.commands);
+        expect(result.type).to.equal('ListCommandsResult');
+      });
+
+      it('throws if serviceProvider.runCommand rejects', async() => {
+        const expectedError = new Error();
+        serviceProvider.runCommand.rejects(expectedError);
+        const catchedError = await database.listCommands()
+          .catch(e => e);
+        expect(catchedError).to.equal(expectedError);
+      });
+    });
   });
 });
 

packages/shell-api/src/database.ts

@@ -917,4 +917,36 @@ export default class Database extends ShellApiClass {
     }
     return result.logComponentVerbosity;
   }
+
+  async commandHelp(name: string): Promise<any> {
+    assertArgsDefined(name);
+    this._emitDatabaseApiCall('commandHelp', { name: name });
+    const command = {} as any;
+    command[name] = 1;
+    command.help = true;
+
+    const result = await this._mongo._serviceProvider.runCommand(
+      this._name,
+      command
+    );
+    if (!result || !result.ok) {
+      throw new MongoshRuntimeError(`Error running command listComands ${result ? result.errmsg || '' : ''}`);
+    }
+    return result.help;
+  }
+
+  @returnsPromise
+  async listCommands(): Promise<any> {
+    this._emitDatabaseApiCall('listCommands', {});
+    const result = await this._mongo._serviceProvider.runCommand(
+      this._name,
+      {
+        listCommands: 1,
+      }
+    );
+    if (!result || !result.ok) {
+      throw new MongoshRuntimeError(`Error running command listCommands ${result ? result.errmsg || '' : ''}`);
+    }
+    return new CommandResult('ListCommandsResult', result.commands);
+  }
 }