Chore/deprecate lib common fetch 03 (supabase#36529)

* Deprecate use of getWithTimeout, refactor BuildingState and RestoringState to use RQ

* Refactor profile-create-mutation to use data/fetchers, and edge-function-status-query to use fetch

* Shift post from lib/common/fetch, refactor bucket-object-download-mutation

* Address feedback

* Minor fix

* Refactor post calls from lib/common/fetch in auth pages to data/fetchers

* Add missing POST users endpoint + small fix when deleting user via context menu

* Remove all use of any imports from lib/common/fetch

* Clean up remaining usage of lib/common/fetch

* Fix fetchHeadWithTimeout

* simplify handleFetchError

* allow handleFetchError to accept unknown

* non-breaking change

* small fixes

* fix query path

---------

Co-authored-by: Alaister Young <[email protected]>

Author: joshenlim

apps/studio/data/fetchers.ts

@@ -176,7 +176,7 @@ export const handleError = (
   throw new ResponseError(undefined)
 }
 
-// [Joshen] The methods below are brought over from lib/common/fetchers because we still need them
+// [Joshen] The methods below are brought over from lib/common/fetch because we still need them
 // primarily for our own endpoints in the dashboard repo. So consolidating all the fetch methods into here.
 
 async function handleFetchResponse<T>(response: Response): Promise<T | ResponseError> {
@@ -196,6 +196,21 @@ async function handleFetchResponse<T>(response: Response): Promise<T | ResponseE
   }
 }
 
+async function handleFetchHeadResponse<T>(
+  response: Response,
+  headers: string[]
+): Promise<T | ResponseError> {
+  try {
+    const res = {} as any
+    headers.forEach((header: string) => {
+      res[header] = response.headers.get(header)
+    })
+    return res
+  } catch (e) {
+    return handleError(response) as T | ResponseError
+  }
+}
+
 async function handleFetchError(response: unknown): Promise<ResponseError> {
   let resJson: any = {}
 
@@ -229,6 +244,34 @@ async function handleFetchError(response: unknown): Promise<ResponseError> {
   return error
 }
 
+/**
+ * To be used only for dashboard API endpoints. Use `fetch` directly if calling a non dashboard API endpoint
+ */
+export async function fetchGet<T = any>(
+  url: string,
+  options?: { [prop: string]: any }
+): Promise<T | ResponseError> {
+  try {
+    const { headers: otherHeaders, abortSignal, ...otherOptions } = options ?? {}
+    const headers = await constructHeaders({
+      'Content-Type': 'application/json',
+      ...DEFAULT_HEADERS,
+      ...otherHeaders,
+    })
+    const response = await fetch(url, {
+      headers,
+      method: 'GET',
+      referrerPolicy: 'no-referrer-when-downgrade',
+      ...otherOptions,
+      signal: abortSignal,
+    })
+    if (!response.ok) return handleFetchError(response)
+    return handleFetchResponse(response)
+  } catch (error) {
+    return handleFetchError(error)
+  }
+}
+
 /**
  * To be used only for dashboard API endpoints. Use `fetch` directly if calling a non dashboard API endpoint
  *
@@ -247,10 +290,10 @@ export async function fetchPost<T = any>(
       ...otherHeaders,
     })
     const response = await fetch(url, {
+      headers,
       method: 'POST',
       body: JSON.stringify(data),
       referrerPolicy: 'no-referrer-when-downgrade',
-      headers,
       ...otherOptions,
       signal: abortSignal,
     })
@@ -260,3 +303,36 @@ export async function fetchPost<T = any>(
     return handleFetchError(error)
   }
 }
+
+/**
+ * To be used only for dashboard API endpoints. Use `fetch` directly if calling a non dashboard API endpoint
+ */
+export async function fetchHeadWithTimeout<T = any>(
+  url: string,
+  headersToRetrieve: string[],
+  options?: { [prop: string]: any }
+): Promise<T | ResponseError> {
+  try {
+    const timeout = options?.timeout ?? 60000
+
+    const { headers: otherHeaders, abortSignal, ...otherOptions } = options ?? {}
+    const headers = await constructHeaders({
+      'Content-Type': 'application/json',
+      ...DEFAULT_HEADERS,
+      ...otherHeaders,
+    })
+
+    const response = await fetch(url, {
+      method: 'HEAD',
+      referrerPolicy: 'no-referrer-when-downgrade',
+      headers,
+      ...otherOptions,
+      signal: AbortSignal.timeout(timeout),
+    })
+
+    if (!response.ok) return handleFetchError(response)
+    return handleFetchHeadResponse(response, headersToRetrieve)
+  } catch (error) {
+    return handleFetchError(error)
+  }
+}

apps/studio/lib/api/apiWrapper.ts

@@ -1,8 +1,25 @@
-import { isResponseOk } from 'lib/common/fetch'
 import type { NextApiHandler, NextApiRequest, NextApiResponse } from 'next'
+
+import { ResponseError, ResponseFailure } from 'types'
 import { IS_PLATFORM } from '../constants'
 import { apiAuthenticate } from './apiAuthenticate'
 
+export function isResponseOk<T>(response: T | ResponseFailure | undefined): response is T {
+  if (response === undefined || response === null) {
+    return false
+  }
+
+  if (response instanceof ResponseError) {
+    return false
+  }
+
+  if (typeof response === 'object' && 'error' in response && Boolean(response.error)) {
+    return false
+  }
+
+  return true
+}
+
 // Purpose of this apiWrapper is to function like a global catchall for ANY errors
 // It's a safety net as the API service should never drop, nor fail