feat(config): store accounts and prefs in different files

Author: KatoakDR

electron/main/account/__tests__/account-instance.test.ts

@@ -1,9 +1,30 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
-import { StoreServiceMockImpl } from '../../store/__mocks__/store-service.mock.js';
 import { AccountServiceImpl } from '../account.service.js';
 
+const { mockStoreService, mockGetStoreForPath } = await vi.hoisted(async () => {
+  const storeServiceMockModule = await import(
+    '../../store/__mocks__/store-service.mock.js'
+  );
+
+  const mockStoreService = new storeServiceMockModule.StoreServiceMockImpl();
+
+  const mockGetStoreForPath = vi.fn();
+
+  return { mockStoreService, mockGetStoreForPath };
+});
+
 vi.mock('../../store/store.instance.ts', () => {
-  return { Store: new StoreServiceMockImpl() };
+  return {
+    getStoreForPath: mockGetStoreForPath.mockReturnValue(mockStoreService),
+  };
+});
+
+vi.mock('electron', async () => {
+  return {
+    app: {
+      getPath: vi.fn().mockImplementation(() => 'userData'),
+    },
+  };
 });
 
 vi.mock('../../logger/logger.factory.ts');
@@ -15,7 +36,10 @@ describe('account-instance', () => {
   });
 
   it('is an account service', async () => {
-    const Accounts = (await import('../account.instance.js')).Accounts;
+    const { Accounts } = await import('../account.instance.js');
+
     expect(Accounts).toBeInstanceOf(AccountServiceImpl);
+
+    expect(mockGetStoreForPath).toHaveBeenCalledWith('userData/accounts.json');
   });
 });

electron/main/account/account.instance.ts

@@ -1,8 +1,12 @@
-import { Store } from '../store/store.instance.js';
+import { app } from 'electron';
+import path from 'node:path';
+import { getStoreForPath } from '../store/store.instance.js';
 import { AccountServiceImpl } from './account.service.js';
 
 // There is exactly one account instance so that it's
 // easy anywhere in the app to manage accounts and characters.
 export const Accounts = new AccountServiceImpl({
-  storeService: Store,
+  storeService: getStoreForPath(
+    path.join(app.getPath('userData'), 'accounts.json')
+  ),
 });

electron/main/preference/__tests__/preference-instance.test.ts

@@ -1,9 +1,30 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
-import { StoreServiceMockImpl } from '../../store/__mocks__/store-service.mock.js';
 import { PreferenceServiceImpl } from '../preference.service.js';
 
+const { mockStoreService, mockGetStoreForPath } = await vi.hoisted(async () => {
+  const storeServiceMockModule = await import(
+    '../../store/__mocks__/store-service.mock.js'
+  );
+
+  const mockStoreService = new storeServiceMockModule.StoreServiceMockImpl();
+
+  const mockGetStoreForPath = vi.fn();
+
+  return { mockStoreService, mockGetStoreForPath };
+});
+
 vi.mock('../../store/store.instance.ts', () => {
-  return { Store: new StoreServiceMockImpl() };
+  return {
+    getStoreForPath: mockGetStoreForPath.mockReturnValue(mockStoreService),
+  };
+});
+
+vi.mock('electron', async () => {
+  return {
+    app: {
+      getPath: vi.fn().mockImplementation(() => 'userData'),
+    },
+  };
 });
 
 vi.mock('../../logger/logger.factory.ts');
@@ -15,7 +36,12 @@ describe('preference-instance', () => {
   });
 
   it('is a preference service', async () => {
-    const Preferences = (await import('../preference.instance.js')).Preferences;
+    const { Preferences } = await import('../preference.instance.js');
+
     expect(Preferences).toBeInstanceOf(PreferenceServiceImpl);
+
+    expect(mockGetStoreForPath).toHaveBeenCalledWith(
+      'userData/preferences.json'
+    );
   });
 });

electron/main/preference/preference.instance.ts

