function predicatesFor()

in apps/mountebank-mock/mountebank-source/src/models/responseResolver.js [146:212]
57 lines of code
15 McCabe index (conditional complexity)

    function predicatesFor (request, matchers, logger) {
        const predicates = [];

        matchers.forEach(matcher => {
            if (matcher.inject) {
                // eslint-disable-next-line no-unused-vars
                const config = { request, logger },
                    injected = `(${matcher.inject})(config);`;

                try {
                    predicates.push(...eval(injected));
                }
                catch (error) {
                    logger.error(`injection X=> ${error}`);
                    logger.error(`    source: ${JSON.stringify(injected)}`);
                    logger.error(`    request: ${JSON.stringify(request)}`);
                    throw exceptions.InjectionError('invalid predicateGenerator injection', { source: injected, data: error.message });
                }
                return;
            }

            const basePredicate = {};
            let hasPredicateOperator = false;
            let predicateOperator; // eslint-disable-line no-unused-vars
            let valueOf = field => field;

            // Add parameters
            Object.keys(matcher).forEach(key => {
                if (key !== 'matches' && key !== 'predicateOperator' && key !== 'ignore') {
                    basePredicate[key] = matcher[key];
                }
                if (key === 'xpath') {
                    valueOf = field => xpathValue(matcher.xpath, field, logger);
                }
                else if (key === 'jsonpath') {
                    valueOf = field => jsonpathValue(matcher.jsonpath, field, logger);
                }
                else if (key === 'predicateOperator') {
                    hasPredicateOperator = true;
                }
            });

            Object.keys(matcher.matches).forEach(fieldName => {
                const matcherValue = matcher.matches[fieldName],
                    predicate = helpers.clone(basePredicate);

                if (matcherValue === true && hasPredicateOperator === false) {
                    predicate.deepEquals = {};
                    predicate.deepEquals[fieldName] = buildDeepEqual(request, fieldName, matcher, valueOf);
                }
                else if (hasPredicateOperator === true && matcher.predicateOperator === 'exists') {
                    predicate[matcher.predicateOperator] = buildExists(request, fieldName, matcherValue, request);
                }
                else if (hasPredicateOperator === true && matcher.predicateOperator !== 'exists') {
                    predicate[matcher.predicateOperator] = valueOf(request);
                }
                else {
                    predicate.equals = {};
                    predicate.equals[fieldName] = buildEquals(request[fieldName], matcherValue, valueOf);
                }

                predicates.push(predicate);
            });
        });

        return predicates;
    }