refactor: Get rid of dependency injector

8 files changed, 68 insertions, 93 deletions

diff --git a/packages/main/package.json b/packages/main/package.json
index 55bc663..48268fb 100644
--- a/packages/main/package.json
+++ b/packages/main/package.json
@@ -17,8 +17,7 @@
     "lodash": "^4.17.21",
     "mobx": "^6.3.10",
     "mobx-state-tree": "^5.1.0",
-    "ms": "^2.1.3",
-    "typed-inject": "^3.0.1"
+    "ms": "^2.1.3"
   },
   "devDependencies": {
     "@types/electron-devtools-installer": "^2.2.1",
diff --git a/packages/main/src/injector.ts b/packages/main/src/CompositionRoot.ts
index 2c05c85..affb186 100644
--- a/packages/main/src/injector.ts
+++ b/packages/main/src/CompositionRoot.ts
@@ -19,21 +19,19 @@
  */
 
 import { app } from 'electron';
-import ms from 'ms';
-import { createInjector, Injector } from 'typed-inject';
 
 import { ConfigController } from './controllers/ConfigController';
-import { MainController } from './controllers/MainController';
 import { NativeThemeController } from './controllers/NativeThemeController';
 import { ConfigPersistenceService } from './services/ConfigPersistenceService';
+import { MainStore } from './stores/MainStore';
+import { DisposeHelper } from './utils';
 
-export const injector: Injector<{
-  'mainController': MainController,
-}> = createInjector()
-  .provideFactory('userDataDir', () => app.getPath('userData'))
-  .provideValue('configFileName', 'config.json5')
-  .provideValue('configDebounceTime', ms('1s'))
-  .provideClass('configPersistenceService', ConfigPersistenceService)
-  .provideClass('configController', ConfigController)
-  .provideClass('nativeThemeController', NativeThemeController)
-  .provideClass('mainController', MainController);
+export class CompositionRoot extends DisposeHelper {
+  async init(store: MainStore): Promise<void> {
+    const configPersistenceService = new ConfigPersistenceService(app.getPath('userData'));
+    await this.registerDisposable(new ConfigController(
+      configPersistenceService,
+    )).connect(store.config);
+    this.registerDisposable(new NativeThemeController()).connect(store);
+  }
+}
diff --git a/packages/main/src/controllers/ConfigController.ts b/packages/main/src/controllers/ConfigController.ts
index a28746c..318506f 100644
--- a/packages/main/src/controllers/ConfigController.ts
+++ b/packages/main/src/controllers/ConfigController.ts
@@ -19,34 +19,30 @@
  */
 
 import { debounce } from 'lodash';
-import {
-  applySnapshot,
-  getSnapshot,
-  IDisposer,
-  onSnapshot,
-} from 'mobx-state-tree';
+import ms from 'ms';
+import { applySnapshot, getSnapshot, onSnapshot } from 'mobx-state-tree';
 
 import type { ConfigPersistenceService } from '../services/ConfigPersistenceService';
 import type { Config, ConfigSnapshotOut } from '../stores/Config';
+import { DisposeHelper } from '../utils';
 
-export class ConfigController {
-  static inject = ['configPersistenceService', 'configDebounceTime'] as const;
+const DEFAULT_CONFIG_DEBOUNCE_TIME = ms('1s');
 
+export class ConfigController extends DisposeHelper {
   private config: Config | null = null;
 
-  private onSnapshotDisposer: IDisposer | null = null;
-
   private lastSnapshotOnDisk: ConfigSnapshotOut | null = null;
 
   private writingConfig: boolean = false;
 
   constructor(
     private readonly persistenceService: ConfigPersistenceService,
-    private readonly debounceTime: number,
+    private readonly debounceTime: number = DEFAULT_CONFIG_DEBOUNCE_TIME,
   ) {
+    super();
   }
 
-  async initConfig(config: Config): Promise<void> {
+  async connect(config: Config): Promise<void> {
     this.config = config;
 
     const foundConfig: boolean = await this.readConfig();
@@ -59,20 +55,20 @@ export class ConfigController {
       }
     }
 
-    this.onSnapshotDisposer = onSnapshot(this.config, debounce((snapshot) => {
+    this.registerDisposable(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);
         })
       }
-    }, this.debounceTime));
+    }, this.debounceTime)));
 
