@sap-cloud-sdk/core/dist/odata-common/uri-conversion/get-resource-path.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.createGetResourcePathForKeys = void 0;
var util_1 = require("@sap-cloud-sdk/util");
var name_converter_1 = require("../name-converter");
var logger = util_1.createLogger({
    package: 'core',
    messageContext: 'get-resource-path'
});
/**
 * Creates a getResourcePathForKeys function using the OData v2 or OData v4 URI converter.
 * The concrete instances for v2 or v4 are initiated in odata/v2/uri-conversion/odata-uri.ts and odata/v4/uri-conversion/odata-uri.ts.
 * @param uriConverter - Uri converter for v2 or v4.
 * @returns The filter getter. See [[GetFilter]]
 */
function createGetResourcePathForKeys(uriConverter) {
    /**
     * Get the resource path of an entity specified by key-value pairs.
     * @typeparam EntityT - Type of the entity to get the resource path for
     * @param keys - Key-value pairs where the key is the name of a key property of the given entity and the value is the respective value
     * @param entityConstructor - Constructor type of the entity to get the resource path for
     * @param uriConverter - OData version specific converter for strings in URIs
     * @returns The path to the resource
     */
    function getResourcePathForKeys(keys, entityConstructor) {
        if (keys === void 0) { keys = {}; }
        keys = filterNonKeyProperties(keys, entityConstructor);
        validateKeys(keys, entityConstructor);
        if (Object.keys(keys).length) {
            var byKey = Object.entries(keys)
                .map(function (_a) {
                var key = _a[0], value = _a[1];
                return keyToOData(key, value, entityConstructor);
            })
                .join(',');
            return entityConstructor._entityName + "(" + byKey + ")";
        }
        return entityConstructor._entityName;
    }
    function getMissingKeys(keys, entityConstructor) {
        var givenKeys = Object.keys(keys);
        return entityConstructor._keyFields // type assertion for backwards compatibility, TODO: remove in v2.0
            .map(function (field) { return field._fieldName; })
            .filter(function (fieldName) { return !givenKeys.includes(fieldName); });
    }
    function getInvalidKeys(keys, entityConstructor) {
        // type assertion for backwards compatibility, TODO: remove in v2.0
        var validKeys = entityConstructor._keyFields.map(function (field) { return field._fieldName; });
        return Object.keys(keys).filter(function (key) { return !validKeys.includes(key); });
    }
    function getNullishKeys(keys) {
        return Object.entries(keys)
            .filter(function (_a) {
            var value = _a[1];
            return util_1.isNullish(value);
        })
            .map(function (_a) {
            var key = _a[0];
            return key;
        });
    }
    function filterNonKeyProperties(keys, entityConstructor) {
        var invalidKeys = getInvalidKeys(keys, entityConstructor);
        if (invalidKeys.length) {
            logger.warn("There are too many key properties. Ignoring the following keys: " + invalidKeys.join(', '));
            return Object.entries(keys)
                .filter(function (_a) {
                var key = _a[0];
                return !invalidKeys.includes(key);
            })
                .reduce(function (validKeys, _a) {
                var _b;
                var key = _a[0], value = _a[1];
                return (__assign(__assign({}, validKeys), (_b = {}, _b[key] = value, _b)));
            }, {});
        }
        return keys;
    }
    function keyToOData(key, value, entityConstructor) {
        var edmType = entityConstructor[name_converter_1.toStaticPropertyFormat(key)].edmType;
        return key + "=" + uriConverter.convertToUriFormat(value, edmType);
    }
    function validateKeys(keys, entityConstructor) {
        var missingKeys = getMissingKeys(keys, entityConstructor);
        if (missingKeys.length) {
            throw new Error("Cannot get resource path for entity " + entityConstructor._entityName + ". The following keys are missing: " + missingKeys.join(', '));
        }
        var nullishKeys = getNullishKeys(keys);
        if (nullishKeys.length) {
            throw new Error("Cannot get resource path for entity " + entityConstructor._entityName + ". The following keys have nullish values, but are not nullable: " + nullishKeys.join(', '));
        }
    }
    return { getResourcePathForKeys: getResourcePathForKeys };
}
exports.createGetResourcePathForKeys = createGetResourcePathForKeys;
//# sourceMappingURL=get-resource-path.js.map