@kontent-ai/sync-sdk/dist/utils/query.utils.js

Sync API v2 for Kontent.ai

import { getDefaultHttpService, getSdkIdHeader, } from "@kontent-ai/core-sdk";
import { sdkInfo } from "../sdk-info.js";
export function getQuery(data) {
    return {
        toPromise: async () => {
            return await resolveQueryAsync(data);
        },
    };
}
export function getPagingQuery(data) {
    return {
        ...getQuery(data),
        toAllPromise: async () => {
            return await resolvePagingQueryAsync(data);
        },
    };
}
export function extractContinuationToken(responseHeaders) {
    return responseHeaders.find((header) => header.name.toLowerCase() === "X-Continuation".toLowerCase())
        ?.value;
}
function getHttpService(config) {
    return config.httpService ?? getDefaultHttpService();
}
function getCombinedRequestHeaders({ requestHeaders, continuationToken, deliveryApiKey, }) {
    return [
        getSdkIdHeader({
            host: "npmjs.com",
            name: sdkInfo.name,
            version: sdkInfo.version,
        }),
        ...requestHeaders,
        ...(continuationToken
            ? [
                {
                    name: "X-Continuation",
                    value: continuationToken,
                },
            ]
            : []),
        ...(deliveryApiKey
            ? [
                {
                    name: "Authorization",
                    value: `Bearer ${deliveryApiKey}`,
                },
            ]
            : []),
    ];
}
async function resolvePagingQueryAsync(data) {
    const responses = [];
    let nextContinuationToken = data.continuationToken;
    while (nextContinuationToken) {
        const { success, response, error } = await getQuery({
            ...data,
            continuationToken: nextContinuationToken,
        }).toPromise();
        if (success) {
            responses.push(response);
            if (data.canFetchNextResponse(response)) {
                nextContinuationToken = response.meta.continuationToken;
            }
            else {
                nextContinuationToken = undefined;
            }
        }
        else {
            return {
                success: false,
                error: error,
            };
        }
    }
    if (responses.length === 0) {
        return {
            success: false,
            error: {
                reason: "noResponses",
                url: data.url,
                message: "No responses were processed. Expected at least one response to be fetched when using paging queries.",
            },
        };
    }
    return {
        success: true,
        responses: responses,
        lastContinuationToken: responses.at(-1)?.meta.continuationToken ?? "",
    };
}
async function resolveQueryAsync({ config, request, url, extraMetadata, zodSchema, continuationToken, }) {
    const { success, response, error } = await getHttpService(config).requestAsync({
        ...request,
        requestHeaders: getCombinedRequestHeaders({
            requestHeaders: request.requestHeaders ?? [],
            continuationToken,
            deliveryApiKey: config.deliveryApiKey,
        }),
    });
    if (!success) {
        return {
            success: false,
            error,
        };
    }
    if (config.responseValidation?.enable) {
        const { isValid, error: validationError } = await validateResponseAsync(response.data, zodSchema);
        if (!isValid) {
            return {
                success: false,
                error: {
                    message: `Failed to validate response schema for url '${url}'`,
                    reason: "validationFailed",
                    zodError: validationError,
                    response,
                    url,
                },
            };
        }
    }
    return {
        success: true,
        response: {
            payload: response.data,
            meta: {
                responseHeaders: response.adapterResponse.responseHeaders,
                status: response.adapterResponse.status,
                continuationToken: extractContinuationToken(response.adapterResponse.responseHeaders),
                ...extraMetadata(response),
            },
        },
    };
}
async function validateResponseAsync(data, zodSchema) {
    const validateResult = await zodSchema.safeParseAsync(data);
    if (validateResult.success) {
        return {
            isValid: true,
        };
    }
    return {
        isValid: false,
        error: validateResult.error,
    };
}
//# sourceMappingURL=query.utils.js.map