@mongosh/node-runtime-worker-thread 1.6.0 → 1.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mongosh/node-runtime-worker-thread",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "MongoDB shell runtime that lives in a worker thread",
   "homepage": "https://github.com/mongodb-js/mongosh",
   "license": "Apache-2.0",
@@ -28,22 +28,18 @@
     "prepublish": "npm run webpack-build"
   },
   "devDependencies": {
-    "@mongosh/browser-runtime-core": "1.6.0",
-    "@mongosh/browser-runtime-electron": "1.6.0",
-    "@mongosh/service-provider-core": "1.6.0",
-    "@mongosh/service-provider-server": "1.6.0",
-    "@mongosh/types": "1.6.0",
-    "bson": "^4.7.0",
+    "@mongosh/browser-runtime-core": "1.6.2",
+    "@mongosh/browser-runtime-electron": "1.6.2",
+    "@mongosh/service-provider-core": "1.6.2",
+    "@mongosh/service-provider-server": "1.6.2",
+    "@mongosh/types": "1.6.2",
+    "bson": "^4.7.1",
     "mocha": "^7.1.2",
-    "postmsg-rpc": "^2.4.0",
-    "terser-webpack-plugin": "^4.2.3",
-    "ts-loader": "^8.0.14",
-    "webpack": "^4.44.2",
-    "webpack-cli": "^4.3.1"
+    "postmsg-rpc": "^2.4.0"
   },
   "dependencies": {
     "interruptor": "^1.0.1",
     "system-ca": "^1.0.2"
   },
-  "gitHead": "fbbf54a08fb315ae5fde693a98d439b9aa3285f8"
+  "gitHead": "a825d141aa5f25d90d915c9048e9c5277027ae9e"
 }

package/src/child-process-proxy.spec.ts

@@ -1,8 +1,10 @@
 import path from 'path';
-import { ChildProcess, fork } from 'child_process';
+import { ChildProcess, fork, spawn } from 'child_process';
 import { Caller, cancel, createCaller } from './rpc';
 import { expect } from 'chai';
 import { WorkerRuntime } from './worker-runtime';
+import { once } from 'events';
+import { promisify } from 'util';
 
 const childProcessModulePath = path.resolve(
   __dirname,
@@ -22,7 +24,7 @@ describe('child process worker proxy', () => {
     }
 
     if (childProcess) {
-      childProcess.kill('SIGTERM');
+      childProcess.disconnect();
       childProcess = null;
     }
   });
@@ -34,4 +36,38 @@ describe('child process worker proxy', () => {
     const result = await caller.evaluate('1 + 1');
     expect(result.printable).to.equal(2);
   });
+
+  it('should exit on its own when the parent process disconnects', async() => {
+    const intermediateProcess = spawn(process.execPath,
+      ['-e', `require("child_process")
+         .fork(${JSON.stringify(childProcessModulePath)})
+         .on("message", function(m) { console.log("message " + m + " from " + this.pid) })`],
+      { stdio: ['pipe', 'pipe', 'inherit'] });
+
+    // Make sure the outer child process runs and has created the inner child process
+    const [message] = await once(intermediateProcess.stdout.setEncoding('utf8'), 'data');
+    const match = message.trim().match(/^message ready from (?<pid>\d+)$/);
+    expect(match).to.not.equal(null);
+
+    // Make sure the inner child process runs
+    const childPid = +match.groups.pid;
+    process.kill(childPid, 0);
+
+    // Kill the intermediate process and wait for the inner child process to also close
+    intermediateProcess.kill('SIGTERM');
+    let innerChildHasStoppedRunning = false;
+    for (let i = 0; i < 200; i++) {
+      try {
+        process.kill(childPid, 0);
+      } catch (err) {
+        if (err.code === 'ESRCH') {
+          innerChildHasStoppedRunning = true;
+          break;
+        }
+        throw err;
+      }
+      await promisify(setTimeout)(10);
+    }
+    expect(innerChildHasStoppedRunning).to.equal(true);
+  });
 });

package/src/child-process-proxy.ts

@@ -114,6 +114,7 @@ const messageBus = createCaller(['emit', 'on'], process);
 
 exposeAll(messageBus, workerProcess);
 
