feat(cli-repl): add flag to control deep inspect behavior

Author: addaleax

packages/arg-parser/src/cli-options.ts

@@ -19,6 +19,7 @@ export interface CliOptions {
   csfleLibraryPath?: string;
   cryptSharedLibPath?: string;
   db?: string;
+  deepInspect?: boolean; // defaults to true
   eval?: string[];
   exposeAsyncRewriter?: boolean; // internal testing only
   gssapiServiceName?: string;

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

@@ -58,6 +58,7 @@ const OPTIONS = {
     'apiDeprecationErrors',
     'apiStrict',
     'buildInfo',
+    'deepInspect',
     'exposeAsyncRewriter',
     'help',
     'ipv6',

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

@@ -53,6 +53,7 @@ import type {
   DevtoolsProxyOptions,
 } from '@mongodb-js/devtools-proxy-support';
 import { useOrCreateAgent } from '@mongodb-js/devtools-proxy-support';
+import { fullDepthInspectOptions } from './format-output';
 
 /**
  * Connecting text key.
@@ -210,10 +211,11 @@ export class CliRepl implements MongoshIOProvider {
     if (jsContext === 'auto' || !jsContext) {
       jsContext = willEnterInteractiveMode ? 'repl' : 'plain-vm';
     }
+    const deepInspect = this.cliOptions.deepInspect ?? willEnterInteractiveMode;
 
     this.mongoshRepl = new MongoshNodeRepl({
       ...options,
-      shellCliOptions: { ...this.cliOptions, jsContext, quiet },
+      shellCliOptions: { ...this.cliOptions, jsContext, quiet, deepInspect },
       nodeReplOptions: options.nodeReplOptions ?? {
         terminal: process.env.MONGOSH_FORCE_TERMINAL ? true : undefined,
       },
@@ -738,7 +740,12 @@ export class CliRepl implements MongoshIOProvider {
           formattedResult = formatForJSONOutput(e, this.cliOptions.json);
         }
       } else {
-        formattedResult = this.mongoshRepl.writer(lastEvalResult);
+        formattedResult = this.mongoshRepl.writer(
+          lastEvalResult,
+          this.cliOptions.deepInspect !== false
+            ? fullDepthInspectOptions
+            : undefined
+        );
       }
       this.output.write(formattedResult + '\n');
     }

packages/cli-repl/src/constants.ts

@@ -43,6 +43,9 @@ export const USAGE = `
         --retryWrites[=true|false]             ${i18n.__(
           'cli-repl.args.retryWrites'
         )}
+        --deep-inspect[=true|false]           ${i18n.__(
+          'cli-repl.args.deepInspect'
+        )}
 
   ${clr(
     i18n.__('cli-repl.args.authenticationOptions'),

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

@@ -36,7 +36,7 @@ export const CONTROL_CHAR_REGEXP_ALLOW_SIMPLE =
   // eslint-disable-next-line no-control-regex
   /[\x00-\x08\x0B-\x1F\x7F-\x9F]/;
 
-const fullDepthInspectOptions = {
+export const fullDepthInspectOptions = {
   depth: Infinity,
   maxArrayLength: Infinity,
   maxStringLength: Infinity,

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

@@ -955,7 +955,7 @@ class MongoshNodeRepl implements EvaluationListener {
   /**
    * Format the result to a string so it can be written to the output stream.
    */
-  writer(result: any): string {
+  writer(result: any, extraFormatOptions?: Partial<FormatOptions>): string {
     // This checks for error instances.
     // The writer gets called immediately by the internal `repl.eval`
     // in case of errors.
@@ -975,7 +975,8 @@ class MongoshNodeRepl implements EvaluationListener {
       this.rawValueToShellResult.get(result) ?? {
         type: null,
         printable: result,
-      }
+      },
+      extraFormatOptions
     );
   }
 

packages/e2e-tests/test/e2e-bson.spec.ts

@@ -589,30 +589,128 @@ describe('BSON e2e', function () {
     });
   });
   describe('inspect nesting depth', function () {
-    it('inspects a full bson document when it is read from the server', async function () {
+    const deepAndNestedDefinition = `({
+        a: { b: { c: { d: { e: { f: { g: { h: "foundme" } } } } } } },
+        array: [...Array(100000).keys()].map(i => ({ num: i })),
+        str: 'All work and no playmakes Jack a dull boy'.repeat(4096) + 'The End'
+      })`;
+    const checkForDeepOutput = (output: string, wantFullOutput: boolean) => {
+      if (wantFullOutput) {
+        expect(output).not.to.include('[Object');
+        expect(output).not.to.include('more items');
+        expect(output).to.include('foundme');
+        expect(output).to.include('num: 99999');
+        expect(output).to.include('The End');
+      } else {
+        expect(output).to.include('[Object');
+        expect(output).to.include('more items');
+        expect(output).not.to.include('foundme');
+        expect(output).not.to.include('num: 99999');
+        expect(output).not.to.include('The End');
+      }
+    };
+
+    beforeEach(async function () {
       await shell.executeLine(`use ${dbName}`);
-      await shell.executeLine(`deepAndNested = ({
-          a: { b: { c: { d: { e: { f: { g: { h: "foundme" } } } } } } },
-          array: [...Array(100000).keys()].map(i => ({ num: i })),
-          str: 'All work and no play makes Jack a dull boy'.repeat(4096) + 'The End'
-      });`);
+      await shell.executeLine(`deepAndNested = ${deepAndNestedDefinition}`);
       await shell.executeLine(`db.coll.insertOne(deepAndNested)`);
+    });
+
+    it('inspects a full bson document when it is read from the server (interactive mode)', async function () {
       // Deeply nested object from the server should be fully printed
       const output = await shell.executeLine('db.coll.findOne()');
-      expect(output).not.to.include('[Object');
-      expect(output).not.to.include('more items');
-      expect(output).to.include('foundme');
-      expect(output).to.include('num: 99999');
-      expect(output).to.include('The End');
+      checkForDeepOutput(output, true);
       // Same object doesn't need to be fully printed if created by the user
       const output2 = await shell.executeLine('deepAndNested');
-      expect(output2).to.include('[Object');
-      expect(output2).to.include('more items');
-      expect(output2).not.to.include('foundme');
-      expect(output2).not.to.include('num: 99999');
-      expect(output2).not.to.include('The End');
+      checkForDeepOutput(output2, false);
+      shell.assertNoErrors();
+    });
+
+    it('can explicitly disable full-depth nesting (interactive mode)', async function () {
+      shell.kill();
+      shell = this.startTestShell({
+        args: [await testServer.connectionString(), '--deepInspect=false'],
+      });
+      await shell.executeLine(`use ${dbName}`);
+      const output = await shell.executeLine('db.coll.findOne()');
+      checkForDeepOutput(output, false);
+      shell.assertNoErrors();
+    });
+
+    it('does not deeply inspect objects in non-interactive mode for intermediate output', async function () {
+      shell.kill();
+      shell = this.startTestShell({
+        args: [
+          await testServer.connectionString(),
+          '--eval',
+          `use(${JSON.stringify(dbName)}); print(db.coll.findOne()); 0`,
+        ],
+      });
+      await shell.waitForSuccessfulExit();
+      checkForDeepOutput(shell.output, false);
+      shell.assertNoErrors();
+      shell = this.startTestShell({
+        args: [
+          await testServer.connectionString(),
+          '--eval',
+          `print(${deepAndNestedDefinition}); 0`,
+        ],
+      });
+      await shell.waitForSuccessfulExit();
+      checkForDeepOutput(shell.output, false);
+      shell.assertNoErrors();
+    });
+
+    it('inspect full objects in non-interactive mode for final output', async function () {
+      shell.kill();
+      shell = this.startTestShell({
+        args: [
+          await testServer.connectionString(),
+          '--eval',
+          `use(${JSON.stringify(dbName)}); db.coll.findOne();`,
+        ],
+      });
+      await shell.waitForSuccessfulExit();
+      checkForDeepOutput(shell.output, true);
+      shell.assertNoErrors();
+      shell = this.startTestShell({
+        args: [
+          await testServer.connectionString(),
+          '--eval',
+          deepAndNestedDefinition,
+        ],
+      });
+      await shell.waitForSuccessfulExit();
+      checkForDeepOutput(shell.output, true);
       shell.assertNoErrors();
     });
+
+    it('can explicitly disable full-depth nesting (non-interactive mode)', async function () {
+      shell.kill();
+      shell = this.startTestShell({
+        args: [
+          await testServer.connectionString(),
+          '--deepInspect=false',
+          '--eval',
+          `use(${JSON.stringify(dbName)}); db.coll.findOne();`,
+        ],
+      });
+      await shell.waitForSuccessfulExit();
+      checkForDeepOutput(shell.output, false);
+      shell.assertNoErrors();
+      shell = this.startTestShell({
+        args: [
+          await testServer.connectionString(),
+          '--deepInspect=false',
+          '--eval',
+          deepAndNestedDefinition,
+        ],
+      });
+      await shell.waitForSuccessfulExit();
+      checkForDeepOutput(shell.output, false);
+      shell.assertNoErrors();
+    });
+
     it('can parse serverStatus back to its original form', async function () {
       // Dates get special treatment but that doesn't currently apply
       // to mongosh's util.inspect that's available to users

packages/i18n/src/locales/en_US.ts

@@ -22,6 +22,8 @@ const translations: Catalog = {
       quiet: 'Silence output from the shell during the connection process',
       shell: 'Run the shell after executing files',
       nodb: "Don't connect to mongod on startup - no 'db address' [arg] expected",
+      deepInspect:
+        'Force full depth inspection of server results (default: true if in interactive mode)',
       norc: "Will not run the '.mongoshrc.js' file on start up",
       eval: 'Evaluate javascript',
       json: 'Print result of --eval as Extended JSON, including errors',

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

@@ -58,6 +58,7 @@ import { deepInspectServiceProviderWrapper } from './deep-inspect/service-provid
  */
 export interface ShellCliOptions {
   nodb?: boolean;
+  deepInspect?: boolean;
 }
 
 /**
@@ -204,9 +205,10 @@ export class ShellInstanceState {
     cliOptions: ShellCliOptions = {},
     bsonLibrary: BSONLibrary = initialServiceProvider.bsonLibrary
   ) {
-    this.initialServiceProvider = deepInspectServiceProviderWrapper(
-      initialServiceProvider
-    );
+    this.initialServiceProvider =
+      cliOptions.deepInspect === false
+        ? initialServiceProvider
+        : deepInspectServiceProviderWrapper(initialServiceProvider);
     this.bsonLibrary = bsonLibrary;
     this.messageBus = messageBus;
     this.shellApi = new ShellApi(this);