@mongosh/node-runtime-worker-thread 1.10.1 → 1.10.2

package/src/index.spec.ts

@@ -2,7 +2,7 @@ import path from 'path';
 import chai, { expect } from 'chai';
 import sinon from 'sinon';
 import sinonChai from 'sinon-chai';
-import { MongoshBus } from '@mongosh/types';
+import type { MongoshBus } from '@mongosh/types';
 import { startTestServer } from '../../../testing/integration-testing-hooks';
 import { WorkerRuntime } from '../dist/index';
 
@@ -10,30 +10,30 @@ import type { DevtoolsConnectOptions } from '@mongosh/service-provider-server';
 
 export const dummyOptions: DevtoolsConnectOptions = Object.freeze({
   productName: 'Test Product',
-  productDocsLink: 'https://example.com/'
+  productDocsLink: 'https://example.com/',
 });
 
 chai.use(sinonChai);
 
 function createMockEventEmitter() {
-  return (sinon.stub({ on() {}, emit() {} }) as unknown) as MongoshBus;
+  return sinon.stub({ on() {}, emit() {} }) as unknown as MongoshBus;
 }
 
 function sleep(ms: number) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-describe('WorkerRuntime', () => {
+describe('WorkerRuntime', function () {
   let runtime: WorkerRuntime;
 
-  afterEach(async() => {
+  afterEach(async function () {
     if (runtime) {
       await runtime.terminate();
       runtime = null;
     }
   });
 
-  describe('spawn errors', () => {
+  describe('spawn errors', function () {
     const brokenScript = path.resolve(
       __dirname,
       '..',
@@ -41,14 +41,18 @@ describe('WorkerRuntime', () => {
       'script-that-throws.js'
     );
 
-    afterEach(() => {
-      delete process.env.CHILD_PROCESS_PROXY_SRC_PATH_DO_NOT_USE_THIS_EXCEPT_FOR_TESTING;
+    afterEach(function () {
+      delete process
+        .env.CHILD_PROCESS_PROXY_SRC_PATH_DO_NOT_USE_THIS_EXCEPT_FOR_TESTING;
     });
 
-    it('should return init error if child process failed to spawn', async() => {
-      process.env.CHILD_PROCESS_PROXY_SRC_PATH_DO_NOT_USE_THIS_EXCEPT_FOR_TESTING = brokenScript;
+    it('should return init error if child process failed to spawn', async function () {
+      process.env.CHILD_PROCESS_PROXY_SRC_PATH_DO_NOT_USE_THIS_EXCEPT_FOR_TESTING =
+        brokenScript;
 
-      runtime = new WorkerRuntime('mongodb://nodb/', dummyOptions, { nodb: true });
+      runtime = new WorkerRuntime('mongodb://nodb/', dummyOptions, {
+        nodb: true,
+      });
 
       let err;
 
@@ -59,15 +63,23 @@ describe('WorkerRuntime', () => {
       }
 
       expect(err).to.be.instanceof(Error);
-      expect(err).to.have.property('message').match(/Child process failed to start/);
+      expect(err)
+        .to.have.property('message')
+        .match(/Child process failed to start/);
     });
 
-    it('should return init error if worker in child process failed to spawn', async() => {
-      runtime = new WorkerRuntime('mongodb://nodb/', dummyOptions, { nodb: true }, {
-        env: {
-          WORKER_RUNTIME_SRC_PATH_DO_NOT_USE_THIS_EXCEPT_FOR_TESTING: brokenScript
+    it('should return init error if worker in child process failed to spawn', async function () {
+      runtime = new WorkerRuntime(
+        'mongodb://nodb/',
+        dummyOptions,
+        { nodb: true },
+        {
+          env: {
+            WORKER_RUNTIME_SRC_PATH_DO_NOT_USE_THIS_EXCEPT_FOR_TESTING:
+              brokenScript,
+          },
         }
-      });
+      );
 
       let err;
 
@@ -78,21 +90,27 @@ describe('WorkerRuntime', () => {
       }
 
       expect(err).to.be.instanceof(Error);
-      expect(err).to.have.property('message').match(/Worker thread failed to start/);
+      expect(err)
+        .to.have.property('message')
+        .match(/Worker thread failed to start/);
     });
   });
 
-  describe('evaluate', () => {
-    it('should evaluate and return basic values', async() => {
-      runtime = new WorkerRuntime('mongodb://nodb/', dummyOptions, { nodb: true });
+  describe('evaluate', function () {
+    it('should evaluate and return basic values', async function () {
+      runtime = new WorkerRuntime('mongodb://nodb/', dummyOptions, {
+        nodb: true,
+      });
       const result = await runtime.evaluate('1+1');
 
       expect(result.printable).to.equal(2);
     });
 
-    describe('errors', () => {
-      it("should throw an error if it's thrown during evaluation", async() => {
-        runtime = new WorkerRuntime('mongodb://nodb/', dummyOptions, { nodb: true });
+    describe('errors', function () {
+      it("should throw an error if it's thrown during evaluation", async function () {
+        runtime = new WorkerRuntime('mongodb://nodb/', dummyOptions, {
+          nodb: true,
+        });
 
         let err: Error;
 
@@ -110,8 +128,10 @@ describe('WorkerRuntime', () => {
           .matches(/TypeError: Oh no, types!/);
       });
 
-      it("should return an error if it's returned from evaluation", async() => {
-        runtime = new WorkerRuntime('mongodb://nodb/', dummyOptions, { nodb: true });
+      it("should return an error if it's returned from evaluation", async function () {
+        runtime = new WorkerRuntime('mongodb://nodb/', dummyOptions, {
+          nodb: true,
+        });
 
         const { printable } = await runtime.evaluate(
           'new SyntaxError("Syntax!")'
@@ -127,35 +147,43 @@ describe('WorkerRuntime', () => {
     });
   });
 
-  describe('getCompletions', () => {
+  describe('getCompletions', function () {
     const testServer = startTestServer('shared');
 
-    it('should return completions', async() => {
-      runtime = new WorkerRuntime(await testServer.connectionString(), dummyOptions);
+    it('should return completions', async function () {
+      runtime = new WorkerRuntime(
+        await testServer.connectionString(),
+        dummyOptions
+      );
       const completions = await runtime.getCompletions('db.coll1.f');
 
       expect(completions).to.deep.contain({ completion: 'db.coll1.find' });
     });
   });
 
-  describe('getShellPrompt', () => {
+  describe('getShellPrompt', function () {
     const testServer = startTestServer('shared');
 
-    it('should return prompt when connected to the server', async() => {
-      runtime = new WorkerRuntime(await testServer.connectionString(), dummyOptions);
+    it('should return prompt when connected to the server', async function () {
+      runtime = new WorkerRuntime(
+        await testServer.connectionString(),
+        dummyOptions
+      );
       const result = await runtime.getShellPrompt();
 
       expect(result).to.match(/>/);
     });
   });
 
-  describe('setEvaluationListener', () => {
-    it('allows to set evaluation listener for runtime', async() => {
+  describe('setEvaluationListener', function () {
+    it('allows to set evaluation listener for runtime', async function () {
       const evalListener = {
-        onPrompt: sinon.spy(() => 'password123')
+        onPrompt: sinon.spy(() => 'password123'),
       };
 
-      runtime = new WorkerRuntime('mongodb://nodb/', dummyOptions, { nodb: true });
+      runtime = new WorkerRuntime('mongodb://nodb/', dummyOptions, {
+        nodb: true,
+      });
 
       runtime.setEvaluationListener(evalListener);
 
@@ -166,10 +194,10 @@ describe('WorkerRuntime', () => {
     });
   });
 
-  describe('eventEmitter', () => {
+  describe('eventEmitter', function () {
     const testServer = startTestServer('shared');
 
-    it('should propagate emitted events from worker', async() => {
+    it('should propagate emitted events from worker', async function () {
       const eventEmitter = createMockEventEmitter();
 
       runtime = new WorkerRuntime(
@@ -182,16 +210,19 @@ describe('WorkerRuntime', () => {
 
       await runtime.evaluate('db.getCollectionNames()');
 
-      expect(eventEmitter.emit).to.have.been.calledWith('mongosh:api-call-with-arguments', {
-        arguments: {},
-        class: 'Database',
-        db: 'test',
-        method: 'getCollectionNames'
-      });
+      expect(eventEmitter.emit).to.have.been.calledWith(
+        'mongosh:api-call-with-arguments',
+        {
+          arguments: {},
+          class: 'Database',
+          db: 'test',
+          method: 'getCollectionNames',
+        }
+      );
     });
   });
 
-  describe('terminate', () => {
+  describe('terminate', function () {
     function isRunning(pid: number): boolean {
       try {
         process.kill(pid, 0);
@@ -203,32 +234,36 @@ describe('WorkerRuntime', () => {
 
     // We will be testing a bunch of private props that can be accessed only with
     // strings to make TS happy
-    /* eslint-disable dot-notation */
-    it('should terminate child process', async() => {
-      const runtime = new WorkerRuntime('mongodb://nodb/', dummyOptions, { nodb: true });
+    it('should terminate child process', async function () {
+      const runtime = new WorkerRuntime('mongodb://nodb/', dummyOptions, {
+        nodb: true,
+      });
       await runtime.terminate();
       expect(runtime['childProcess']).to.have.property('killed', true);
       expect(isRunning(runtime['childProcess'].pid)).to.equal(false);
     });
 
-    it('should remove all listeners from childProcess', async() => {
-      const runtime = new WorkerRuntime('mongodb://nodb/', dummyOptions, { nodb: true });
+    it('should remove all listeners from childProcess', async function () {
+      const runtime = new WorkerRuntime('mongodb://nodb/', dummyOptions, {
+        nodb: true,
+      });
       await runtime.terminate();
       expect(runtime['childProcess'].listenerCount('message')).to.equal(0);
     });
-    /* eslint-enable dot-notation */
 
-    it('should cancel any in-flight runtime calls', async() => {
-      const runtime = new WorkerRuntime('mongodb://nodb/', dummyOptions, { nodb: true });
+    it('should cancel any in-flight runtime calls', async function () {
+      const runtime = new WorkerRuntime('mongodb://nodb/', dummyOptions, {
+        nodb: true,
+      });
       let err: Error;
       try {
         await Promise.all([
           runtime.evaluate('while(true){}'),
-          (async() => {
+          (async () => {
             // smol sleep to make sure we actually issued a call
             await sleep(100);
             await runtime.terminate();
-          })()
+          })(),
         ]);
       } catch (e: any) {
         err = e;
@@ -238,9 +273,11 @@ describe('WorkerRuntime', () => {
     });
   });
 
-  describe('interrupt', () => {
-    it('should interrupt in-flight async tasks', async() => {
-      runtime = new WorkerRuntime('mongodb://nodb/', dummyOptions, { nodb: true });
+  describe('interrupt', function () {
+    it('should interrupt in-flight async tasks', async function () {
+      runtime = new WorkerRuntime('mongodb://nodb/', dummyOptions, {
+        nodb: true,
+      });
 
       await runtime.waitForRuntimeToBeReady();
 
@@ -249,13 +286,13 @@ describe('WorkerRuntime', () => {
       try {
         await Promise.all([
           runtime.evaluate('sleep(1000000)'),
-          (async() => {
+          (async () => {
             // This is flaky when not enought time given to the worker to
             // finish the sync part of the work. If it causes too much issues
             // it would be okay to disable this test completely
             await sleep(5000);
             await runtime.interrupt();
-          })()
+          })(),
         ]);
       } catch (e: any) {
         err = e;
@@ -267,8 +304,10 @@ describe('WorkerRuntime', () => {
         .match(/Async script execution was interrupted/);
     });
 
-    it('should interrupt in-flight synchronous tasks', async() => {
-      runtime = new WorkerRuntime('mongodb://nodb/', dummyOptions, { nodb: true });
+    it('should interrupt in-flight synchronous tasks', async function () {
+      runtime = new WorkerRuntime('mongodb://nodb/', dummyOptions, {
+        nodb: true,
+      });
 
       await runtime.waitForRuntimeToBeReady();
 
@@ -277,10 +316,10 @@ describe('WorkerRuntime', () => {
       try {
         await Promise.all([
           runtime.evaluate('while(true){}'),
-          (async() => {
+          (async () => {
             await sleep(200);
             await runtime.interrupt();
-          })()
+          })(),
         ]);
       } catch (e: any) {
         err = e;
@@ -292,18 +331,20 @@ describe('WorkerRuntime', () => {
         .match(/Script execution was interrupted/);
     });
 
-    it('should allow to evaluate again after interruption', async() => {
-      runtime = new WorkerRuntime('mongodb://nodb/', dummyOptions, { nodb: true });
+    it('should allow to evaluate again after interruption', async function () {
+      runtime = new WorkerRuntime('mongodb://nodb/', dummyOptions, {
+        nodb: true,
+      });
 
       await runtime.waitForRuntimeToBeReady();
 
       try {
         await Promise.all([
           runtime.evaluate('while(true){}'),
-          (async() => {
+          (async () => {
             await sleep(200);
             await runtime.interrupt();
-          })()
+          })(),
         ]);
       } catch (e: any) {
         // ignore

package/src/index.ts

@@ -1,24 +1,31 @@
 /* istanbul ignore file */
 /* ^^^ we test the dist directly, so isntanbul can't calculate the coverage correctly */
 
-import { ChildProcess, spawn, SpawnOptionsWithoutStdio } from 'child_process';
-import {
+import type { ChildProcess, SpawnOptionsWithoutStdio } from 'child_process';
+import { spawn } from 'child_process';
+import type {
   Runtime,
   RuntimeEvaluationListener,
-  RuntimeEvaluationResult
+  RuntimeEvaluationResult,
 } from '@mongosh/browser-runtime-core';
 import type { MongoshBus } from '@mongosh/types';
 import path from 'path';
 import { EventEmitter, once } from 'events';
 import { kill } from './spawn-child-from-source';
-import { Caller, createCaller, cancel } from './rpc';
+import type { Caller } from './rpc';
+import { createCaller, cancel } from './rpc';
 import { ChildProcessEvaluationListener } from './child-process-evaluation-listener';
 import type { WorkerRuntime as WorkerThreadWorkerRuntime } from './worker-runtime';
-import { deserializeEvaluationResult, serializeConnectOptions } from './serializer';
+import {
+  deserializeEvaluationResult,
+  serializeConnectOptions,
+} from './serializer';
 import { ChildProcessMongoshBus } from './child-process-mongosh-bus';
 import type { CompassServiceProvider } from '@mongosh/service-provider-server';
 
-type DevtoolsConnectOptions = Parameters<(typeof CompassServiceProvider)['connect']>[1];
+type DevtoolsConnectOptions = Parameters<
+  (typeof CompassServiceProvider)['connect']
+>[1];
 type ChildProcessRuntime = Caller<WorkerThreadWorkerRuntime>;
 
 function parseStderrToError(str: string): Error | null {
@@ -93,11 +100,11 @@ class WorkerRuntime implements Runtime {
       [this.childProcessProxySrcPath],
       {
         stdio: ['inherit', 'inherit', 'pipe', 'ipc'],
-        ...spawnOptions
+        ...spawnOptions,
       }
     );
 
-    const waitForReadyMessage = async() => {
+    const waitForReadyMessage = async () => {
       let msg: string;
       while (([msg] = await once(this.childProcess, 'message'))) {
         if (msg === 'ready') return;
@@ -106,12 +113,11 @@ class WorkerRuntime implements Runtime {
 
     let spawnError = '';
 
-    // eslint-disable-next-line chai-friendly/no-unused-expressions
     this.childProcess?.stderr?.setEncoding('utf8')?.on('data', (chunk) => {
       spawnError += chunk;
     });
 
-    const waitForError = async() => {
+    const waitForError = async () => {
       const [exitCode] = await once(this.childProcess, 'exit');
 
       if (exitCode) {
@@ -121,7 +127,9 @@ class WorkerRuntime implements Runtime {
           error.message = `Child process failed to start with the following error: ${error.message}`;
         } else {
           error = new Error(
-            `Worker runtime failed to start: child process exited with code ${exitCode}`
+            `Worker runtime failed to start: child process exited with code ${
+              exitCode as number | string
+            }`
           );
         }
 
@@ -144,7 +152,7 @@ class WorkerRuntime implements Runtime {
         'getCompletions',
         'setEvaluationListener',
         'getShellPrompt',
-        'interrupt'
+        'interrupt',
       ],
       this.childProcess
     );
@@ -159,7 +167,11 @@ class WorkerRuntime implements Runtime {
       this.childProcess
     );
 
-    await this.childProcessRuntime.init(uri, serializeConnectOptions(driverOptions), cliOptions);
+    await this.childProcessRuntime.init(
+      uri,
+      serializeConnectOptions(driverOptions),
+      cliOptions
+    );
   }
 
   async evaluate(code: string): Promise<RuntimeEvaluationResult> {

package/src/lock.spec.ts

@@ -5,21 +5,21 @@ function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-describe('Lock', () => {
-  it('should allow to create a lock promise that can be resolved programmatically', async() => {
+describe('Lock', function () {
+  it('should allow to create a lock promise that can be resolved programmatically', async function () {
     const lock = new Lock();
     const [token, wasUnlocked] = await Promise.all([
       lock.lock(),
-      (async() => {
+      (async () => {
         await sleep(50);
         return lock.unlock();
-      })()
+      })(),
     ]);
     expect(lock.isUnlockToken(token)).to.equal(true);
     expect(wasUnlocked).to.equal(true);
   });
 
-  it('throws when trying to create locks when locked', () => {
+  it('throws when trying to create locks when locked', function () {
     const lock = new Lock();
 
     // eslint-disable-next-line @typescript-eslint/no-floating-promises
@@ -42,15 +42,15 @@ describe('Lock', () => {
       .match(/Can't create another lock while locked/);
   });
 
-  describe('unlock', () => {
-    it('should return false if lock is not locked', () => {
+  describe('unlock', function () {
+    it('should return false if lock is not locked', function () {
       const lock = new Lock();
       expect(lock.unlock()).to.equal(false);
     });
   });
 
-  describe('isLocked', () => {
-    it('shoult return current lock status', () => {
+  describe('isLocked', function () {
+    it('shoult return current lock status', function () {
       const lock = new Lock();
       expect(lock.isLocked()).to.equal(false);
       // eslint-disable-next-line @typescript-eslint/no-floating-promises

package/src/lock.ts

@@ -9,7 +9,7 @@ export class Lock {
 
   lock(): Promise<UNLOCKED> {
     if (this.isLocked()) {
-      throw new Error('Can\'t create another lock while locked');
+      throw new Error("Can't create another lock while locked");
     }
 
     this.promise = new Promise((resolve) => {