fix: schema error and test updation flow (hoppscotch#5124)

Co-authored-by: jamesgeorge007 <[email protected]>

Author: nivedin

packages/hoppscotch-common/src/components/http/Response.vue

@@ -24,9 +24,9 @@ import { HoppRequestDocument } from "~/helpers/rest/document"
 import { useResponseBody } from "@composables/lens-actions"
 import { getStatusCodeReasonPhrase } from "~/helpers/utils/statusCodes"
 import {
-  HoppRESTResponseOriginalRequest,
   HoppRESTRequestResponse,
-  RESTResOriginalReqSchemaVersion,
+  HoppRESTResponseOriginalRequest,
+  makeHoppRESTResponseOriginalRequest,
 } from "@hoppscotch/data"
 import { editRESTRequest } from "~/newstore/collections"
 import { useToast } from "@composables/toast"
@@ -94,17 +94,17 @@ const onSaveAsExample = () => {
       requestVariables,
     } = response.req
 
-    const originalRequest: HoppRESTResponseOriginalRequest = {
-      v: RESTResOriginalReqSchemaVersion,
-      method,
-      endpoint,
-      headers,
-      body,
-      auth,
-      params,
-      name,
-      requestVariables,
-    }
+    const originalRequest: HoppRESTResponseOriginalRequest =
+      makeHoppRESTResponseOriginalRequest({
+        method,
+        endpoint,
+        headers,
+        body,
+        auth,
+        params,
+        name,
+        requestVariables,
+      })
 
     const resName = responseName.value.trim()
 

packages/hoppscotch-common/src/components/http/TestResultEnv.vue

@@ -14,7 +14,7 @@
         </span>
         <span class="inline-flex text-secondaryDark">
           <icon-lucide-minus class="svg-icons mr-2" />
-          {{ env.value }}
+          {{ env.currentValue }}
         </span>
         <span
           v-if="status === 'updations'"
@@ -45,7 +45,7 @@ type Status = "updations" | "additions" | "deletions"
 type Props = {
   env: {
     key: string
-    value: string
+    currentValue: string
     previousValue?: string
   }
   status: Status

packages/hoppscotch-common/src/helpers/RequestRunner.ts

@@ -455,10 +455,10 @@ export function runRESTRequest$(
               }))
             ) as E.Right<SandboxTestResult>
 
