ENGG-3146: Authorization support in local sync (#137)

Author: RuntimeTerror10

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

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

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

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

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

@@ -14,6 +14,7 @@ import {
   removeUndefinedFromRoot,
 } from "./common-utils";
 import {
+  COLLECTION_AUTH_FILE,
   COLLECTION_VARIABLES_FILE,
   CONFIG_FILE,
   DESCRIPTION_FILE,
@@ -37,10 +38,12 @@ import {
 } from "./fs-utils";
 import {
   ApiRecord,
+  Auth,
   Config,
   Description,
   EnvironmentRecord,
   Variables,
+  AuthType,
 } from "./schemas";
 import {
   API,
@@ -530,6 +533,48 @@ export class FsManager {
     }
   }
 
+  async updateCollectionAuthData(
+    id: string,
+    authData: Static<typeof Auth>
+  ): Promise<FileSystemResult<Static<typeof Auth>>> {
+    try {
+      const authFileResource = this.createResource({
+        id: getIdFromPath(appendPath(id, COLLECTION_AUTH_FILE)),
+        type: "file",
+      });
+
+      if (authData.currentAuthType === AuthType.NO_AUTH) {
+        const deleteResult = await deleteFsResource(authFileResource);
+        if (deleteResult.type === "error") {
+          return deleteResult;
+        }
+        return {
+          type: "success",
+          content: {
+            authConfigStore: {},
+            currentAuthType: AuthType.NO_AUTH,
+          },
+        };
+      }
+      const writeResult = await writeContent(authFileResource, authData, Auth);
+      if (writeResult.type === "error") {
+        return writeResult;
+      }
+      return {
+        type: "success",
+        content: authData,
+      };
+    } 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

@@ -20,6 +20,7 @@ import {
   parseContent,
 } from "./common-utils";
 import {
+  COLLECTION_AUTH_FILE,
   COLLECTION_VARIABLES_FILE,
   CONFIG_FILE,
   DESCRIPTION_FILE,
@@ -38,6 +39,7 @@ import {
   EnvironmentVariableType,
   GlobalConfig,
   Description,
+  Auth,
 } from "./schemas";
 import { Stats } from "node:fs";
 
@@ -483,7 +485,7 @@ async function getCollectionVariables(
   } as FileSystemResult<Static<typeof Variables>>;
 }
 
-async function getDescription(
+async function getCollectionDescription(
   rootPath: string,
   folder: FolderResource
 ): Promise<FileSystemResult<string>> {
@@ -511,6 +513,33 @@ async function getDescription(
   };
 }
 
+async function getCollectionAuthData(
+  rootPath: string,
+  folder: FolderResource
+): Promise<FileSystemResult<Static<typeof Auth>>> {
+  const authPath = appendPath(folder.path, COLLECTION_AUTH_FILE);
+  const authFileExists = await fsp
+    .lstat(authPath)
+    .then((stats) => stats.isFile())
+    .catch(() => false);
+
+  if (authFileExists) {
+    return parseFile({
+      resource: createFsResource({
+        rootPath,
+        path: authPath,
+        type: "file",
+      }),
+      validator: Auth,
+    });
+  }
+
+  return {
+    type: "success",
+    content: {},
+  } as FileSystemResult<Static<typeof Auth>>;
+}
+
 export async function parseFolderToCollection(
   rootPath: string,
   folder: FolderResource
@@ -523,12 +552,24 @@ export async function parseFolderToCollection(
     return collectionVariablesResult;
   }
 
-  const descriptionFileResult = await getDescription(rootPath, folder);
+  const descriptionFileResult = await getCollectionDescription(
+    rootPath,
+    folder
+  );
   if (descriptionFileResult.type === "error") {
     return descriptionFileResult;
   }
 
+  const collectionAuthDataResult = await getCollectionAuthData(
+    rootPath,
+    folder
+  );
+  if (collectionAuthDataResult.type === "error") {
+    return collectionAuthDataResult;
+  }
+
   const collectionVariables = collectionVariablesResult.content;
+  const collectionAuthData = collectionAuthDataResult.content;
   const collectionDescription = descriptionFileResult.content;
 
   const collection: Collection = {
@@ -538,6 +579,7 @@ export async function parseFolderToCollection(
     collectionId: getCollectionId(rootPath, folder),
     variables: collectionVariables,
     description: collectionDescription,
+    auth: collectionAuthData,
   };
 
   const result: FileSystemResult<Collection> = {
@@ -599,6 +641,7 @@ export function sanitizeFsResourceList(
     (resource) => resource.path !== appendPath(rootPath, CONFIG_FILE),
     (resource) => !resource.path.endsWith(COLLECTION_VARIABLES_FILE),
     (resource) => !resource.path.endsWith(DESCRIPTION_FILE),
+    (resource) => !resource.path.endsWith(COLLECTION_AUTH_FILE),
     (resource) => !resource.path.includes(DS_STORE_FILE),
   ];
   if (type === "api") {

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

@@ -21,6 +21,14 @@ export enum ApiMethods {
   OPTIONS = "OPTIONS",
 }
 
+export enum AuthType {
+  INHERIT = "INHERIT",
+  NO_AUTH = "NO_AUTH",
+  API_KEY = "API_KEY",
+  BEARER_TOKEN = "BEARER_TOKEN",
+  BASIC_AUTH = "BASIC_AUTH",
+}
+
 type RequestBodyContainer = {
   text?: string;
   form?: KeyValuePair[];
@@ -40,6 +48,30 @@ interface KeyValuePair {
   type?: string;
 }
 
+export const Auth = Type.Object({
+  authConfigStore: Type.Object({
+    API_KEY: Type.Optional(
+      Type.Object({
+        addTo: Type.String(),
+        key: Type.String(),
+        value: Type.String(),
+      })
+    ),
+    BASIC_AUTH: Type.Optional(
+      Type.Object({
+        username: Type.String(),
+        password: Type.String(),
+      })
+    ),
+    BEARER_TOKEN: Type.Optional(
+      Type.Object({
+        bearer: Type.String(),
+      })
+    ),
+  }),
+  currentAuthType: Type.Enum(AuthType),
+});
+
 export const Description = Type.String();
 
 export const ApiRecord = Type.Object({
@@ -71,6 +103,7 @@ export const ApiRecord = Type.Object({
   body: Type.Optional(Type.Any()),
   bodyContainer: Type.Optional(Type.Any()),
   contentType: Type.Optional(Type.Enum(RequestContentType)),
+  auth: Type.Optional(Auth),
   scripts: Type.Optional(
     Type.Object({
       preRequest: Type.String(),

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

@@ -1,4 +1,5 @@
-import { EnvironmentVariableType } from "./schemas";
+import { Static } from "@sinclair/typebox";
+import { Auth, EnvironmentVariableType } from "./schemas";
 
 export type FileSystemError = { message: string; path: string };
 export type ContentfulSuccess<T> = T extends void
@@ -36,6 +37,7 @@ export type Collection = {
   name: string;
   variables?: Record<string, any>;
   description?: string;
+  auth?: Static<typeof Auth>;
 };
 
 export type API = {