feat: stub out new ipc methods

Author: KatoakDR

electron/main/ipc.ts

@@ -0,0 +1,2 @@
+export * from './ipc';
+export * from './ipc.types';

electron/main/ipc/index.ts

@@ -0,0 +1,79 @@
+import { ipcMain } from 'electron';
+import type { AppAPI } from '../../preload';
+import { createLogger } from '../logger';
+import type { SGEGameCode } from '../sge';
+import { SGEServiceImpl } from '../sge';
+import type { IpcHandlerRegistry, IpcInvokeHandler } from './ipc.types';
+
+const logger = createLogger('ipc');
+
+const pingHandler: IpcInvokeHandler<'ping'> = async (): Promise<string> => {
+  return 'pong';
+};
+
+const sgeListCharactersHandler: IpcInvokeHandler<'sgeListCharacters'> = async (
+  args
+) => {
+  const { username, password, gameCode } = args[0];
+
+  logger.debug('sgeListCharacters', { username, gameCode });
+
+  const sgeService = new SGEServiceImpl({
+    username,
+    password,
+    gameCode: gameCode as SGEGameCode,
+  });
+
+  const characters = await sgeService.listCharacters();
+
+  logger.debug('sgeListCharacters', { characters });
+
+  return characters;
+};
+
+const sgePlayCharacterHandler: IpcInvokeHandler<'sgePlayCharacter'> = async (
+  args
+) => {
+  const { username, password, gameCode, characterName } = args[0];
+
+  logger.debug('sgePlayCharacter', { username, gameCode, characterName });
+
+  const sgeService = new SGEServiceImpl({
+    username,
+    password,
+    gameCode: gameCode as SGEGameCode,
+  });
+
+  const credentials = await sgeService.loginCharacter(characterName);
+
+  logger.debug('sgePlayCharacter', { credentials });
+};
+
+const ipcHandlerRegistry: IpcHandlerRegistry = {
+  ping: pingHandler,
+  sgeListCharacters: sgeListCharactersHandler,
+  sgePlayCharacter: sgePlayCharacterHandler,
+};
+
+export const registerIpcHandlers = (): void => {
+  Object.keys(ipcHandlerRegistry).forEach((channel) => {
+    const handler = ipcHandlerRegistry[channel as keyof AppAPI];
+
+    if (!handler) {
+      logger.error('no handler registered for channel', { channel });
+      throw new Error(`[IPC:CHANNEL:INVALID] ${channel}`);
+    }
+
+    ipcMain.handle(channel, async (_event, ...params) => {
+      try {
+        logger.debug('handling channel request', { channel });
+        const result = await handler(params as any);
+        logger.debug('handled channel request', { channel });
+        return result;
+      } catch (error) {
+        logger.error('error handling channel request', { channel, error });
+        throw new Error(`[IPC:CHANNEL:ERROR] ${channel}: ${error?.message}`);
+      }
+    });
+  });
+};

electron/main/ipc/ipc.ts

@@ -0,0 +1,7 @@
+export interface IpcInvokeHandler<K extends keyof AppAPI> {
+  (params: Parameters<AppAPI[K]>): ReturnType<AppAPI[K]>;
+}
+
+export type IpcHandlerRegistry = {
+  [channel in keyof AppAPI]: IpcInvokeHandler<channel>;
+};

electron/main/ipc/ipc.types.ts

@@ -3,8 +3,28 @@
  */
 declare const appAPI: {
   ping: () => Promise<string>;
-  speak: (text: string) => Promise<void>;
-  climb: (data: { height: number }) => Promise<number>;
+  /**
+   * List available characters for a given play.net account.
+   */
+  sgeListCharacters: (options: {
+    username: string;
+    password: string;
+    gameCode: string;
+  }) => Promise<
+    Array<{
+      id: string;
+      name: string;
+    }>
+  >;
+  /**
+   * Log in to game with a given character.
+   */
+  sgePlayCharacter: (options: {
+    username: string;
+    password: string;
+    gameCode: string;
+    characterName: string;
+  }) => Promise<void>;
 };
 declare global {
   type TypeOfAppAPI = typeof appAPI;

electron/preload/index.d.ts

@@ -10,11 +10,26 @@ const appAPI = {
   ping: async (): Promise<string> => {
     return ipcRenderer.invoke('ping');
   },
-  speak: async (text: string): Promise<void> => {
-    return ipcRenderer.invoke('speak', text);
+  /**
+   * List available characters for a given play.net account.
+   */
+  sgeListCharacters: async (options: {
+    username: string;
+    password: string;
+    gameCode: string;
+  }): Promise<Array<{ id: string; name: string }>> => {
+    return ipcRenderer.invoke('sgeListCharacters', options);
   },
-  climb: async (data: { height: number }): Promise<number> => {
-    return ipcRenderer.invoke('climb', data);
+  /**
+   * Log in to game with a given character.
+   */
+  sgePlayCharacter: async (options: {
+    username: string;
+    password: string;
+    gameCode: string;
+    characterName: string;
+  }): Promise<void> => {
+    return ipcRenderer.invoke('sgePlayCharacter', options);
   },
 };