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

package/src/serializer.ts

@@ -1,6 +1,6 @@
 import { inspect } from 'util';
 import { EJSON } from 'bson';
-import { RuntimeEvaluationResult } from '@mongosh/browser-runtime-core';
+import type { RuntimeEvaluationResult } from '@mongosh/browser-runtime-core';
 import type { DevtoolsConnectOptions } from '@mongosh/service-provider-server';
 
 function isPrimitive(
@@ -44,13 +44,13 @@ export function deserializeError(err: any): Error {
 export enum SerializedResultTypes {
   SerializedErrorResult = 'SerializedErrorResult',
   InspectResult = 'InspectResult',
-  SerializedShellApiResult = 'SerializedShellApiResult'
+  SerializedShellApiResult = 'SerializedShellApiResult',
 }
 
 export function serializeEvaluationResult({
   type,
   printable,
-  source
+  source,
 }: RuntimeEvaluationResult): RuntimeEvaluationResult {
   // Primitive values don't require any special treatment for serialization
   if (isPrimitive(printable)) {
@@ -62,7 +62,7 @@ export function serializeEvaluationResult({
     return {
       type: SerializedResultTypes.SerializedErrorResult,
       printable: serializeError(printable),
-      source
+      source,
     };
   }
 
@@ -76,7 +76,7 @@ export function serializeEvaluationResult({
     return {
       type: SerializedResultTypes.InspectResult,
       printable: inspect(printable),
-      source
+      source,
     };
   }
 
@@ -87,15 +87,15 @@ export function serializeEvaluationResult({
     type: SerializedResultTypes.SerializedShellApiResult,
     printable: {
       origType: type,
-      serializedValue: EJSON.serialize(printable)
-    }
+      serializedValue: EJSON.serialize(printable),
+    },
   };
 }
 
 export function deserializeEvaluationResult({
   type,
   printable,
-  source
+  source,
 }: RuntimeEvaluationResult): RuntimeEvaluationResult {
   if (type === SerializedResultTypes.SerializedErrorResult) {
     return { type, printable: deserializeError(printable), source };
@@ -105,38 +105,45 @@ export function deserializeEvaluationResult({
     return {
       type: printable.origType,
       printable: EJSON.deserialize(printable.serializedValue),
-      source
+      source,
     };
   }
 
   return { type, printable, source };
 }
 
-const autoEncryptionBSONOptions = [
-  'schemaMap',
-  'encryptedFieldsMap'
-] as const;
+const autoEncryptionBSONOptions = ['schemaMap', 'encryptedFieldsMap'] as const;
 
-export function serializeConnectOptions(options: Readonly<DevtoolsConnectOptions>): DevtoolsConnectOptions {
+export function serializeConnectOptions(
+  options: Readonly<DevtoolsConnectOptions>
+): DevtoolsConnectOptions {
   const serializedOptions = { ...options };
   for (const autoEncryptionOption of autoEncryptionBSONOptions) {
     if (serializedOptions.autoEncryption?.[autoEncryptionOption]) {
       serializedOptions.autoEncryption = {
         ...serializedOptions.autoEncryption,
-        [autoEncryptionOption]: EJSON.serialize(serializedOptions.autoEncryption[autoEncryptionOption], { relaxed: false })
+        [autoEncryptionOption]: EJSON.serialize(
+          serializedOptions.autoEncryption[autoEncryptionOption],
+          { relaxed: false }
+        ),
       };
     }
   }
   return serializedOptions;
 }
 
-export function deserializeConnectOptions(options: Readonly<DevtoolsConnectOptions>): DevtoolsConnectOptions {
+export function deserializeConnectOptions(
+  options: Readonly<DevtoolsConnectOptions>
+): DevtoolsConnectOptions {
   const deserializedOptions: any = { ...options };
   for (const autoEncryptionOption of autoEncryptionBSONOptions) {
     if (deserializedOptions.autoEncryption?.[autoEncryptionOption]) {
       deserializedOptions.autoEncryption = {
         ...deserializedOptions.autoEncryption,
-        [autoEncryptionOption]: EJSON.deserialize(deserializedOptions.autoEncryption[autoEncryptionOption], { relaxed: false })
+        [autoEncryptionOption]: EJSON.deserialize(
+          deserializedOptions.autoEncryption[autoEncryptionOption],
+          { relaxed: false }
+        ),
       };
     }
   }

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

@@ -1,19 +1,20 @@
 import { expect } from 'chai';
-import childProcess, { ChildProcess } from 'child_process';
+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', () => {
+describe('spawnChildFromSource', function () {
   let spawned: ChildProcess;
 
-  afterEach(async() => {
+  afterEach(async function () {
     if (spawned) {
       await kill(spawned, 'SIGKILL');
       spawned = null;
     }
   });
 
-  it('should throw if stdin is missing', async() => {
+  it('should throw if stdin is missing', async function () {
     let err: Error;
 
     try {
@@ -21,7 +22,7 @@ describe('spawnChildFromSource', () => {
         // Making istanbul happy by passing stuff that's not allowed
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-expect-error
-        stdio: 'ignore'
+        stdio: 'ignore',
       });
     } catch (e: any) {
       err = e;
@@ -33,12 +34,12 @@ describe('spawnChildFromSource', () => {
       .match(/missing stdin/);
   });
 
-  it('should resolve with a child process', async() => {
+  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() => {
+  it('should spawn a process with an ipc channel open', async function () {
     spawned = await spawnChildFromSource(
       'process.on("message", (data) => process.send(data))'
     );
@@ -47,7 +48,7 @@ describe('spawnChildFromSource', () => {
     expect(message).to.equal('Hi!');
   });
 
-  it('should fail if process exited before successfully starting', async() => {
+  it('should fail if process exited before successfully starting', async function () {
     let err: Error;
 
     try {
@@ -68,7 +69,7 @@ describe('spawnChildFromSource', () => {
     );
   });
 
-  it('should fail if a timeout exceeded before the process is "ready"', async() => {
+  it('should fail if a timeout exceeded before the process is "ready"', async function () {
     let err: Error;
 
     try {

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

@@ -1,11 +1,11 @@
-import {
+import type {
   ChildProcess,
   Serializable,
-  spawn,
   SpawnOptions,
   StdioNull,
-  StdioPipe
+  StdioPipe,
 } from 'child_process';
+import { spawn } from 'child_process';
 import { once } from 'events';
 
 export async function kill(
@@ -25,12 +25,12 @@ export default function spawnChildFromSource(
   _stdout: StdioNull | StdioPipe = 'inherit',
   _stderr: StdioNull | StdioPipe = 'inherit'
 ): Promise<ChildProcess> {
-  return new Promise(async(resolve, reject) => {
+  return new Promise(async (resolve, reject) => {
     const readyToken = Date.now().toString(32);
 
     const childProcess = spawn(process.execPath, {
       stdio: ['pipe', _stdout, _stderr, 'ipc'],
-      ...spawnOptions
+      ...spawnOptions,
     });
 
     if (!childProcess.stdin) {