ai-utils.js/util/api/postToApi.cjs

Build AI applications, chatbots, and agents with JavaScript and TypeScript.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.postToApi = exports.postJsonToApi = exports.createTextResponseHandler = exports.createJsonResponseHandler = void 0;
const ApiCallError_js_1 = require("./ApiCallError.cjs");
const createJsonResponseHandler = (responseSchema) => async ({ response, url, requestBodyValues }) => {
    const parsedResult = responseSchema.safeParse(await response.json());
    if (!parsedResult.success) {
        throw new ApiCallError_js_1.ApiCallError({
            message: "Invalid JSON response",
            cause: parsedResult.error,
            statusCode: response.status,
            url,
            requestBodyValues,
        });
    }
    return parsedResult.data;
};
exports.createJsonResponseHandler = createJsonResponseHandler;
const createTextResponseHandler = () => async ({ response }) => response.text();
exports.createTextResponseHandler = createTextResponseHandler;
const postJsonToApi = async ({ url, apiKey, body, failedResponseHandler, successfulResponseHandler, abortSignal, }) => (0, exports.postToApi)({
    url,
    apiKey,
    contentType: "application/json",
    body: {
        content: JSON.stringify(body),
        values: body,
    },
    failedResponseHandler,
    successfulResponseHandler,
    abortSignal,
});
exports.postJsonToApi = postJsonToApi;
const postToApi = async ({ url, apiKey, contentType, body, successfulResponseHandler, failedResponseHandler, abortSignal, }) => {
    try {
        const headers = {};
        if (apiKey !== undefined) {
            headers["Authorization"] = `Bearer ${apiKey}`;
        }
        if (contentType !== null) {
            headers["Content-Type"] = contentType;
        }
        const response = await fetch(url, {
            method: "POST",
            headers,
            body: body.content,
            signal: abortSignal,
        });
        if (!response.ok) {
            try {
                throw await failedResponseHandler({
                    response,
                    url,
                    requestBodyValues: body.values,
                });
            }
            catch (error) {
                if (error instanceof Error) {
                    if (error.name === "AbortError" || error instanceof ApiCallError_js_1.ApiCallError) {
                        throw error;
                    }
                }
                throw new ApiCallError_js_1.ApiCallError({
                    message: "Failed to process error response",
                    cause: error,
                    statusCode: response.status,
                    url,
                    requestBodyValues: body.values,
                });
            }
        }
        try {
            return await successfulResponseHandler({
                response,
                url,
                requestBodyValues: body.values,
            });
        }
        catch (error) {
            if (error instanceof Error) {
                if (error.name === "AbortError" || error instanceof ApiCallError_js_1.ApiCallError) {
                    throw error;
                }
            }
            throw new ApiCallError_js_1.ApiCallError({
                message: "Failed to process successful response",
                cause: error,
                statusCode: response.status,
                url,
                requestBodyValues: body.values,
            });
        }
    }
    catch (error) {
        if (error instanceof Error) {
            if (error.name === "AbortError") {
                throw error;
            }
        }
        throw error;
    }
};
exports.postToApi = postToApi;