chore(connection-storage): split connection storage between processes COMPASS-7078 (#4704)

Author: mabaasit

package-lock.json

@@ -69,6 +69,7 @@
   "dependencies": {
     "@mongodb-js/compass-components": "^1.11.0",
     "@mongodb-js/compass-logging": "^1.1.7",
+    "@mongodb-js/compass-utils": "^0.3.1",
     "@mongodb-js/devtools-connect": "^2.4.0",
     "@mongodb-js/oidc-plugin": "^0.3.0",
     "electron": "^23.3.12",

packages/atlas-service/package.json

@@ -12,7 +12,11 @@ import fetch from 'node-fetch';
 import type { SimplifiedSchema } from 'mongodb-schema';
 import type { Document } from 'mongodb';
 import type { AIQuery, IntrospectInfo, Token, UserInfo } from './util';
-import { broadcast, ipcExpose } from './util';
+import {
+  broadcast,
+  ipcExpose,
+  throwIfAborted,
+} from '@mongodb-js/compass-utils';
 import {
   createLoggerAndTelemetry,
   mongoLogId,
@@ -335,10 +339,7 @@ export class AtlasService {
   static async isAuthenticated({
     signal,
   }: { signal?: AbortSignal } = {}): Promise<boolean> {
-    if (signal?.aborted) {
-      const err = signal.reason ?? new Error('This operation was aborted.');
-      throw err;
-    }
+    throwIfAborted(signal);
     if (!this.token) {
       return false;
     }
@@ -356,10 +357,7 @@ export class AtlasService {
       return this.signInPromise;
     }
     try {
-      if (signal?.aborted) {
-        const err = signal.reason ?? new Error('This operation was aborted.');
-        throw err;
-      }
+      throwIfAborted(signal);
 
       this.signInPromise = (async () => {
         log.info(mongoLogId(1_001_000_218), 'AtlasService', 'Starting sign in');
@@ -402,10 +400,7 @@ export class AtlasService {
   static async getUserInfo({
     signal,
   }: { signal?: AbortSignal } = {}): Promise<UserInfo> {
-    if (signal?.aborted) {
-      const err = signal.reason ?? new Error('This operation was aborted.');
-      throw err;
-    }
+    throwIfAborted(signal);
     await this.maybeWaitForToken({ signal });
     const res = await this.fetch(`${this.issuer}/v1/userinfo`, {
       headers: {
@@ -421,10 +416,7 @@ export class AtlasService {
   }
 
   static async introspect({ signal }: { signal?: AbortSignal } = {}) {
-    if (signal?.aborted) {
-      const err = signal.reason ?? new Error('This operation was aborted.');
-      throw err;
-    }
+    throwIfAborted(signal);
 
     const url = new URL(`${this.issuer}/v1/introspect`);
     url.searchParams.set('client_id', this.clientId);
@@ -463,10 +455,7 @@ export class AtlasService {
     sampleDocuments?: Document[];
     signal?: AbortSignal;
   }) {
-    if (signal?.aborted) {
-      const err = signal.reason ?? new Error('This operation was aborted.');
-      throw err;
-    }
+    throwIfAborted(signal);
 
     let msgBody = JSON.stringify({
       userInput,

packages/atlas-service/src/main.ts

@@ -1,5 +1,5 @@
 import type { AtlasService as AtlasServiceMain } from './main';
-import { ipcInvoke } from './util';
+import { ipcInvoke } from '@mongodb-js/compass-utils';
 import {
   signInWithModalPrompt,
   tokenRefreshFailed,

packages/atlas-service/src/renderer.ts

@@ -1,4 +1,3 @@
-import { BrowserWindow, ipcMain, ipcRenderer } from 'electron';
 import type * as plugin from '@mongodb-js/oidc-plugin';
 
 export type UserInfo = {
@@ -17,159 +16,3 @@ export type AIQuery = {
     query?: unknown;
   };
 };
-
-type SerializedError = { $$error: Error & { statusCode?: number } };
-
-// We are serializing errors to get a better error shape on the other end, ipc
-// will only preserve message from the original error. See https://github.com/electron/electron/issues/24427
-function serializeErrorForIpc(err: any): SerializedError {
-  return {
-    $$error: {
-      name: err.name,
-      message: err.message,
-      statusCode: err.statusCode,
-      stack: err.stack,
-    },
-  };
-}
-
-function deserializeErrorFromIpc({ $$error: err }: SerializedError) {
-  const e = new Error(err.message);
-  e.name = err.name;
-  e.stack = err.stack;
-  (e as any).statusCode = err.statusCode;
-  return e;
-}
-
-function isSerializedError(err: any): err is { $$error: Error } {
-  return err !== null && typeof err === 'object' && !!err.$$error;
-}
-
-// Exported for testing purposes
-export const ControllerMap = new Map<string, AbortController>();
-
-let cId = 0;
-
-let setup = false;
-
-export function setupSignalHandler(
-  _ipcMain: Pick<typeof ipcMain, 'handle'> = ipcMain,
-  forceSetup = false
-) {
-  if (!forceSetup && setup) {
-    return;
-  }
-
-  setup = true;
-
-  _ipcMain.handle('ipcHandlerInvoke', (_evt, id: string) => {
-    ControllerMap.set(id, new AbortController());
-  });
-
-  _ipcMain.handle('ipcHandlerAborted', (_evt, id: string) => {
-    ControllerMap.get(id)?.abort();
-  });
-}
-
-type PickByValue<T, K> = Pick<
-  T,
-  { [k in keyof T]: T[k] extends K ? k : never }[keyof T]
->;
-
-export function ipcExpose<T>(
-  serviceName: string,
-  obj: T,
-  methodNames: Extract<
-    keyof PickByValue<T, (options: any) => Promise<any>>,
-    string
-  >[],
-  _ipcMain: Pick<typeof ipcMain, 'handle'> = ipcMain,
-  _forceSetup = false
-) {
-  setupSignalHandler(_ipcMain, _forceSetup);
-
-  for (const name of methodNames) {
-    const channel = `${serviceName}.${name}`;
-    _ipcMain.handle(
-      channel,
-      async (
-        _evt,
-        { signal, ...rest }: { signal: string } & Record<string, unknown>
-      ) => {
-        try {
-          const controller = ControllerMap.get(signal);
-          return await (obj[name] as (...args: any[]) => any).call(obj, {
-            signal: controller?.signal,
-            ...rest,
-          });
-        } catch (err) {
-          return serializeErrorForIpc(err);
-        } finally {
-          ControllerMap.delete(signal);
-        }
-      }
-    );
-  }
-}
-
-export function ipcInvoke<
-  T,
-  K extends Extract<
-    keyof PickByValue<T, (options: any) => Promise<any>>,
-    string
-  >
->(
-  serviceName: string,
-  methodNames: K[],
-  _ipcRenderer: Pick<typeof ipcRenderer, 'invoke'> = ipcRenderer
-) {
-  return Object.fromEntries(
-    methodNames.map((name) => {
-      const channel = `${serviceName}.${name}`;
-      const signalId = `${channel}:${++cId}`;
-      return [
-        name,
-        async ({
-          signal,
-          ...rest
-        }: { signal?: AbortSignal } & Record<string, unknown> = {}) => {
-          await _ipcRenderer.invoke('ipcHandlerInvoke', signalId);
-          const onAbort = () => {
-            return _ipcRenderer.invoke('ipcHandlerAborted', signalId);
-          };
-          // If signal is already aborted, make sure that handler will see it
-          // when it runs, otherwise just set up abort listener to communicate
-          // this to main process
-          if (signal?.aborted) {
-            await onAbort();
-          } else {
-            signal?.addEventListener(
-              'abort',
-              () => {
-                void onAbort();
-              },
-              { once: true }
-            );
-          }
-          const res = await _ipcRenderer.invoke(`${serviceName}.${name}`, {
-            // We replace this with a matched signal on the other side, this
-            // is mostly for testing / debugging purposes
-            signal: signalId,
-            ...rest,
-          });
-          if (isSerializedError(res)) {
-            throw deserializeErrorFromIpc(res);
-          }
-          return res;
-        },
-      ];
-    })
-  ) as Pick<T, K>;
-}
-
-export function broadcast(channel: string, ...args: any[]) {
-  // We might not be in electron environment
-  BrowserWindow?.getAllWindows().forEach((browserWindow) => {
-    browserWindow.webContents.send(channel, ...args);
-  });
-}

packages/atlas-service/src/util.ts

@@ -13,7 +13,7 @@ import { SelectTable } from './select-table';
 import type { ImportExportResult } from '../hooks/common';
 import { useOpenModalThroughIpc } from '../hooks/common';
 import { useExportConnections } from '../hooks/use-export';
-import type { ConnectionInfo } from '@mongodb-js/connection-storage';
+import type { ConnectionInfo } from '@mongodb-js/connection-storage/renderer';
 import { usePreference } from 'compass-preferences-model';
 
 const TOAST_TIMEOUT_MS = 5000;

packages/compass-connection-import-export/src/components/export-modal.tsx

@@ -14,7 +14,7 @@ import { SelectTable } from './select-table';
 import type { ImportExportResult } from '../hooks/common';
 import { useOpenModalThroughIpc } from '../hooks/common';
 import { useImportConnections } from '../hooks/use-import';
-import type { ConnectionInfo } from '@mongodb-js/connection-storage';
+import type { ConnectionInfo } from '@mongodb-js/connection-storage/renderer';
 
 const TOAST_TIMEOUT_MS = 5000;
 

packages/compass-connection-import-export/src/components/import-modal.tsx

@@ -3,7 +3,6 @@ import sinon from 'sinon';
 import {
   useImportExportConnectionsCommon,
   COMMON_INITIAL_STATE,
-  makeConnectionInfoFilter,
   useOpenModalThroughIpc,
 } from './common';
 import { renderHook, act } from '@testing-library/react-hooks';
@@ -56,18 +55,6 @@ describe('common utilities', function () {
     });
   });
 
-  describe('makeConnectionInfoFilter', function () {
-    it('creates a filter function from a list of selected connections', function () {
-      const filter = makeConnectionInfoFilter([
-        { id: 'id1', name: 'name1', selected: true },
-        { id: 'id2', name: 'name2', selected: false },
-      ]);
-      expect(filter({ id: 'id1' })).to.equal(true);
-      expect(filter({ id: 'id2' })).to.equal(false);
-      expect(filter({ id: 'none' })).to.equal(false);
-    });
-  });
-
   describe('useOpenModalThroughIpc', function () {
     it("allows modifying a modal's state through ipc events", function () {
       const fakeIpc = new EventEmitter();