refactor: initial iterations

Co-authored-by: Andrew Bastin <andrewbastin.k@gmail.com>

packages/hoppscotch-common/src/helpers/adapters/WorkspaceRESTCollectionTreeAdapter.ts

@@ -0,0 +1,129 @@
+import {
+  ChildrenResult,
+  SmartTreeAdapter,
+} from "@hoppscotch/ui/dist/src/helpers/treeAdapter"
+import { Ref, computed, ref, watchEffect } from "vue"
+import { NewWorkspaceService } from "~/services/new-workspace"
+import { HandleRef } from "~/services/new-workspace/handle"
+import {
+  RESTCollectionViewCollection,
+  RESTCollectionViewRequest,
+} from "~/services/new-workspace/view"
+import { Workspace } from "~/services/new-workspace/workspace"
+import * as E from "fp-ts/Either"
+
+type WorkspaceRESTCollectionListNode =
+  | { type: "collection"; value: RESTCollectionViewCollection }
+  | { type: "request"; value: RESTCollectionViewRequest }
+
+export class WorkspaceRESTCollectionTreeAdapter
+  implements SmartTreeAdapter<WorkspaceRESTCollectionListNode>
+{
+  constructor(
+    private workspaceHandle: HandleRef<Workspace>,
+    private workspaceService: NewWorkspaceService
+  ) {}
+
+  public getChildren(
+    nodeID: string | null
+  ): Ref<ChildrenResult<WorkspaceRESTCollectionListNode>> {
+    if (this.workspaceHandle.value.type !== "ok") {
+      throw new Error("Cannot issue children with invalid workspace handle")
+    }
+
+    const result = ref<ChildrenResult<WorkspaceRESTCollectionListNode>>({
+      status: "loading",
+    })
+
+    if (nodeID !== null) {
+      ;(async () => {
+        const collectionHandleResult =
+          await this.workspaceService.getCollectionHandle(
+            this.workspaceHandle,
+            nodeID
+          )
+
+        // TODO: Better error handling
+        if (E.isLeft(collectionHandleResult)) {
+          throw new Error(JSON.stringify(collectionHandleResult.left.error))
+        }
+
+        const collectionHandle = collectionHandleResult.right
+
+        const collectionChildrenResult =
+          await this.workspaceService.getRESTCollectionChildrenView(
+            collectionHandle
+          )
+
+        // TODO: Better error handling
+        if (E.isLeft(collectionChildrenResult)) {
+          throw new Error(JSON.stringify(collectionChildrenResult.left.error))
+        }
+
+        const collectionChildrenViewHandle = collectionChildrenResult.right
+
+        watchEffect(() => {
+          if (collectionChildrenViewHandle.value.type !== "ok") return
+
+          if (collectionChildrenViewHandle.value.data.loading.value) {
+            result.value = {
+              status: "loading",
+            }
+          } else {
+            result.value = {
+              status: "loaded",
+              data: collectionChildrenViewHandle.value.data.content.value.map(
+                (item) => ({
+                  id:
+                    item.type === "request"
+                      ? item.value.requestID
+                      : item.value.collectionID,
+
+                  data: item,
+                })
+              ),
+            }
+          }
+        })
+      })()
+    } else {
+      ;(async () => {
+        const viewResult =
+          await this.workspaceService.getRESTRootCollectionView(
+            this.workspaceHandle
+          )
+
+        // TODO: Better error handling
+        if (E.isLeft(viewResult)) {
+          throw new Error(JSON.stringify(viewResult.left.error))
+        }
+
+        const viewHandle = viewResult.right
+
+        watchEffect(() => {
+          if (viewHandle.value.type !== "ok") return
+
+          if (viewHandle.value.data.loading.value) {
+            result.value = {
+              status: "loading",
+            }
+          } else {
+            result.value = {
+              status: "loaded",
+              data: viewHandle.value.data.collections.value.map((coll) => ({
+                id: coll.collectionID,
+
+                data: {
+                  type: "collection",
+                  value: coll,
+                },
+              })),
+            }
+          }
+        })
+      })()
+    }
+
+    return result
+  }
+}

packages/hoppscotch-common/src/helpers/rest/labelColoring.ts

@@ -1,17 +1,13 @@
 import { pipe } from "fp-ts/function"
 import * as O from "fp-ts/Option"
 import * as RR from "fp-ts/ReadonlyRecord"
-import { HoppRESTRequest } from "@hoppscotch/data"
 
 export const REQUEST_METHOD_LABEL_COLORS = {
-  get: "var(--method-get-color)",
-  post: "var(--method-post-color)",
-  put: "var(--method-put-color)",
-  patch: "var(--method-patch-color)",
-  delete: "var(--method-delete-color)",
-  head: "var(--method-head-color)",
-  options: "var(--method-options-color)",
-  default: "var(--method-default-color)",
+  get: "var(--success-color)",
+  post: "var(--warning-color)",
+  put: "var(--blue-color)",
+  delete: "var(--cl-error-color)",
+  default: "#6b7280",
 } as const
 
 /**
@@ -19,18 +15,10 @@ export const REQUEST_METHOD_LABEL_COLORS = {
  * @param request The HoppRESTRequest object to get the value for
  * @returns The class value for the given HTTP VERB, if not, a generic verb class
  */
-export function getMethodLabelColorClassOf(request: HoppRESTRequest) {
+export function getMethodLabelColorClassOf(request: { method: string }) {
   return pipe(
     REQUEST_METHOD_LABEL_COLORS,
     RR.lookup(request.method.toLowerCase()),
     O.getOrElseW(() => REQUEST_METHOD_LABEL_COLORS.default)
   )
 }
-
-export function getMethodLabelColor(method: string) {
-  return pipe(
-    REQUEST_METHOD_LABEL_COLORS,
-    RR.lookup(method.toLowerCase()),
-    O.getOrElseW(() => REQUEST_METHOD_LABEL_COLORS.default)
-  )
-}