Merge pull request #18 from nateshmbhat/persistancy

added data persistance

app/App.svelte

@@ -1,20 +1,22 @@
 <script lang="ts">
   import TapRpc from "./renderer/components/TapRpc.svelte";
   import { MaterialApp } from "svelte-materialify";
-  import { onMount } from "svelte";
+  import { onDestroy, onMount } from "svelte";
   import { ProtoFilesDiskStore } from "./disk_storage/protos";
   import { ProtoUtil } from "./commons/utils";
   import { protoImportPathsStore } from "./stores";
   import AppSnackBar from "./renderer/components/microComponents/AppSnackBar.svelte";
+  import { AppDataDiskStore } from "./disk_storage/appDataDiskStorage";
+  import { appConfigStore } from "./stores/appConfigStore";
 
   onMount(async () => {
     const protoFilePaths = ProtoFilesDiskStore.fetchProtoFiles();
-    ProtoUtil.loadProtoFilesAndStartServer(
+    await ProtoUtil.loadProtoFilesAndStartServer(
       protoFilePaths,
       $protoImportPathsStore
     );
+    appConfigStore.setValue(AppDataDiskStore.fetchAppData());
   });
-
 </script>
 
 <MaterialApp>
@@ -60,5 +62,4 @@
   .flex-expand {
     flex: 1 1 auto;
   }
-
 </style>

app/commons/ipc/ipcChannelInterface.ts

@@ -1,9 +1,11 @@
-import type { IpcMainEvent , IpcRendererEvent } from "electron";
+import type { IpcMainEvent, IpcRendererEvent } from "electron";
 
 export enum IpcChannel {
     startServer = 'setProtoFiles',
     setProtoImportPaths = 'setProtoImportPaths',
-    onRequest= 'onRequest'
+    onRequest = 'onRequest',
+    onAppCloseRequest = 'onAppCloseRequest',
+    closeElectronApp = 'closeElectronApp'
 }
 
 export interface IpcRequest {

app/commons/utils/util.ts

@@ -3,18 +3,17 @@ import type { OpenDialogReturnValue } from "electron/main";
 import { loadProtos, RpcProtoInfo } from "../../renderer/behaviour";
 import { protoFilesStore, servicesStore } from "../../stores";
 import faker, { random } from 'faker';
-import { appConfigStore } from "../../stores/tabStore";
 import { get } from "svelte/store";
 import type { IncomingRequest, TabConfigModel } from "../../renderer/components/types/types";
 import { Metadata } from "@grpc/grpc-js";
 import type { MethodPayload } from "bloomrpc-mock-js";
-import { randomInt } from "crypto";
+import { appConfigStore } from "../../stores/appConfigStore";
 
 export class ProtoUtil {
     static async getMethodRpc(serviceName: string, methodName: string): Promise<RpcProtoInfo> {
         const services = await servicesStore.getValue()
         return new Promise<RpcProtoInfo>((res, rej) => {
-            const filteredServices = services.filter((service, index) => service.serviceName === serviceName)
+            const filteredServices = services.filter((service, index) => service.fullServiceName === serviceName)
             if (filteredServices.length == 0) {
                 rej('could not find the service ' + serviceName)
                 return
@@ -62,7 +61,7 @@ export class TabUtil {
         const appConfig = get(appConfigStore)
         return appConfig.tabs.find((tabModel, index, allTabs) => {
             const rpc = tabModel.selectedRpc
-            return rpc?.serviceName == rpcProtoInfo.serviceName && rpc.methodName == rpcProtoInfo.methodName
+            return rpc?.fullServiceName == rpcProtoInfo.fullServiceName && rpc.methodName == rpcProtoInfo.methodName
         })
     }
 }

app/disk_storage/appDataDiskStorage.ts

@@ -0,0 +1,127 @@
+// @ts-ignore
+import * as Store from "electron-store";
+import { get } from "svelte/store";
+import type { Certificate, RpcProtoInfo } from "../renderer/behaviour";
+import { EditorEventEmitter } from "../renderer/behaviour/responseStateController";
+import { AppConfigModel, EditorDataFlowMode, MockRpcEditorModel, MonitorConnectionStatus, RpcOperationMode, TabConfigModel } from "../renderer/components/types/types";
+import { protoFilesStore } from "../stores";
+
+
+export function getDefaultTabConfig(): TabConfigModel {
+	return ({
+		id: '0',
+		selectedRpc: undefined,
+		targetGrpcServerUrl: '',
+		rpcOperationMode: RpcOperationMode.monitor,
+		monitorRequestEditorState: {
+			connectionStatus: MonitorConnectionStatus.waiting,
+			eventEmitter: new EditorEventEmitter(), dataFlowMode: EditorDataFlowMode.passThrough
+		},
+		clientRequestEditorState: { text: '{}', metadata: '' },
+		monitorResponseEditorState: {
+			connectionStatus: MonitorConnectionStatus.waiting,
+			eventEmitter: new EditorEventEmitter(), dataFlowMode: EditorDataFlowMode.passThrough
+		},
+		clientResponseEditorState: { text: '', metadata: '' },
+		mockRpcEditorState: { responseText: '{}' }
+	});
+}
+
+const appDataDiskStore = new Store({
+	name: "appDataDiskStore",
+});
+
+const KEYS = {
+	tabs: 'tabs',
+	activeTabIndex: 'activeTabIndex',
+	defaultTargetServerUrl: 'defaultTargetServerUrl'
+};
+
+export abstract class AppDataDiskStore {
+	static storeAppData(appConfigModel: AppConfigModel) {
+		const serializedTabs = appConfigModel.tabs.map(tabModel => TabModelConverter.serializeModel(tabModel))
+		console.log('seraizlied tabs = ', serializedTabs)
+		appDataDiskStore.set(KEYS.tabs, serializedTabs)
+		appDataDiskStore.set(KEYS.activeTabIndex, appConfigModel.activeTabIndex)
+		appDataDiskStore.set(KEYS.defaultTargetServerUrl, appConfigModel.defaultTargetServerUrl)
+	}
+
+	static fetchAppData(): AppConfigModel {
+		const defaultTabConfig = getDefaultTabConfig();
+		const tabsSavedData: SerializedTabConfigModel[] | undefined = appDataDiskStore.get(KEYS.tabs)
+		console.log('saved tabs = ', tabsSavedData)
+		return {
+			tabs: tabsSavedData !== undefined ? tabsSavedData.map(t => TabModelConverter.deserializeToModel(t)) : [defaultTabConfig],
+			activeTabIndex: appDataDiskStore.get(KEYS.activeTabIndex, 0),
+			defaultTargetServerUrl: appDataDiskStore.get(KEYS.defaultTargetServerUrl, defaultTabConfig.targetGrpcServerUrl)
+		}
+	}
+
+	static clear() {
+		return appDataDiskStore.clear()
+	}
+}
+
+interface SerializedTabConfigModel {
+	selectedProto: ({
+		protoFileName?: string;
+		fullServiceName?: string;
+		methodName?: string;
+	}),
+	id: string;
+	targetGrpcServerUrl: string;
+	rpcOperationMode: RpcOperationMode;
+	// monitorRequestEditorState: MonitorRequestEditorModel;
+	// monitorResponseEditorState: MonitorResponseEditorModel;
+	tlsCertificate?: Certificate,
+	clientRequestEditorState: {
+		text: string;
+		metadata: string;
+	};
+	clientResponseEditorState: {
+		text: string;
+		metadata: string;
+	};
+	mockRpcEditorState: MockRpcEditorModel;
+}
+
+abstract class TabModelConverter {
+	static serializeModel(tabConfigModel: TabConfigModel): SerializedTabConfigModel {
+		return {
+			id: tabConfigModel.id,
+			mockRpcEditorState: tabConfigModel.mockRpcEditorState,
+			rpcOperationMode: tabConfigModel.rpcOperationMode,
+			targetGrpcServerUrl: tabConfigModel.targetGrpcServerUrl,
+			tlsCertificate: tabConfigModel.tlsCertificate,
+			selectedProto: {
+				methodName: tabConfigModel.selectedRpc?.methodName,
+				fullServiceName: tabConfigModel.selectedRpc?.fullServiceName,
+				protoFileName: tabConfigModel.selectedRpc?.protoFileName,
+			},
+			clientRequestEditorState: { ...tabConfigModel.clientRequestEditorState },
+			clientResponseEditorState: { ...tabConfigModel.clientResponseEditorState },
+		}
+	}
+
+	static deserializeToModel(serializedTabConfig: SerializedTabConfigModel): TabConfigModel {
+		const selectedRpcInfo = serializedTabConfig.selectedProto
+		const allProtoFiles = get(protoFilesStore)
+		let services = allProtoFiles.find((file) => file.fileName === selectedRpcInfo.protoFileName)?.services
+		let selectedRpc: RpcProtoInfo | undefined
+		if (services !== undefined) {
+			selectedRpc = Object.values(services).find(s => s.fullServiceName === selectedRpcInfo.fullServiceName)?.methods[selectedRpcInfo.methodName!]
+		}
+		const defaultTabConfig = getDefaultTabConfig()
+		return {
+			...defaultTabConfig,
+			selectedRpc,
+			clientRequestEditorState: serializedTabConfig.clientRequestEditorState,
+			clientResponseEditorState: serializedTabConfig.clientResponseEditorState,
+			id: serializedTabConfig.id,
+			mockRpcEditorState: serializedTabConfig.mockRpcEditorState,
+			rpcOperationMode: serializedTabConfig.rpcOperationMode,
+			targetGrpcServerUrl: serializedTabConfig.targetGrpcServerUrl,
+			tlsCertificate: serializedTabConfig.tlsCertificate,
+		}
+	}
+}

app/disk_storage/index.ts

@@ -1,11 +1,14 @@
 import { ProtoPathDiskStore } from "./importPaths";
 import { ProtoFilesDiskStore } from "./protos";
 import { TlsCertDiskStore } from "./certificates";
+import { AppDataDiskStore } from "./appDataDiskStorage";
 
 export class ElectronDiskStorage {
   clearAllDiskStores() {
-    ProtoPathDiskStore.clear();
-    ProtoFilesDiskStore.clear();
-    TlsCertDiskStore.clear();
+    ProtoPathDiskStore.clear()
+    ProtoFilesDiskStore.clear()
+    TlsCertDiskStore.clear()
+    TlsCertDiskStore.clear()
+    AppDataDiskStore.clear()
   }
 }

app/index.ts

@@ -1,6 +1,6 @@
 import { ipcRenderer } from 'electron';
 import App from './App.svelte';
-import { RequestHandlerChannel } from './renderer/ipc/ipcRendererChannels';
+import { AppQuitHandlerChannel, RequestHandlerChannel } from './renderer/ipc/ipcRendererChannels';
 import type { IpcRendererChannelInterface } from './commons/ipc/ipcChannelInterface';
 
 
@@ -11,6 +11,6 @@ const app = new App({
 function registerIpcChannels(ipcChannels: IpcRendererChannelInterface[]) {
 	ipcChannels.forEach(channel => ipcRenderer.on(channel.getName(), (event, request) => channel.handle(event, request)));
 }
-registerIpcChannels([new RequestHandlerChannel()])
+registerIpcChannels([new RequestHandlerChannel(), new AppQuitHandlerChannel()])
 
 export default app;