1 files changed, 80 insertions, 64 deletions

diff --git a/packages/main/src/infrastructure/config/impl/ConfigFile.ts b/packages/main/src/infrastructure/config/impl/ConfigFile.ts
index e8237b4..8f0cc3f 100644
--- a/packages/main/src/infrastructure/config/impl/ConfigFile.ts
+++ b/packages/main/src/infrastructure/config/impl/ConfigFile.ts
@@ -22,120 +22,136 @@ import { watch } from 'node:fs';
 import { readFile, stat, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 
-import JSON5 from 'json5';
-import { throttle } from 'lodash-es';
+import { debounce } from 'lodash-es';
 
-import type Config from '../../../stores/config/Config';
-import type Disposer from '../../../utils/Disposer';
-import { getLogger } from '../../../utils/log';
-import type ConfigRepository from '../ConfigRepository';
-import type { ReadConfigResult } from '../ConfigRepository';
+import type Disposer from '../../../utils/Disposer.js';
+import getLogger from '../../../utils/getLogger.js';
+import isErrno from '../../../utils/isErrno.js';
+import type ConfigRepository from '../ConfigRepository.js';
+import type { ReadConfigResult } from '../ConfigRepository.js';
 
 const log = getLogger('ConfigFile');
 
-export default class ConfigFile implements ConfigRepository {
-  readonly #userDataDir: string;
-
-  readonly #configFileName: string;
+export const CONFIG_FILE_NAME = 'settings.json';
+export const DEFAULT_CONFIG_CHANGE_DEBOUNCE_MS = 10;
 
-  readonly #configFilePath: string;
+export default class ConfigFile implements ConfigRepository {
+  private readonly configFilePath: string;
 
-  #writingConfig = false;
+  private writingConfig = false;
 
-  #timeLastWritten: Date | undefined;
+  private timeLastWritten: Date | undefined;
 
-  constructor(userDataDir: string, configFileName = 'config.json5') {
-    this.#userDataDir = userDataDir;
-    this.#configFileName = configFileName;
-    this.#configFilePath = path.join(userDataDir, configFileName);
+  constructor(
+    private readonly userDataDir: string,
+    private readonly configFileName = CONFIG_FILE_NAME,
+    private readonly debounceTime = DEFAULT_CONFIG_CHANGE_DEBOUNCE_MS,
+  ) {
+    this.configFilePath = path.join(userDataDir, configFileName);
   }
 
   async readConfig(): Promise<ReadConfigResult> {
-    let configStr: string;
+    let contents: string;
     try {
-      configStr = await readFile(this.#configFilePath, 'utf8');
+      contents = await readFile(this.configFilePath, 'utf8');
     } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-        log.debug('Config file', this.#configFilePath, 'was not found');
+      if (isErrno(error, 'ENOENT')) {
+        log.debug('Config file', this.configFilePath, 'was not found');
         return { found: false };
       }
       throw error;
     }
-    log.info('Read config file', this.#configFilePath);
+    log.debug('Read config file', this.configFilePath);
     return {
       found: true,
-      data: JSON5.parse(configStr),
+      contents,
     };
   }
 
-  async writeConfig(configSnapshot: Config): Promise<void> {
-    const configJson = JSON5.stringify(configSnapshot, {
-      space: 2,
-    });
-    this.#writingConfig = true;
+  async writeConfig(contents: string): Promise<void> {
+    if (this.writingConfig) {
+      throw new Error('writeConfig cannot be called reentrantly');
+    }
+    this.writingConfig = true;
     try {
-      await writeFile(this.#configFilePath, configJson, 'utf8');
-      const { mtime } = await stat(this.#configFilePath);
-      log.trace('Config file', this.#configFilePath, 'last written at', mtime);
-      this.#timeLastWritten = mtime;
+      await writeFile(this.configFilePath, contents, 'utf8');
+      const { mtime } = await stat(this.configFilePath);
+      log.trace('Config file', this.configFilePath, 'last written at', mtime);
+      this.timeLastWritten = mtime;
     } finally {
-      this.#writingConfig = false;
+      this.writingConfig = false;
     }
-    log.debug('Wrote config file', this.#configFilePath);
+    log.debug('Wrote config file', this.configFilePath);
   }
 
-  watchConfig(callback: () => Promise<void>, throttleMs: number): Disposer {
-    log.debug('Installing watcher for', this.#userDataDir);
+  watchConfig(callback: () => Promise<void>): Disposer {
+    log.debug('Installing watcher for', this.userDataDir);
 
-    const configChanged = throttle(async () => {
+    const configChanged = debounce(async () => {
       let mtime: Date;
       try {
-        const stats = await stat(this.#configFilePath);
+        const stats = await stat(this.configFilePath);
         mtime = stats.mtime;
         log.trace('Config file last modified at', mtime);
       } catch (error) {
-        if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        if (isErrno(error, 'ENOENT')) {
           log.debug(
             'Config file',
-            this.#configFilePath,
+            this.configFilePath,
             'was deleted after being changed',
           );
           return;
         }
-        throw error;
+        log.error(
+          'Unexpected error while listening for config file changes',
+          error,
+        );
+        return;
       }
       if (
-        !this.#writingConfig &&
-        (this.#timeLastWritten === undefined || mtime > this.#timeLastWritten)
+        !this.writingConfig &&
+        (this.timeLastWritten === undefined || mtime > this.timeLastWritten)
       ) {
         log.debug(
           'Found a config file modified at',
           mtime,
-          'whish is newer than last written',
-          this.#timeLastWritten,
+          'which is newer than last written',
+          this.timeLastWritten,
         );
-        await callback();
-      }
-    }, throttleMs);
-
-    const watcher = watch(this.#userDataDir, {
-      persistent: false,
-    });
-
-    watcher.on('change', (eventType, filename) => {
-      if (
-        eventType === 'change' &&
-        (filename === this.#configFileName || filename === null)
-      ) {
-        configChanged()?.catch((err) => {
-          log.error('Unhandled error while listening for config changes', err);
-        });
+        try {
+          await callback();
+        } catch (error) {
+          log.error('Callback error while listening for config changes', error);
+        }
       }
-    });
+    }, this.debounceTime);
+
+    const watcher = watch(
+      this.userDataDir,
+      {
+        persistent: false,
+        recursive: false,
+      },
+      (_eventType, filename) => {
+        // We handle both `rename` and `change` events for maximum portability.
+        // This may result in multiple calls to `configChanged` for a single config change,
+        // so we debounce it with a short (imperceptible) delay.
+        if (filename === this.configFileName || filename === null) {
+          configChanged()?.catch((err) => {
+            // This should never happen, because `configChanged` handles all exceptions.
+            log.error(
+              'Unhandled error while listening for config changes',
+              err,
+            );
+          });
+        }
+      },
+    );
 
     return () => {
-      log.trace('Removing watcher for', this.#configFilePath);
+      log.trace('Removing watcher for', this.configFilePath);
       watcher.close();
+      configChanged.cancel();
     };
   }
 }