Add support to use local disk as storage (#133)

* feat: setup for any RPC Service Over IPC

* draft: example of the code structure for using the RPC service class to model local sync implementation

* chore: code from group discussion

* register open folder dialog event

* allow directory creation in fodler dialog

* Added basic integration

* Add support to fetch all API records

* Organized imports

* Added getAllRecords

* Adding support for env sync

* Add result based types

* Added support to sanitize parsed resource list

* Add getRecord and other utils

* expose getAllEnvironments method

* Added create record

* add variable type in file

* Adding support for update record

* Added support to create record with id

* expose env creation flow

* Added support for collection methods

* expose update env function

* Fixed bug where parent path parsing was incorrect

* Added support to duplicate

* expose env duplication function

* Fixed folder creation bug

* Fixed bug where methods were being exposed multiple times

* sync remaining request data and types fix

* Added support for global config

* update optional properties in API record schema

* Split building local-sync manager and actual methods

* Fixed bug where init was called from constructor as well

* Added support for path in fs error

* Added support to move entities

* fix: validate special characters in collection renaming

* Added path to error

* Added flag to throw error if fs folder exists

* Added support to set collection vars

* write sync value in env file

* Made deletion idempotent

* update queryparam and headers schema to have optional value

---------

Co-authored-by: nsrCodes <[email protected]>
Co-authored-by: Parth Bhardwaj <[email protected]>

Author: 3 people

package-lock.json

@@ -212,6 +212,7 @@
     "@types/node": "17.0.23",
     "@types/node-forge": "^1.3.11",
     "@types/terser-webpack-plugin": "^5.0.4",
+    "@types/uuid": "^10.0.0",
     "@types/webpack-env": "^1.16.3",
     "browserslist-config-erb": "^0.0.3",
     "chalk": "^4.1.2",
@@ -258,6 +259,7 @@
     "@requestly/requestly-proxy": "^1.3.5",
     "@sentry/browser": "^8.34.0",
     "@sentry/electron": "^5.6.0",
+    "@sinclair/typebox": "^0.34.25",
     "address": "^2.0.3",
     "assert": "^2.0.0",
     "async": "^3.2.1",
@@ -287,7 +289,7 @@
     "mkdirp": "^1.0.4",
     "node-forge": "^1.3.1",
     "node-gsettings-wrapper": "^0.5.0",
-    "node-simctl": "^7.6.2",
+    "node-simctl": "^7.7.1",
     "os-browserify": "^0.3.0",
     "path-browserify": "^1.0.1",
     "portfinder": "^1.0.28",
@@ -301,7 +303,7 @@
     "ts-node": "^10.9.2",
     "ua-parser-js": "^1.0.2",
     "util": "^0.12.4",
-    "uuid": "^9.0.0",
+    "uuid": "^9.0.1",
     "ws": "^8.2.3",
     "yargs": "^17.2.1"
   },

package.json

@@ -28,4 +28,10 @@ export const setupIPCForwardingToWebApp = (webAppWindow) => {
       });
     }
   );
+
+  ipcMain.on("send-from-background-to-webapp", (event, incomingData) => {
+    const { payload, channel } = incomingData;
+    console.log("Sending to webapp", channel, payload);
+    webAppWindow.webContents.send(channel, payload);
+  });
 };

src/main/actions/setupIPCForwarding.js

@@ -255,4 +255,13 @@ export const registerMainProcessCommonEvents = () => {
     const fileDialogPromise = dialog.showOpenDialog(options ?? {});
     return fileDialogPromise;
   });
+
+  ipcMain.handle("open-folder-dialog", async (event, options = {}) => {
+    const dialogOptions = {
+      ...options,
+      properties: ["openDirectory", "createDirectory"],
+    };
+    const folderDialogPromise = await dialog.showOpenDialog(dialogOptions);
+    return folderDialogPromise;
+  });
 };

src/main/events.js

@@ -29,6 +29,7 @@ import { trackEventViaWebApp } from "./actions/events";
 import EVENTS from "./actions/events/constants";
 import fs from "fs";
 import logger from "../utils/logger";
