chore: print console logs continuously

src/editors/playgroundController.ts

@@ -5,7 +5,6 @@ import { ProgressLocation } from 'vscode';
 import vm from 'vm';
 import os from 'os';
 import transpiler from 'bson-transpilers';
-import util from 'util';
 
 import type ActiveConnectionCodeLensProvider from './activeConnectionCodeLensProvider';
 import type PlaygroundSelectedCodeActionProvider from './playgroundSelectedCodeActionProvider';
@@ -159,6 +158,8 @@ export default class PlaygroundController {
       }
     );
 
+    languageServerController._consoleOutputChannel = this._outputChannel;
+
     const onDidChangeActiveTextEditor = (
       editor: vscode.TextEditor | undefined
     ) => {
@@ -467,7 +468,7 @@ export default class PlaygroundController {
             // If a user clicked the cancel button terminate all playground scripts.
             this._languageServerController.cancelAll();
 
-            return { outputLines: undefined, result: undefined };
+            return { result: undefined };
           });
 
           // Run all playground scripts.
@@ -483,10 +484,7 @@ export default class PlaygroundController {
     } catch (error) {
       log.error('Evaluating playground with cancel modal failed', error);
 
-      return {
-        outputLines: undefined,
-        result: undefined,
-      };
+      return { result: undefined };
     }
   }
 
