@aws-sdk/util-endpoints 3.159.0 → 3.167.0

package/CHANGELOG.md

@@ -3,6 +3,30 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.167.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.166.0...v3.167.0) (2022-09-08)
+
+**Note:** Version bump only for package @aws-sdk/util-endpoints
+
+
+
+
+
+# [3.162.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.161.0...v3.162.0) (2022-08-31)
+
+**Note:** Version bump only for package @aws-sdk/util-endpoints
+
+
+
+
+
+# [3.160.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.159.0...v3.160.0) (2022-08-29)
+
+**Note:** Version bump only for package @aws-sdk/util-endpoints
+
+
+
+
+
 # [3.159.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.158.0...v3.159.0) (2022-08-26)
 
 

package/dist-cjs/index.js

@@ -1,4 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./EndpointError"), exports);
+tslib_1.__exportStar(require("./resolveEndpoint"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/dist-cjs/lib/getAttr.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAttr = void 0;
-const EndpointError_1 = require("../EndpointError");
+const types_1 = require("../types");
 const getAttrPathList_1 = require("./getAttrPathList");
 const getAttr = (value, path) => (0, getAttrPathList_1.getAttrPathList)(path).reduce((acc, index) => {
     if (typeof acc !== "object") {
-        throw new EndpointError_1.EndpointError(`Index '${index}' in '${path}' not found in '${JSON.stringify(value)}'`);
+        throw new types_1.EndpointError(`Index '${index}' in '${path}' not found in '${JSON.stringify(value)}'`);
     }
     else if (Array.isArray(acc)) {
         return acc[parseInt(index)];

package/dist-cjs/lib/getAttrPathList.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAttrPathList = void 0;
-const __1 = require("../");
+const types_1 = require("../types");
 const getAttrPathList = (path) => {
     const parts = path.split(".");
     const pathList = [];
@@ -9,11 +9,11 @@ const getAttrPathList = (path) => {
         const squareBracketIndex = part.indexOf("[");
         if (squareBracketIndex !== -1) {
             if (part.indexOf("]") !== part.length - 1) {
-                throw new __1.EndpointError(`Path: '${path}' does not end with ']'`);
+                throw new types_1.EndpointError(`Path: '${path}' does not end with ']'`);
             }
             const arrayIndex = part.slice(squareBracketIndex + 1, -1);
             if (Number.isNaN(parseInt(arrayIndex))) {
-                throw new __1.EndpointError(`Invalid array index: '${arrayIndex}' in path: '${path}'`);
+                throw new types_1.EndpointError(`Invalid array index: '${arrayIndex}' in path: '${path}'`);
             }
             if (squareBracketIndex !== 0) {
                 pathList.push(part.slice(0, squareBracketIndex));

package/dist-cjs/resolveEndpoint.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEndpoint = void 0;
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+const resolveEndpoint = (ruleSetObject, options) => {
+    var _a;
+    const { endpointParams, logger } = options;
+    const { parameters, rules } = ruleSetObject;
+    const requiredParams = Object.entries(parameters)
+        .filter(([, v]) => v.required)
+        .map(([k]) => k);
+    for (const requiredParam of requiredParams) {
+        if (endpointParams[requiredParam] == null) {
+            throw new types_1.EndpointError(`Missing required parameter: '${requiredParam}'`);
+        }
+    }
+    const paramsWithDefault = Object.entries(parameters)
+        .filter(([, v]) => v.default != null)
+        .map(([k, v]) => [k, v.default]);
+    if (paramsWithDefault.length > 0) {
+        for (const [paramKey, paramDefaultValue] of paramsWithDefault) {
+            endpointParams[paramKey] = (_a = endpointParams[paramKey]) !== null && _a !== void 0 ? _a : paramDefaultValue;
+        }
+    }
+    return (0, utils_1.evaluateRules)(rules, { endpointParams, logger, referenceRecord: {} });
+};
+exports.resolveEndpoint = resolveEndpoint;

package/dist-cjs/types/EndpointRuleObject.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-cjs/types/ErrorRuleObject.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-cjs/types/RuleSetObject.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-cjs/types/TreeRuleObject.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-cjs/types/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./EndpointError"), exports);
+tslib_1.__exportStar(require("./EndpointRuleObject"), exports);
+tslib_1.__exportStar(require("./ErrorRuleObject"), exports);
+tslib_1.__exportStar(require("./RuleSetObject"), exports);
+tslib_1.__exportStar(require("./TreeRuleObject"), exports);
+tslib_1.__exportStar(require("./shared"), exports);

package/dist-cjs/types/shared.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-cjs/utils/callFunction.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callFunction = void 0;
+const tslib_1 = require("tslib");
+const lib = tslib_1.__importStar(require("../lib"));
+const evaluateExpression_1 = require("./evaluateExpression");
+const callFunction = ({ fn, argv }, options) => {
+    const argvArray = argv.map((arg) => (typeof arg === "boolean" ? arg : (0, evaluateExpression_1.evaluateExpression)(arg, "arg", options)));
+    return lib[fn](...argvArray);
+};
+exports.callFunction = callFunction;

package/dist-cjs/utils/evaluateCondition.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateCondition = void 0;
+const types_1 = require("../types");
+const callFunction_1 = require("./callFunction");
+const evaluateCondition = ({ assign, ...fnArgs }, options) => {
+    if (assign && assign in options.referenceRecord) {
+        throw new types_1.EndpointError(`'${assign}' is already defined in Reference Record.`);
+    }
+    const value = (0, callFunction_1.callFunction)(fnArgs, options);
+    return {
+        result: !!value,
+        ...(assign != null && { toAssign: { name: assign, value } }),
+    };
+};
+exports.evaluateCondition = evaluateCondition;

package/dist-cjs/utils/evaluateConditions.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateConditions = void 0;
+const evaluateCondition_1 = require("./evaluateCondition");
+const evaluateConditions = (conditions = [], options) => {
+    const conditionsReferenceRecord = {};
+    for (const condition of conditions) {
+        const { result, toAssign } = (0, evaluateCondition_1.evaluateCondition)(condition, {
+            ...options,
+            referenceRecord: {
+                ...options.referenceRecord,
+                ...conditionsReferenceRecord,
+            },
+        });
+        if (!result) {
+            return { result };
+        }
+        if (toAssign) {
+            conditionsReferenceRecord[toAssign.name] = toAssign.value;
+        }
+    }
+    return { result: true, referenceRecord: conditionsReferenceRecord };
+};
+exports.evaluateConditions = evaluateConditions;

package/dist-cjs/utils/evaluateEndpointRule.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateEndpointRule = void 0;
+const evaluateConditions_1 = require("./evaluateConditions");
+const getEndpointHeaders_1 = require("./getEndpointHeaders");
+const getEndpointProperties_1 = require("./getEndpointProperties");
+const getEndpointUrl_1 = require("./getEndpointUrl");
+const evaluateEndpointRule = (endpointRule, options) => {
+    const { conditions, endpoint } = endpointRule;
+    const { result, referenceRecord } = (0, evaluateConditions_1.evaluateConditions)(conditions, options);
+    if (!result) {
+        return;
+    }
+    const endpointRuleOptions = {
+        ...options,
+        referenceRecord: { ...options.referenceRecord, ...referenceRecord },
+    };
+    const { url, properties, headers } = endpoint;
+    return {
+        ...(headers != undefined && {
+            headers: (0, getEndpointHeaders_1.getEndpointHeaders)(headers, endpointRuleOptions),
+        }),
+        ...(properties != undefined && {
+            properties: (0, getEndpointProperties_1.getEndpointProperties)(properties, endpointRuleOptions),
+        }),
+        url: (0, getEndpointUrl_1.getEndpointUrl)(url, endpointRuleOptions),
+    };
+};
+exports.evaluateEndpointRule = evaluateEndpointRule;

package/dist-cjs/utils/evaluateErrorRule.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateErrorRule = void 0;
+const types_1 = require("../types");
+const evaluateConditions_1 = require("./evaluateConditions");
+const evaluateExpression_1 = require("./evaluateExpression");
+const evaluateErrorRule = (errorRule, options) => {
+    const { conditions, error } = errorRule;
+    const { result, referenceRecord } = (0, evaluateConditions_1.evaluateConditions)(conditions, options);
+    if (!result) {
+        return;
+    }
+    throw new types_1.EndpointError((0, evaluateExpression_1.evaluateExpression)(error, "Error", {
+        ...options,
+        referenceRecord: { ...options.referenceRecord, ...referenceRecord },
+    }));
+};
+exports.evaluateErrorRule = evaluateErrorRule;

package/dist-cjs/utils/evaluateExpression.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateExpression = void 0;
+const types_1 = require("../types");
+const callFunction_1 = require("./callFunction");
+const evaluateTemplate_1 = require("./evaluateTemplate");
+const getReferenceValue_1 = require("./getReferenceValue");
+const evaluateExpression = (obj, keyName, options) => {
+    if (typeof obj === "string") {
+        return (0, evaluateTemplate_1.evaluateTemplate)(obj, options);
+    }
+    else if (obj["fn"]) {
+        return (0, callFunction_1.callFunction)(obj, options);
+    }
+    else if (obj["ref"]) {
+        return (0, getReferenceValue_1.getReferenceValue)(obj, options);
+    }
+    throw new types_1.EndpointError(`'${keyName}': ${String(obj)} is not a string, function or reference.`);
+};
+exports.evaluateExpression = evaluateExpression;

package/dist-cjs/utils/evaluateRules.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateRules = void 0;
+const types_1 = require("../types");
+const evaluateEndpointRule_1 = require("./evaluateEndpointRule");
+const evaluateErrorRule_1 = require("./evaluateErrorRule");
+const evaluateTreeRule_1 = require("./evaluateTreeRule");
+const evaluateRules = (rules, options) => {
+    for (const rule of rules) {
+        if (rule.type === "endpoint") {
+            const endpointOrUndefined = (0, evaluateEndpointRule_1.evaluateEndpointRule)(rule, options);
+            if (endpointOrUndefined) {
+                return endpointOrUndefined;
+            }
+        }
+        else if (rule.type === "error") {
+            (0, evaluateErrorRule_1.evaluateErrorRule)(rule, options);
+        }
+        else if (rule.type === "tree") {
+            const endpointOrUndefined = (0, evaluateTreeRule_1.evaluateTreeRule)(rule, options);
+            if (endpointOrUndefined) {
+                return endpointOrUndefined;
+            }
+        }
+        else {
+            throw new types_1.EndpointError(`Unknown endpoint rule: ${rule}`);
+        }
+    }
+    throw new types_1.EndpointError(`Rules evaluation failed`);
+};
+exports.evaluateRules = evaluateRules;

package/dist-cjs/utils/evaluateTemplate.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateTemplate = void 0;
+const lib_1 = require("../lib");
+const ATTR_SHORTHAND_REGEX = new RegExp("\\${([\\w]+)#([\\w]+)}", "g");
+const evaluateTemplate = (template, options) => {
+    const templateToEvaluate = template
+        .replace(new RegExp(`\{([^{}]+)\}`, "g"), "${$1}")
+        .replace(new RegExp(`\{\\$\{([^{}]+)\}\}`, "g"), "{$1}");
+    const templateContext = {
+        ...options.endpointParams,
+        ...options.referenceRecord,
+    };
+    const attrShortHandList = templateToEvaluate.match(ATTR_SHORTHAND_REGEX) || [];
+    const attrShortHandMap = attrShortHandList.reduce((acc, attrShortHand) => {
+        const indexOfHash = attrShortHand.indexOf("#");
+        const refName = attrShortHand.substring(2, indexOfHash);
+        const attrName = attrShortHand.substring(indexOfHash + 1, attrShortHand.length - 1);
+        acc[attrShortHand] = (0, lib_1.getAttr)(templateContext[refName], attrName);
+        return acc;
+    }, {});
+    const templateWithAttr = Object.entries(attrShortHandMap).reduce((acc, [shortHand, value]) => acc.replace(shortHand, value), templateToEvaluate);
+    const templateContextNames = Object.keys(templateContext);
+    const templateContextValues = Object.values(templateContext);
+    return new Function(...templateContextNames, `return \`${templateWithAttr}\``)(...templateContextValues);
+};
+exports.evaluateTemplate = evaluateTemplate;

package/dist-cjs/utils/evaluateTreeRule.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateTreeRule = void 0;
+const evaluateConditions_1 = require("./evaluateConditions");
+const evaluateRules_1 = require("./evaluateRules");
+const evaluateTreeRule = (treeRule, options) => {
+    const { conditions, rules } = treeRule;
+    const { result, referenceRecord } = (0, evaluateConditions_1.evaluateConditions)(conditions, options);
+    if (!result) {
+        return;
+    }
+    return (0, evaluateRules_1.evaluateRules)(rules, {
+        ...options,
+        referenceRecord: { ...options.referenceRecord, ...referenceRecord },
+    });
+};
+exports.evaluateTreeRule = evaluateTreeRule;

package/dist-cjs/utils/getEndpointHeaders.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEndpointHeaders = void 0;
+const types_1 = require("../types");
+const evaluateExpression_1 = require("./evaluateExpression");
+const getEndpointHeaders = (headers, options) => Object.entries(headers).reduce((acc, [headerKey, headerVal]) => ({
+    ...acc,
+    [headerKey]: headerVal.map((headerValEntry) => {
+        const processedExpr = (0, evaluateExpression_1.evaluateExpression)(headerValEntry, "Header value entry", options);
+        if (typeof processedExpr !== "string") {
+            throw new types_1.EndpointError(`Header '${headerKey}' value '${processedExpr}' is not a string`);
+        }
+        return processedExpr;
+    }),
+}), {});
+exports.getEndpointHeaders = getEndpointHeaders;

package/dist-cjs/utils/getEndpointProperties.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEndpointProperties = void 0;
+const getEndpointProperty_1 = require("./getEndpointProperty");
+const getEndpointProperties = (properties, options) => Object.entries(properties).reduce((acc, [propertyKey, propertyVal]) => ({
+    ...acc,
+    [propertyKey]: (0, getEndpointProperty_1.getEndpointProperty)(propertyVal, options),
+}), {});
+exports.getEndpointProperties = getEndpointProperties;

package/dist-cjs/utils/getEndpointProperty.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEndpointProperty = void 0;
+const types_1 = require("../types");
+const evaluateTemplate_1 = require("./evaluateTemplate");
+const getEndpointProperties_1 = require("./getEndpointProperties");
+const getEndpointProperty = (property, options) => {
+    if (Array.isArray(property)) {
+        return property.map((propertyEntry) => (0, exports.getEndpointProperty)(propertyEntry, options));
+    }
+    switch (typeof property) {
+        case "string":
+            return (0, evaluateTemplate_1.evaluateTemplate)(property, options);
+        case "object":
+            if (property === null) {
+                throw new types_1.EndpointError(`Unexpected endpoint property: ${property}`);
+            }
+            return (0, getEndpointProperties_1.getEndpointProperties)(property, options);
+        case "boolean":
+            return property;
+        default:
+            throw new types_1.EndpointError(`Unexpected endpoint property type: ${typeof property}`);
+    }
+};
+exports.getEndpointProperty = getEndpointProperty;

package/dist-cjs/utils/getEndpointUrl.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEndpointUrl = void 0;
+const types_1 = require("../types");
+const evaluateExpression_1 = require("./evaluateExpression");
+const getEndpointUrl = (endpointUrl, options) => {
+    const expression = (0, evaluateExpression_1.evaluateExpression)(endpointUrl, "Endpoint URL", options);
+    if (typeof expression === "string") {
+        return new URL(expression);
+    }
+    throw new types_1.EndpointError(`Endpoint URL must be a string, got ${typeof expression}`);
+};
+exports.getEndpointUrl = getEndpointUrl;

package/dist-cjs/utils/getReferenceValue.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReferenceValue = void 0;
+const types_1 = require("../types");
+const getReferenceValue = ({ ref }, options) => {
+    const referenceRecord = {
+        ...options.endpointParams,
+        ...options.referenceRecord,
+    };
+    if (referenceRecord[ref] == undefined) {
+        throw new types_1.EndpointError(`Reference '${ref}' not defined`);
+    }
+    return referenceRecord[ref];
+};
+exports.getReferenceValue = getReferenceValue;

package/dist-cjs/utils/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./evaluateRules"), exports);

package/dist-es/index.js

@@ -1 +1,2 @@
-export * from "./EndpointError";
+export * from "./resolveEndpoint";
+export * from "./types";

package/dist-es/lib/getAttr.js

@@ -1,4 +1,4 @@
-import { EndpointError } from "../EndpointError";
+import { EndpointError } from "../types";
 import { getAttrPathList } from "./getAttrPathList";
 export var getAttr = function (value, path) {
     return getAttrPathList(path).reduce(function (acc, index) {

package/dist-es/lib/getAttrPathList.js

@@ -1,5 +1,5 @@
 import { __values } from "tslib";
-import { EndpointError } from "../";
+import { EndpointError } from "../types";
 export var getAttrPathList = function (path) {
     var e_1, _a;
     var parts = path.split(".");

package/dist-es/resolveEndpoint.js

@@ -0,0 +1,58 @@
+import { __read, __values } from "tslib";
+import { EndpointError } from "./types";
+import { evaluateRules } from "./utils";
+export var resolveEndpoint = function (ruleSetObject, options) {
+    var e_1, _a, e_2, _b;
+    var _c;
+    var endpointParams = options.endpointParams, logger = options.logger;
+    var parameters = ruleSetObject.parameters, rules = ruleSetObject.rules;
+    var requiredParams = Object.entries(parameters)
+        .filter(function (_a) {
+        var _b = __read(_a, 2), v = _b[1];
+        return v.required;
+    })
+        .map(function (_a) {
+        var _b = __read(_a, 1), k = _b[0];
+        return k;
+    });
+    try {
+        for (var requiredParams_1 = __values(requiredParams), requiredParams_1_1 = requiredParams_1.next(); !requiredParams_1_1.done; requiredParams_1_1 = requiredParams_1.next()) {
+            var requiredParam = requiredParams_1_1.value;
+            if (endpointParams[requiredParam] == null) {
+                throw new EndpointError("Missing required parameter: '".concat(requiredParam, "'"));
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (requiredParams_1_1 && !requiredParams_1_1.done && (_a = requiredParams_1.return)) _a.call(requiredParams_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    var paramsWithDefault = Object.entries(parameters)
+        .filter(function (_a) {
+        var _b = __read(_a, 2), v = _b[1];
+        return v.default != null;
+    })
+        .map(function (_a) {
+        var _b = __read(_a, 2), k = _b[0], v = _b[1];
+        return [k, v.default];
+    });
+    if (paramsWithDefault.length > 0) {
+        try {
+            for (var paramsWithDefault_1 = __values(paramsWithDefault), paramsWithDefault_1_1 = paramsWithDefault_1.next(); !paramsWithDefault_1_1.done; paramsWithDefault_1_1 = paramsWithDefault_1.next()) {
+                var _d = __read(paramsWithDefault_1_1.value, 2), paramKey = _d[0], paramDefaultValue = _d[1];
+                endpointParams[paramKey] = (_c = endpointParams[paramKey]) !== null && _c !== void 0 ? _c : paramDefaultValue;
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (paramsWithDefault_1_1 && !paramsWithDefault_1_1.done && (_b = paramsWithDefault_1.return)) _b.call(paramsWithDefault_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    }
+    return evaluateRules(rules, { endpointParams: endpointParams, logger: logger, referenceRecord: {} });
+};

package/dist-es/types/EndpointRuleObject.js

@@ -0,0 +1 @@
+export {};

package/dist-es/types/ErrorRuleObject.js

@@ -0,0 +1 @@
+export {};

package/dist-es/types/RuleSetObject.js

@@ -0,0 +1 @@
+export {};

package/dist-es/types/TreeRuleObject.js

@@ -0,0 +1 @@
+export {};

package/dist-es/types/index.js

@@ -0,0 +1,6 @@
+export * from "./EndpointError";
+export * from "./EndpointRuleObject";
+export * from "./ErrorRuleObject";
+export * from "./RuleSetObject";
+export * from "./TreeRuleObject";
+export * from "./shared";

package/dist-es/types/shared.js

@@ -0,0 +1 @@
+export {};

package/dist-es/utils/callFunction.js

@@ -0,0 +1,8 @@
+import { __read, __spreadArray } from "tslib";
+import * as lib from "../lib";
+import { evaluateExpression } from "./evaluateExpression";
+export var callFunction = function (_a, options) {
+    var fn = _a.fn, argv = _a.argv;
+    var argvArray = argv.map(function (arg) { return (typeof arg === "boolean" ? arg : evaluateExpression(arg, "arg", options)); });
+    return lib[fn].apply(lib, __spreadArray([], __read(argvArray), false));
+};

package/dist-es/utils/evaluateCondition.js

@@ -0,0 +1,11 @@
+import { __assign, __rest } from "tslib";
+import { EndpointError } from "../types";
+import { callFunction } from "./callFunction";
+export var evaluateCondition = function (_a, options) {
+    var assign = _a.assign, fnArgs = __rest(_a, ["assign"]);
+    if (assign && assign in options.referenceRecord) {
+        throw new EndpointError("'".concat(assign, "' is already defined in Reference Record."));
+    }
+    var value = callFunction(fnArgs, options);
+    return __assign({ result: !!value }, (assign != null && { toAssign: { name: assign, value: value } }));
+};

package/dist-es/utils/evaluateConditions.js

@@ -0,0 +1,27 @@
+import { __assign, __values } from "tslib";
+import { evaluateCondition } from "./evaluateCondition";
+export var evaluateConditions = function (conditions, options) {
+    var e_1, _a;
+    if (conditions === void 0) { conditions = []; }
+    var conditionsReferenceRecord = {};
+    try {
+        for (var conditions_1 = __values(conditions), conditions_1_1 = conditions_1.next(); !conditions_1_1.done; conditions_1_1 = conditions_1.next()) {
+            var condition = conditions_1_1.value;
+            var _b = evaluateCondition(condition, __assign(__assign({}, options), { referenceRecord: __assign(__assign({}, options.referenceRecord), conditionsReferenceRecord) })), result = _b.result, toAssign = _b.toAssign;
+            if (!result) {
+                return { result: result };
+            }
+            if (toAssign) {
+                conditionsReferenceRecord[toAssign.name] = toAssign.value;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (conditions_1_1 && !conditions_1_1.done && (_a = conditions_1.return)) _a.call(conditions_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return { result: true, referenceRecord: conditionsReferenceRecord };
+};

package/dist-es/utils/evaluateEndpointRule.js

@@ -0,0 +1,19 @@
+import { __assign } from "tslib";
+import { evaluateConditions } from "./evaluateConditions";
+import { getEndpointHeaders } from "./getEndpointHeaders";
+import { getEndpointProperties } from "./getEndpointProperties";
+import { getEndpointUrl } from "./getEndpointUrl";
+export var evaluateEndpointRule = function (endpointRule, options) {
+    var conditions = endpointRule.conditions, endpoint = endpointRule.endpoint;
+    var _a = evaluateConditions(conditions, options), result = _a.result, referenceRecord = _a.referenceRecord;
+    if (!result) {
+        return;
+    }
+    var endpointRuleOptions = __assign(__assign({}, options), { referenceRecord: __assign(__assign({}, options.referenceRecord), referenceRecord) });
+    var url = endpoint.url, properties = endpoint.properties, headers = endpoint.headers;
+    return __assign(__assign(__assign({}, (headers != undefined && {
+        headers: getEndpointHeaders(headers, endpointRuleOptions),
+    })), (properties != undefined && {
+        properties: getEndpointProperties(properties, endpointRuleOptions),
+    })), { url: getEndpointUrl(url, endpointRuleOptions) });
+};

package/dist-es/utils/evaluateErrorRule.js

@@ -0,0 +1,12 @@
+import { __assign } from "tslib";
+import { EndpointError } from "../types";
+import { evaluateConditions } from "./evaluateConditions";
+import { evaluateExpression } from "./evaluateExpression";
+export var evaluateErrorRule = function (errorRule, options) {
+    var conditions = errorRule.conditions, error = errorRule.error;
+    var _a = evaluateConditions(conditions, options), result = _a.result, referenceRecord = _a.referenceRecord;
+    if (!result) {
+        return;
+    }
+    throw new EndpointError(evaluateExpression(error, "Error", __assign(__assign({}, options), { referenceRecord: __assign(__assign({}, options.referenceRecord), referenceRecord) })));
+};