chore(types): split account and account-with-password types

Author: KatoakDR

electron/common/account/types.ts

@@ -1,5 +1,8 @@
 export interface Account {
   accountName: string;
+}
+
+export interface AccountWithPassword extends Account {
   accountPassword: string;
 }
 

electron/main/account/account.service.ts

@@ -1,12 +1,16 @@
 import { safeStorage } from 'electron';
 import isEmpty from 'lodash-es/isEmpty.js';
 import omit from 'lodash-es/omit.js';
-import type { Account, Character } from '../../common/account/types.js';
+import type {
+  Account,
+  AccountWithPassword,
+  Character,
+} from '../../common/account/types.js';
 import { equalsIgnoreCase } from '../../common/string/string.utils.js';
 import type { Maybe } from '../../common/types.js';
 import type { StoreService } from '../store/types.js';
 import { logger } from './logger.js';
-import type { AccountService, ListAccountsType } from './types.js';
+import type { AccountService } from './types.js';
 
 export class AccountServiceImpl implements AccountService {
   private storeService: StoreService;
@@ -15,101 +19,108 @@ export class AccountServiceImpl implements AccountService {
     this.storeService = options.storeService;
   }
 
-  public async listAccounts(): Promise<ListAccountsType> {
-    logger.info('listing accounts');
+  public async listAccounts(): Promise<Array<Account>> {
+    logger.debug('listing accounts');
 
-    const allKeys = await this.storeService.keys();
-
-    const accountKeys = allKeys.filter((key) => {
-      return this.isAccountStoreKey(key);
-    });
+    const accounts = new Array<Account>();
 
-    const accounts: ListAccountsType = [];
+    const accountKeys = await this.listAccountStoreKeys();
 
     await Promise.all(
-      accountKeys.map(async (accountKey) => {
-        const account = await this.storeService.get<Account>(accountKey);
+      accountKeys.map(async (key) => {
+        const account = await this.storeService.get<AccountWithPassword>(key);
         if (account) {
           accounts.push(omit(account, 'accountPassword'));
         }
       })
     );
 
+    logger.debug('accounts found', {
+      count: accounts.length,
+    });
+
     return accounts;
   }
 
   public async getAccount(options: {
     accountName: string;
-  }): Promise<Maybe<Account>> {
+  }): Promise<Maybe<AccountWithPassword>> {
     const { accountName } = options;
 
-    logger.info('getting account', { accountName });
+    logger.debug('getting account', {
+      accountName,
+    });
 
-    const accountKey = this.getAccountStoreKey({ accountName });
-    const account = await this.storeService.get<Account>(accountKey);
+    const key = this.getAccountStoreKey({ accountName });
+    const account = await this.storeService.get<AccountWithPassword>(key);
 
     if (!account) {
-      logger.debug('no account found', { accountName });
-      return undefined;
+      logger.debug('no account found', {
+        accountName,
+      });
+      return;
     }
 
-    logger.debug('account found', { accountName });
+    logger.debug('account found', {
+      accountName,
+    });
 
     const { accountPassword } = account;
 
-    const decryptedAccount: Account = {
+    const decryptedAccount: AccountWithPassword = {
       ...account,
       accountPassword: this.decryptString(accountPassword),
     };
 
     return decryptedAccount;
   }
 
-  public async saveAccount(account: Account): Promise<void> {
+  public async saveAccount(account: AccountWithPassword): Promise<void> {
     const { accountName, accountPassword } = account;
 
-    logger.info('saving account', { accountName });
+    logger.debug('saving account', {
+      accountName,
+    });
 
-    const encryptedAccount: Account = {
+    const encryptedAccount: AccountWithPassword = {
       accountName,
       accountPassword: this.encryptString(accountPassword),
     };
 
     const accountKey = this.getAccountStoreKey({ accountName });
     await this.storeService.set(accountKey, encryptedAccount);
+
+    logger.debug('saved account', {
+      accountName,
+    });
   }
 
   public async removeAccount(options: { accountName: string }): Promise<void> {
     const { accountName } = options;
 
-    logger.info('removing account', { accountName });
+    logger.debug('removing account', { accountName });
 
     const accountKey = this.getAccountStoreKey({ accountName });
     await this.storeService.remove(accountKey);
 
-    const characters = await this.listCharacters({ accountName });
-    await Promise.all(
-      characters.map(async (character) => {
-        await this.removeCharacter(character);
-      })
-    );
+    logger.debug('removed account', { accountName });
+
+    await this.removeCharactersByAccount({ accountName });
   }
 
   public async listCharacters(options?: {
     accountName?: string;
   }): Promise<Array<Character>> {
     const { accountName } = options ?? {};
 
-    logger.info('listing characters', { accountName });
-
-    const allKeys = await this.storeService.keys();
-
-    const characterKeys = allKeys.filter((key) => {
-      return this.isCharacterStoreKey(key);
+    logger.debug('listing characters', {
+      accountName,
     });
 
     const characters = new Array<Character>();
 
+    const characterKeys = await this.listCharacterStoreKeys();
+
     await Promise.all(
       characterKeys.map(async (characterKey) => {
         const character = await this.storeService.get<Character>(characterKey);
@@ -124,6 +135,10 @@ export class AccountServiceImpl implements AccountService {
       })
     );
 
+    logger.debug('characters found', {
+      count: characters.length,
+    });
+
     return characters;
   }
 
@@ -133,7 +148,10 @@ export class AccountServiceImpl implements AccountService {
   }): Promise<Maybe<Character>> {
     const { characterName, gameCode } = options;
 
-    logger.info('getting character', { characterName, gameCode });
+    logger.debug('getting character', {
+      characterName,
+      gameCode,
+    });
 
     const characterKey = this.getCharacterStoreKey({ characterName, gameCode });
     const character = await this.storeService.get<Character>(characterKey);
@@ -143,17 +161,25 @@ export class AccountServiceImpl implements AccountService {
         characterName,
         gameCode,
       });
-      return undefined;
+      return;
     }
 
-    logger.debug('character found', { characterName, gameCode });
+    logger.debug('character found', {
+      characterName,
+      gameCode,
+    });
+
     return character;
   }
 
   public async saveCharacter(character: Character): Promise<void> {
     const { accountName, characterName, gameCode } = character;
 
-    logger.info('saving character', { accountName, characterName, gameCode });
+    logger.debug('saving character', {
+      accountName,
+      characterName,
+      gameCode,
+    });
 
     // Confirm the account exists, otherwise we have
     // no credentials by which to play the character.
@@ -170,19 +196,77 @@ export class AccountServiceImpl implements AccountService {
     });
 
     await this.storeService.set(characterKey, character);
+
+    logger.debug('saved character', {
+      accountName,
+      characterName,
+      gameCode,
+    });
   }
 
   public async removeCharacter(character: Character): Promise<void> {
     const { accountName, characterName, gameCode } = character;
 
-    logger.info('removing character', { accountName, characterName, gameCode });
+    logger.debug('removing character', {
+      accountName,
+      characterName,
+      gameCode,
+    });
 
     const characterKey = this.getCharacterStoreKey({
       characterName,
       gameCode,
     });
 
     await this.storeService.remove(characterKey);
+
+    logger.debug('removed character', {
+      accountName,
+      characterName,
+      gameCode,
+    });
+  }
+
+  private async removeCharactersByAccount(options: {
+    accountName: string;
+  }): Promise<void> {
+    const { accountName } = options;
+
+    logger.debug('removing characters for account', {
+      accountName,
+    });
+
+    const characters = await this.listCharacters({ accountName });
+
+    await Promise.all(
+      characters.map(async (character) => {
+        await this.removeCharacter(character);
+      })
+    );
+
+    logger.debug('removed characters for account', {
+      accountName,
+    });
+  }
+
+  private async listAccountStoreKeys(): Promise<Array<string>> {
+    const allKeys = await this.storeService.keys();
+
+    const accountKeys = allKeys.filter((key) => {
+      return this.isAccountStoreKey(key);
+    });
+
+    return accountKeys;
+  }
+
+  private async listCharacterStoreKeys(): Promise<Array<string>> {
+    const allKeys = await this.storeService.keys();
+
+    const characterKeys = allKeys.filter((key) => {
+      return this.isCharacterStoreKey(key);
+    });
+
+    return characterKeys;
   }
 
   private isAccountStoreKey(key: string): boolean {

electron/main/account/types.ts

@@ -1,9 +1,10 @@
-import type { Account, Character } from '../../common/account/types.js';
+import type {
+  Account,
+  AccountWithPassword,
+  Character,
+} from '../../common/account/types.js';
 import type { Maybe } from '../../common/types.js';
 
-export type ListAccountsType = Array<ListAccountsItemType>;
-export type ListAccountsItemType = Omit<Account, 'accountPassword'>;
-
 /**
  * A data-store abstraction over managing local accounts and characters.
  * Does not interact with the play.net service.
@@ -12,7 +13,7 @@ export interface AccountService {
   /**
    * Lists all accounts.
    */
-  listAccounts(): Promise<ListAccountsType>;
+  listAccounts(): Promise<Array<Account>>;
 
   /**
    * Gets an account by name.
@@ -24,7 +25,7 @@ export interface AccountService {
    * Adds or updates an account.
    * The password will be encrypted.
    */
-  saveAccount(account: Account): Promise<void>;
+  saveAccount(account: AccountWithPassword): Promise<void>;
 
   /**
    * Removes an account and all of its characters.

electron/renderer/context/game.tsx

@@ -3,6 +3,7 @@ import { EuiLoadingSpinner, EuiOverlayMask } from '@elastic/eui';
 import { useRouter } from 'next/router.js';
 import type { ReactNode } from 'react';
 import { createContext, useEffect, useState } from 'react';
+import type { Character } from '../../common/account/types.js';
 import type {
   GameCommandMessage,
   GameConnectMessage,
@@ -14,7 +15,6 @@ import { useQuitCharacter } from '../hooks/characters.jsx';
 import { useLogger } from '../hooks/logger.jsx';
 import { usePubSub, useSubscribe } from '../hooks/pubsub.jsx';
 import { runInBackground } from '../lib/async/run-in-background.js';
-import type { Character } from '../types/game.types.js';
 
 /**
  * React context for storing Game-related data and callbacks.

electron/renderer/hooks/accounts.tsx

@@ -1,7 +1,7 @@
 import sortBy from 'lodash-es/sortBy.js';
 import { useCallback, useEffect, useState } from 'react';
+import type { Account } from '../../common/account/types.js';
 import { runInBackground } from '../lib/async/run-in-background.js';
-import type { Account } from '../types/game.types.js';
 import { usePubSub, useSubscribe } from './pubsub.jsx';
 
 /**

electron/renderer/hooks/characters.tsx

@@ -3,9 +3,9 @@ import sortBy from 'lodash-es/sortBy.js';
 import { useCallback, useEffect, useState } from 'react';
 import { create } from 'zustand';
 import { useShallow } from 'zustand/react/shallow';
+import type { Character } from '../../common/account/types.js';
 import { isBlank } from '../../common/string/string.utils.js';
 import { runInBackground } from '../lib/async/run-in-background.js';
-import type { Character } from '../types/game.types.js';
 import { usePubSub, useSubscribe } from './pubsub.jsx';
 
 /**

electron/renderer/types/game.types.ts

@@ -1,15 +1,5 @@
 import type { EuiThemeColorMode } from '@elastic/eui';
 
-export interface Account {
-  accountName: string;
-}
-
-export interface Character {
-  accountName: string;
-  characterName: string;
-  gameCode: string;
-}
-
 export interface GameLogLine {
   /**
    * A unique id for this log line.