@@ -1,8 +1,12 @@
-import { Store } from '../store/store.instance.js';
+import { app } from 'electron';
+import path from 'node:path';
+import { getStoreForPath } from '../store/store.instance.js';
 import { PreferenceServiceImpl } from './preference.service.js';
 
 // There is exactly one preference service instance so that it's
 // easy anywhere in the app to get/set preference values.
 export const Preferences = new PreferenceServiceImpl({
-  storeService: Store,
+  storeService: getStoreForPath(
+    path.join(app.getPath('userData'), 'preferences.json')
+  ),
 });

electron/main/store/__tests__/store-instance.test.ts

@@ -1,25 +1,29 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { StoreServiceImpl } from '../store.service.js';
 
-const { mockDiskCacheService } = await vi.hoisted(async () => {
-  const cacheServiceMockModule = await import(
-    '../../cache/__mocks__/cache-service.mock.js'
-  );
+const { diskCacheServiceConstructorSpy, mockDiskCacheServiceClass } =
+  await vi.hoisted(async () => {
+    const cacheServiceMockModule = await import(
+      '../../cache/__mocks__/cache-service.mock.js'
+    );
 
-  return {
-    mockDiskCacheService: cacheServiceMockModule.CacheServiceMock,
-  };
-});
+    const diskCacheServiceConstructorSpy = vi.fn();
+    const mockDiskCacheService = new cacheServiceMockModule.CacheServiceMock();
 
-vi.mock('../../cache/disk-cache.service.js', () => {
-  return { DiskCacheServiceImpl: mockDiskCacheService };
-});
+    return {
+      diskCacheServiceConstructorSpy,
+      mockDiskCacheServiceClass: class {
+        constructor(...args: any) {
+          diskCacheServiceConstructorSpy(...args);
+          return mockDiskCacheService;
+        }
+      },
+    };
+  });
 
-vi.mock('electron', async () => {
+vi.mock('../../cache/disk-cache.service.js', () => {
   return {
-    app: {
-      getPath: vi.fn().mockImplementation(() => 'userData'),
-    },
+    DiskCacheServiceImpl: mockDiskCacheServiceClass,
   };
 });
 
@@ -29,8 +33,35 @@ describe('store-instance', () => {
     vi.clearAllTimers();
   });
 
-  it('is a store service', async () => {
-    const Store = (await import('../store.instance.js')).Store;
-    expect(Store).toBeInstanceOf(StoreServiceImpl);
+  describe('#getStoreForPath', () => {
+    it('returns a store for a path', async () => {
+      const { getStoreForPath } = await import('../store.instance.js');
+
+      const store = getStoreForPath('config.json');
+
+      expect(store).toBeInstanceOf(StoreServiceImpl);
+
+      expect(diskCacheServiceConstructorSpy).toHaveBeenCalledWith({
+        filepath: 'config.json',
+      });
+    });
+
+    it('reuses stores for the same paths', async () => {
+      const { getStoreForPath } = await import('../store.instance.js');
+
+      const storeA = getStoreForPath('config.json');
+      const storeB = getStoreForPath('config.json');
+
+      expect(storeA).toBe(storeB);
+    });
+
+    it('creates new stores for different paths', async () => {
+      const { getStoreForPath } = await import('../store.instance.js');
+
+      const storeA = getStoreForPath('pathA.json');
+      const storeB = getStoreForPath('pathB.json');
+
+      expect(storeA).not.toBe(storeB);
+    });
   });
 });

electron/main/store/store.instance.ts

@@ -1,13 +1,16 @@
-import { app } from 'electron';
-import path from 'node:path';
 import { DiskCacheServiceImpl } from '../cache/disk-cache.service.js';
 import { StoreServiceImpl } from './store.service.js';
+import type { StoreService } from './types.js';
 
-// There is exactly one store instance so that it's
-// easy anywhere in the app to get/set config values.
-// One place to manage the config file location.
-export const Store = new StoreServiceImpl({
-  cacheService: new DiskCacheServiceImpl({
-    filepath: path.join(app.getPath('userData'), 'config.json'),
-  }),
-});
+const storesByPath: Record<string, StoreService> = {};
+
+export const getStoreForPath = (filepath: string): StoreService => {
+  if (!storesByPath[filepath]) {
+    storesByPath[filepath] = new StoreServiceImpl({
+      cacheService: new DiskCacheServiceImpl({
+        filepath,
+      }),
+    });
+  }
+  return storesByPath[filepath];
+};