@sap-cloud-sdk/core/dist/connectivity/scp-cf/destination/destination.js

"use strict";
var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.noDestinationErrorMessage = exports.isDestinationJson = exports.isDestinationConfiguration = exports.toDestinationNameUrl = exports.parseDestination = exports.sanitizeDestination = void 0;
var util_1 = require("@sap-cloud-sdk/util");
var destination_service_types_1 = require("./destination-service-types");
/**
 * Takes an existing or a parsed destination and returns an SDK compatible destination object.
 * @param destination - An object that adheres to the [[Destination]] interface.
 * @returns An SDK compatible destination object.
 */
function sanitizeDestination(destination) {
    validateDestinationInput(destination);
    var destAuthToken = parseAuthTokens(destination);
    var parsedDestination = parseCertificates(destAuthToken);
    parsedDestination = setDefaultAuthenticationFallback(parsedDestination);
    parsedDestination = setTrustAll(parsedDestination);
    parsedDestination = setOriginalProperties(parsedDestination);
    return parsedDestination;
}
exports.sanitizeDestination = sanitizeDestination;
/**
 * Takes a JSON object returned by any of the calls to the destination service and returns an SDK compatible destination object.
 * This function only accepts destination configurations of type 'HTTP' and will error if no 'URL' is given.
 * @param destinationJson - A JSON object returned by the destination service.
 * @returns An SDK compatible destination object.
 */
function parseDestination(destinationJson) {
    var destinationConfig = getDestinationConfig(destinationJson);
    validateDestinationConfig(destinationConfig);
    var destination = Object.entries(destinationConfig).reduce(function (dest, _a) {
        var originalKey = _a[0], value = _a[1];
        if (originalKey in configMapping) {
            dest[configMapping[originalKey]] = value;
        }
        return dest;
    }, {
        originalProperties: destinationJson,
        authTokens: destinationJson['authTokens'] || [],
        certificates: destinationJson['certificates'] || []
    });
    var additionalHeadersAndQueryParameters = getAdditionalHeadersAndQueryParameters(destinationConfig);
    return sanitizeDestination(__assign(__assign({}, destination), additionalHeadersAndQueryParameters));
}
exports.parseDestination = parseDestination;
/**
 * Get either additional headers or query parameters from a destination, depending on the given prefix.
 * @param destinationConfig - Original destination config that could include additional headers or query parameters.
 * @param originalKeyPrefix - This is what the additional header and query keys start with, when specified in the original destination config.
 * @returns An object with either the headers or query parameters and their values, depending on the `originalKeyPrefix`.
 */
function getAdditionalProperties(destinationConfig, originalKeyPrefix) {
    var relevantConfigEntries = Object.entries(destinationConfig).filter(function (_a) {
        var key = _a[0];
        return key.startsWith(originalKeyPrefix);
    });
    return relevantConfigEntries.reduce(function (additionalProperties, _a) {
        var originalKey = _a[0], value = _a[1];
        var headerKey = originalKey.replace(originalKeyPrefix, '');
        additionalProperties[headerKey] = value;
        return additionalProperties;
    }, {});
}
/**
 * Get additional headers and/or query parameters from a destination.
 * Destinations can specify additional headers and/or query parameters, that should be added to every request against the given destination.
 * They are specified in the following format:
 * `URL.headers.<header-name>` or `URL.queries.<query-parameter-name>`
 * @param destinationConfig - Original destination config that could include additional headers or query parameters.
 * @returns An object with either the headers or query parameters and their values, depending on the `originalKeyPrefix`.
 */
function getAdditionalHeadersAndQueryParameters(destinationConfig) {
    var additionalHeaders = getAdditionalProperties(destinationConfig, 'URL.headers.');
    var additionalQueryParameters = getAdditionalProperties(destinationConfig, 'URL.queries.');
    var additionalProperties = {};
    if (Object.keys(additionalHeaders).length) {
        additionalProperties['headers'] = additionalHeaders;
    }
    if (Object.keys(additionalQueryParameters).length) {
        additionalProperties['queryParameters'] = additionalQueryParameters;
    }
    return additionalProperties;
}
function getDestinationConfig(destinationJson) {
    return isDestinationJson(destinationJson)
        ? destinationJson.destinationConfiguration
        : destinationJson;
}
function validateDestinationConfig(destinationConfig) {
    if (isHttpDestination(destinationConfig) &&
        typeof destinationConfig.URL === 'undefined') {
        throw Error("Property 'URL' of destination configuration must not be undefined.");
    }
}
function validateDestinationInput(destinationInput) {
    if (isHttpDestination(destinationInput) &&
        typeof destinationInput.url === 'undefined') {
        throw Error("Property 'url' of destination input must not be undefined.");
    }
}
function isHttpDestination(destinationInput) {
    return (destinationInput.Type === 'HTTP' ||
        destinationInput.type === 'HTTP' ||
        (typeof destinationInput.type === 'undefined' &&
            typeof destinationInput.Type === 'undefined'));
}
/* eslint-disable-next-line valid-jsdoc */
/**
 * @hidden
 */
