feat(playground): add support local require VSCODE-468

src/editors/playgroundController.ts

@@ -449,6 +449,7 @@ export default class PlaygroundController {
       result = await this._languageServerController.evaluate({
         codeToEvaluate,
         connectionId,
+        filePath: vscode.window.activeTextEditor?.document.uri.fsPath,
       });
     } catch (error) {
       const msg =

src/language/languageServerController.ts

@@ -186,6 +186,7 @@ export default class LanguageServerController {
   ): Promise<ShellEvaluateResult> {
     log.info('Running a playground...', {
       connectionId: playgroundExecuteParameters.connectionId,
+      filePath: playgroundExecuteParameters.filePath,
       inputLength: playgroundExecuteParameters.codeToEvaluate.length,
     });
     this._isExecutingInProgress = true;

src/language/mongoDBService.ts

@@ -296,6 +296,7 @@ export default class MongoDBService {
           name: ServerCommands.EXECUTE_CODE_FROM_PLAYGROUND,
           data: {
             codeToEvaluate: params.codeToEvaluate,
+            filePath: params.filePath,
             connectionString: this.connectionString,
             connectionOptions: this.connectionOptions,
           },

src/language/worker.ts

@@ -36,14 +36,25 @@ const getLanguage = (evaluationResult: EvaluationResult) => {
   return 'plaintext';
 };
 
+type ExecuteCodeOptions = {
+  codeToEvaluate: string;
+  connectionString: string;
+  connectionOptions: MongoClientOptions;
+  filePath?: string;
+};
+
 /**
  * Execute code from a playground.
  */
-const execute = async (
-  codeToEvaluate: string,
-  connectionString: string,
-  connectionOptions: MongoClientOptions
-): Promise<{ data?: ShellEvaluateResult; error?: any }> => {
+const execute = async ({
+  codeToEvaluate,
+  connectionString,
+  connectionOptions,
+  filePath,
+}: ExecuteCodeOptions): Promise<{
+  data?: ShellEvaluateResult;
+  error?: any;
+}> => {
   const serviceProvider = await CliServiceProvider.connect(
     connectionString,
     connectionOptions
@@ -67,6 +78,19 @@ const execute = async (
       },
     });
 
+    // In order to support local require directly from the file where code lives, we can not wrap the
+    // whole code in a function for two reasons:
+    // 1. We need to return the response and can not simply add return. And
+    // 2. We can not use eval to evaluate the *codeToEvaluate* as mongosh async-rewriter can’t see into the eval.
+    // We are also not directly concatenating the require with the code either due to "use strict"
+    if (filePath) {
+      await runtime.evaluate(`(function () {
+        globalThis.require = require('module').createRequire(${JSON.stringify(
+          filePath
+        )});
+      } ())`);
+    }
+
     // Evaluate a playground content.
     const { source, type, printable } = await runtime.evaluate(codeToEvaluate);
     const namespace =
@@ -94,11 +118,7 @@ const handleMessageFromParentPort = async ({ name, data }): Promise<void> => {
   if (name === ServerCommands.EXECUTE_CODE_FROM_PLAYGROUND) {
     parentPort?.postMessage({
       name: ServerCommands.CODE_EXECUTION_RESULT,
-      payload: await execute(
-        data.codeToEvaluate,
-        data.connectionString,
-        data.connectionOptions
-      ),
+      payload: await execute(data),
     });
   }
 };

src/test/suite/language/mongoDBService.test.ts

@@ -10,7 +10,8 @@ import {
 import type { CompletionItem } from 'vscode-languageclient/node';
 import chai from 'chai';
 import { createConnection } from 'vscode-languageserver/node';
-import fs from 'fs';
+import fs from 'fs/promises';
+import os from 'os';
 import path from 'path';
 import { TextDocument } from 'vscode-languageserver-textdocument';
 import type { Db } from 'mongodb';
@@ -45,7 +46,7 @@ suite('MongoDBService Test Suite', () => {
       'dist',
       languageServerWorkerFileName
     );
-    await fs.promises.stat(languageServerModuleBundlePath);
+    await fs.stat(languageServerModuleBundlePath);
   });
 
   suite('Extension path', () => {
@@ -3008,6 +3009,44 @@ suite('MongoDBService Test Suite', () => {
         expect(result).to.deep.equal(expectedResult);
       });
     });
+
+    suite('evaluate allows to import local files', function () {
+      let tmpDir: string;
+      beforeEach(async () => {
+        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'local-import'));
+        await fs.writeFile(
+          path.join(tmpDir, 'utils.js'),
+          `module.exports.add = function (a, b) {
+            return a + b;
+          };
+        `
+        );
+      });
+      afterEach(async () => {
+        await fs.rm(tmpDir, { recursive: true });
+      });
+      test('evaluate allows to import file', async () => {
+        const source = new CancellationTokenSource();
+        const result = await testMongoDBService.evaluate(
+          {
+            connectionId: 'pineapple',
+            codeToEvaluate: 'const { add } = require("./utils.js"); add(1, 2);',
+            filePath: path.join(tmpDir, 'utils.js'),
+          },
+          source.token
+        );
+        const expectedResult = {
+          result: {
+            namespace: null,
+            type: 'number',
+            content: 3,
+            language: 'plaintext',
+          },
+        };
+
+        expect(result).to.deep.equal(expectedResult);
+      });
+    });
   });
 
   suite('Export to language mode', function () {

src/types/playgroundType.ts

@@ -21,6 +21,7 @@ export type ShellEvaluateResult =
 export type PlaygroundEvaluateParams = {
   codeToEvaluate: string;
   connectionId: string;
+  filePath?: string;
 };
 
 export interface ExportToLanguageAddons {