#158 - save draft request on close

Author: vicky16898

src/main/main.ts

@@ -1,4 +1,4 @@
-import { app, BrowserWindow, shell } from 'electron';
+import { app, BrowserWindow, ipcMain, shell } from 'electron';
 import { EnvironmentService } from 'main/environment/service/environment-service';
 import 'main/event/main-event-service';
 import path from 'node:path';
@@ -33,6 +33,30 @@ const createWindow = async () => {
     return { action: 'deny' };
   });
 
+  // Handle window close event
+  let isClosing = false;
+  mainWindow.on('close', async (event) => {
+    if (!isClosing) {
+      isClosing = true;
+      event.preventDefault();
+      mainWindow?.webContents.send('before-close');
+
+      // Wait for the renderer to respond or timeout
+      try {
+        await new Promise<void>((resolve, reject) => {
+          ipcMain.once('ready-to-close', () => resolve());
+          setTimeout(() => reject(new Error('Timeout')), 30000);
+        });
+      } catch (error) {
+        console.error('Could not handle close event in renderer:', error);
+      }
+
+      // Close app
+      mainWindow.close();
+      app.quit();
+    }
+  });
+
   // Load the index.html of the app.
   if (MAIN_WINDOW_VITE_DEV_SERVER_URL) {
     await mainWindow.loadURL(MAIN_WINDOW_VITE_DEV_SERVER_URL);

src/main/persistence/service/persistence-service.ts

@@ -305,7 +305,7 @@ export class PersistenceService {
 
   private async loadRequest(parentId: string, dirPath: string): Promise<TrufosRequest> {
     const type = 'request' as const;
-    const draft = !(await exists(path.join(dirPath, type + '.json')));
+    const draft = await exists(path.join(dirPath, '~' + type + '.json'));
     const info = await this.readInfoFile(dirPath, type, draft);
     this.idToPathMap.set(info.id, dirPath);
 

src/renderer/services/event/renderer-event-service.ts

@@ -1,36 +1,17 @@
 import { IEventService } from 'shim/event-service';
 import { MainProcessError } from '@/error/MainProcessError';
 
-const METHOD_NAMES = new Set<keyof IEventService>([
-  'saveRequest',
-  'sendRequest',
-  'getAppVersion',
-  'loadCollection',
-  'saveChanges',
-  'discardChanges',
-  'deleteObject',
-  'getActiveEnvironmentVariables',
-  'getVariable',
-  'setCollectionVariables',
-]);
-
-const INSTANCE = {} as IEventService;
-for (const methodName of METHOD_NAMES) {
-  Reflect.defineProperty(INSTANCE, methodName, {
-    value: createEventMethod(methodName),
-    writable: false,
-    enumerable: true,
-    configurable: false,
-  });
-}
-
 /**
  * Creates a method that sends an IPC event to the main process and returns the result. If the
  * result is an error, it is thrown.
  * @param methodName The name of the event method to call in the main process.
  */
-function createEventMethod(methodName: keyof IEventService) {
-  return async function (...args: any[]) {
+function createEventMethod<T extends keyof IEventService>(methodName: T) {
+  return async function (
+    ...args: Parameters<IEventService[T]>
+  ): Promise<
+    ReturnType<IEventService[T]> extends Promise<infer R> ? R : ReturnType<IEventService[T]>
+  > {
     const result = await window.electron.ipcRenderer.invoke(methodName, ...args);
     if (result instanceof Error) {
       throw new MainProcessError(result.message);
@@ -40,7 +21,33 @@ function createEventMethod(methodName: keyof IEventService) {
   };
 }
 
-export const RendererEventService = {
-  /** The singleton instance of the RendererEventService */
-  instance: INSTANCE,
-};
+export interface RendererEventService {
+  on(event: 'before-close', listener: () => void): this;
+
+  emit(event: 'ready-to-close'): this;
+}
+
+export class RendererEventService implements IEventService {
+  public static readonly instance = new RendererEventService();
+
+  on(event: string, listener: (...args: unknown[]) => void) {
+    window.electron.ipcRenderer.on(event, listener);
+    return this;
+  }
+
+  emit(event: string, ...args: unknown[]) {
+    window.electron.ipcRenderer.send(event, ...args);
+    return this;
+  }
+
+  saveRequest = createEventMethod('saveRequest');
+  sendRequest = createEventMethod('sendRequest');
+  getAppVersion = createEventMethod('getAppVersion');
+  loadCollection = createEventMethod('loadCollection');
+  saveChanges = createEventMethod('saveChanges');
+  discardChanges = createEventMethod('discardChanges');
+  deleteObject = createEventMethod('deleteObject');
+  getActiveEnvironmentVariables = createEventMethod('getActiveEnvironmentVariables');
+  getVariable = createEventMethod('getVariable');
+  setCollectionVariables = createEventMethod('setCollectionVariables');
+}

src/renderer/state/requestStore.ts

@@ -8,6 +8,16 @@ import { RendererEventService } from '@/services/event/renderer-event-service';
 import { useActions } from '@/state/util';
 
 const eventService = RendererEventService.instance;
+eventService.on('before-close', async () => {
+  console.info('Saving currently opened request before closing');
+  const state = useRequestStore.getState();
+  const request = selectRequest(state);
+  if (request != null && request.draft) {
+    console.debug(`Saving request with ID ${request.id}`);
+    await eventService.saveRequest(request, state.requestEditor?.getValue());
+  }
+  eventService.emit('ready-to-close');
+});
 
 interface RequestState {
   requests: TrufosRequest[];