refactor: compile data in handles

Introduce a handle for requests.

packages/hoppscotch-common/src/services/new-workspace/index.ts

@@ -8,10 +8,10 @@ import {
   shallowRef,
   watch,
 } from "vue"
-import { WorkspaceProvider } from "./provider"
+import { UpdatedCollectionProperties, WorkspaceProvider } from "./provider"
 import { HandleRef } from "./handle"
 import * as E from "fp-ts/Either"
-import { Workspace, WorkspaceCollection } from "./workspace"
+import { Workspace, WorkspaceCollection, WorkspaceRequest } from "./workspace"
 import { RESTCollectionChildrenView, RootRESTCollectionView } from "./view"
 import { HoppRESTRequest } from "@hoppscotch/data"
 
@@ -138,6 +138,36 @@ export class NewWorkspaceService extends Service {
     return E.right(result.right)
   }
 
+  public async getRequestHandle(
+    parentCollHandle: HandleRef<WorkspaceCollection>,
+    requestID: string
+  ): Promise<
+    E.Either<
+      WorkspaceError<"INVALID_HANDLE" | "INVALID_PROVIDER">,
+      HandleRef<WorkspaceRequest>
+    >
+  > {
+    if (parentCollHandle.value.type === "invalid") {
+      return E.left({ type: "SERVICE_ERROR", error: "INVALID_HANDLE" })
+    }
+
+    const provider = this.registeredProviders.get(
+      parentCollHandle.value.data.providerID
+    )
+
+    if (!provider) {
+      return E.left({ type: "SERVICE_ERROR", error: "INVALID_PROVIDER" })
+    }
+
+    const result = await provider.getRequestHandle(parentCollHandle, requestID)
+
+    if (E.isLeft(result)) {
+      return E.left({ type: "PROVIDER_ERROR", error: result.left })
+    }
+
+    return E.right(result.right)
+  }
+
   public async createRESTRootCollection(
     workspaceHandle: HandleRef<Workspace>,
     collectionName: string
@@ -173,8 +203,7 @@ export class NewWorkspaceService extends Service {
 
   public async createRESTChildCollection(
     parentCollHandle: HandleRef<WorkspaceCollection>,
-    collectionName: string,
-    path: string
+    collectionName: string
   ): Promise<
     E.Either<
       WorkspaceError<"INVALID_HANDLE" | "INVALID_PROVIDER">,
@@ -195,8 +224,7 @@ export class NewWorkspaceService extends Service {
 
     const result = await provider.createRESTChildCollection(
       parentCollHandle,
-      collectionName,
-      path
+      collectionName
     )
 
     if (E.isLeft(result)) {
@@ -206,10 +234,166 @@ export class NewWorkspaceService extends Service {
     return E.right(result.right)
   }
 
+  public async editRESTRootCollection(
+    collHandle: HandleRef<WorkspaceCollection>,
+    newCollectionName: string
+  ): Promise<
+    E.Either<
+      WorkspaceError<"INVALID_HANDLE" | "INVALID_PROVIDER">,
+      HandleRef<WorkspaceCollection>
+    >
+  > {
+    if (collHandle.value.type === "invalid") {
+      return E.left({ type: "SERVICE_ERROR", error: "INVALID_HANDLE" })
+    }
+
+    const provider = this.registeredProviders.get(
+      collHandle.value.data.providerID
+    )
+
+    if (!provider) {
+      return E.left({ type: "SERVICE_ERROR", error: "INVALID_PROVIDER" })
+    }
+
+    const result = await provider.editRESTRootCollection(
+      collHandle,
+      newCollectionName
+    )
+
+    if (E.isLeft(result)) {
+      return E.left({ type: "PROVIDER_ERROR", error: result.left })
+    }
+
+    return E.right(result.right)
+  }
+
+  public async editRESTChildCollection(
+    collHandle: HandleRef<WorkspaceCollection>,
+    newCollectionName: string
+  ): Promise<
+    E.Either<
+      WorkspaceError<"INVALID_HANDLE" | "INVALID_PROVIDER">,
+      HandleRef<WorkspaceCollection>
+    >
+  > {
+    if (collHandle.value.type === "invalid") {
+      return E.left({ type: "SERVICE_ERROR", error: "INVALID_HANDLE" })
+    }
+
+    const provider = this.registeredProviders.get(
+      collHandle.value.data.providerID
+    )
+
+    if (!provider) {
+      return E.left({ type: "SERVICE_ERROR", error: "INVALID_PROVIDER" })
+    }
+
+    const result = await provider.editRESTChildCollection(
+      collHandle,
+      newCollectionName
+    )
+
+    if (E.isLeft(result)) {
+      return E.left({ type: "PROVIDER_ERROR", error: result.left })
+    }
+
+    return E.right(result.right)
+  }
+
+  public async editRESTCollectionProperties(
+    collHandle: HandleRef<WorkspaceCollection>,
+    updatedCollProps: UpdatedCollectionProperties
+  ): Promise<
+    E.Either<
+      WorkspaceError<"INVALID_HANDLE" | "INVALID_PROVIDER">,
+      HandleRef<WorkspaceCollection>
+    >
+  > {
+    if (collHandle.value.type === "invalid") {
+      return E.left({ type: "SERVICE_ERROR", error: "INVALID_HANDLE" })
+    }
+
+    const provider = this.registeredProviders.get(
+      collHandle.value.data.providerID
+    )
+
+    if (!provider) {
+      return E.left({ type: "SERVICE_ERROR", error: "INVALID_PROVIDER" })
+    }
+
+    const result = await provider.editRESTCollectionProperties(
+      collHandle,
+      updatedCollProps
+    )
+
+    if (E.isLeft(result)) {
+      return E.left({ type: "PROVIDER_ERROR", error: result.left })
+    }
+
+    return E.right(result.right)
+  }
+
+  public async removeRESTRootCollection(
+    collHandle: HandleRef<WorkspaceCollection>
+  ): Promise<
+    E.Either<
+      WorkspaceError<"INVALID_HANDLE" | "INVALID_PROVIDER">,
+      HandleRef<WorkspaceCollection>
+    >
+  > {
+    if (collHandle.value.type === "invalid") {
+      return E.left({ type: "SERVICE_ERROR", error: "INVALID_HANDLE" })
+    }
+
+    const provider = this.registeredProviders.get(
+      collHandle.value.data.providerID
+    )
+
+    if (!provider) {
+      return E.left({ type: "SERVICE_ERROR", error: "INVALID_PROVIDER" })
+    }
+
+    const result = await provider.removeRESTRootCollection(collHandle)
+
+    if (E.isLeft(result)) {
+      return E.left({ type: "PROVIDER_ERROR", error: result.left })
+    }
+
+    return E.right(result.right)
+  }
+
+  public async removeRESTChildCollection(
+    parentCollHandle: HandleRef<WorkspaceCollection>
+  ): Promise<
+    E.Either<
+      WorkspaceError<"INVALID_HANDLE" | "INVALID_PROVIDER">,
+      HandleRef<WorkspaceCollection>
+    >
+  > {
+    if (parentCollHandle.value.type === "invalid") {
+      return E.left({ type: "SERVICE_ERROR", error: "INVALID_HANDLE" })
+    }
+
+    const provider = this.registeredProviders.get(
+      parentCollHandle.value.data.providerID
+    )
+
+    if (!provider) {
+      return E.left({ type: "SERVICE_ERROR", error: "INVALID_PROVIDER" })
+    }
+
+    const result = await provider.removeRESTChildCollection(parentCollHandle)
+
+    if (E.isLeft(result)) {
+      return E.left({ type: "PROVIDER_ERROR", error: result.left })
+    }
+
+    return E.right(result.right)
+  }
+
   public async createRESTRequest(
     parentCollHandle: HandleRef<WorkspaceCollection>,
-    requestName: string,
-    path: string
+    requestName: string
   ): Promise<
     E.Either<
       WorkspaceError<"INVALID_HANDLE" | "INVALID_PROVIDER">,
@@ -230,8 +414,7 @@ export class NewWorkspaceService extends Service {
 
     const result = await provider.createRESTRequest(
       parentCollHandle,
-      requestName,
-      path
+      requestName
     )
 
     if (E.isLeft(result)) {
@@ -242,104 +425,26 @@ export class NewWorkspaceService extends Service {
   }
 
   public async removeRESTRequest(
-    parentCollHandle: HandleRef<WorkspaceCollection>,
-    path: string,
-    requestIndex: number
+    requestHandle: HandleRef<WorkspaceRequest>
   ): Promise<
     E.Either<
       WorkspaceError<"INVALID_HANDLE" | "INVALID_PROVIDER">,
-      HandleRef<WorkspaceCollection>
+      HandleRef<WorkspaceRequest>
     >
   > {
-    if (parentCollHandle.value.type === "invalid") {
+    if (requestHandle.value.type === "invalid") {
       return E.left({ type: "SERVICE_ERROR", error: "INVALID_HANDLE" })
     }
 
     const provider = this.registeredProviders.get(
-      parentCollHandle.value.data.providerID
+      requestHandle.value.data.providerID
     )
 
     if (!provider) {
       return E.left({ type: "SERVICE_ERROR", error: "INVALID_PROVIDER" })
     }
 
-    const result = await provider.removeRESTRequest(
-      parentCollHandle,
-      path,
-      requestIndex
-    )
-
-    if (E.isLeft(result)) {
-      return E.left({ type: "PROVIDER_ERROR", error: result.left })
-    }
-
-    return E.right(result.right)
-  }
-
-  public async selectRESTRequest(
-    parentCollHandle: HandleRef<WorkspaceCollection>,
-    collPath: string,
-    requestIndex: string,
-    request: HoppRESTRequest
-  ): Promise<
-    E.Either<
-      WorkspaceError<"INVALID_HANDLE" | "INVALID_PROVIDER">,
-      HandleRef<WorkspaceCollection>
-    >
-  > {
-    if (parentCollHandle.value.type === "invalid") {
-      return E.left({ type: "SERVICE_ERROR", error: "INVALID_HANDLE" })
-    }
-
-    const provider = this.registeredProviders.get(
-      parentCollHandle.value.data.providerID
-    )
-
-    if (!provider) {
-      return E.left({ type: "SERVICE_ERROR", error: "INVALID_PROVIDER" })
-    }
-
-    const result = await provider.selectRESTRequest(
-      parentCollHandle,
-      collPath,
-      requestIndex,
-      request
-    )
-
-    if (E.isLeft(result)) {
-      return E.left({ type: "PROVIDER_ERROR", error: result.left })
-    }
-
-    return E.right(result.right)
-  }
-
-  public async duplicateRESTRequest(
-    parentCollHandle: HandleRef<WorkspaceCollection>,
-    collPath: string,
-    request: HoppRESTRequest
-  ): Promise<
-    E.Either<
-      WorkspaceError<"INVALID_HANDLE" | "INVALID_PROVIDER">,
-      HandleRef<WorkspaceCollection>
-    >
-  > {
-    if (parentCollHandle.value.type === "invalid") {
-      return E.left({ type: "SERVICE_ERROR", error: "INVALID_HANDLE" })
-    }
-
-    const provider = this.registeredProviders.get(
-      parentCollHandle.value.data.providerID
-    )
-
-    if (!provider) {
-      return E.left({ type: "SERVICE_ERROR", error: "INVALID_PROVIDER" })
-    }
-
-    const result = await provider.duplicateRESTRequest(
-      parentCollHandle,
-      collPath,
-      request
-    )
+    const result = await provider.removeRESTRequest(requestHandle)
 
     if (E.isLeft(result)) {
       return E.left({ type: "PROVIDER_ERROR", error: result.left })
@@ -349,34 +454,27 @@ export class NewWorkspaceService extends Service {
   }
 
   public async editRESTRequest(
-    parentCollHandle: HandleRef<WorkspaceCollection>,
-    collPath: string,
-    requestIndex: number,
-    request: HoppRESTRequest
+    requestHandle: HandleRef<WorkspaceRequest>,
+    newRequestName: string
   ): Promise<
     E.Either<
       WorkspaceError<"INVALID_HANDLE" | "INVALID_PROVIDER">,
-      HandleRef<WorkspaceCollection>
+      HandleRef<WorkspaceRequest>
     >
   > {
-    if (parentCollHandle.value.type === "invalid") {
+    if (requestHandle.value.type === "invalid") {
       return E.left({ type: "SERVICE_ERROR", error: "INVALID_HANDLE" })
     }
 
     const provider = this.registeredProviders.get(
-      parentCollHandle.value.data.providerID
+      requestHandle.value.data.providerID
     )
 
     if (!provider) {
       return E.left({ type: "SERVICE_ERROR", error: "INVALID_PROVIDER" })
     }
 
-    const result = await provider.editRESTRequest(
-      parentCollHandle,
-      collPath,
-      requestIndex,
-      request
-    )
+    const result = await provider.editRESTRequest(requestHandle, newRequestName)
 
     if (E.isLeft(result)) {
       return E.left({ type: "PROVIDER_ERROR", error: result.left })
@@ -385,6 +483,35 @@ export class NewWorkspaceService extends Service {
     return E.right(result.right)
   }
 
+  public async saveRESTRequest(
+    requestHandle: HandleRef<WorkspaceRequest>,
+    updatedRequest: HoppRESTRequest
+  ): Promise<
+    E.Either<
+      WorkspaceError<"INVALID_HANDLE" | "INVALID_PROVIDER">,
+      HandleRef<WorkspaceRequest>
+    >
+  > {
+    if (requestHandle.value.type === "invalid") {
+      return E.left({ type: "SERVICE_ERROR", error: "INVALID_HANDLE" })
+    }
+
+    const provider = this.registeredProviders.get(
+      requestHandle.value.data.providerID
+    )
+
+    if (!provider) {
+      return E.left({ type: "SERVICE_ERROR", error: "INVALID_PROVIDER" })
+    }
+
+    const result = await provider.saveRESTRequest(requestHandle, updatedRequest)
+
+    if (E.isLeft(result)) {
+      return E.left({ type: "PROVIDER_ERROR", error: result.left })
+    }
+
+    return E.right(result.right)
+  }
 
   public async getRESTCollectionChildrenView(
     collectionHandle: HandleRef<WorkspaceCollection>

packages/hoppscotch-common/src/services/new-workspace/provider.ts

@@ -1,9 +1,19 @@
 import { Ref } from "vue"
 import * as E from "fp-ts/Either"
 import { HandleRef } from "./handle"
-import { Workspace, WorkspaceCollection, WorkspaceDecor } from "./workspace"
+import {
+  Workspace,
+  WorkspaceCollection,
+  WorkspaceDecor,
+  WorkspaceRequest,
+} from "./workspace"
 import { RESTCollectionChildrenView, RootRESTCollectionView } from "./view"
-import { HoppRESTRequest } from "@hoppscotch/data"
+import { HoppRESTAuth, HoppRESTHeaders, HoppRESTRequest } from "@hoppscotch/data"
+
+export type UpdatedCollectionProperties = {
+  auth: HoppRESTAuth
+  headers: HoppRESTHeaders
+}
 
 export interface WorkspaceProvider {
   providerID: string
@@ -17,6 +27,10 @@ export interface WorkspaceProvider {
     workspaceHandle: HandleRef<Workspace>,
     collectionID: string
   ): Promise<E.Either<unknown, HandleRef<WorkspaceCollection>>>
+  getRequestHandle(
+    parentCollHandle: HandleRef<WorkspaceCollection>,
+    requestID: string
+  ): Promise<E.Either<unknown, HandleRef<WorkspaceRequest>>>
 
   getRESTRootCollectionView(
     workspaceHandle: HandleRef<Workspace>
@@ -31,34 +45,39 @@ export interface WorkspaceProvider {
   ): Promise<E.Either<unknown, HandleRef<WorkspaceCollection>>>
   createRESTChildCollection(
     parentCollHandle: HandleRef<WorkspaceCollection>,
-    collectionName: string,
-    path: string
+    collectionName: string
+  ): Promise<E.Either<unknown, HandleRef<WorkspaceCollection>>>
+  editRESTRootCollection(
+    collHandle: HandleRef<WorkspaceCollection>,
+    newCollectionName: string
+  ): Promise<E.Either<unknown, HandleRef<WorkspaceCollection>>>
+  editRESTChildCollection(
+    parentCollHandle: HandleRef<WorkspaceCollection>,
+    newCollectionName: string
+  ): Promise<E.Either<unknown, HandleRef<WorkspaceCollection>>>
+  editRESTCollectionProperties(
+    parentCollHandle: HandleRef<WorkspaceCollection>,
+    updatedCollProps: UpdatedCollectionProperties
+  ): Promise<E.Either<unknown, HandleRef<WorkspaceCollection>>>
+  removeRESTRootCollection(
+    collHandle: HandleRef<WorkspaceCollection>
+  ): Promise<E.Either<unknown, HandleRef<WorkspaceCollection>>>
+  removeRESTChildCollection(
+    parentCollHandle: HandleRef<WorkspaceCollection>
   ): Promise<E.Either<unknown, HandleRef<WorkspaceCollection>>>
   createRESTRequest(
     parentCollHandle: HandleRef<WorkspaceCollection>,
-    requestName: string,
-    path: string
+    requestName: string
   ): Promise<E.Either<unknown, HandleRef<WorkspaceCollection>>>
   removeRESTRequest(
-    parentCollHandle: HandleRef<WorkspaceCollection>,
-    path: string,
-    requestIndex: number
-  ): Promise<E.Either<unknown, HandleRef<WorkspaceCollection>>>
-  selectRESTRequest(
-    parentCollHandle: HandleRef<WorkspaceCollection>,
-    collPath: string,
-    requestIndex: string,
-    request: HoppRESTRequest
-  ): Promise<E.Either<unknown, HandleRef<WorkspaceCollection>>>
-  duplicateRESTRequest(
-    parentCollHandle: HandleRef<WorkspaceCollection>,
-    collPath: string,
-    request: HoppRESTRequest
-  ): Promise<E.Either<unknown, HandleRef<WorkspaceCollection>>>
+    requestHandle: HandleRef<WorkspaceRequest>
+  ): Promise<E.Either<unknown, HandleRef<WorkspaceRequest>>>
   editRESTRequest(
-    parentCollHandle: HandleRef<WorkspaceCollection>,
-    collPath: string,
-    requestIndex: number,
-    request: HoppRESTRequest
-  ): Promise<E.Either<unknown, HandleRef<WorkspaceCollection>>>
+    requestHandle: HandleRef<WorkspaceRequest>,
+    newRequestName: string
+  ): Promise<E.Either<unknown, HandleRef<WorkspaceRequest>>>
+  saveRESTRequest(
+    requestHandle: HandleRef<WorkspaceRequest>,
+    updatedRequest: HoppRESTRequest
+  ): Promise<E.Either<unknown, HandleRef<WorkspaceRequest>>>
 }

packages/hoppscotch-common/src/services/new-workspace/view.ts

@@ -1,16 +1,16 @@
-import { HoppRESTRequest } from "@hoppscotch/data"
+import { HoppCollection, HoppRESTRequest } from "@hoppscotch/data"
 import { Ref } from "vue"
 
 export type RESTCollectionViewCollection = {
   collectionID: string
-  name: string
+
+  collection: HoppCollection
 }
 
 export type RESTCollectionViewRequest = {
+  collectionID: string
   requestID: string
 
-  name: string
-  method: string
   request: HoppRESTRequest
 }
 

packages/hoppscotch-common/src/services/new-workspace/workspace.ts

@@ -1,3 +1,4 @@
+import { HoppCollection, HoppRESTRequest } from "@hoppscotch/data"
 import { Component } from "vue"
 
 export type Workspace = {
@@ -5,8 +6,6 @@ export type Workspace = {
   workspaceID: string
 
   name: string
-
-  collectionsAreReadonly: boolean
 }
 
 export type WorkspaceCollection = {
@@ -14,7 +13,16 @@ export type WorkspaceCollection = {
   workspaceID: string
   collectionID: string
 
-  name: string
+  collection: HoppCollection | null
+}
+
+export type WorkspaceRequest = {
+  providerID: string
+  workspaceID: string
+  collectionID: string
+  requestID: string
+
+  request: HoppRESTRequest | null
 }
 
 export type WorkspaceDecor = {