integreat-transporter-http/dist/utils/response.js

HTTP transporter for Integreat

import { HTTPError, } from 'got';
export const dataFromResponse = (response) => typeof response.data === 'string'
    ? response.data
    : response.data === null || response.data === undefined
        ? undefined
        : JSON.stringify(response.data);
export function statusCodeFromResponse(response) {
    switch (response.status) {
        case 'ok':
        case 'noaction':
            return 200;
        case 'queued':
            return 201;
        case 'badrequest':
            return 400;
        case 'autherror':
            return 401;
        case 'noaccess':
            return response.reason === 'noauth' ? 401 : 403;
        case 'notfound':
            return 404;
        case 'timeout':
            return 408;
        case 'toomany':
            return 429;
        default:
            return 500;
    }
}
export const normalizeHeaders = (headers) => headers
    ? Object.fromEntries(Object.entries(headers)
        .filter(([, value]) => value !== undefined)
        .map(([key, value]) => [key.toLowerCase(), value]))
    : undefined;
export const createResponse = (action, status, data, error, headers) => ({
    ...action.response,
    status,
    ...(data !== undefined && data !== '' ? { data } : {}),
    ...(error !== undefined ? { error } : {}),
    ...(headers ? { headers } : {}),
});
const isGotResponse = (response) => !!response &&
    typeof response === 'object' &&
    typeof response.statusCode === 'number';
const isGetRequestError = (error) => typeof error.code === 'string';
const getStatusCodeFromError = (error) => isGetRequestError(error) && error.code === 'ETIMEDOUT' ? 408 : undefined;
const extractFromError = (error) => isGotResponse(error)
    ? [error.statusCode, error.statusMessage, error.body]
    : error instanceof HTTPError
        ? [error.response.statusCode, error.response.statusMessage, undefined]
        : error instanceof Error
            ? [getStatusCodeFromError(error), error.message, undefined]
            : [undefined, 'Unknown response', undefined];
function responseStatusFromCode(statusCode) {
    switch (statusCode) {
        case 400:
            return 'badrequest';
        case 401:
        case 403:
            return 'noaccess';
        case 404:
            return 'notfound';
        case 408:
            return 'timeout';
        case 429:
            return 'toomany';
        default:
            return 'error';
    }
}
function errorFromStatus(status, hasAuth, url, statusCode, statusMessage) {
    if (statusCode === undefined) {
        return `Server returned '${statusMessage}' for ${url}`;
    }
    else {
        switch (status) {
            case 'noaccess':
                return hasAuth
                    ? `Not authorized (${statusCode})`
                    : `Service requires authentication (${statusCode})`;
            case 'notfound':
                return `Could not find the url ${url}`;
            default:
                return `Server returned ${statusCode} for ${url}`;
        }
    }
}
export function createResponseWithError(action, url, err) {
    const [statusCode, statusMessage, data] = extractFromError(err);
    const status = responseStatusFromCode(statusCode);
    const error = errorFromStatus(status, !!action.meta?.auth, url, statusCode, statusMessage);
    return createResponse(action, status, data, error);
}
//# sourceMappingURL=response.js.map