integreat/dist/utils/response.js

Node.js integration layer

import debugLib from 'debug';
import { isOkStatus, isErrorResponse, isNotNullOrUndefined, isDuplicate, } from './is.js';
const debug = debugLib('great');
const extractErrorMessage = (error) => error instanceof Error
    ? error.message
    : typeof error === 'string'
        ? error
        : undefined;
export function createErrorResponse(error, origin, status = 'error', reason) {
    const message = extractErrorMessage(error);
    return {
        status,
        ...(isOkStatus(status)
            ? { warning: message }
            : { error: message ?? 'Unknown error' }),
        ...(reason ? { reason } : {}),
        ...(origin ? { origin } : {}),
    };
}
export function createUnknownServiceError(type, serviceId, actionType) {
    const error = serviceId
        ? `Service with id '${serviceId || '<not set>'}' does not exist`
        : `No service exists for type '${type || '<not set>'}'`;
    debug(`${actionType}: ${error}`);
    return createErrorResponse(error, `handler:${actionType}`);
}
const getCombinedStatus = (responses) => responses
    .map((response) => response.status)
    .reduce((combined, status) => (combined === status ? combined : 'error'));
function getCombinedErrors(responses) {
    const errors = responses
        .filter((response) => response.error || isErrorResponse(response))
        .map((response) => `[${response.status}] ${response.error}`)
        .filter(isDuplicate);
    return errors.join(' | ');
}
const getCombinedWarnings = (responses) => responses
    .map((response) => response.warning)
    .filter(isNotNullOrUndefined)
    .filter(isDuplicate)
    .join(' | ');
function getCombinedOrigins(responses) {
    const origins = responses
        .map((response) => response.origin)
        .filter(isNotNullOrUndefined)
        .filter(isDuplicate);
    return origins.length === 1 ? origins[0] : undefined;
}
export function combineResponses(responses) {
    responses = responses.filter(isNotNullOrUndefined);
    if (responses.length < 2) {
        return responses[0];
    }
    else {
        const status = getCombinedStatus(responses);
        const error = getCombinedErrors(responses);
        const warning = getCombinedWarnings(responses);
        const origin = getCombinedOrigins(responses);
        return {
            status,
            ...(error && { error }),
            ...(warning && { warning }),
            ...(origin && { origin }),
        };
    }
}
const generateOrigin = (origin, responseOrigin, doPrefix) => responseOrigin
    ? doPrefix && origin !== responseOrigin
        ? `${origin}:${responseOrigin}`
        : responseOrigin
    : origin;
export const setOrigin = (response, origin, doPrefix = false) => (typeof response.status !== 'string' && !response.error) ||
    response.status === 'ok' ||
    response.status === 'queued'
    ? response
    : {
        ...response,
        origin: generateOrigin(origin, response.origin, doPrefix),
    };
//# sourceMappingURL=response.js.map