-            const updatedRunResult = updateEnvsAfterTestScript(combinedResult)
-
-            tab.value.document.testResults =
-              translateToSandboxTestResults(updatedRunResult)
+            tab.value.document.testResults = translateToSandboxTestResults(
+              combinedResult.right
+            )
+            updateEnvsAfterTestScript(combinedResult)
           } else {
             tab.value.document.testResults = {
               description: "",
@@ -492,26 +492,6 @@ export function runRESTRequest$(
 }
 
 function updateEnvsAfterTestScript(runResult: E.Right<SandboxTestResult>) {
-  const updatedGlobalEnvVariables = updateEnvironments(
-    // @ts-expect-error Typescript can't figure out this inference for some reason
-    cloneDeep(runResult.right.envs.global),
-    "global"
-  )
-
-  const updatedSelectedEnvVariables = updateEnvironments(
-    // @ts-expect-error Typescript can't figure out this inference for some reason
-    cloneDeep(runResult.right.envs.selected),
-    "selected"
-  )
-
-  const updatedRunResult = {
-    ...runResult.right,
-    envs: {
-      global: updatedGlobalEnvVariables,
-      selected: updatedSelectedEnvVariables,
-    },
-  }
-
   const globalEnvVariables = updateEnvironments(
     // @ts-expect-error Typescript can't figure out this inference for some reason
     runResult.right.envs.global,
@@ -522,6 +502,11 @@ function updateEnvsAfterTestScript(runResult: E.Right<SandboxTestResult>) {
     v: 2,
     variables: globalEnvVariables,
   })
+  updateEnvironments(
+    // @ts-expect-error Typescript can't figure out this inference for some reason
+    cloneDeep(runResult.right.envs.selected),
+    "selected"
+  )
   if (environmentsStore.value.selectedEnvironmentIndex.type === "MY_ENV") {
     const env = getEnvironment({
       type: "MY_ENV",
@@ -531,7 +516,7 @@ function updateEnvsAfterTestScript(runResult: E.Right<SandboxTestResult>) {
       name: env.name,
       v: 2,
       id: "id" in env ? env.id : "",
-      variables: updatedRunResult.envs.selected,
+      variables: runResult.right.envs.selected,
     })
   } else if (
     environmentsStore.value.selectedEnvironmentIndex.type === "TEAM_ENV"
@@ -541,14 +526,12 @@ function updateEnvsAfterTestScript(runResult: E.Right<SandboxTestResult>) {
     })
     pipe(
       updateTeamEnvironment(
-        JSON.stringify(updatedRunResult.envs.selected),
+        JSON.stringify(runResult.right.envs.selected),
         environmentsStore.value.selectedEnvironmentIndex.teamEnvID,
         env.name
       )
     )()
   }
-
-  return updatedRunResult
 }
 
 /**

packages/hoppscotch-common/src/helpers/fixBrokenEnvironmentVersion.ts

@@ -0,0 +1,27 @@
+import {
+  Environment,
+  translateToNewEnvironmentVariables,
+} from "@hoppscotch/data"
+
+/**
+ * Fixes broken environment versions in the given environments.
+ * This function ensures that all environment variables are translated
+ * to the new format, which is necessary for compatibility with the latest
+ * version of the application.
+ *
+ * Some environments may have been created with an unsupported
+ * variable format, which can lead to issues when trying to access or manipulate those environments.
+ *
+ *
+ * @param envs - The array of environments to fix.
+ * @returns The fixed array of environments with updated variable formats.
+ */
+export const fixBrokenEnvironmentVersion = (envs: Environment[]) => {
+  if (!Array.isArray(envs)) {
+    return envs
+  }
+  return envs.map((env) => ({
+    ...env,
+    variables: (env.variables ?? []).map(translateToNewEnvironmentVariables),
+  }))
+}

packages/hoppscotch-common/src/helpers/fixBrokenRequestVersion.ts

@@ -0,0 +1,54 @@
+import {
+  getDefaultRESTRequest,
+  safelyExtractRESTRequest,
+} from "@hoppscotch/data"
+import { z } from "zod"
+import { REST_TAB_STATE_SCHEMA } from "~/services/persistence/validation-schemas"
+
+type HoppRESTab = z.infer<typeof REST_TAB_STATE_SCHEMA>
+
+/**
+ * Fixes broken request versions in the given REST tab documents.
+ * This function ensures that all requests and test runners have valid
+ * request data, defaulting to the default REST request structure if necessary.
+ *
+ * There were requests in the REST tab that had an invalid version
+ * structure, with response and parent request which could lead to issues when trying to access or
+ * manipulate those requests. This function iterates through the
+ * ordered documents of the REST tab and checks each request.
+ *
+ * @param docs - The ordered documents of the REST tab to fix.
+ * @returns The fixed ordered documents with valid request structures.
+ */
+export const fixBrokenRequestVersion = (
+  docs: HoppRESTab["orderedDocs"]
+): HoppRESTab["orderedDocs"] => {
+  return docs.map((x: HoppRESTab["orderedDocs"][number]) => {
+    if (x.doc.type === "request") {
+      const req = safelyExtractRESTRequest(
+        x.doc.request,
+        getDefaultRESTRequest()
+      )
+      if (req) {
+        x.doc.request = req
+      }
+    }
+
+    if (x.doc.type === "test-runner") {
+      x.doc.request = safelyExtractRESTRequest(
+        x.doc.request,
+        getDefaultRESTRequest()
+      )
+
+      if (x.doc.resultCollection) {
+        x.doc.resultCollection.requests = x.doc.resultCollection?.requests.map(
+          (req) => {
+            return safelyExtractRESTRequest(req, getDefaultRESTRequest())
+          }
+        )
+      }
+    }
+
+    return x
+  })
+}

packages/hoppscotch-common/src/helpers/import-export/import/openapi.ts

@@ -20,7 +20,7 @@ import {
   HoppRESTRequest,
   HoppRESTRequestResponses,
   HoppRESTResponseOriginalRequest,
-  RESTResOriginalReqSchemaVersion,
+  makeHoppRESTResponseOriginalRequest,
 } from "@hoppscotch/data"
 import { pipe, flow } from "fp-ts/function"
 import * as A from "fp-ts/Array"
@@ -828,24 +828,27 @@ const convertPathToHoppReqs = (
             (info.parameters as OpenAPIParamsType[] | undefined) ?? []
           ),
 
-          responses: parseOpenAPIResponses(doc, info, {
-            name: info.operationId ?? info.summary ?? "Untitled Request",
-            auth: parseOpenAPIAuth(doc, info),
-            body: parseOpenAPIBody(doc, info),
-            endpoint,
-            // We don't need to worry about reference types as the Dereferencing pass should remove them
-            params: parseOpenAPIParams(
-              (info.parameters as OpenAPIParamsType[] | undefined) ?? []
-            ),
-            headers: parseOpenAPIHeaders(
-              (info.parameters as OpenAPIParamsType[] | undefined) ?? []
-            ),
-            method: method.toUpperCase(),
-            requestVariables: parseOpenAPIVariables(
-              (info.parameters as OpenAPIParamsType[] | undefined) ?? []
-            ),
-            v: RESTResOriginalReqSchemaVersion,
-          }),
+          responses: parseOpenAPIResponses(
+            doc,
+            info,
+            makeHoppRESTResponseOriginalRequest({
+              name: info.operationId ?? info.summary ?? "Untitled Request",
+              auth: parseOpenAPIAuth(doc, info),
+              body: parseOpenAPIBody(doc, info),
+              endpoint,
+              // We don't need to worry about reference types as the Dereferencing pass should remove them
+              params: parseOpenAPIParams(
+                (info.parameters as OpenAPIParamsType[] | undefined) ?? []
+              ),
+              headers: parseOpenAPIHeaders(
+                (info.parameters as OpenAPIParamsType[] | undefined) ?? []
+              ),
+              method: method.toUpperCase(),
+              requestVariables: parseOpenAPIVariables(
+                (info.parameters as OpenAPIParamsType[] | undefined) ?? []
+              ),
+            })
+          ),
         }),
         metadata: {
           tags: info.tags ?? [],

packages/hoppscotch-common/src/helpers/import-export/import/postman.ts

@@ -10,8 +10,9 @@ import {
   knownContentTypes,
   makeCollection,
   makeRESTRequest,
-  RESTResOriginalReqSchemaVersion,
   ValidContentTypes,
+  HoppRESTRequestResponses,
+  makeHoppRESTResponseOriginalRequest,
 } from "@hoppscotch/data"
 import * as A from "fp-ts/Array"
 import { flow, pipe } from "fp-ts/function"
@@ -31,7 +32,6 @@ import {
 import { stringArrayJoin } from "~/helpers/functional/array"
 import { PMRawLanguage } from "~/types/pm-coll-exts"
 import { IMPORTER_INVALID_FILE_FORMAT } from "."
-import { HoppRESTRequestResponses } from "@hoppscotch/data"
 
 const safeParseJSON = (jsonStr: string) => O.tryCatch(() => JSON.parse(jsonStr))
 
@@ -160,7 +160,7 @@ const getHoppResponses = (
           body: response.body ?? "",
           headers: getHoppReqHeaders(response.headers),
           code: response.code,
-          originalRequest: {
+          originalRequest: makeHoppRESTResponseOriginalRequest({
             auth: getHoppReqAuth(response.originalRequest?.auth),
             body: getHoppReqBody({
               body: response.originalRequest?.body,
@@ -178,8 +178,7 @@ const getHoppResponses = (
             requestVariables: getHoppReqVariables(
               response.originalRequest?.url.variables ?? null
             ),
-            v: RESTResOriginalReqSchemaVersion,
-          },
+          }),
         }
         return [response.name, res]
       })

packages/hoppscotch-common/src/helpers/teams/TeamEnvironmentAdapter.ts

@@ -11,7 +11,6 @@ import {
 } from "../backend/graphql"
 import { TeamEnvironment } from "./TeamEnvironment"
 import { Environment, EnvironmentSchemaVersion } from "@hoppscotch/data"
-import { entityReference } from "verzod"
 
 type EntityType = "environment"
 type EntityID = `${EntityType}-${string}`
@@ -121,18 +120,18 @@ export default class TeamEnvironmentAdapter {
             variables: JSON.parse(x.variables),
           }
 
-          const parsedEnvironment =
-            entityReference(Environment).safeParse(environment)
+          const parsedEnvironment = Environment.safeParse(environment)
 
           return <TeamEnvironment>{
             id: x.id,
             teamID: x.teamID,
-            environment: parsedEnvironment.success
-              ? parsedEnvironment.data
-              : {
-                  ...environment,
-                  v: EnvironmentSchemaVersion,
-                },
+            environment:
+              parsedEnvironment.type === "ok"
+                ? parsedEnvironment.value
+                : {
+                    ...environment,
+                    v: EnvironmentSchemaVersion,
+                  },
           }
         })
       )

packages/hoppscotch-common/src/helpers/utils/statusCodes.ts

@@ -111,7 +111,7 @@ export const getFullStatusCodePhrase = () => {
 // return all status codes and their phrases
 // like code • phrase
 export const getStatusCodePhrase = (
-  code: number | undefined,
+  code: number | undefined | null,
   statusText: string
 ) => {
   if (!code) return statusText

packages/hoppscotch-common/src/kernel/store.ts

@@ -57,11 +57,16 @@ export const Store = (() => {
       return module().listNamespaces(STORE_PATH)
     },
 
-    listKeys: async (namespace: string): Promise<E.Either<StoreError, string[]>> => {
+    listKeys: async (
+      namespace: string
+    ): Promise<E.Either<StoreError, string[]>> => {
       return module().listKeys(STORE_PATH, namespace)
     },
 
-    watch: async (namespace: string, key: string): Promise<StoreEventEmitter<StoreEvents>> => {
+    watch: async (
+      namespace: string,
+      key: string
+    ): Promise<StoreEventEmitter<StoreEvents>> => {
       return module().watch(STORE_PATH, namespace, key)
     },
   } as const