Merge branch 'main' of github.com:mongodb-js/mongosh into gagik/options

Author: gagik

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

@@ -1,8 +1,8 @@
-import type { CliOptions } from '@mongosh/arg-parser';
 import parser from 'yargs-parser';
 import { z } from 'zod/v4';
 import type { Options as YargsOptions } from 'yargs-parser';
 import {
+  type CliOptions,
   CliOptionsSchema,
   processPositionalCliOptions,
   validateCliOptions,

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

@@ -14,6 +14,8 @@ export const CurrentCliOptionsSchema = z.object({
   awsSessionToken: z.string().optional(),
   csfleLibraryPath: z.string().optional(),
   cryptSharedLibPath: z.string().optional(),
+  // TODO: This default doesn't do anything on its own but is used as documentation for now.
+  deepInspect: z.boolean().default(true).optional(),
   db: z.string().optional(),
   gssapiServiceName: z.string().optional(),
   sspiHostnameCanonicalization: z.string().optional(),

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,
@@ -428,6 +428,7 @@ function dateInspect(
 function inspect(output: unknown, options: FormatOptions): string {
   // Set a custom inspection function for 'Date' objects. Since we only want this
   // to affect mongosh scripts, we unset it later.
+  const originalDateInspect = (Date.prototype as any)[util.inspect.custom];
   (Date.prototype as any)[util.inspect.custom] = dateInspect;
   try {
     return util.inspect(
@@ -443,6 +444,8 @@ function inspect(output: unknown, options: FormatOptions): string {
     );
   } finally {
     delete (Date.prototype as any)[util.inspect.custom];
+    if (originalDateInspect)
+      (Date.prototype as any)[util.inspect.custom] = originalDateInspect;
   }
 }
 

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

@@ -12,7 +12,7 @@ import path from 'path';
 import type { Duplex } from 'stream';
 import { PassThrough } from 'stream';
 import type { StubbedInstance } from 'ts-sinon';
-import { stubInterface } from 'ts-sinon';
+import sinon, { stubInterface } from 'ts-sinon';
 import { inspect, promisify } from 'util';
 import {
   expect,
@@ -95,6 +95,7 @@ describe('MongoshNodeRepl', function () {
       },
     });
     sp.runCommandWithCheck.resolves({ ok: 1 });
+    sp.find.resolves(sinon.stub());
 
     if (process.env.USE_NEW_AUTOCOMPLETE) {
       sp.listCollections.resolves([{ name: 'coll' }]);

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

@@ -956,7 +956,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.
@@ -976,7 +976,8 @@ class MongoshNodeRepl implements EvaluationListener {
       this.rawValueToShellResult.get(result) ?? {
         type: null,
         printable: result,
-      }
+      },
+      extraFormatOptions
     );
   }
 

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

@@ -588,4 +588,140 @@ describe('BSON e2e', function () {
       shell.assertNoErrors();
     });
   });
+  describe('inspect nesting depth', 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 = ${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()');
+      checkForDeepOutput(output, true);
+      // Same object doesn't need to be fully printed if created by the user
+      const output2 = await shell.executeLine('deepAndNested');
+      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.waitForPrompt();
+      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`,
+        ],
+      });
+      checkForDeepOutput(await shell.waitForCleanOutput(), false);
+      shell = this.startTestShell({
+        args: [
+          await testServer.connectionString(),
+          '--eval',
+          `print(${deepAndNestedDefinition}); 0`,
+        ],
+      });
+      checkForDeepOutput(await shell.waitForCleanOutput(), false);
+    });
+
+    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();`,
+        ],
+      });
+      checkForDeepOutput(await shell.waitForCleanOutput(), true);
+      shell = this.startTestShell({
+        args: [
+          await testServer.connectionString(),
+          '--eval',
+          deepAndNestedDefinition,
+        ],
+      });
+      checkForDeepOutput(await shell.waitForCleanOutput(), true);
+    });
+
+    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();`,
+        ],
+      });
+      checkForDeepOutput(await shell.waitForCleanOutput(), false);
+      shell = this.startTestShell({
+        args: [
+          await testServer.connectionString(),
+          '--deepInspect=false',
+          '--eval',
+          deepAndNestedDefinition,
+        ],
+      });
+      checkForDeepOutput(await shell.waitForCleanOutput(), false);
+    });
+
+    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
+      // (although maybe it should?).
+      await shell.executeLine(
+        `Date.prototype[Symbol.for('nodejs.util.inspect.custom')] = function(){ return 'ISODate("' + this.toISOString() + '")'; };`
+      );
+      // 'void 0' to avoid large output in the shell from serverStatus
+      await shell.executeLine(
+        'A = db.adminCommand({ serverStatus: 1 }); void 0'
+      );
+      await shell.executeLine('util.inspect(A)');
+      await shell.executeLine(`B = eval('(' + util.inspect(A) + ')'); void 0`);
+      shell.assertNoErrors();
+      const output1 = await shell.executeLineWithJSONResult('A', {
+        parseAsEJSON: false,
+      });
+      const output2 = await shell.executeLineWithJSONResult('B', {
+        parseAsEJSON: false,
+      });
+      expect(output1).to.deep.equal(output2);
+      shell.assertNoErrors();
+    });
+  });
 });

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

@@ -374,7 +374,7 @@ describe('OIDC auth e2e', function () {
 
     // Internal hack to get a state-share server as e.g. Compass or the VSCode extension would
     let handle = await shell.executeLine(
-      'db.getMongo()._serviceProvider.currentClientOptions.parentState.getStateShareServer()'
+      'db.getMongo()._serviceProvider[Symbol.for("@@mongosh.originalServiceProvider")].currentClientOptions.parentState.getStateShareServer()'
     );
     // `handle` can include the next prompt when returned by `shell.executeLine()`,
     // so look for the longest prefix of it that is valid JSON.

packages/e2e-tests/test/test-shell.ts

@@ -302,14 +302,17 @@ export class TestShell {
     return this._output.slice(previousOutputLength);
   }
 
-  async executeLineWithJSONResult(line: string): Promise<any> {
+  async executeLineWithJSONResult(
+    line: string,
+    { parseAsEJSON = true } = {}
+  ): Promise<any> {
     const output = await this.executeLine(
       `">>>>>>" + EJSON.stringify(${line}, {relaxed:false}) + "<<<<<<"`
     );
     const matching = output.match(/>>>>>>(.+)<<<<<</)?.[1];
     if (!matching)
       throw new Error(`Could not parse output from line: '${output}'`);
-    return EJSON.parse(matching);
+    return (parseAsEJSON ? EJSON : JSON).parse(matching);
   }
 
   assertNoErrors(): void {