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

package/src/rpc.spec.ts

@@ -1,16 +1,15 @@
 import { expect } from 'chai';
 import { EventEmitter } from 'events';
 
+import type { Caller, Exposed } from './rpc';
 import {
   createCaller,
   exposeAll,
   close,
   cancel,
-  Caller,
-  Exposed,
   serialize,
   deserialize,
-  removeTrailingUndefined
+  removeTrailingUndefined,
 } from './rpc';
 
 function createMockRpcMesageBus() {
@@ -26,25 +25,25 @@ function sleep(ms: number) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-describe('rpc helpers', () => {
-  describe('serialize', () => {
-    it('returns base64 representation of an input', () => {
+describe('rpc helpers', function () {
+  describe('serialize', function () {
+    it('returns base64 representation of an input', function () {
       expect(serialize('Hello')).to.equal('data:;base64,/w0iBUhlbGxv');
     });
   });
 
-  describe('deserialize', () => {
-    it("converts base64 representation of input back to it's original form", () => {
+  describe('deserialize', function () {
+    it("converts base64 representation of input back to it's original form", function () {
       expect(deserialize(serialize('Hello'))).to.equal('Hello');
     });
 
-    it("returns original string if it's not a base64 data uri", () => {
+    it("returns original string if it's not a base64 data uri", function () {
       expect(deserialize('Hi')).to.equal('Hi');
     });
   });
 
-  describe('removeTrailingUndefined', () => {
-    it('removes trailing undefineds from an array', () => {
+  describe('removeTrailingUndefined', function () {
+    it('removes trailing undefineds from an array', function () {
       expect(
         removeTrailingUndefined([1, 2, 3, undefined, undefined, undefined])
       ).to.deep.equal([1, 2, 3]);
@@ -52,7 +51,7 @@ describe('rpc helpers', () => {
   });
 });
 
-describe('rpc', () => {
+describe('rpc', function () {
   let messageBus: EventEmitter;
   let caller: Caller<{
     meow(...args: any[]): string;
@@ -64,7 +63,7 @@ describe('rpc', () => {
   }>;
   let exposed: Exposed<unknown>;
 
-  afterEach(() => {
+  afterEach(function () {
     if (messageBus) {
       messageBus.removeAllListeners();
       messageBus = null;
@@ -81,7 +80,7 @@ describe('rpc', () => {
     }
   });
 
-  it('exposes functions and allows to call them', async() => {
+  it('exposes functions and allows to call them', async function () {
     messageBus = createMockRpcMesageBus();
     caller = createCaller(['meow'], messageBus);
 
@@ -89,7 +88,7 @@ describe('rpc', () => {
       {
         meow() {
           return 'Meow meow meow!';
-        }
+        },
       },
       messageBus
     );
@@ -97,7 +96,7 @@ describe('rpc', () => {
     expect(await caller.meow()).to.equal('Meow meow meow!');
   });
 
-  it('serializes and de-serializes errors when thrown', async() => {
+  it('serializes and de-serializes errors when thrown', async function () {
     messageBus = createMockRpcMesageBus();
     caller = createCaller(['throws'], messageBus);
 
@@ -105,7 +104,7 @@ describe('rpc', () => {
       {
         throws() {
           throw new TypeError('Uh-oh, error!');
-        }
+        },
       },
       messageBus
     );
@@ -127,7 +126,7 @@ describe('rpc', () => {
       .match(/TypeError: Uh-oh, error!\r?\n\s+at throws/);
   });
 
-  it('throws on client if arguments are not serializable', async() => {
+  it('throws on client if arguments are not serializable', async function () {
     messageBus = createMockRpcMesageBus();
     caller = createCaller(['callMe'], messageBus);
 
@@ -135,7 +134,7 @@ describe('rpc', () => {
       {
         callMe(fn: any) {
           fn(1, 2);
-        }
+        },
       },
       messageBus
     );
@@ -154,7 +153,7 @@ describe('rpc', () => {
       .match(/could not be cloned/);
   });
 
-  it('throws on client if retured value from the server is not serializable', async() => {
+  it('throws on client if retured value from the server is not serializable', async function () {
     messageBus = createMockRpcMesageBus();
     caller = createCaller(['returnsFunction'], messageBus);
 
@@ -162,7 +161,7 @@ describe('rpc', () => {
       {
         returnsFunction() {
           return () => {};
-        }
+        },
       },
       messageBus
     );
@@ -181,15 +180,15 @@ describe('rpc', () => {
       .match(/could not be cloned/);
   });
 
-  describe('createCaller', () => {
-    it('creates a caller with provided method names', () => {
+  describe('createCaller', function () {
+    it('creates a caller with provided method names', function () {
       messageBus = createMockRpcMesageBus();
       caller = createCaller(['meow', 'woof'], messageBus);
       expect(caller).to.have.property('meow');
       expect(caller).to.have.property('woof');
     });
 
-    it('attaches caller listener to provided process', (done) => {
+    it('attaches caller listener to provided process', function (done) {
       messageBus = createMockRpcMesageBus();
       caller = createCaller(['meow'], messageBus);
 
@@ -203,19 +202,19 @@ describe('rpc', () => {
       });
     });
 
-    describe('cancel', () => {
-      it('stops all in-flight evaluations', async() => {
+    describe('cancel', function () {
+      it('stops all in-flight evaluations', async function () {
         messageBus = createMockRpcMesageBus();
         caller = createCaller(['neverResolves'], messageBus);
         let err: Error;
         try {
           await Promise.all([
             caller.neverResolves(),
-            (async() => {
+            (async () => {
               // smol sleep to make sure we actually issued a call
               await sleep(100);
               caller[cancel]();
-            })()
+            })(),
           ]);
         } catch (e: any) {
           err = e;
@@ -226,15 +225,15 @@ describe('rpc', () => {
     });
   });
 
-  describe('exposeAll', () => {
-    it('exposes passed methods on provided process', (done) => {
+  describe('exposeAll', function () {
+    it('exposes passed methods on provided process', function (done) {
       messageBus = createMockRpcMesageBus();
 
       exposed = exposeAll(
         {
           meow() {
             return 'Meow meow meow meow!';
-          }
+          },
         },
         messageBus
       );
@@ -255,12 +254,12 @@ describe('rpc', () => {
       messageBus.emit('message', {
         sender: 'postmsg-rpc/client',
         func: 'meow',
-        id: '123abc'
+        id: '123abc',
       });
     });
 
-    describe('close', () => {
-      it('disables all exposed listeners', () => {
+    describe('close', function () {
+      it('disables all exposed listeners', function () {
         messageBus = createMockRpcMesageBus();
         exposed = exposeAll({ doSomething() {} }, messageBus);
         expect(messageBus.listenerCount('message')).to.equal(1);

package/src/rpc.ts

@@ -5,7 +5,7 @@ import type {
   MessageData,
   PostmsgRpcOptions,
   ServerMessageData,
-  ClientMessageData
+  ClientMessageData,
 } from 'postmsg-rpc';
 
 export function serialize(data: unknown): string {
@@ -28,7 +28,7 @@ type RPCMessageBus = { on: Function; off: Function } & (
 
 enum RPCMessageTypes {
   Message,
-  Error
+  Error,
 }
 
 type RPCMessage = {
@@ -101,7 +101,7 @@ function getRPCOptions(messageBus: RPCMessageBus): PostmsgRpcOptions {
         } catch (e: any) {
           data.res = serialize({
             type: RPCMessageTypes.Error,
-            payload: serializeError(e)
+            payload: serializeError(e),
           });
         }
       }
@@ -122,7 +122,7 @@ function getRPCOptions(messageBus: RPCMessageBus): PostmsgRpcOptions {
       }
 
       return data;
-    }
+    },
   };
 }
 
@@ -135,10 +135,10 @@ export type Exposed<T> = { [k in keyof T]: T[k] & { close(): void } } & {
 };
 
 export function exposeAll<O>(obj: O, messageBus: RPCMessageBus): Exposed<O> {
-  Object.entries(obj).forEach(([key, val]) => {
+  Object.entries(obj as Record<string, any>).forEach(([key, val]) => {
     const { close } = expose(
       key,
-      async(...args: unknown[]) => {
+      async (...args: unknown[]) => {
         try {
           return { type: RPCMessageTypes.Message, payload: await val(...args) };
         } catch (e: any) {
@@ -156,10 +156,12 @@ export function exposeAll<O>(obj: O, messageBus: RPCMessageBus): Exposed<O> {
   Object.defineProperty(obj, close, {
     enumerable: false,
     value() {
-      Object.values(obj).forEach((fn) => {
-        fn.close();
-      });
-    }
+      Object.values(obj as Record<string, { close: () => void }>).forEach(
+        (fn) => {
+          fn.close();
+        }
+      );
+    },
   });
   return obj as Exposed<O>;
 }
@@ -173,14 +175,14 @@ export function createCaller<Impl extends {}>(
   methodNames: Extract<keyof Impl, string>[],
   messageBus: RPCMessageBus,
   processors: Partial<
-    Record<typeof methodNames[number], (...input: any[]) => any[]>
+    Record<(typeof methodNames)[number], (...input: any[]) => any[]>
   > = {}
-): Caller<Impl, typeof methodNames[number]> {
+): Caller<Impl, (typeof methodNames)[number]> {
   const obj = {};
   const inflight = new Set<CancelablePromise<unknown>>();
   methodNames.forEach((name) => {
     const c = caller(name as string, getRPCOptions(messageBus));
-    (obj as any)[name] = async(...args: unknown[]) => {
+    (obj as any)[name] = async (...args: unknown[]) => {
       const processed =
         typeof processors[name] === 'function'
           ? processors[name]?.(...args)
@@ -200,8 +202,7 @@ export function createCaller<Impl extends {}>(
         cancelable.cancel();
         inflight.delete(cancelable);
       }
-    }
+    },
   });
-  return obj as Caller<Impl, typeof methodNames[number]>;
+  return obj as Caller<Impl, (typeof methodNames)[number]>;
 }
-

package/src/serializer.spec.ts

@@ -1,4 +1,4 @@
-import { DevtoolsConnectOptions } from '@mongosh/service-provider-server/lib/cli-service-provider';
+import type { DevtoolsConnectOptions } from '@mongosh/service-provider-server/lib/cli-service-provider';
 import { expect } from 'chai';
 import { UUID, Long } from 'bson';
 import {
@@ -8,13 +8,13 @@ import {
   deserializeEvaluationResult,
   SerializedResultTypes,
   serializeConnectOptions,
-  deserializeConnectOptions
+  deserializeConnectOptions,
 } from './serializer';
 import { dummyOptions } from './index.spec';
 
-describe('serializer', () => {
-  describe('serializeError', () => {
-    it('serializer Error to plain object', () => {
+describe('serializer', function () {
+  describe('serializeError', function () {
+    it('serializer Error to plain object', function () {
       const serialized = serializeError(new TypeError('Uh-oh'));
 
       expect(serialized).to.have.own.property('name', 'TypeError');
@@ -23,8 +23,8 @@ describe('serializer', () => {
     });
   });
 
-  describe('deserializeError', () => {
-    it('creates an instance of an error from plain object', () => {
+  describe('deserializeError', function () {
+    it('creates an instance of an error from plain object', function () {
       const err = deserializeError({ name: 'CustomError', message: 'Error!' });
 
       expect(err).to.be.instanceof(Error);
@@ -33,21 +33,21 @@ describe('serializer', () => {
     });
   });
 
-  describe('serializeEvaluationResult', () => {
-    it('should return primitive values as-is', () => {
+  describe('serializeEvaluationResult', function () {
+    it('should return primitive values as-is', function () {
       const serialized = serializeEvaluationResult({
         type: 'primitive',
-        printable: 123
+        printable: 123,
       });
 
       expect(serialized).to.have.property('type', 'primitive');
       expect(serialized).to.have.property('printable', 123);
     });
 
-    it('should serialize error values', () => {
+    it('should serialize error values', function () {
       const serialized = serializeEvaluationResult({
         type: 'error',
-        printable: new SyntaxError('Ooops!')
+        printable: new SyntaxError('Ooops!'),
       });
 
       expect(serialized).to.have.property(
@@ -62,10 +62,10 @@ describe('serializer', () => {
       expect(serialized).to.have.nested.property('printable.message', 'Ooops!');
     });
 
-    it('should return inspect result for non shell-api result types (type === null)', () => {
+    it('should return inspect result for non shell-api result types (type === null)', function () {
       const serialized = serializeEvaluationResult({
         type: null,
-        printable: function abc() {}
+        printable: function abc() {},
       });
 
       expect(serialized).to.have.property(
@@ -75,10 +75,10 @@ describe('serializer', () => {
       expect(serialized).to.have.property('printable', '[Function: abc]');
     });
 
-    it('should serialize shell-api result type', () => {
+    it('should serialize shell-api result type', function () {
       const serialized = serializeEvaluationResult({
         type: 'TotallyRealShellApiType',
-        printable: { foo: 'bar' }
+        printable: { foo: 'bar' },
       });
 
       expect(serialized).to.have.property(
@@ -92,16 +92,16 @@ describe('serializer', () => {
       expect(serialized)
         .to.have.nested.property('printable.serializedValue')
         .deep.equal({
-          foo: 'bar'
+          foo: 'bar',
         });
     });
   });
 
-  describe('deserializeEvaluationResult', () => {
-    it('should deserialize SerializedErrorResult', () => {
+  describe('deserializeEvaluationResult', function () {
+    it('should deserialize SerializedErrorResult', function () {
       const deserialized = deserializeEvaluationResult({
         type: SerializedResultTypes.SerializedErrorResult,
-        printable: { name: 'TypeError', message: 'Uh-oh' }
+        printable: { name: 'TypeError', message: 'Uh-oh' },
       });
 
       expect(deserialized).to.have.property('printable').be.instanceof(Error);
@@ -115,13 +115,13 @@ describe('serializer', () => {
       );
     });
 
-    it('should deserialize SerializedShellApiResult', () => {
+    it('should deserialize SerializedShellApiResult', function () {
       const deserialized = deserializeEvaluationResult({
         type: SerializedResultTypes.SerializedShellApiResult,
         printable: {
           origType: 'ShellApiResult',
-          serializedValue: { foo: 'bar' }
-        }
+          serializedValue: { foo: 'bar' },
+        },
       });
 
       expect(deserialized).to.have.property('type', 'ShellApiResult');
@@ -130,19 +130,22 @@ describe('serializer', () => {
         .deep.equal({ foo: 'bar' });
     });
 
-    it('should return unknown types as-is', () => {
+    it('should return unknown types as-is', function () {
       const deserialized = deserializeEvaluationResult({
         type: 'SomethingSomethingResultType',
-        printable: 'Hello'
+        printable: 'Hello',
       });
 
-      expect(deserialized).to.have.property('type', 'SomethingSomethingResultType');
+      expect(deserialized).to.have.property(
+        'type',
+        'SomethingSomethingResultType'
+      );
       expect(deserialized).to.have.property('printable', 'Hello');
     });
   });
 
-  describe('connection options', () => {
-    it('should serialize and deserialize FLE1 connection options', () => {
+  describe('connection options', function () {
+    it('should serialize and deserialize FLE1 connection options', function () {
       const options: DevtoolsConnectOptions = {
         ...dummyOptions,
         autoEncryption: {
@@ -152,15 +155,15 @@ describe('serializer', () => {
               properties: {
                 taxid: {
                   encrypt: {
-                    keyId: [ new UUID('a21ddc6a-8806-4384-9fdf-8ba02a767b5f') ],
+                    keyId: [new UUID('a21ddc6a-8806-4384-9fdf-8ba02a767b5f')],
                     bsonType: 'string',
-                    algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Random'
-                  }
-                }
-              }
-            }
-          }
-        }
+                    algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Random',
+                  },
+                },
+              },
+            },
+          },
+        },
       };
 
       const serialized = serializeConnectOptions(options);
@@ -174,35 +177,44 @@ describe('serializer', () => {
               properties: {
                 taxid: {
                   encrypt: {
-                    keyId: [ { $binary: { base64: 'oh3caogGQ4Sf34ugKnZ7Xw==', subType: '04' } } ],
+                    keyId: [
+                      {
+                        $binary: {
+                          base64: 'oh3caogGQ4Sf34ugKnZ7Xw==',
+                          subType: '04',
+                        },
+                      },
+                    ],
                     bsonType: 'string',
-                    algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Random'
-                  }
-                }
-              }
-            }
-          }
-        }
+                    algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Random',
+                  },
+                },
+              },
+            },
+          },
+        },
       });
 
       expect(deserializeConnectOptions(serialized)).to.deep.equal(options);
     });
 
-    it('should serialize and deserialize FLE2 connection options', () => {
+    it('should serialize and deserialize FLE2 connection options', function () {
       const options: DevtoolsConnectOptions = {
         ...dummyOptions,
         autoEncryption: {
           encryptedFieldsMap: {
             'hr.employees': {
-              fields: [{
-                path: 'phoneNumber',
-                keyId: new UUID('fd6275d7-9260-4e6c-a86b-68ec5240814a'),
-                bsonType: 'string',
-                queries: { queryType: 'equality', contention: new Long(0) }
-              }]
-            }
-          }
-        }
+              fields: [
+                {
+                  path: 'phoneNumber',
+                  keyId: new UUID('fd6275d7-9260-4e6c-a86b-68ec5240814a'),
+                  bsonType: 'string',
+                  queries: { queryType: 'equality', contention: new Long(0) },
+                },
+              ],
+            },
+          },
+        },
       };
 
       const serialized = serializeConnectOptions(options);
@@ -212,15 +224,25 @@ describe('serializer', () => {
         autoEncryption: {
           encryptedFieldsMap: {
             'hr.employees': {
-              fields: [{
-                path: 'phoneNumber',
-                keyId: { $binary: { base64: '/WJ115JgTmyoa2jsUkCBSg==', subType: '04' } },
-                bsonType: 'string',
-                queries: { queryType: 'equality', contention: { $numberLong: '0' } }
-              }]
-            }
-          }
-        }
+              fields: [
+                {
+                  path: 'phoneNumber',
+                  keyId: {
+                    $binary: {
+                      base64: '/WJ115JgTmyoa2jsUkCBSg==',
+                      subType: '04',
+                    },
+                  },
+                  bsonType: 'string',
+                  queries: {
+                    queryType: 'equality',
+                    contention: { $numberLong: '0' },
+                  },
+                },
+              ],
+            },
+          },
+        },
       });
 
       expect(deserializeConnectOptions(serialized)).to.deep.equal(options);