ENGG-3158: collection description support in local sync (#136)

Author: RuntimeTerror10

src/renderer/actions/local-sync/constants.ts

@@ -1,7 +1,7 @@
 import { homedir } from "os";
 
-
 export const CONFIG_FILE = "requestly.json";
+export const DESCRIPTION_FILE = "README.md";
 export const COLLECTION_VARIABLES_FILE = "vars.json";
 export const ENVIRONMENT_VARIABLES_FILE = "env.json";
 export const ENVIRONMENT_VARIABLES_FOLDER = "environments";

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

@@ -107,5 +107,10 @@ export class FsManagerRPCService extends RPCServiceOverIPC {
       "duplicateEnvironment",
       this.fsManager.duplicateEnvironment.bind(this.fsManager)
     );
+
+    this.exposeMethodOverIPC(
+      "updateCollectionDescription",
+      this.fsManager.updateCollectionDescription.bind(this.fsManager)
+    );
   }
 }

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

@@ -16,6 +16,7 @@ import {
 import {
   COLLECTION_VARIABLES_FILE,
   CONFIG_FILE,
+  DESCRIPTION_FILE,
   ENVIRONMENT_VARIABLES_FOLDER,
   GLOBAL_ENV_FILE,
 } from "./constants";
@@ -34,7 +35,13 @@ import {
   sanitizeFsResourceList,
   writeContent,
 } from "./fs-utils";
-import { ApiRecord, Config, EnvironmentRecord, Variables } from "./schemas";
+import {
+  ApiRecord,
+  Config,
+  Description,
+  EnvironmentRecord,
+  Variables,
+} from "./schemas";
 import {
   API,
   APIEntity,
@@ -354,7 +361,6 @@ export class FsManager {
       if (createResult.type === "error") {
         return createResult;
       }
-
       return parseFolderToCollection(this.rootPath, resource);
     } catch (e: any) {
       return {
@@ -480,6 +486,50 @@ export class FsManager {
     }
   }
 
+  async updateCollectionDescription(
+    id: string,
+    description: string
+  ): Promise<FileSystemResult<string>> {
+    try {
+      const descriptionFileResource = this.createResource({
+        id: getIdFromPath(appendPath(id, DESCRIPTION_FILE)),
+        type: "file",
+      });
+      if (!description.length) {
+        const deleteResult = await deleteFsResource(descriptionFileResource);
+        if (deleteResult.type === "error") {
+          return deleteResult;
+        }
+        return {
+          type: "success",
+          content: "",
+        };
+      }
+
+      const writeResult = await writeContent(
+        descriptionFileResource,
+        description,
+        Description,
+        false
+      );
+      if (writeResult.type === "error") {
+        return writeResult;
+      }
+      return {
+        type: "success",
+        content: description,
+      };
+    } catch (e: any) {
+      return {
+        type: "error",
+        error: {
+          message: e.message || "An unexpected error has occured!",
+          path: e.path || "Unknown path",
+        },
+      };
+    }
+  }
+
   async moveCollection(
     id: string,
     newParentId: string

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

@@ -22,6 +22,7 @@ import {
 import {
   COLLECTION_VARIABLES_FILE,
   CONFIG_FILE,
+  DESCRIPTION_FILE,
   DS_STORE_FILE,
   ENVIRONMENT_VARIABLES_FOLDER,
   GLOBAL_CONFIG_FILE_NAME,
@@ -36,6 +37,7 @@ import {
   Variables,
   EnvironmentVariableType,
   GlobalConfig,
+  Description,
 } from "./schemas";
 import { Stats } from "node:fs";
 
@@ -198,28 +200,35 @@ export async function copyRecursive<T extends FsResource>(
   }
 }
 
-export function serializeContentForWriting(content: Record<any, any>) {
+export function serializeContentForWriting(content: string | Record<any, any>) {
+  if (typeof content === "string") {
+    return content;
+  }
   return JSON.stringify(content, null, 2);
 }
 
 export async function writeContent<T extends TSchema>(
   resource: FileResource,
-  content: Record<any, any>,
-  validator: T
+  content: string | Record<any, any>,
+  validator: T,
+  parseAsJson = true
 ): Promise<FileSystemResult<{ resource: FileResource }>> {
   try {
     const serializedContent = serializeContentForWriting(content);
-    const parsedContentResult = parseContent(serializedContent, validator);
-    if (parsedContentResult.type === "error") {
-      return {
-        type: "error",
-        error: {
-          message: parsedContentResult.error.message,
-          path: resource.path,
-        },
-      };
+    if (parseAsJson) {
+      const parsedContentResult = parseContent(serializedContent, validator);
+      if (parsedContentResult.type === "error") {
+        return {
+          type: "error",
+          error: {
+            message: parsedContentResult.error.message,
+            path: resource.path,
+          },
+        };
+      }
     }
-    console.log('writing at', resource.path);
+
+    console.log("writing at", resource.path);
     await fsp.writeFile(resource.path, serializedContent);
     return {
       type: "success",
@@ -231,7 +240,7 @@ export async function writeContent<T extends TSchema>(
     return {
       type: "error",
       error: {
-        message: e.message || "An unexpected error has occured!",
+        message: e.message || "An unexpected error has occurred!",
         path: resource.path,
       },
     };
@@ -241,10 +250,17 @@ export async function writeContent<T extends TSchema>(
 export async function parseFile<T extends TSchema>(params: {
   resource: FileResource;
   validator: T;
+  parseAsJson?: boolean;
 }): Promise<FileSystemResult<Static<T>>> {
-  const { resource, validator } = params;
+  const { resource, validator, parseAsJson = true } = params;
   try {
     const content = (await fsp.readFile(resource.path)).toString();
+    if (!parseAsJson) {
+      return {
+        type: "success",
+        content,
+      } as FileSystemResult<Static<T>>;
+    }
     const parsedContentResult = parseContent(content, validator);
     if (parsedContentResult.type === "error") {
       return {
@@ -440,46 +456,88 @@ function getCollectionId(rootPath: string, fsResource: FsResource) {
   return getIdFromPath(parentPath);
 }
 
-export async function parseFolderToCollection(
+async function getCollectionVariables(
   rootPath: string,
   folder: FolderResource
-): Promise<FileSystemResult<Collection>> {
+): Promise<FileSystemResult<Static<typeof Variables>>> {
   const varsPath = appendPath(folder.path, COLLECTION_VARIABLES_FILE);
   const collectionVariablesExist = await fsp
     .lstat(varsPath)
     .then((stats) => stats.isFile())
     .catch(() => false);
 
-  const collectionVariablesResult = await (async () => {
-    if (collectionVariablesExist) {
-      return parseFile({
-        resource: createFsResource({
-          rootPath,
-          path: varsPath,
-          type: "file",
-        }),
-        validator: Variables,
-      });
-    }
+  if (collectionVariablesExist) {
+    return parseFile({
+      resource: createFsResource({
+        rootPath,
+        path: varsPath,
+        type: "file",
+      }),
+      validator: Variables,
+    });
+  }
 
-    return {
-      type: "success",
-      content: {},
-    } as FileSystemResult<Static<typeof Variables>>;
-  })();
+  return {
+    type: "success",
+    content: {},
+  } as FileSystemResult<Static<typeof Variables>>;
+}
+
+async function getDescription(
+  rootPath: string,
+  folder: FolderResource
+): Promise<FileSystemResult<string>> {
+  const descriptionPath = appendPath(folder.path, DESCRIPTION_FILE);
+  const descriptionFileExists = await fsp
+    .lstat(descriptionPath)
+    .then((stats) => stats.isFile())
+    .catch(() => false);
+
+  if (descriptionFileExists) {
+    return parseFile({
+      resource: createFsResource({
+        rootPath,
+        path: descriptionPath,
+        type: "file",
+      }),
+      validator: Description,
+      parseAsJson: false,
+    });
+  }
 
+  return {
+    type: "success",
+    content: "",
+  };
+}
+
+export async function parseFolderToCollection(
+  rootPath: string,
+  folder: FolderResource
+): Promise<FileSystemResult<Collection>> {
+  const collectionVariablesResult = await getCollectionVariables(
+    rootPath,
+    folder
+  );
   if (collectionVariablesResult.type === "error") {
     return collectionVariablesResult;
   }
 
+  const descriptionFileResult = await getDescription(rootPath, folder);
+  if (descriptionFileResult.type === "error") {
+    return descriptionFileResult;
+  }
+
   const collectionVariables = collectionVariablesResult.content;
+  const collectionDescription = descriptionFileResult.content;
 
   const collection: Collection = {
     type: "collection",
     id: getIdFromPath(folder.path),
     name: getNameOfResource(folder),
     collectionId: getCollectionId(rootPath, folder),
     variables: collectionVariables,
+    description: collectionDescription,
   };
 
   const result: FileSystemResult<Collection> = {
@@ -540,6 +598,7 @@ export function sanitizeFsResourceList(
   const checks: ((resource: FsResource) => boolean)[] = [
     (resource) => resource.path !== appendPath(rootPath, CONFIG_FILE),
     (resource) => !resource.path.endsWith(COLLECTION_VARIABLES_FILE),
+    (resource) => !resource.path.endsWith(DESCRIPTION_FILE),
     (resource) => !resource.path.includes(DS_STORE_FILE),
   ];
   if (type === "api") {

src/renderer/actions/local-sync/schemas.ts

@@ -40,6 +40,8 @@ interface KeyValuePair {
   type?: string;
 }
 
+export const Description = Type.String();
+
 export const ApiRecord = Type.Object({
   name: Type.String(),
   url: Type.String(),

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

@@ -35,6 +35,7 @@ export type Collection = {
   id: string;
   name: string;
   variables?: Record<string, any>;
+  description?: string;
 };
 
 export type API = {