function normalizeConditionExpression()

in packages/dynamodb-data-marshaller/src/marshallExpression.ts [166:234]
23 lines of code
8 McCabe index (conditional complexity)

function normalizeConditionExpression(
    expression: ConditionExpression,
    schema: Schema
): ConditionExpression {
    if (FunctionExpression.isFunctionExpression(expression)) {
        return normalizeFunctionExpression(expression, schema);
    }

    switch (expression.type) {
        case 'Equals':
        case 'NotEquals':
        case 'LessThan':
        case 'LessThanOrEqualTo':
        case 'GreaterThan':
        case 'GreaterThanOrEqualTo':
            return {
                ...expression,
                subject: toSchemaName(expression.subject, schema),
                object: normalizeIfPath(expression.object, schema),
            };

        case 'Function':
            switch (expression.name) {
                case 'attribute_exists':
                case 'attribute_not_exists':
                    return {
                        ...expression,
                        subject: toSchemaName(expression.subject, schema)
                    };
                case 'attribute_type':
                case 'begins_with':
                case 'contains':
                    return {
                        ...expression,
                        subject: toSchemaName(expression.subject, schema)
                    };
            }

        case 'Between':
            return {
                ...expression,
                subject: toSchemaName(expression.subject, schema),
                lowerBound: normalizeIfPath(expression.lowerBound, schema),
                upperBound: normalizeIfPath(expression.upperBound, schema),
            };
        case 'Membership':
            return {
                ...expression,
                subject: toSchemaName(expression.subject, schema),
                values: expression.values.map(arg => normalizeIfPath(arg, schema)),
            };
        case 'Not':
            return {
                ...expression,
                condition: normalizeConditionExpression(
                    expression.condition,
                    schema
                ),
            };
        case 'And':
        case 'Or':
            return {
                ...expression,
                conditions: expression.conditions.map(condition =>
                    normalizeConditionExpression(condition, schema)
                ),
            };
    }
}