-    this.persistenceService.watchConfig(async () => {
+    this.registerDisposable(this.persistenceService.watchConfig(async () => {
       if (!this.writingConfig) {
         await this.readConfig();
       }
-    }, this.debounceTime);
+    }, this.debounceTime));
   }
 
   private async readConfig(): Promise<boolean> {
@@ -100,8 +96,4 @@ export class ConfigController {
       this.writingConfig = false;
     }
   }
-
-  dispose(): void {
-    this.onSnapshotDisposer?.();
-  }
 }
diff --git a/packages/main/src/controllers/NativeThemeController.ts b/packages/main/src/controllers/NativeThemeController.ts
index a50d41e..931660c 100644
--- a/packages/main/src/controllers/NativeThemeController.ts
+++ b/packages/main/src/controllers/NativeThemeController.ts
@@ -20,30 +20,23 @@
 
 import { nativeTheme } from 'electron';
 import { autorun } from 'mobx';
-import { IDisposer } from 'mobx-state-tree';
 
 import type { MainStore } from '../stores/MainStore';
+import { DisposeHelper } from '../utils';
 
-export class NativeThemeController {
-  private autorunDisposer: IDisposer | null = null;
-
-  private shouldUseDarkColorsListener: (() => void) | null = null;
-
+export class NativeThemeController extends DisposeHelper {
   connect(store: MainStore): void {
-    this.autorunDisposer = autorun(() => {
+    this.registerDisposable(autorun(() => {
       nativeTheme.themeSource = store.config.themeSource;
-    });
+    }));
+
     store.setShouldUseDarkColors(nativeTheme.shouldUseDarkColors);
-    this.shouldUseDarkColorsListener = () => {
+    const shouldUseDarkColorsListener = () => {
       store.setShouldUseDarkColors(nativeTheme.shouldUseDarkColors);
     };
-    nativeTheme.on('updated', this.shouldUseDarkColorsListener);
-  }
-
-  dispose(): void {
-    if (this.shouldUseDarkColorsListener !== null) {
-      nativeTheme.off('updated', this.shouldUseDarkColorsListener);
-    }
-    this.autorunDisposer?.();
+    nativeTheme.on('updated', shouldUseDarkColorsListener);
+    this.registerDisposable(() => {
+      nativeTheme.off('updated', shouldUseDarkColorsListener);
+    });
   }
 }
diff --git a/packages/main/src/index.ts b/packages/main/src/index.ts
index 8eb0803..3e9e338 100644
--- a/packages/main/src/index.ts
+++ b/packages/main/src/index.ts
@@ -41,11 +41,11 @@ import {
 } from '@sophie/shared';
 import { URL } from 'url';
 
+import { CompositionRoot } from './CompositionRoot';
 import {
   installDevToolsExtensions,
   openDevToolsWhenReady,
 } from './devTools';
-import { injector } from './injector';
 import { createMainStore } from './stores/MainStore';
 
 const isDevelopment = import.meta.env.MODE === 'development';
@@ -104,10 +104,12 @@ if (isDevelopment) {
 let mainWindow: BrowserWindow | null = null;
 
 const store = createMainStore();
-
-const controller = injector.resolve('mainController');
-controller.connect(store).catch((err) => {
-  console.log('Error while initializing app', err);
+const compositionRoot = new CompositionRoot();
+compositionRoot.init(store).catch((err) => {
+  console.log('Failed to initialize application', err);
+});
+app.on('will-quit', () => {
+  compositionRoot.dispose();
 });
 
 const rendererBaseUrl = getResourceUrl('../renderer/');
diff --git a/packages/main/src/services/ConfigPersistenceService.ts b/packages/main/src/services/ConfigPersistenceService.ts
index 61123d9..34d0e3e 100644
--- a/packages/main/src/services/ConfigPersistenceService.ts
+++ b/packages/main/src/services/ConfigPersistenceService.ts
@@ -17,28 +17,25 @@
  *
  * SPDX-License-Identifier: AGPL-3.0-only
  */
-import { FSWatcher, watch } from 'fs';
+import { watch } from 'fs';
 import { readFile, stat, writeFile } from 'fs/promises';
 import JSON5 from 'json5';
 import { throttle } from 'lodash';
 import { join } from 'path';
 
 import type { ConfigSnapshotOut } from  '../stores/Config';
+import type { Disposer } from '../utils';
 
 export type ReadConfigResult = { found: true; data: unknown; } | { found: false; };
 
 export class ConfigPersistenceService {
-  static inject = ['userDataDir', 'configFileName'] as const;
-
   private readonly configFilePath: string;
 
   private timeLastWritten: Date | null = null;
 
-  private watcher: FSWatcher | null = null;
-
   constructor(
     private readonly userDataDir: string,
-    private readonly configFileName: string,
+    private readonly configFileName: string = 'config.json5',
   ) {
     this.configFileName = configFileName;
     this.configFilePath = join(this.userDataDir, this.configFileName);
@@ -69,11 +66,7 @@ export class ConfigPersistenceService {
     this.timeLastWritten = stats.mtime;
   }
 
-  watchConfig(callback: () => Promise<void>, throttleMs: number): void {
-    if (this.watcher !== null) {
-      throw new Error('watchConfig was already called');
-    }
-
+  watchConfig(callback: () => Promise<void>, throttleMs: number): Disposer {
     const configChanged = throttle(async () => {
       let mtime: Date;
       try {
@@ -90,11 +83,11 @@ export class ConfigPersistenceService {
       }
     }, throttleMs);
 
-    this.watcher = watch(this.userDataDir, {
+    const watcher = watch(this.userDataDir, {
       persistent: false,
     });
 
-    this.watcher.on('change', (eventType, filename) => {
+    watcher.on('change', (eventType, filename) => {
       if (eventType === 'change'
         && (filename === this.configFileName || filename === null)) {
         configChanged()?.catch((err) => {
@@ -102,9 +95,7 @@ export class ConfigPersistenceService {
         });
       }
     });
-  }
 
-  dispose(): void {
-    this.watcher?.close();
+    return () => watcher.close();
   }
 }
diff --git a/packages/main/src/controllers/MainController.ts b/packages/main/src/utils.ts
index 6b97330..11c78e9 100644
--- a/packages/main/src/controllers/MainController.ts
+++ b/packages/main/src/utils.ts
@@ -18,21 +18,29 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import type { ConfigController } from './ConfigController';
-import type { NativeThemeController } from './NativeThemeController';
-import type { MainStore } from '../stores/MainStore';
+export type Disposable = Disposer | DisposableObject;
 
-export class MainController {
-  static inject = ['configController', 'nativeThemeController'] as const;
+export type Disposer = () => void;
 
-  constructor(
-    private readonly configController: ConfigController,
-    private readonly nativeThemeController: NativeThemeController,
-  ) {
+export interface DisposableObject {
+  dispose(): void;
+}
+
+export class DisposeHelper implements DisposableObject {
+  private readonly disposers: Disposer[] = [];
+
+  protected registerDisposable<T extends Disposable>(disposable: T): T {
+    if (typeof disposable === 'object') {
+      this.disposers.push(() => disposable.dispose());
+    } else {
+      this.disposers.push(disposable);
+    }
+    return disposable;
   }
 
-  async connect(store: MainStore): Promise<void> {
-    await this.configController.initConfig(store.config);
-    this.nativeThemeController.connect(store);
+  dispose(): void {
+    for (let i = this.disposers.length - 1; i >= 0; i -= 1) {
+      this.disposers[i]();
+    }
   }
 }
diff --git a/yarn.lock b/yarn.lock
index 918aa7a..214d987 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1238,7 +1238,6 @@ __metadata:
     mobx-state-tree: ^5.1.0
     ms: ^2.1.3
     rimraf: ^3.0.2
-    typed-inject: ^3.0.1
     typescript: ^4.5.4
     vite: ^2.7.7
   languageName: unknown
@@ -7378,13 +7377,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"typed-inject@npm:^3.0.1":
-  version: 3.0.1
-  resolution: "typed-inject@npm:3.0.1"
-  checksum: a400797a42951bc46a38873e9be40fe90fdba6ae3362e2d4da4972c4ec48e962ff167bc5f090ca42dc20bb3f6063cd07a80426df520c64dc9e94d1e89ff4779e
-  languageName: node
-  linkType: hard
-
 "typedarray-to-buffer@npm:^3.1.5":
   version: 3.1.5
   resolution: "typedarray-to-buffer@npm:3.1.5"