+import { setupIPCForwardingToWebApp } from "./actions/setupIPCForwarding";
 
 // Init remote so that it could be consumed in renderer
 const remote = require("@electron/remote/main");
@@ -430,6 +431,7 @@ app.on("ready", () => {
     // Create Renderer Window
     await createWindow();
     // Register Remaining IPC Events that involve browser windows
+    setupIPCForwardingToWebApp(webAppWindow);
     registerMainProcessEventsForWebAppWindow(webAppWindow);
     registerMainProcessCommonEvents();
 

src/main/main.ts

@@ -0,0 +1,19 @@
+/* Define all methods invokable from webapp here, dummy for now */
+export function test(serializableData: any, secodArg: any) {
+  return new Promise((resolve) => {
+    console.log("test", serializableData);
+    console.log("second arg", secodArg);
+    const result = Math.floor(Math.random() * 100);
+    console.log("Random result: ", result);
+    resolve(`Test result: ${result}`);
+  });
+}
+
+export function magic(anything: any) {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      console.log("Magic: ", anything);
+      resolve("Magic done");
+    }, 2000);
+  });
+}

src/renderer/actions/local-files/actions.ts

@@ -0,0 +1,34 @@
+import { RPCServiceOverIPC } from "../../lib/RPCServiceOverIPC";
+
+import * as MethodsToExpose from "./actions";
+
+/* only contains template code right now but can be THE place for files code */
+
+export class LocalFileSync extends RPCServiceOverIPC {
+  constructor() {
+    super("fs"); // namespace for this service
+    this.init();
+  }
+
+  init() {
+    // any initialization logic if needed
+
+    // setup all methods to be exposed over IPC
+    Object.values(MethodsToExpose).forEach((method) => {
+      this.exposeMethodOverIPC(method.name, method);
+    });
+
+    // setup OS event listener however
+    // setInterval(() => {
+    //   /* GARGBAGE POC CODE FOR NOW */
+    //   const randomMessage = Math.floor(Math.random() * 100);
+    //   console.log(`${Date.now()} - Sending event to webapp: `, randomMessage);
+
+    //   // relay those events over to webapp
+    //   this.sendServiceEvent({
+    //     type: "test",
+    //     data: { test: "data - non-changing", message: randomMessage },
+    //   });
+    // }, 7500);
+  }
+}

src/renderer/actions/local-files/index.ts

@@ -0,0 +1,24 @@
+import { RPCServiceOverIPC } from "renderer/lib/RPCServiceOverIPC";
+
+export class TestClass {
+  constructor(
+    readonly base: number,
+    // readonly emitter: (event: any)=> void
+    readonly emitter: typeof RPCServiceOverIPC.prototype.sendServiceEvent
+  ) {
+    this.base = base;
+    console.log("DBG: Event emitter set");
+    setInterval(() => {
+      emitter(`${this.base}: time${Date.now()}`);
+    }, 3000);
+  }
+
+  async add(x: number) {
+    console.log("DBG: add called with x having type", x);
+    return this.base + x;
+  }
+
+  async multiply(x: number) {
+    return this.base * x;
+  }
+}

src/renderer/actions/local-files/sample/base.ts

@@ -0,0 +1,28 @@
+import { RPCServiceOverIPC } from "renderer/lib/RPCServiceOverIPC";
+import { TestClass } from "./base";
+
+export class TestService extends RPCServiceOverIPC {
+  instance?: TestClass;
+
+  constructor() {
+    super("test"); // namespace for this service
+    // const instance = new TestClass(base);
+    // this.instance = instance;
+    this.init();
+  }
+
+  init() {
+    console.log("DBG: exposed build method");
+    this.exposeMethodOverIPC("build", this.build.bind(this));
+  }
+
+  async build(base: number) {
+    console.log("DBG: build called");
+    this.instance = new TestClass(base, this.sendServiceEvent.bind(this));
+    this.exposeMethodOverIPC("add", this.instance.add.bind(this.instance));
+    this.exposeMethodOverIPC(
+      "multiply",
+      this.instance.multiply.bind(this.instance)
+    );
+  }
+}