@@ -572,22 +570,7 @@ export default class PlaygroundController {
     const evaluateResponse: ShellEvaluateResult =
       await this._evaluateWithCancelModal();
 
-    if (evaluateResponse?.outputLines?.length) {
-      for (const line of evaluateResponse.outputLines) {
-        this._outputChannel.appendLine(
-          typeof line.content === 'string'
-            ? line.content
-            : util.inspect(line.content)
-        );
-      }
-
-      this._outputChannel.show(true);
-    }
-
-    if (
-      !evaluateResponse ||
-      (!evaluateResponse.outputLines && !evaluateResponse.result)
-    ) {
+    if (!evaluateResponse || !evaluateResponse.result) {
       return false;
     }
 

src/language/languageServerController.ts

@@ -12,6 +12,7 @@ import {
 } from 'vscode-languageclient/node';
 import type { ExtensionContext } from 'vscode';
 import { workspace } from 'vscode';
+import util from 'util';
 
 import { createLogger } from '../logging';
 import type {
@@ -37,6 +38,7 @@ export default class LanguageServerController {
   _currentConnectionId: string | null = null;
   _currentConnectionString?: string;
   _currentConnectionOptions?: MongoClientOptions;
+  _consoleOutputChannel?: vscode.OutputChannel;
 
   constructor(context: ExtensionContext) {
     this._context = context;
@@ -151,6 +153,19 @@ export default class LanguageServerController {
         void vscode.window.showErrorMessage(messsage);
       }
     );
+
+    this._client.onNotification(
+      ServerCommands.SHOW_CONSOLE_OUTPUT,
+      (outputs) => {
+        for (const line of outputs) {
+          this._consoleOutputChannel?.appendLine(
+            typeof line === 'string' ? line : util.inspect(line)
+          );
+        }
+
+        this._consoleOutputChannel?.show(true);
+      }
+    );
   }
 
   deactivate(): Thenable<void> | undefined {

src/language/mongoDBService.ts

@@ -267,9 +267,16 @@ export default class MongoDBService {
           )
         );
 
-        worker?.on(
-          'message',
-          ({ error, data }: { data?: ShellEvaluateResult; error?: any }) => {
+        worker?.on('message', ({ name, payload }) => {
+          if (name === ServerCommands.SHOW_CONSOLE_OUTPUT) {
+            void this._connection.sendNotification(name, payload);
+          }
+
+          if (name === ServerCommands.EXECUTE_CODE_FROM_PLAYGROUND) {
+            const { error, data } = payload as {
+              data?: ShellEvaluateResult;
+              error?: any;
+            };
             if (error) {
               this._connection.console.error(
                 `WORKER error: ${util.inspect(error)}`
@@ -283,7 +290,7 @@ export default class MongoDBService {
               resolve(data);
             });
           }
-        );
+        });
 
         worker.postMessage({
           name: ServerCommands.EXECUTE_CODE_FROM_PLAYGROUND,

src/language/serverCommands.ts

@@ -10,6 +10,7 @@ export enum ServerCommands {
   CLEAR_CACHED_COMPLETIONS = 'CLEAR_CACHED_COMPLETIONS',
   MONGODB_SERVICE_CREATED = 'MONGODB_SERVICE_CREATED',
   INITIALIZE_MONGODB_SERVICE = 'INITIALIZE_MONGODB_SERVICE',
+  SHOW_CONSOLE_OUTPUT = 'SHOW_CONSOLE_OUTPUT',
 }
 
 export type PlaygroundRunParameters = {

src/language/worker.ts

@@ -6,7 +6,6 @@ import { ServerCommands } from './serverCommands';
 
 import type {
   ShellEvaluateResult,
-  PlaygroundDebug,
   WorkerEvaluate,
   MongoClientOptions,
 } from '../types/playgroundType';
@@ -52,19 +51,14 @@ const execute = async (
   try {
     // Create a new instance of the runtime for each playground evaluation.
     const runtime = new ElectronRuntime(serviceProvider);
-    const outputLines: PlaygroundDebug = [];
 
     // Collect console.log() output.
     runtime.setEvaluationListener({
       onPrint(values: EvaluationResult[]) {
-        for (const { type, printable } of values) {
-          outputLines.push({
-            type,
-            content: printable,
-            namespace: null,
-            language: null,
-          });
-        }
+        parentPort?.postMessage({
+          name: ServerCommands.SHOW_CONSOLE_OUTPUT,
+          payload: values.map((v) => v.printable),
+        });
       },
     });
 
@@ -83,7 +77,7 @@ const execute = async (
       language: getLanguage({ type, printable }),
     };
 
-    return { data: { outputLines, result } };
+    return { data: { result } };
   } catch (error) {
     return { error };
   } finally {
@@ -93,13 +87,14 @@ const execute = async (
 
 const handleMessageFromParentPort = async ({ name, data }): Promise<void> => {
   if (name === ServerCommands.EXECUTE_CODE_FROM_PLAYGROUND) {
-    parentPort?.postMessage(
-      await execute(
+    parentPort?.postMessage({
+      name: ServerCommands.EXECUTE_CODE_FROM_PLAYGROUND,
+      payload: await execute(
         data.codeToEvaluate,
         data.connectionString,
         data.connectionOptions
-      )
-    );
+      ),
+    });
   }
 };
 

src/test/suite/editors/playgroundController.test.ts

@@ -332,10 +332,7 @@ suite('Playground Controller Test Suite', function () {
         const result =
           await testPlaygroundController._evaluateWithCancelModal();
 
-        expect(result).to.deep.equal({
-          outputLines: undefined,
-          result: undefined,
-        });
+        expect(result).to.deep.equal({ result: undefined });
       });
 
       test('playground controller loads the active editor on start', () => {
@@ -405,9 +402,9 @@ suite('Playground Controller Test Suite', function () {
         let outputChannelShowStub: SinonStub;
 
         beforeEach(function () {
-          outputChannelAppendLineStub = sinon.stub();
-          outputChannelClearStub = sinon.stub();
-          outputChannelShowStub = sinon.stub();
+          outputChannelAppendLineStub = sandbox.stub();
+          outputChannelClearStub = sandbox.stub();
+          outputChannelShowStub = sandbox.stub();
 
           const mockOutputChannel = {
             appendLine: outputChannelAppendLineStub,
@@ -422,40 +419,20 @@ suite('Playground Controller Test Suite', function () {
           showInformationMessageStub.resolves('Yes');
         });
 
-        test('show the output in the vscode output channel as a string', async () => {
-          const outputLines = [
-            'test',
-            { pineapple: 'yes' },
-            ['porcupine', { anObject: true }],
-          ].map((content) => ({ content }));
+        test('clear output channel when evaluating', async () => {
           sandbox.replace(
             testPlaygroundController,
             '_evaluateWithCancelModal',
             sandbox.stub().resolves({
-              outputLines,
               result: '123',
             })
           );
 
           expect(outputChannelClearStub).to.not.be.called;
-          expect(outputChannelShowStub).to.not.be.called;
-          expect(outputChannelAppendLineStub).to.not.be.called;
 
           await testPlaygroundController.runAllPlaygroundBlocks();
 
           expect(outputChannelClearStub).to.be.calledOnce;
-          expect(outputChannelShowStub).to.be.calledOnce;
-          expect(outputChannelAppendLineStub.calledThrice).to.be.true;
-          expect(outputChannelAppendLineStub.firstCall.args[0]).to.equal(
-            'test'
-          );
-          // Make sure we're not printing anything like [object Object].
-          expect(outputChannelAppendLineStub.secondCall.args[0]).to.equal(
-            "{ pineapple: 'yes' }"
-          );
-          expect(outputChannelAppendLineStub.thirdCall.args[0]).to.equal(
-            "[ 'porcupine', { anObject: true } ]"
-          );
         });
       });
 
@@ -464,10 +441,7 @@ suite('Playground Controller Test Suite', function () {
           sandbox.replace(
             testPlaygroundController,
             '_evaluateWithCancelModal',
-            sandbox.stub().resolves({
-              outputLines: [],
-              result: '123',
-            })
+            sandbox.stub().resolves({ result: '123' })
           );
           sandbox.replace(
             testPlaygroundController,
@@ -479,6 +453,10 @@ suite('Playground Controller Test Suite', function () {
         test('show a confirmation message if mdb.confirmRunAll is true', async () => {
           showInformationMessageStub.resolves('Yes');
 
+          await vscode.workspace
+            .getConfiguration('mdb')
+            .update('confirmRunAll', true);
+
           const result =
             await testPlaygroundController.runAllPlaygroundBlocks();