refactor: Clarify main process architecture

* stores: reactive data structures to hold application state
* controllers: subscribe to store changes and call store actions in
  response to external events from services
* services: integrate with the nodejs and electron environment (should
  be mocked for unit testing)

7 files changed, 179 insertions, 146 deletions

diff --git a/packages/main/src/controllers/ConfigController.ts b/packages/main/src/controllers/ConfigController.ts
new file mode 100644
index 0000000..6690548
--- /dev/null
+++ b/packages/main/src/controllers/ConfigController.ts
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C)  2021-2022 Kristóf Marussy <kristof@marussy.com>
+ *
+ * This file is part of Sophie.
+ *
+ * Sophie is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import { debounce } from 'lodash';
+import {
+  applySnapshot,
+  getSnapshot,
+  IDisposer,
+  onSnapshot,
+} from 'mobx-state-tree';
+import ms from 'ms';
+
+import { ConfigPersistenceService } from '../services/ConfigPersistenceService';
+import { Config, ConfigSnapshotOut } from '../stores/Config';
+
+const DEFAULT_DEBOUNCE_TIME = ms('1s');
+
+class ConfigController {
+  readonly #config: Config;
+
+  readonly #persistenceService: ConfigPersistenceService;
+
+  readonly #onSnapshotDisposer: IDisposer;
+
+  readonly #watcherDisposer: IDisposer;
+
+  #lastSnapshotOnDisk: ConfigSnapshotOut | null = null;
+
+  #writingConfig: boolean = false;
+
+  #configMTime: Date | null = null;
+
+  constructor(
+    config: Config,
+    persistenceService: ConfigPersistenceService,
+    debounceTime: number,
+  ) {
+    this.#config = config;
+    this.#persistenceService = persistenceService;
+    this.#onSnapshotDisposer = onSnapshot(this.#config, debounce((snapshot) => {
+      // We can compare snapshots by reference, since it is only recreated on store changes.
+      if (this.#lastSnapshotOnDisk !== snapshot) {
+        this.#writeConfig().catch((err) => {
+          console.log('Failed to write config on config change', err);
+        })
+      }
+    }, debounceTime));
+    this.#watcherDisposer = this.#persistenceService.watchConfig(async (mtime) => {
+      if (!this.#writingConfig && (this.#configMTime === null || mtime > this.#configMTime)) {
+        await this.#readConfig();
+      }
+    }, debounceTime);
+  }
+
+  async #readConfig(): Promise<boolean> {
+    const result = await this.#persistenceService.readConfig();
+    if (result.found) {
+      try {
+        applySnapshot(this.#config, result.data);
+        this.#lastSnapshotOnDisk = getSnapshot(this.#config);
+        console.log('Loaded config');
+      } catch (err) {
+        console.error('Failed to read config', result.data, err);
+      }
+    }
+    return result.found;
+  }
+
+  async #writeConfig(): Promise<void> {
+    const snapshot = getSnapshot(this.#config);
+    this.#writingConfig = true;
+    try {
+      this.#configMTime = await this.#persistenceService.writeConfig(snapshot);
+      this.#lastSnapshotOnDisk = snapshot;
+      console.log('Wrote config');
+    } finally {
+      this.#writingConfig = false;
+    }
+  }
+
+  async initConfig(): Promise<void> {
+    const foundConfig: boolean = await this.#readConfig();
+    if (!foundConfig) {
+      console.log('Creating new config file');
+      try {
+        await this.#writeConfig();
+      } catch (err) {
+        console.error('Failed to initialize config');
+      }
+    }
+  }
+
+  dispose(): void {
+    this.#onSnapshotDisposer();
+    this.#watcherDisposer();
+  }
+}
+
+export async function initConfig(
+  config: Config,
+  persistenceService: ConfigPersistenceService,
+  debounceTime: number = DEFAULT_DEBOUNCE_TIME,
+): Promise<IDisposer> {
+  const controller = new ConfigController(config, persistenceService, debounceTime);
+  await controller.initConfig();
+  return () => controller.dispose();
+}
diff --git a/packages/main/src/services/MainEnv.ts b/packages/main/src/controllers/NativeThemeController.ts
index 23ee9a1..07a3292 100644
--- a/packages/main/src/services/MainEnv.ts
+++ b/packages/main/src/controllers/NativeThemeController.ts
@@ -18,21 +18,21 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import { IAnyStateTreeNode, getEnv as getAnyEnv } from 'mobx-state-tree';
+import { autorun } from 'mobx';
+import type { IDisposer } from 'mobx-state-tree';
 
