feat: improve requirements typing

Author: MarcScheib

src/app/config.ts

@@ -65,6 +65,5 @@ export function getConfig(cleanCache = false): Config {
   };
 
   config = { ...defaultConfig, ...packageConfig, ...argsConfig };
-
   return config;
 }

src/app/core/index.ts

@@ -0,0 +1 @@
+export { getRequirements } from './requirements';

src/app/core/requirements.ts

@@ -0,0 +1,54 @@
+import { exec } from 'child_process';
+import { BrowserWindow, IpcMainEvent, IpcMainInvokeEvent } from 'electron';
+import { promisify } from 'util';
+import {
+  Requirement,
+  RequirementsResource,
+} from '../../shared/types/requirements';
+
+const requirements = [
+  'node -v',
+  'npm -v',
+  'mvn --version',
+  'java -version',
+  'git --version',
+];
+const execPromise = promisify(exec);
+
+export default class RequirementsFacade implements RequirementsResource {
+  async getRequirements(): Promise<Requirement[]> {
+    return Promise.all(
+      requirements.map(requirement =>
+        execPromise(requirement).then(({ stdout, stderr }) => ({
+          name: requirement,
+          cmd: requirement,
+          state: stdout ? ('ok' as const) : ('error' as const),
+          message: stdout || stderr,
+        }))
+      )
+    );
+  }
+}
+
+const cache: {
+  [windowId: string]: RequirementsFacade;
+} = {};
+
+export const getRequirements = (
+  e: IpcMainEvent | IpcMainInvokeEvent
+): RequirementsFacade => {
+  const sourceWindow = BrowserWindow.fromWebContents(e.sender);
+  if (!sourceWindow) {
+    throw new Error('Could not resolve current window');
+  }
+
+  const windowId = sourceWindow.id;
+
+  let instance = cache[windowId];
+  if (!instance) {
+    instance = new RequirementsFacade();
+    cache[windowId] = instance;
+  }
+
+  return new RequirementsFacade();
+};

src/app/ipc-main.ts

@@ -1,32 +1,13 @@
-import { exec } from 'child_process';
-import { ipcMain } from 'electron';
-import { promisify } from 'util';
+import { IpcMainInvokeEvent, ipcMain } from 'electron';
 import * as events from '../shared/events';
-import createLogger from './logger';
+import { getRequirements } from './core';
 
-const logger = createLogger('app');
-
-const requirements = [
-  'node -v',
-  'npm -v',
-  'mvn --version',
-  'java -version',
-  'git --version',
-];
-const execPromise = promisify(exec);
-
-async function getRequirements(): Promise<
-  { stdout: string; stderr: string }[]
-> {
-  return Promise.all(
-    requirements.map(requirement => {
-      return execPromise(requirement);
-    })
+function registerRequirementsIPCMainHandlers() {
+  ipcMain.handle(events.TIP_GET_REQUIREMENTS, (e: IpcMainInvokeEvent) =>
+    getRequirements(e).getRequirements()
   );
 }
 
 export const registerIPCMainHandlers = (): void => {
-  logger.info('registerIPCMainHandlers');
-
-  ipcMain.handle(events.TIP_GET_REQUIREMENTS, getRequirements);
+  registerRequirementsIPCMainHandlers();
 };

src/app/preload.ts

@@ -1,9 +1,11 @@
 import { contextBridge, ipcRenderer } from 'electron';
-import { TipManagerAPI } from '../shared/api';
+import { TipManagerResource } from '../shared/api';
 import * as events from '../shared/events';
 
-const tipManagerAPI: TipManagerAPI = {
-  getRequirements: () => ipcRenderer.invoke(events.TIP_GET_REQUIREMENTS),
+const tipManagerResource: TipManagerResource = {
+  requirements: {
+    getRequirements: () => ipcRenderer.invoke(events.TIP_GET_REQUIREMENTS),
+  },
 };
 
-contextBridge.exposeInMainWorld('tipmanager', tipManagerAPI);
+contextBridge.exposeInMainWorld('tipmanager', tipManagerResource);

src/shared/api.ts

@@ -1,3 +1,5 @@
-export interface TipManagerAPI {
-  getRequirements(): Promise<{ stdout: string; stderr: string }[]>;
+import { RequirementsResource } from './types/requirements';
+
+export interface TipManagerResource {
+  requirements: RequirementsResource;
 }

src/shared/types/requirements.ts

@@ -0,0 +1,10 @@
+export interface Requirement {
+  name: string;
+  cmd: string;
+  state: 'ok' | 'error';
+  message: string;
+}
+
+export interface RequirementsResource {
+  getRequirements(): Promise<Requirement[]>;
+}

src/ui/electron-api/common.ts

@@ -1,11 +1,11 @@
 import Button from '@mui/material/Button';
 import { useState } from 'react';
-import { CommonAPI } from '../../electron-api/common';
+import { RequirementsResourceImpl } from '../../tip-manager-api/requirements';
 
 export default function Requirements() {
   const getRequirements = async () => {
-    const requirements = await new CommonAPI().getRequirements();
-    setRequirements(requirements.map(requirement => requirement.stdout));
+    const requirements = await new RequirementsResourceImpl().getRequirements();
+    setRequirements(requirements.map(requirement => requirement.message));
   };
 
   const [requirements, setRequirements] = useState<string[]>([]);

src/ui/modules/requirements/requirements.tsx

@@ -1,13 +1,13 @@
-import { TipManagerAPI } from '../../shared/api';
+import { TipManagerResource } from '../../shared/api';
 
 declare global {
   interface Window {
-    tipmanager: TipManagerAPI;
+    tipmanager: TipManagerResource;
   }
 }
 
 export class BaseAPI {
-  private _base: TipManagerAPI;
+  private _base: TipManagerResource;
 
   get base() {
     return this._base;

src/ui/electron-api/base.ts src/ui/tip-manager-api/base.ts

@@ -0,0 +1,14 @@
+import type {
+  Requirement,
+  RequirementsResource,
+} from '../../shared/types/requirements';
+import { BaseAPI } from './base';
+
+export class RequirementsResourceImpl
+  extends BaseAPI
+  implements RequirementsResource
+{
+  async getRequirements(): Promise<Requirement[]> {
+    return this.base.requirements.getRequirements();
+  }
+}