@careevolution/orchestrate/dist/esm/httpHandler.js

A TypeScript client for the Orchestrate API

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
import { OrchestrateClientError, OrchestrateHttpError } from "./exceptions.js";
class OperationalOutcomeIssue {
}
function readJsonOutcomes(responseText) {
    return __awaiter(this, void 0, void 0, function* () {
        try {
            const json = JSON.parse(responseText);
            if (json.issue) {
                return json.issue;
            }
            if (json.type === "https://tools.ietf.org/html/rfc9110#section-15.5.1") {
                return [{
                        severity: "error",
                        code: json.title,
                        diagnostics: json.detail,
                    }];
            }
            return [];
        }
        catch (e) {
            return [];
        }
    });
}
function readOperationalOutcomes(responseText) {
    return __awaiter(this, void 0, void 0, function* () {
        const outcomes = yield readJsonOutcomes(responseText);
        if (outcomes.length > 0) {
            return outcomes.map((o) => `${o.severity}: ${o.code} - ${o.diagnostics}`);
        }
        return [responseText];
    });
}
function errorFromResponse(response) {
    return __awaiter(this, void 0, void 0, function* () {
        const responseText = yield response.text();
        const operationalOutcomes = yield readOperationalOutcomes(responseText);
        if (response.status >= 400 && response.status < 600) {
            throw new OrchestrateClientError(responseText, operationalOutcomes);
        }
        throw new OrchestrateHttpError(responseText);
    });
}
export class HttpHandler {
    constructor(baseUrl, defaultHeaders) {
        this.baseUrl = baseUrl;
        this.defaultHeaders = defaultHeaders;
    }
    mergeHeaders(headers) {
        return Object.assign(Object.assign({}, this.defaultHeaders), (headers !== null && headers !== void 0 ? headers : {}));
    }
    toString() {
        return this.baseUrl;
    }
    post(path, body, // eslint-disable-line @typescript-eslint/no-explicit-any
    headers) {
        return __awaiter(this, void 0, void 0, function* () {
            const requestHeaders = this.mergeHeaders(headers);
            const preparedBody = requestHeaders["Content-Type"] === "application/json" ? JSON.stringify(body) : body;
            const url = this.baseUrl + path;
            const response = yield fetch(url, {
                method: "POST",
                headers: requestHeaders,
                body: preparedBody,
            });
            if (!response.ok) {
                yield errorFromResponse(response);
            }
            if (requestHeaders["Accept"] === "application/zip" || requestHeaders["Accept"] === "application/pdf") {
                return yield response.arrayBuffer();
            }
            if (requestHeaders["Accept"] === "application/json") {
                return yield response.json();
            }
            return yield response.text();
        });
    }
    get(path, headers) {
        return __awaiter(this, void 0, void 0, function* () {
            const requestHeaders = this.mergeHeaders(headers);
            const url = this.baseUrl + path;
            const response = yield fetch(url, {
                method: "GET",
                headers: requestHeaders,
            });
            if (!response.ok) {
                yield errorFromResponse(response);
            }
            return yield response.json();
        });
    }
}