Chore/user config handling and performance fixes

src/ElectronBackend/main/__tests__/menu.test.ts

@@ -5,7 +5,7 @@
 import electron, { BrowserWindow, MenuItemConstructorOptions } from 'electron';
 
 import { createMenu } from '../menu';
-import { UserSettings } from '../user-settings';
+import { UserSettingsService } from '../user-settings-service';
 
 jest.mock('electron', () => ({
   BrowserWindow: class BrowserWindowMock {},
@@ -49,7 +49,7 @@ describe('create menu', () => {
   ];
   testCases.forEach((testCase) => {
     it(`evaluates ${testCase.darkMode ? 'dark' : 'light'} mode properly`, async () => {
-      await UserSettings.init();
+      await UserSettingsService.init();
       const mainWindow = new BrowserWindow();
 
       // Important to set this up only here and not in the mock setup

src/ElectronBackend/main/__tests__/user-settings-provider.test.ts

@@ -0,0 +1,151 @@
+// SPDX-FileCopyrightText: Meta Platforms, Inc. and its affiliates
+// SPDX-FileCopyrightText: TNG Technology Consulting GmbH <https://www.tngtech.com>
+//
+// SPDX-License-Identifier: Apache-2.0
+import { BrowserWindow } from 'electron';
+import settings from 'electron-settings';
+import { rmSync } from 'node:fs';
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { AllowedFrontendChannels } from '../../../shared/ipc-channels';
+import {
+  DEFAULT_PANEL_SIZES,
+  DEFAULT_USER_SETTINGS,
+} from '../../../shared/shared-constants';
+import { UserSettingsService } from '../user-settings-service';
+
+type MockedBrowserWindow = BrowserWindow & {
+  sendFunction: (channel: string, ...args: Array<unknown>) => void;
+};
+
+jest.mock('electron', () => {
+  const sendFunction = jest.fn();
+  return {
+    BrowserWindow: {
+      getAllWindows: () => {
+        return [
+          {
+            webContents: {
+              send: sendFunction,
+            },
+          },
+        ];
+      },
+      sendFunction,
+    },
+  };
+});
+
+describe('UserSettings', () => {
+  let temporaryDir: string | undefined = undefined;
+  beforeEach(async () => {
+    temporaryDir = await mkdtemp(join(tmpdir(), 'OpossumUiTesting-'));
+    settings.configure({ dir: temporaryDir, atomicSave: true });
+  });
+
+  afterEach(() => {
+    if (temporaryDir) {
+      rmSync(temporaryDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('init', () => {
+    it('sets up the default values if empty', async () => {
+      await UserSettingsService.init();
+
+      const result = await settings.get();
+
+      expect(result).toEqual(DEFAULT_USER_SETTINGS);
+    });
+
+    it('overwrites only the non set values if there are already values set', async () => {
+      await settings.set('qaMode', true);
+
+      await UserSettingsService.init();
+
+      const result = await settings.get();
+
+      expect(result).toEqual({ ...DEFAULT_USER_SETTINGS, qaMode: true });
+    });
+
+    it('resets everything if reset is requested', async () => {
+      const oldEnvironment = process.env;
+      process.env = { ...oldEnvironment, RESET: 'TRUE' };
+
+      await settings.set('qaMode', true);
+
+      await UserSettingsService.init();
+
+      const result = await settings.get();
+
+      expect(result).toEqual({ ...DEFAULT_USER_SETTINGS });
+      process.env = oldEnvironment;
+    });
+  });
+
+  describe('get', () => {
+    it('gets a user setting from a predescribed path', async () => {
+      await UserSettingsService.init();
+
+      const panelSizes = await UserSettingsService.get('panelSizes');
+
+      expect(panelSizes).toEqual(DEFAULT_PANEL_SIZES);
+    });
+
+    it('gets the full user settings', async () => {
+      await UserSettingsService.init();
+
+      const userSettings = await UserSettingsService.get();
+
+      expect(userSettings).toEqual(DEFAULT_USER_SETTINGS);
+    });
+  });
+
+  describe('write operations', () => {
+    it('sets a value and communicates to the frontend', async () => {
+      await UserSettingsService.set('qaMode', true);
+
+      const qaMode = await UserSettingsService.get('qaMode');
+      expect(qaMode).toBe(true);
+      expect(
+        (BrowserWindow as unknown as MockedBrowserWindow).sendFunction,
+      ).toHaveBeenCalledWith(AllowedFrontendChannels.UserSettingsChanged, {
+        qaMode: true,
+      });
+    });
+
+    it('sets a value and does not communicates to the frontend if disabled', async () => {
+      await UserSettingsService.set('qaMode', true, {
+        skipNotification: true,
+      });
+
+      const qaMode = await UserSettingsService.get('qaMode');
+      expect(qaMode).toBe(true);
+      expect(
+        (BrowserWindow as unknown as MockedBrowserWindow).sendFunction,
+      ).not.toHaveBeenCalled();
+    });
+
+    it('allows to update multiple values at once', async () => {
+      await UserSettingsService.init();
+
+      await UserSettingsService.update({
+        qaMode: true,
+        showClassifications: false,
+      });
+
+      const userSettings = await UserSettingsService.get();
+
+      expect(
+        (BrowserWindow as unknown as MockedBrowserWindow).sendFunction,
+      ).toHaveBeenCalledTimes(2);
+      expect(userSettings).toEqual({
+        ...DEFAULT_USER_SETTINGS,
+        qaMode: true,
+        showClassifications: false,
+      });
+    });
+  });
+});

src/ElectronBackend/main/listeners.ts

@@ -55,7 +55,7 @@ import {
 } from './globalBackendState';
 import logger from './logger';
 import { createMenu } from './menu';
-import { UserSettings } from './user-settings';
+import { UserSettingsService } from './user-settings-service';
 
 const MAX_NUMBER_OF_RECENTLY_OPENED_PATHS = 10;
 
@@ -361,8 +361,10 @@ export async function openFile(
 }
 
 async function updateRecentlyOpenedPaths(filePath: string): Promise<void> {
-  const recentlyOpenedPaths = await UserSettings.get('recentlyOpenedPaths');
-  await UserSettings.set(
+  const recentlyOpenedPaths = await UserSettingsService.get(
+    'recentlyOpenedPaths',
+  );
+  await UserSettingsService.set(
     'recentlyOpenedPaths',
     uniq([filePath, ...(recentlyOpenedPaths ?? [])]).slice(
       0,

src/ElectronBackend/main/main.ts

@@ -6,6 +6,7 @@ import { dialog, ipcMain, systemPreferences } from 'electron';
 import os from 'os';
 
 import { AllowedFrontendChannels, IpcChannel } from '../../shared/ipc-channels';
+import { UserSettings } from '../../shared/shared-types';
 import { getMessageBoxContentForErrorsWrapper } from '../errorHandling/errorHandling';
 import { createWindow, loadWebApp } from './createWindow';
 import {
@@ -21,7 +22,7 @@ import {
 import { createMenu } from './menu';
 import { DisabledMenuItemHandler } from './menu/DisabledMenuItemHandler';
 import { openFileFromCliOrEnvVariableIfProvided } from './openFileFromCliOrEnvVariableIfProvided';
-import { UserSettings } from './user-settings';
+import { UserSettingsService } from './user-settings-service';
 
 export async function main(): Promise<void> {
   try {
@@ -35,7 +36,7 @@ export async function main(): Promise<void> {
 
     const mainWindow = createWindow();
 
-    await UserSettings.init();
+    await UserSettingsService.init();
     await createMenu(mainWindow);
 
     mainWindow.webContents.session.webRequest.onBeforeSendHeaders(
@@ -92,11 +93,11 @@ export async function main(): Promise<void> {
       }),
     );
     ipcMain.handle(IpcChannel.OpenLink, openLinkListener);
-    ipcMain.handle(IpcChannel.GetUserSettings, (_, key) =>
-      UserSettings.get(key),
-    );
-    ipcMain.handle(IpcChannel.SetUserSettings, (_, { key, value }) =>
-      UserSettings.set(key, value, { skipNotification: true }),
+    ipcMain.handle(IpcChannel.GetUserSettings, () => UserSettingsService.get());
+    ipcMain.handle(
+      IpcChannel.SetUserSettings,
+      (_, userSettings: Partial<UserSettings>) =>
+        UserSettingsService.update(userSettings, true),
     );
 
     await loadWebApp(mainWindow);

src/ElectronBackend/main/menu/fileMenu.ts

@@ -31,7 +31,7 @@ import {
 } from '../listeners';
 import logger from '../logger';
 import { createMenu } from '../menu';
-import { UserSettings } from '../user-settings';
+import { UserSettingsService } from '../user-settings-service';
 import { DisabledMenuItemHandler } from './DisabledMenuItemHandler';
 
 export const importFileFormats: Array<FileFormatInfo> = [
@@ -67,7 +67,9 @@ function getOpenFile(mainWindow: BrowserWindow): MenuItemConstructorOptions {
 async function getOpenRecent(
   mainWindow: BrowserWindow,
 ): Promise<MenuItemConstructorOptions> {
-  const recentlyOpenedPaths = await UserSettings.get('recentlyOpenedPaths');
+  const recentlyOpenedPaths = await UserSettingsService.get(
+    'recentlyOpenedPaths',
+  );
 
   return {
     icon: getIconBasedOnTheme('icons/open-white.png', 'icons/open-black.png'),
@@ -101,7 +103,7 @@ function getOpenRecentSubmenu(
       id: 'clear-recent',
       label: text.menu.fileSubmenu.clearRecent,
       click: async () => {
-        await UserSettings.set('recentlyOpenedPaths', []);
+        await UserSettingsService.set('recentlyOpenedPaths', []);
         await createMenu(mainWindow);
       },
     },

src/ElectronBackend/main/menu/switchableMenuItem.ts

@@ -7,7 +7,7 @@ import { BrowserWindow, MenuItemConstructorOptions } from 'electron';
 import { UserSettings as IUserSettings } from '../../../shared/shared-types';
 import { getCheckboxBasedOnThemeAndCheckState } from '../iconHelpers';
 import { createMenu } from '../menu';
-import { UserSettings } from '../user-settings';
+import { UserSettingsService } from '../user-settings-service';
 
 export interface SwitchableItemOptions {
   id: string;
@@ -19,13 +19,13 @@ export async function switchableMenuItem(
   mainWindow: BrowserWindow,
   options: SwitchableItemOptions,
 ): Promise<MenuItemConstructorOptions> {
-  const state = !!(await UserSettings.get(options.userSettingsKey));
+  const state = !!(await UserSettingsService.get(options.userSettingsKey));
   return {
     icon: getCheckboxBasedOnThemeAndCheckState(state),
     id: state ? `enabled-${options.id}` : `disabled-${options.id}`,
     label: options.label,
     click: async () => {
-      await UserSettings.set(options.userSettingsKey, !state);
+      await UserSettingsService.set(options.userSettingsKey, !state);
       await createMenu(mainWindow);
     },
   };

src/ElectronBackend/main/user-settings-service.ts

@@ -0,0 +1,74 @@
+// SPDX-FileCopyrightText: Meta Platforms, Inc. and its affiliates
+// SPDX-FileCopyrightText: TNG Technology Consulting GmbH <https://www.tngtech.com>
+//
+// SPDX-License-Identifier: Apache-2.0
+import { BrowserWindow } from 'electron';
+import log from 'electron-log';
+import settings from 'electron-settings';
+
+import { AllowedFrontendChannels } from '../../shared/ipc-channels';
+import { DEFAULT_USER_SETTINGS } from '../../shared/shared-constants';
+import {
+  UserSettings as IUserSettings,
+  UserSettings,
+} from '../../shared/shared-types';
+
+export class UserSettingsService {
+  public static async init() {
+    if (process.argv.includes('--reset') || process.env.RESET) {
+      log.info('Resetting user settings');
+      await settings.set(DEFAULT_USER_SETTINGS as unknown as never);
+    } else {
+      const currentSettings = await settings.get();
+      await settings.set({
+        ...DEFAULT_USER_SETTINGS,
+        ...currentSettings,
+      });
+    }
+  }
+
+  public static get<T extends keyof IUserSettings>(
+    path: T,
+  ): Promise<IUserSettings[T]>;
+  public static get(): Promise<IUserSettings>;
+  public static get<T extends keyof IUserSettings>(
+    path?: T,
+  ): Promise<IUserSettings[T]> | Promise<IUserSettings> {
+    if (path) {
+      return settings.get(path) as Promise<IUserSettings[T]>;
+    }
+    return settings.get() as unknown as Promise<IUserSettings>;
+  }
+
+  public static async update(
+    userSettings: Partial<IUserSettings>,
+    skipNotification: boolean = false,
+  ): Promise<void> {
+    for (const key of Object.keys(userSettings)) {
+      const properKey = key as keyof UserSettings;
+      if (userSettings[properKey] !== undefined) {
+        await UserSettingsService.set(properKey, userSettings[properKey], {
+          skipNotification,
+        });
+      }
+    }
+  }
+
+  public static async set<T extends keyof IUserSettings>(
+    path: T,
+    value: IUserSettings[T],
+    { skipNotification }: { skipNotification?: boolean } = {},
+  ): Promise<void> {
+    await settings.set(path, value);
+
+    if (!skipNotification) {
+      const partialSettingsToUpdate = Object.fromEntries([[path, value]]);
+      BrowserWindow.getAllWindows().forEach((window) => {
+        window.webContents.send(
+          AllowedFrontendChannels.UserSettingsChanged,
+          partialSettingsToUpdate,
+        );
+      });
+    }
+  }
+}