export function serializeConditionExpression()

in packages/dynamodb-expressions/src/ConditionExpression.ts [401:474]
71 lines of code
21 McCabe index (conditional complexity)

export function serializeConditionExpression(
    condition: ConditionExpression,
    attributes: ExpressionAttributes
): string {
    if (FunctionExpression.isFunctionExpression(condition)) {
        return condition.serialize(attributes);
    }

    switch (condition.type) {
        case 'Equals':
            return serializeBinaryComparison(condition, attributes, '=');
        case 'NotEquals':
            return serializeBinaryComparison(condition, attributes, '<>');
        case 'LessThan':
            return serializeBinaryComparison(condition, attributes, '<');
        case 'LessThanOrEqualTo':
            return serializeBinaryComparison(condition, attributes, '<=');
        case 'GreaterThan':
            return serializeBinaryComparison(condition, attributes, '>');
        case 'GreaterThanOrEqualTo':
            return serializeBinaryComparison(condition, attributes, '>=');
        case 'Between':
            return `${
                attributes.addName(condition.subject)
            } BETWEEN ${
                serializeOperand(condition.lowerBound, attributes)
            } AND ${
                serializeOperand(condition.upperBound, attributes)
            }`;
        case 'Membership':
            return `${
                attributes.addName(condition.subject)
            } IN (${
                condition.values.map(val => serializeOperand(val, attributes))
                    .join(', ')
            })`;
        case 'Function':
            const subject = AttributePath.isAttributePath(condition.subject)
                ? condition.subject
                : new AttributePath(condition.subject);

            switch (condition.name) {
                case 'attribute_exists':
                case 'attribute_not_exists':
                    return (new FunctionExpression(condition.name, subject))
                        .serialize(attributes);
                case 'attribute_type':
                case 'begins_with':
                case 'contains':
                    return (new FunctionExpression(
                        condition.name,
                        subject,
                        condition.expected
                    ))
                        .serialize(attributes);
            }
        case 'Not':
            return `NOT (${
                serializeConditionExpression(condition.condition, attributes)
            })`;
        case 'And':
        case 'Or':
            if (condition.conditions.length === 1) {
                return serializeConditionExpression(
                    condition.conditions[0],
                    attributes
                );
            }

            return condition.conditions
                .map(cond => `(${serializeConditionExpression(cond, attributes)})`)
                .join(` ${condition.type.toUpperCase()} `);
    }
}