140 lines
4.5 KiB
JavaScript
140 lines
4.5 KiB
JavaScript
/**
|
|
* A simple HTTP REST client
|
|
*
|
|
* We use this in the useBackend hook, but it's also possible to use this with
|
|
* any other REST API.
|
|
* This uses the fetch API, so it has no dependencies.
|
|
* However, that means you cannot use this with a REST API using a non-trusted X.509 certificate, since fetch does not provide an escape hatch for that.
|
|
* If that's your use-case, use Axios instead.
|
|
*
|
|
* @param {string} baseUrl - The base URL of the API that will be used as a prefix for all calls
|
|
* @param {string} baseHeaders - Any headers to add to each request. Eg for authentication
|
|
* @return {object} client - An object with get, post, and put methods
|
|
*/
|
|
export function RestClient(baseUrl = '', baseHeaders = {}) {
|
|
this.baseUrl = baseUrl
|
|
this.baseHeaders = baseHeaders
|
|
|
|
this.delete = async function (url, headers, raw, log) {
|
|
return withoutBody('DELETE', baseUrl + url, { ...baseHeaders, ...headers }, raw, log)
|
|
}
|
|
|
|
this.get = async function (url, headers, raw, log) {
|
|
return withoutBody('GET', baseUrl + url, { ...baseHeaders, ...headers }, raw, log)
|
|
}
|
|
|
|
this.head = async function (url, headers, raw, log) {
|
|
return withoutBody('HEAD', baseUrl + url, { ...baseHeaders, ...headers }, raw, log)
|
|
}
|
|
|
|
this.patch = async function (url, data, headers, raw, log) {
|
|
return withBody('PATCH', baseUrl + url, data, { ...baseHeaders, ...headers }, raw, log)
|
|
}
|
|
|
|
this.post = async function (url, data, headers, raw, log) {
|
|
return withBody('POST', baseUrl + url, data, { ...baseHeaders, ...headers }, raw, log)
|
|
}
|
|
|
|
this.put = async function (url, data, headers, raw, log) {
|
|
return withBody('PUT', baseUrl + url, data, { ...baseHeaders, headers }, raw, log)
|
|
}
|
|
|
|
return this
|
|
}
|
|
|
|
/*
|
|
* General purpose method to call a REST API without a body (eg: GET or DELETE requests)
|
|
*
|
|
* @param {string} url - The URL to call
|
|
* @param {object} headers - Any request headers to add
|
|
* @param {bool} raw - Set this to something truthy to not parse the result as JSON
|
|
* @param {function} log - Optional custom logging method to log errors
|
|
* @return {response} array - An array with status code followed by either the result parse as JSON, the raw result, or false in case of trouble
|
|
*/
|
|
async function withoutBody(method = 'GET', url, headers = {}, raw = false, log = console.log) {
|
|
let response
|
|
try {
|
|
response = await fetch(url, { method, headers })
|
|
} catch (err) {
|
|
if (log) console.log({ url, err })
|
|
}
|
|
|
|
if (!response) return [false, false]
|
|
|
|
/*
|
|
* Can we parse the response as JSON?
|
|
*/
|
|
let body
|
|
try {
|
|
body = raw ? await response.text() : await response.json()
|
|
} catch (err) {
|
|
console.log(err)
|
|
try {
|
|
body = await response.text()
|
|
} catch (err) {
|
|
console.log(err)
|
|
body = false
|
|
}
|
|
}
|
|
|
|
return [response.status || false, body]
|
|
}
|
|
|
|
/*
|
|
* General purpose method to call a REST API with a body (eg: PATCH, PUT, or POST requests)
|
|
*
|
|
* @param {url} string - The URL to call
|
|
* @param {data} string - The data to send
|
|
* @param {object} headers - Any request headers to add
|
|
* @param {raw} string - Set this to something truthy to not parse the result as JSON
|
|
* @param {function} log - Optional logging method to log errors
|
|
* @return {response} array - An array with status code followed by either the result parse as JSON, the raw result, or false in case of trouble
|
|
*/
|
|
async function withBody(method = 'POST', url, data, headers, raw = false, log = console.log) {
|
|
const request = { method, headers }
|
|
if (data && typeof data === 'object' && Object.keys(data).length > 0) {
|
|
request.body = JSON.stringify(data)
|
|
request.headers['Content-Type'] = 'application/json'
|
|
}
|
|
|
|
let response
|
|
try {
|
|
response = await fetch(url, request)
|
|
} catch (err) {
|
|
if (log) log(err)
|
|
}
|
|
|
|
/*
|
|
* Some status codes have no response body
|
|
*/
|
|
if (response.status && [204].includes(response.status)) return [response.status, {}]
|
|
else if (response.status && response.status < 400) {
|
|
let data
|
|
try {
|
|
data = raw ? await response.text() : await response.json()
|
|
} catch (err) {
|
|
if (log) log(err)
|
|
return raw ? [response.status, { err }] : [response.status, data]
|
|
}
|
|
return [response.status, data]
|
|
}
|
|
|
|
/*
|
|
* If we end up here, status code is 400 or higher so it's an error
|
|
* We still attempt to parse the body though
|
|
*/
|
|
let body
|
|
try {
|
|
body = raw ? await response.text() : await response.json()
|
|
} catch (err) {
|
|
console.log(err)
|
|
try {
|
|
body = await response.text()
|
|
} catch (err) {
|
|
console.log(err)
|
|
body = false
|
|
}
|
|
}
|
|
|
|
return [response.status || 500, body]
|
|
}
|