-import type { ConfigPersistence } from './ConfigPersistence';
+import type { NativeThemeService } from '../services/NativeThemeService';
+import type { MainStore } from '../stores/MainStore';
 
-export interface MainEnv {
-  configPersistence: ConfigPersistence;
-}
-
-/**
- * Gets a well-typed environment from `model`.
- *
- * Only useable inside state trees created by `createAndConnectRootStore`.
- *
- * @param model The state tree node.
- */
-export function getEnv(model: IAnyStateTreeNode): MainEnv {
-  return getAnyEnv<MainEnv>(model);
+export function initNativeTheme(store: MainStore, service: NativeThemeService): IDisposer {
+  const themeSourceReactionDisposer = autorun(() => {
+    service.setThemeSource(store.config.themeSource);
+  });
+  const onShouldUseDarkColorsUpdatedDisposer = service.onShouldUseDarkColorsUpdated(
+    store.setShouldUseDarkColors,
+  );
+  return () => {
+    onShouldUseDarkColorsUpdatedDisposer();
+    themeSourceReactionDisposer();
+  };
 }
diff --git a/packages/main/src/index.ts b/packages/main/src/index.ts
index 8297ff5..67f5546 100644
--- a/packages/main/src/index.ts
+++ b/packages/main/src/index.ts
@@ -23,7 +23,6 @@ import {
   BrowserView,
   BrowserWindow,
   ipcMain,
-  nativeTheme,
 } from 'electron';
 import { readFileSync } from 'fs';
 import { readFile } from 'fs/promises';
@@ -47,7 +46,10 @@ import {
   installDevToolsExtensions,
   openDevToolsWhenReady,
 } from './devTools';
-import { ConfigPersistenceImpl } from './services/impl/ConfigPersistenceImpl';
+import { initConfig } from './controllers/ConfigController';
+import { initNativeTheme } from './controllers/NativeThemeController';
+import { ConfigPersistenceService } from './services/ConfigPersistenceService';
+import { NativeThemeService } from './services/NativeThemeService';
 import { createMainStore } from './stores/MainStore';
 
 const isDevelopment = import.meta.env.MODE === 'development';
@@ -105,23 +107,14 @@ if (isDevelopment) {
 
 let mainWindow: BrowserWindow | null = null;
 
-const store = createMainStore({
-  configPersistence: new ConfigPersistenceImpl(
-    app.getPath('userData'),
-    'config.json5',
-  ),
-});
-
-autorun(() => {
-  nativeTheme.themeSource = store.config.themeSource;
-});
-
-store.setShouldUseDarkColors(nativeTheme.shouldUseDarkColors);
-nativeTheme.on('updated', () => {
-  store.setShouldUseDarkColors(nativeTheme.shouldUseDarkColors);
-});
+const store = createMainStore();
 
-store.config.initConfig();
+initConfig(
+  store.config,
+  new ConfigPersistenceService(app.getPath('userData'), 'config.json5'),
+).then(() => {
+  initNativeTheme(store, new NativeThemeService());
+}).catch((err) => console.error(err));
 
 const rendererBaseUrl = getResourceUrl('../renderer/');
 function shouldCancelMainWindowRequest(url: string, method: string): boolean {
diff --git a/packages/main/src/services/impl/ConfigPersistenceImpl.ts b/packages/main/src/services/ConfigPersistenceService.ts
index 097ab74..85b0088 100644
--- a/packages/main/src/services/impl/ConfigPersistenceImpl.ts
+++ b/packages/main/src/services/ConfigPersistenceService.ts
@@ -25,10 +25,11 @@ import { throttle } from 'lodash';
 import { IDisposer } from 'mobx-state-tree';
 import { join } from 'path';
 
-import { CONFIG_DEBOUNCE_TIME, ConfigPersistence, ReadConfigResult } from '../ConfigPersistence';
-import type { ConfigSnapshotOut } from  '../../stores/Config';
+import type { ConfigSnapshotOut } from  '../stores/Config';
 
-export class ConfigPersistenceImpl implements ConfigPersistence {
+export type ReadConfigResult = { found: true; data: unknown; } | { found: false; };
+
+export class ConfigPersistenceService {
   readonly #userDataDir: string;
 
   readonly #configFileName: string;
@@ -69,7 +70,7 @@ export class ConfigPersistenceImpl implements ConfigPersistence {
     return mtime;
   }
 
-  watchConfig(callback: (mtime: Date) => Promise<void>): IDisposer {
+  watchConfig(callback: (mtime: Date) => Promise<void>, throttleMs: number): IDisposer {
     const configChanged = throttle(async () => {
       let mtime: Date;
       try {
@@ -82,7 +83,7 @@ export class ConfigPersistenceImpl implements ConfigPersistence {
         throw err;
       }
       return callback(mtime);
-    }, CONFIG_DEBOUNCE_TIME);
+    }, throttleMs);
 
     const watcher = watch(this.#userDataDir, {
       persistent: false,
diff --git a/packages/main/src/services/ConfigPersistence.ts b/packages/main/src/services/NativeThemeService.ts
index f9a82de..7a26c3c 100644
--- a/packages/main/src/services/ConfigPersistence.ts
+++ b/packages/main/src/services/NativeThemeService.ts
@@ -18,19 +18,21 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import { IDisposer } from 'mobx-state-tree';
-import ms from 'ms';
+import { nativeTheme } from 'electron';
+import type { IDisposer } from 'mobx-state-tree';
+import type { ThemeSource } from '@sophie/shared';
 
-import type { ConfigSnapshotOut } from '../stores/Config';
+export class NativeThemeService {
+  setThemeSource(themeSource: ThemeSource): void {
+    nativeTheme.themeSource = themeSource;
+  }
 
-export const CONFIG_DEBOUNCE_TIME: number = ms('1s');
-
-export type ReadConfigResult = { found: true; data: unknown; } | { found: false; };
-
-export interface ConfigPersistence {
-  readConfig(): Promise<ReadConfigResult>;
-
-  writeConfig(configSnapshot: ConfigSnapshotOut): Promise<Date>;
-
-  watchConfig(callback: (mtime: Date) => Promise<void>): IDisposer;
+  onShouldUseDarkColorsUpdated(callback: (shouldUseDarkColors: boolean) => void): IDisposer {
+    const wrappedCallback = () => {
+      callback(nativeTheme.shouldUseDarkColors);
+    };
+    wrappedCallback();
+    nativeTheme.on('updated', wrappedCallback);
+    return () => nativeTheme.off('updated', wrappedCallback);
+  }
 }
diff --git a/packages/main/src/stores/Config.ts b/packages/main/src/stores/Config.ts
index eb53635..7d1168f 100644
--- a/packages/main/src/stores/Config.ts
+++ b/packages/main/src/stores/Config.ts
@@ -18,15 +18,7 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import { debounce } from 'lodash';
-import {
-  applySnapshot,
-  flow,
-  getSnapshot,
-  IDisposer,
-  Instance,
-  onSnapshot,
-} from 'mobx-state-tree';
+import { Instance } from 'mobx-state-tree';
 import {
   config as originalConfig,
   ConfigSnapshotIn,
@@ -34,86 +26,11 @@ import {
   ThemeSource,
 } from '@sophie/shared';
 
-import { CONFIG_DEBOUNCE_TIME, ReadConfigResult } from '../services/ConfigPersistence';
-import { getEnv } from '../services/MainEnv';
-
 export const config = originalConfig.actions((self) => ({
   setThemeSource(mode: ThemeSource) {
     self.themeSource = mode;
   },
-})).actions((self) => {
-  let lastSnapshotOnDisk: ConfigSnapshotOut | null = null;
-  let writingConfig = false;
-  let configMtime: Date | null = null;
-  let onSnapshotDisposer: IDisposer | null = null;
-  let watcherDisposer: IDisposer | null = null;
-
-  function dispose() {
-    onSnapshotDisposer?.();
-    watcherDisposer?.();
-  }
-
-  const actions: {
-    beforeDetach(): void,
-    readConfig(): Promise<boolean>;
-    writeConfig(): Promise<void>;
-    initConfig(): Promise<void>;
-  } = {
-    beforeDetach() {
-      dispose();
-    },
-    readConfig: flow(function*() {
-      const result: ReadConfigResult = yield getEnv(self).configPersistence.readConfig();
-      if (result.found) {
-        try {
-          applySnapshot(self, result.data);
-          lastSnapshotOnDisk = getSnapshot(self);
-          console.log('Loaded config');
-        } catch (err) {
-          console.error('Failed to read config', result.data, err);
-        }
-      }
-      return result.found;
-    }),
-    writeConfig: flow(function*() {
-      const snapshot = getSnapshot(self);
-      writingConfig = true;
-      try {
-        configMtime = yield getEnv(self).configPersistence.writeConfig(snapshot);
-        lastSnapshotOnDisk = snapshot;
-        console.log('Wrote config');
-      } finally {
-        writingConfig = false;
-      }
-    }),
-    initConfig: flow(function*() {
-      dispose();
-      const foundConfig: boolean = yield actions.readConfig();
-      if (!foundConfig) {
-        console.log('Creating new config file');
-        try {
-          yield actions.writeConfig();
-        } catch (err) {
-          console.error('Failed to initialize config');
-        }
-      }
-      onSnapshotDisposer = onSnapshot(self, debounce((snapshot) => {
-        // We can compare snapshots by reference, since it is only recreated on store changes.
-        if (lastSnapshotOnDisk !== snapshot) {
-          actions.writeConfig().catch((err) => {
-            console.log('Failed to write config on config change', err);
-          })
-        }
-      }, CONFIG_DEBOUNCE_TIME));
-      watcherDisposer = getEnv(self).configPersistence.watchConfig(async (mtime) => {
-        if (!writingConfig && (configMtime === null || mtime > configMtime)) {
-          await actions.readConfig();
-        }
-      });
-    }),
-  };
-  return actions;
-});
+}));
 
 export interface Config extends Instance<typeof config> {}
 
diff --git a/packages/main/src/stores/MainStore.ts b/packages/main/src/stores/MainStore.ts
index ee215a7..4b85c22 100644
--- a/packages/main/src/stores/MainStore.ts
+++ b/packages/main/src/stores/MainStore.ts
@@ -22,7 +22,6 @@ import { applySnapshot, Instance, types } from 'mobx-state-tree';
 import { BrowserViewBounds, emptySharedStore } from '@sophie/shared';
 
 import type { Config } from './Config';
-import { MainEnv } from '../services/MainEnv';
 import { sharedStore } from './SharedStore';
 
 export const mainStore = types.model('MainStore', {
@@ -46,14 +45,11 @@ export const mainStore = types.model('MainStore', {
   }
 }));
 
-export interface RootStore extends Instance<typeof mainStore> {}
+export interface MainStore extends Instance<typeof mainStore> {}
 
-export function createMainStore(env: MainEnv): RootStore {
-  return mainStore.create(
-    {
-      browserViewBounds: {},
-      shared: emptySharedStore,
-    },
-    env,
-  );
+export function createMainStore(): MainStore {
+  return mainStore.create({
+    browserViewBounds: {},
+    shared: emptySharedStore,
+  });
 }