function toDestinationNameUrl(destination) {
    return (0, destination_service_types_1.isDestinationNameAndJwt)(destination)
        ? "name: ".concat(destination.destinationName)
        : "name: ".concat(destination.name, ", url: ").concat(destination.url);
}
exports.toDestinationNameUrl = toDestinationNameUrl;
function setOriginalProperties(destination) {
    var originalProperties = destination.originalProperties
        ? destination.originalProperties
        : destination;
    return (0, util_1.assoc)('originalProperties', originalProperties, destination);
}
function setDefaultAuthenticationFallback(destination) {
    return destination.authentication
        ? destination
        : (0, util_1.assoc)('authentication', getAuthenticationType(destination), destination);
}
function parseCertificate(certificate) {
    return {
        name: certificate.Name || certificate.name,
        content: certificate.Content || certificate.content,
        type: certificate.Type || certificate.type
    };
}
function parseCertificates(destination) {
    var certificates = destination.certificates
        ? destination.certificates.map(parseCertificate)
        : [];
    return (0, util_1.assoc)('certificates', certificates, destination);
}
function parseAuthToken(authToken) {
    return {
        type: authToken.type,
        value: authToken.value,
        expiresIn: authToken.expires_in,
        error: 'error' in authToken ? authToken.error : null,
        http_header: authToken.http_header
    };
}
function parseAuthTokens(destination) {
    var authTokens = destination.authTokens
        ? destination.authTokens.map(parseAuthToken)
        : [];
    return (0, util_1.assoc)('authTokens', authTokens, destination);
}
function setTrustAll(destination) {
    return (0, util_1.assoc)('isTrustingAllCertificates', parseTrustAll(destination.isTrustingAllCertificates), destination);
}
function parseTrustAll(isTrustingAllCertificates) {
    if (typeof isTrustingAllCertificates === 'string') {
        return isTrustingAllCertificates.toLowerCase() === 'true';
    }
    return !!isTrustingAllCertificates;
}
function getAuthenticationType(destination) {
    return destination.authentication ||
        (destination.username && destination.password)
        ? 'BasicAuthentication'
        : 'NoAuthentication';
}
/* eslint-disable-next-line valid-jsdoc */
/**
 * @hidden
 */
function isDestinationConfiguration(destination) {
    return destination.URL !== undefined;
}
exports.isDestinationConfiguration = isDestinationConfiguration;
/* eslint-disable-next-line valid-jsdoc */
/**
 * @hidden
 */
function isDestinationJson(destination) {
    return Object.keys(destination).includes('destinationConfiguration');
}
exports.isDestinationJson = isDestinationJson;
var configMapping = {
    URL: 'url',
    Name: 'name',
    User: 'username',
    Password: 'password',
    ProxyType: 'proxyType',
    'sap-client': 'sapClient',
    Authentication: 'authentication',
    TrustAll: 'isTrustingAllCertificates',
    Type: 'type',
    tokenServiceURL: 'tokenServiceUrl',
    clientId: 'clientId',
    clientSecret: 'clientSecret',
    tokenServiceUser: 'tokenServiceUser',
    tokenServicePassword: 'tokenServicePassword',
    CloudConnectorLocationId: 'cloudConnectorLocationId',
    certificates: 'certificates',
    KeyStoreLocation: 'keyStoreName',
    KeyStorePassword: 'keyStorePassword',
    SystemUser: 'systemUser'
};
function noDestinationErrorMessage(destination) {
    return (0, destination_service_types_1.isDestinationNameAndJwt)(destination)
        ? "Could not find a destination with name \"".concat(destination.destinationName, "\"! Unable to execute request.")
        : 'Could not find a destination to execute request against and no destination name has been provided (this should never happen)!';
}
exports.noDestinationErrorMessage = noDestinationErrorMessage;
//# sourceMappingURL=destination.js.map