+process.once('disconnect', () => process.exit());
 process.nextTick(() => {
   // eslint-disable-next-line chai-friendly/no-unused-expressions
   process.send?.('ready');

package/webpack.config.js

@@ -1,43 +1,17 @@
+'use strict';
+const { merge } = require('webpack-merge');
 const path = require('path');
-const TerserPlugin = require('terser-webpack-plugin');
+
+const baseWebpackConfig = require('../../config/webpack.base.config');
 
 /** @type import('webpack').Configuration */
 const config = {
-  target: 'node',
-
   output: {
     path: path.resolve(__dirname, 'dist'),
     filename: '[name].js',
     libraryTarget: 'umd'
   },
 
-  module: {
-    rules: [
-      {
-        test: /\.ts$/,
-        use: [{ loader: 'ts-loader' }],
-        exclude: [/node_modules/]
-      }
-    ]
-  },
-
-  resolve: {
-    extensions: ['.ts', '.js']
-  },
-
-  optimization: {
-    minimizer: [
-      new TerserPlugin({
-        terserOptions: {
-          // Not keeping classnames breaks shell-api during minification
-          keep_classnames: true
-        }
-      })
-    ]
-  },
-
-  node: false,
-
   externals: {
     'mongodb-client-encryption': 'commonjs2 mongodb-client-encryption',
     kerberos: 'commonjs2 kerberos',
@@ -51,6 +25,6 @@ const config = {
 module.exports = ['index', 'child-process-proxy', 'worker-runtime'].map(
   (entry) => ({
     entry: { [entry]: path.resolve(__dirname, 'src', `${entry}.ts`) },
-    ...config
+    ...merge(baseWebpackConfig, config)
   })
 );

package/dist/src/child-process-evaluation-listener.d.ts

@@ -1,10 +0,0 @@
-/// <reference types="node" />
-import { ChildProcess } from 'child_process';
-import { Exposed } from './rpc';
-import type { WorkerRuntime } from './index';
-import { RuntimeEvaluationListener } from '@mongosh/browser-runtime-core';
-export declare class ChildProcessEvaluationListener {
-    exposedListener: Exposed<Required<Omit<RuntimeEvaluationListener, 'onLoad' | 'getCryptLibraryOptions'>>>;
-    constructor(workerRuntime: WorkerRuntime, childProcess: ChildProcess);
-    terminate(): void;
-}

package/dist/src/child-process-mongosh-bus.d.ts

@@ -1,9 +0,0 @@
-/// <reference types="node" />
-import { ChildProcess } from 'child_process';
-import { MongoshBus } from '@mongosh/types';
-import { Exposed } from './rpc';
-export declare class ChildProcessMongoshBus {
-    exposedEmitter: Exposed<MongoshBus>;
-    constructor(eventEmitter: MongoshBus, childProcess: ChildProcess);
-    terminate(): void;
-}

package/dist/src/child-process-proxy.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/index.d.ts

@@ -1,29 +0,0 @@
-/// <reference types="node" />
-import { SpawnOptionsWithoutStdio } from 'child_process';
-import { Runtime, RuntimeEvaluationListener, RuntimeEvaluationResult } from '@mongosh/browser-runtime-core';
-import type { MongoshBus } from '@mongosh/types';
-import type { CompassServiceProvider } from '@mongosh/service-provider-server';
-declare type DevtoolsConnectOptions = Parameters<(typeof CompassServiceProvider)['connect']>[1];
-declare class WorkerRuntime implements Runtime {
-    private initOptions;
-    evaluationListener: RuntimeEvaluationListener | null;
-    private eventEmitter;
-    private childProcessMongoshBus;
-    private childProcessEvaluationListener;
-    private childProcess;
-    private childProcessRuntime;
-    private initWorkerPromise;
-    private childProcessProxySrcPath;
-    constructor(uri: string, driverOptions?: DevtoolsConnectOptions, cliOptions?: {
-        nodb?: boolean;
-    }, spawnOptions?: SpawnOptionsWithoutStdio, eventEmitter?: MongoshBus);
-    private initWorker;
-    evaluate(code: string): Promise<RuntimeEvaluationResult>;
-    getCompletions(code: string): Promise<import("@mongosh/browser-runtime-core").Completion[]>;
-    getShellPrompt(): Promise<string>;
-    setEvaluationListener(listener: RuntimeEvaluationListener | null): RuntimeEvaluationListener | null;
-    terminate(): Promise<void>;
-    interrupt(): Promise<boolean>;
-    waitForRuntimeToBeReady(): Promise<void>;
-}
-export { WorkerRuntime };

package/dist/src/lock.d.ts

@@ -1,10 +0,0 @@
-export declare type UNLOCKED = 'UNLOCKED';
-export declare class Lock {
-    private static UNLOCK_TOKEN;
-    private promise;
-    private resolve;
-    lock(): Promise<UNLOCKED>;
-    unlock(): boolean;
-    isLocked(): boolean;
-    isUnlockToken(resolvedValue: any): resolvedValue is UNLOCKED;
-}

package/dist/src/rpc.d.ts

@@ -1,28 +0,0 @@
-export declare function serialize(data: unknown): string;
-export declare function deserialize<T = unknown>(str: string): T | string;
-declare type RPCMessageBus = {
-    on: Function;
-    off: Function;
-} & ({
-    postMessage: Function;
-    send?: never;
-} | {
-    postMessage?: never;
-    send?: Function;
-});
-export declare function removeTrailingUndefined(arr: unknown[]): unknown[];
-export declare const close: unique symbol;
-export declare const cancel: unique symbol;
-export declare type Exposed<T> = {
-    [k in keyof T]: T[k] & {
-        close(): void;
-    };
-} & {
-    [close]: () => void;
-};
-export declare function exposeAll<O>(obj: O, messageBus: RPCMessageBus): Exposed<O>;
-export declare type Caller<Impl, Keys extends keyof Impl = keyof Impl> = CancelableMethods<Pick<Impl, Keys>> & {
-    [cancel]: () => void;
-};
-export declare function createCaller<Impl extends {}>(methodNames: Extract<keyof Impl, string>[], messageBus: RPCMessageBus, processors?: Partial<Record<typeof methodNames[number], (...input: any[]) => any[]>>): Caller<Impl, typeof methodNames[number]>;
-export {};

package/dist/src/serializer.d.ts

@@ -1,13 +0,0 @@
-import { RuntimeEvaluationResult } from '@mongosh/browser-runtime-core';
-import type { DevtoolsConnectOptions } from '@mongosh/service-provider-server/lib/cli-service-provider';
-export declare function serializeError(err: Error): Error;
-export declare function deserializeError(err: any): Error;
-export declare enum SerializedResultTypes {
-    SerializedErrorResult = "SerializedErrorResult",
-    InspectResult = "InspectResult",
-    SerializedShellApiResult = "SerializedShellApiResult"
-}
-export declare function serializeEvaluationResult({ type, printable, source }: RuntimeEvaluationResult): RuntimeEvaluationResult;
-export declare function deserializeEvaluationResult({ type, printable, source }: RuntimeEvaluationResult): RuntimeEvaluationResult;
-export declare function serializeConnectOptions(options?: Readonly<DevtoolsConnectOptions>): DevtoolsConnectOptions;
-export declare function deserializeConnectOptions(options: Readonly<DevtoolsConnectOptions>): DevtoolsConnectOptions;

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

@@ -1,4 +0,0 @@
-/// <reference types="node" />
-import { ChildProcess, SpawnOptions, StdioNull, StdioPipe } from 'child_process';
-export declare function kill(childProcess: ChildProcess, code?: NodeJS.Signals | number): Promise<void>;
-export default function spawnChildFromSource(src: string, spawnOptions?: Omit<SpawnOptions, 'stdio'>, timeoutMs?: number, _stdout?: StdioNull | StdioPipe, _stderr?: StdioNull | StdioPipe): Promise<ChildProcess>;

package/dist/src/worker-runtime.d.ts

@@ -1,14 +0,0 @@
-import { Runtime, RuntimeEvaluationListener } from '@mongosh/browser-runtime-core';
-import { CompassServiceProvider } from '@mongosh/service-provider-server';
-import { InterruptHandle } from 'interruptor';
-declare type DevtoolsConnectOptions = Parameters<(typeof CompassServiceProvider)['connect']>[1];
-export declare type WorkerRuntimeEvaluationListener = RuntimeEvaluationListener & {
-    onRunInterruptible(handle: InterruptHandle | null): void;
-};
-export declare type WorkerRuntime = Runtime & {
-    init(uri: string, driverOptions?: DevtoolsConnectOptions, cliOptions?: {
-        nodb?: boolean;
-    }): Promise<void>;
-    interrupt(): boolean;
-};
-export {};