@mongosh/node-runtime-worker-thread 2.3.0 → 2.3.2

package/src/child-process-proxy.ts

@@ -1,124 +0,0 @@
-/* istanbul ignore file */
-/* ^^^ we test the dist directly, so isntanbul can't calculate the coverage correctly */
-
-/**
- * This proxy is needed as a workaround for the old electron verison "bug" where
- * due to the electron runtime being a chromium, not just node (even with
- * `ELECTRON_RUN_AS_NODE` enabled), SIGINT doesn't break code execution. This is
- * fixed in the later versions of electron/node but we are still on the older
- * one, we have to have this proxy in place
- *
- * @todo as soon as we update electron version in compass, we can get rid of
- * this part of the worker runtime as it becomes redundant
- *
- * @see {@link https://github.com/nodejs/node/pull/36344}
- */
-import { once } from 'events';
-import { SHARE_ENV, Worker } from 'worker_threads';
-import path from 'path';
-import { exposeAll, createCaller } from './rpc';
-import type { InterruptHandle } from 'interruptor';
-import { interrupt as nativeInterrupt } from 'interruptor';
-
-const workerRuntimeSrcPath =
-  process.env.WORKER_RUNTIME_SRC_PATH_DO_NOT_USE_THIS_EXCEPT_FOR_TESTING ||
-  path.resolve(__dirname, 'worker-runtime.js');
-
-const workerProcess = new Worker(workerRuntimeSrcPath, { env: SHARE_ENV });
-
-const workerReadyPromise: Promise<void> = (async () => {
-  const waitForReadyMessage = async () => {
-    let msg: string;
-    while (([msg] = await once(workerProcess, 'message'))) {
-      if (msg === 'ready') return;
-    }
-  };
-
-  const waitForError = async () => {
-    const [err] = await once(workerProcess, 'error');
-    if (err) {
-      err.message = `Worker thread failed to start with the following error: ${err.message}`;
-      throw err;
-    }
-  };
-
-  await Promise.race([waitForReadyMessage(), waitForError()]);
-})();
-
-// We expect the amount of listeners to be more than the default value of 10 but
-// probably not more than ~25 (all exposed methods on
-// ChildProcessEvaluationListener and ChildProcessMongoshBus + any concurrent
-// in-flight calls on ChildProcessRuntime) at once
-process.setMaxListeners(25);
-workerProcess.setMaxListeners(25);
-
-let interruptHandle: InterruptHandle | null = null;
-
-const { interrupt } = createCaller(['interrupt'], workerProcess);
-
-const worker = Object.assign(
-  createCaller(
-    ['init', 'evaluate', 'getCompletions', 'getShellPrompt'],
-    workerProcess
-  ),
-  {
-    interrupt(): boolean {
-      if (interruptHandle) {
-        nativeInterrupt(interruptHandle);
-        return true;
-      }
-
-      return interrupt();
-    },
-  }
-);
-
-function waitForWorkerReadyProxy<T extends Function>(fn: T): T {
-  return new Proxy(fn, {
-    async apply(target, thisArg, argumentsList) {
-      await workerReadyPromise;
-      return target.call(thisArg, ...Array.from(argumentsList));
-    },
-  });
-}
-
-// Every time parent process wants to request something from worker through
-// proxy, we want to make sure worker process is ready
-(Object.keys(worker) as (keyof typeof worker)[]).forEach((key) => {
-  worker[key] = waitForWorkerReadyProxy(worker[key]);
-});
-
-exposeAll(worker, process);
-
-const evaluationListener = Object.assign(
-  createCaller(
-    [
-      'onPrint',
-      'onPrompt',
-      'getConfig',
-      'setConfig',
-      'resetConfig',
-      'validateConfig',
-      'listConfigOptions',
-      'onClearCommand',
-      'onExit',
-    ],
-    process
-  ),
-  {
-    onRunInterruptible(handle: InterruptHandle | null) {
-      interruptHandle = handle;
-    },
-  }
-);
-
-exposeAll(evaluationListener, workerProcess);
-
-const messageBus = createCaller(['emit', 'on'], process);
-
-exposeAll(messageBus, workerProcess);
-
-process.once('disconnect', () => process.exit());
-process.nextTick(() => {
-  process.send?.('ready');
-});

package/src/spawn-child-from-source.spec.ts

