ENGG-3151: Track and handle file errors in local sync (#138)

Author: RuntimeTerror10

src/renderer/actions/local-sync/common-utils.ts

@@ -74,22 +74,22 @@ export function createFsResource<T extends FsResource["type"]>(params: {
   }
 }
 
-export function parseRawJson<T extends TSchema>(
-  json: Record<any, any>,
+export function parseRaw<T extends TSchema>(
+  content: any,
   validator: T
 ): ContentParseResult<Static<T>> {
   try {
     const parsedContent = Value.Parse(
       ["Assert"],
       validator,
-      json
+      content
     ) as Static<T>;
     return {
       type: "success",
       content: parsedContent,
     } as ContentParseResult<Static<T>>; // Casting because TS was not able to infer from fn result type
   } catch {
-    const error = [...Value.Errors(validator, json)][0];
+    const error = [...Value.Errors(validator, content)][0];
     return {
       type: "error",
       error: {
@@ -99,13 +99,13 @@ export function parseRawJson<T extends TSchema>(
   }
 }
 
-export function parseContent<T extends TSchema>(
+export function parseJsonContent<T extends TSchema>(
   content: string,
   validator: T
 ): ContentParseResult<Static<T>> {
   try {
     const parsedJson = JSON.parse(content);
-    return parseRawJson(parsedJson, validator);
+    return parseRaw(parsedJson, validator);
   } catch (e: any) {
     return {
       type: "error",
@@ -123,6 +123,7 @@ export function getIdFromPath(path: string) {
 export function mapSuccessWrite<
   T extends FileSystemResult<{ resource: FsResource }>,
   R extends FileSystemResult<any>
+  // eslint-disable-next-line no-unused-vars
 >(writeResult: T, fn: (id: string) => R) {
   if (writeResult.type === "success") {
     const { resource } = writeResult.content;
@@ -140,6 +141,7 @@ export function mapSuccessfulFsResult<
   Content,
   T extends FileSystemResult<Content>,
   R
+  // eslint-disable-next-line no-unused-vars
 >(result: T, fn: (param: T & { type: "success" }) => R) {
   if (result.type === "success") {
     const newContent = fn(result as T & { type: "success" });

src/renderer/actions/local-sync/file-types/file-type.interface.ts

@@ -0,0 +1,11 @@
+import { Static, TSchema } from "@sinclair/typebox";
+import { ContentParseResult, FileTypeEnum } from "../types";
+
+export abstract class FileType<V extends TSchema> {
+  abstract type: FileTypeEnum;
+
+  abstract validator: V;
+
+  // eslint-disable-next-line no-unused-vars
+  abstract parse(content: any): ContentParseResult<Static<V>>;
+}

src/renderer/actions/local-sync/file-types/file-types.ts

@@ -0,0 +1,109 @@
+/* eslint-disable max-classes-per-file */
+
+import { FileType } from "./file-type.interface";
+import {
+  ApiRecord,
+  Auth,
+  Description,
+  EnvironmentRecord,
+  GlobalConfig,
+  Variables,
+} from "../schemas";
+import { FileTypeEnum } from "../types";
+import { TUnknown, Type } from "@sinclair/typebox";
+import { parseJsonContent, parseRaw } from "../common-utils";
+
+export class ApiRecordFileType extends FileType<typeof ApiRecord> {
+  validator = ApiRecord;
+
+  type = FileTypeEnum.API;
+
+  parse(content: string) {
+    return parseJsonContent(content, this.validator);
+  }
+}
+
+export class EnvironmentRecordFileType extends FileType<
+  typeof EnvironmentRecord
+> {
+  validator = EnvironmentRecord;
+
+  type = FileTypeEnum.ENVIRONMENT;
+
+  parse(content: string) {
+    return parseJsonContent(content, this.validator);
+  }
+}
+
+export class CollectionVariablesRecordFileType extends FileType<
+  typeof Variables
+> {
+  validator = Variables;
+
+  type = FileTypeEnum.COLLECTION_VARIABLES;
+
+  parse(content: string) {
+    return parseJsonContent(content, this.validator);
+  }
+}
+
+export class ReadmeRecordFileType extends FileType<typeof Description> {
+  validator = Description;
+
+  type = FileTypeEnum.DESCRIPTION;
+
+  parse(content: string) {
+    return parseRaw(content, this.validator);
+  }
+}
+
+export class AuthRecordFileType extends FileType<typeof Auth> {
+  validator = Auth;
+
+  type = FileTypeEnum.AUTH;
+
+  parse(content: string) {
+    return parseJsonContent(content, this.validator);
+  }
+}
+
+export class GlobalConfigRecordFileType extends FileType<typeof GlobalConfig> {
+  validator = GlobalConfig;
+
+  type = FileTypeEnum.GLOBAL_CONFIG;
+
+  parse(content: string) {
+    return parseJsonContent(content, this.validator);
+  }
+}
+
+export class UnknownFileType extends FileType<TUnknown> {
+  validator = Type.Unknown();
+
+  type = FileTypeEnum.UNKNOWN;
+
+  parse(content: string) {
+    return parseRaw(content, this.validator);
+  }
+}
+
+export function parseFileType(type: string): FileType<any> {
+  switch (type) {
+    case FileTypeEnum.API:
+      return new ApiRecordFileType();
+    case FileTypeEnum.ENVIRONMENT:
+      return new EnvironmentRecordFileType();
+    case FileTypeEnum.COLLECTION_VARIABLES:
+      return new CollectionVariablesRecordFileType();
+    case FileTypeEnum.DESCRIPTION:
+      return new ReadmeRecordFileType();
+    case FileTypeEnum.AUTH:
+      return new AuthRecordFileType();
+    case FileTypeEnum.GLOBAL_CONFIG:
+      return new GlobalConfigRecordFileType();
+    case FileTypeEnum.UNKNOWN:
+      return new UnknownFileType();
+    default:
+      throw new Error("Invalid file type!");
+  }
+}

src/renderer/actions/local-sync/fs-manager.rpc-service.ts

@@ -117,5 +117,13 @@ export class FsManagerRPCService extends RPCServiceOverIPC {
       "updateCollectionAuthData",
       this.fsManager.updateCollectionAuthData.bind(this.fsManager)
     );
+    this.exposeMethodOverIPC(
+      "writeRawRecord",
+      this.fsManager.writeRawRecord.bind(this.fsManager)
+    );
+    this.exposeMethodOverIPC(
+      "getRawFileData",
+      this.fsManager.getRawFileData.bind(this.fsManager)
+    );
   }
 }