@@ -1,90 +0,0 @@
-import { expect } from 'chai';
-import type { ChildProcess } from 'child_process';
-import childProcess from 'child_process';
-import { once } from 'events';
-import spawnChildFromSource, { kill } from './spawn-child-from-source';
-
-describe('spawnChildFromSource', function () {
-  let spawned: ChildProcess;
-
-  afterEach(async function () {
-    if (spawned) {
-      await kill(spawned, 'SIGKILL');
-      spawned = null;
-    }
-  });
-
-  it('should throw if stdin is missing', async function () {
-    let err: Error;
-
-    try {
-      spawned = await spawnChildFromSource('console.log("Hi")', {
-        // Making istanbul happy by passing stuff that's not allowed
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-expect-error
-        stdio: 'ignore',
-      });
-    } catch (e: any) {
-      err = e;
-    }
-
-    expect(err).to.be.instanceof(Error);
-    expect(err)
-      .to.have.property('message')
-      .match(/missing stdin/);
-  });
-
-  it('should resolve with a child process', async function () {
-    spawned = await spawnChildFromSource('');
-    expect(spawned).to.be.instanceof((childProcess as any).ChildProcess);
-  });
-
-  it('should spawn a process with an ipc channel open', async function () {
-    spawned = await spawnChildFromSource(
-      'process.on("message", (data) => process.send(data))'
-    );
-    spawned.send('Hi!');
-    const [message] = await once(spawned, 'message');
-    expect(message).to.equal('Hi!');
-  });
-
-  it('should fail if process exited before successfully starting', async function () {
-    let err: Error;
-
-    try {
-      spawned = await spawnChildFromSource(
-        'throw new Error("Whoops!")',
-        {},
-        undefined,
-        'ignore',
-        'ignore'
-      );
-    } catch (e: any) {
-      err = e;
-    }
-
-    expect(err).to.be.instanceof(Error);
-    expect(err.message).to.match(
-      /Child process exited with error before starting/
-    );
-  });
-
-  it('should fail if a timeout exceeded before the process is "ready"', async function () {
-    let err: Error;
-
-    try {
-      spawned = await spawnChildFromSource(
-        'let i = 0; while(++i < 10000000000){};',
-        {},
-        10
-      );
-    } catch (e: any) {
-      err = e;
-    }
-
-    expect(err).to.be.instanceof(Error);
-    expect(err.message).to.match(
-      /Timed out while waiting for child process to start/
-    );
-  });
-});

package/src/spawn-child-from-source.ts

@@ -1,102 +0,0 @@
-import type {
-  ChildProcess,
-  Serializable,
-  SpawnOptions,
-  StdioNull,
-  StdioPipe,
-} from 'child_process';
-import { spawn } from 'child_process';
-import { once } from 'events';
-
-export async function kill(
-  childProcess: ChildProcess,
-  code: NodeJS.Signals | number = 'SIGTERM'
-) {
-  childProcess.kill(code);
-  if (childProcess.exitCode === null && childProcess.signalCode === null) {
-    await once(childProcess, 'exit');
-  }
-}
-
-export default function spawnChildFromSource(
-  src: string,
-  spawnOptions: Omit<SpawnOptions, 'stdio'> = {},
-  timeoutMs?: number,
-  _stdout: StdioNull | StdioPipe = 'inherit',
-  _stderr: StdioNull | StdioPipe = 'inherit'
-): Promise<ChildProcess> {
-  return new Promise((resolve, reject) => {
-    const readyToken = Date.now().toString(32);
-
-    const childProcess = spawn(process.execPath, {
-      stdio: ['pipe', _stdout, _stderr, 'ipc'],
-      ...spawnOptions,
-    });
-
-    if (!childProcess.stdin) {
-      kill(childProcess)
-        .then(() => {
-          reject(
-            new Error("Can't write src to the spawned process, missing stdin")
-          );
-        })
-        .catch((err: any) => {
-          reject(err);
-        });
-      return;
-    }
-
-    // eslint-disable-next-line prefer-const
-    let timeoutId: NodeJS.Timeout | null;
-
-    function cleanupListeners() {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-      if (childProcess.stdin) {
-        childProcess.stdin.off('error', onWriteError);
-      }
-      childProcess.off('message', onMessage);
-      childProcess.off('exit', onExit);
-    }
-
-    function onExit(exitCode: number | null) {
-      if (exitCode && exitCode > 0) {
-        cleanupListeners();
-        reject(new Error('Child process exited with error before starting'));
-      }
-    }
-
-    /* really hard to reproduce in tests and coverage is not happy */
-    /* istanbul ignore next */
-    async function onWriteError(error: Error) {
-      cleanupListeners();
-      await kill(childProcess);
-      reject(error);
-    }
-
-    async function onTimeout() {
-      cleanupListeners();
-      await kill(childProcess);
-      reject(new Error('Timed out while waiting for child process to start'));
-    }
-
-    function onMessage(data: Serializable) {
-      if (data === readyToken) {
-        cleanupListeners();
-        resolve(childProcess);
-      }
-    }
-
-    childProcess.on('message', onMessage);
-    childProcess.on('exit', onExit);
-    childProcess.stdin.on('error', onWriteError);
-
-    childProcess.stdin.write(src);
-    childProcess.stdin.write(`;process.send(${JSON.stringify(readyToken)})`);
-    childProcess.stdin.end();
-
-    timeoutId =
-      timeoutMs !== undefined ? setTimeout(onTimeout, timeoutMs) : null;
-  });
-}

package/tsconfig.test.json

@@ -1,11 +0,0 @@
-{
-  "extends": "@mongodb-js/tsconfig-mongosh/tsconfig.test.json",
-  "ts-node": {
-    "files": true
-  },
-  "compilerOptions": {
-    "outDir": "./lib",
-    "allowJs": false
-  },
-  "files": ["./src/index.d.ts"]
-}