Light, fluffy, and always free - The AWS Local Emulator alternative
fix(dynamodb): reject redundant parens, contains() dup operand, begins_with non-string (#1442)
Hector Ventura1f99d9255458
diff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbJsonHandler.javaindex 38357827c4..fcd3835126 100644--- a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbJsonHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbJsonHandler.java@@ -313,6 +313,8 @@ public class DynamoDbJsonHandler {"ExpressionAttributeValues can only be specified when using expressions: ConditionExpression is null", 400);}+ ExpressionEvaluator.validateExpression(conditionExpression, "ConditionExpression", exprAttrNames, exprAttrValues);+validateItemSets(item);JsonNode oldItem = null;@@ -417,6 +419,8 @@ public class DynamoDbJsonHandler {+ String.join("; ", delValidationErrors), 400);}+ ExpressionEvaluator.validateExpression(conditionExpression, "ConditionExpression", exprAttrNames, exprAttrValues);+JsonNode expectedDel = request.has("Expected") ? request.get("Expected") : null;String condOpDel = request.has("ConditionalOperator")? request.get("ConditionalOperator").asText() : "AND";@@ -482,6 +486,8 @@ public class DynamoDbJsonHandler {+ "Non-expression parameters: {AttributeUpdates} Expression parameters: {UpdateExpression}", 400);}+ ExpressionEvaluator.validateExpression(conditionExpression, "ConditionExpression", exprAttrNames, exprAttrValues);+if (conditionExpression != null && expectedUpd != null) {throw new AwsException("ValidationException","Can not use both expression and non-expression parameters in the same request: "@@ -708,6 +714,9 @@ public class DynamoDbJsonHandler {"Invalid KeyConditionExpression: The expression can not be empty;", 400);}+ ExpressionEvaluator.validateExpression(keyConditionExpr, "KeyConditionExpression", exprAttrNames, exprAttrValues);+ ExpressionEvaluator.validateExpression(filterExpr, "FilterExpression", exprAttrNames, exprAttrValues);+if (select != null && !VALID_SELECT.contains(select)) {throw new AwsException("ValidationException","1 validation error detected: Value '" + select + "' at 'select' failed to satisfy constraint: "@@ -837,6 +846,8 @@ public class DynamoDbJsonHandler {+ "Segment: " + segment + " is not less than TotalSegments: " + totalSegments, 400);}+ ExpressionEvaluator.validateExpression(filterExpr, "FilterExpression", exprAttrNames, exprAttrValues);+String projectionExpressionScan = request.has("ProjectionExpression")? request.get("ProjectionExpression").asText() : null;diff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/ExpressionEvaluator.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/ExpressionEvaluator.javaindex fccf76a978..369cb496b6 100644--- a/src/main/java/io/github/hectorvent/floci/services/dynamodb/ExpressionEvaluator.java+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/ExpressionEvaluator.java@@ -3,6 +3,7 @@ package io.github.hectorvent.floci.services.dynamodb;import com.fasterxml.jackson.databind.JsonNode;import com.fasterxml.jackson.databind.node.JsonNodeFactory;import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.core.common.AwsException;import java.math.BigDecimal;import java.util.ArrayList;@@ -373,6 +374,134 @@ final class ExpressionEvaluator {return expr;}+ // ── Structural / semantic validation ──++ /**+ * Validates an expression for the structural and semantic errors that DynamoDB rejects+ * at parse time with a ValidationException, independent of the item being evaluated:+ * - redundant parentheses, e.g. {@code ((a = b))}+ * - {@code contains(x, x)} where the first operand is not distinct from the second+ * - {@code begins_with(path, value)} where the value operand is not a string/binary+ *+ * {@code exprType} is the label used in the {@code "Invalid <exprType>: ..."} prefix+ * (e.g. "ConditionExpression", "FilterExpression", "KeyConditionExpression").+ */+ static void validateExpression(String expression, String exprType,+ JsonNode exprAttrNames, JsonNode exprAttrValues) {+ if (expression == null || expression.isBlank()) return;+ List<Token> tokens = tokenize(expression.trim());+ checkRedundantParentheses(tokens, exprType);+ Expr expr;+ try {+ expr = parse(expression);+ } catch (IllegalArgumentException e) {+ // Other syntax errors are surfaced by the existing parse/evaluate paths.+ return;+ }+ validateSemantics(expr, exprType, exprAttrNames, exprAttrValues);+ }++ // A pair of parentheses is redundant when its entire content is itself a single+ // parenthesised group — i.e. "( ( ... ) )". Single wraps "(x)" and full wraps+ // "(a AND b)" are legal; only the doubled form is rejected.+ private static void checkRedundantParentheses(List<Token> tokens, String exprType) {+ for (int i = 0; i + 1 < tokens.size(); i++) {+ if (tokens.get(i).type() == TokenType.LPAREN+ && tokens.get(i + 1).type() == TokenType.LPAREN) {+ int innerClose = matchingParen(tokens, i + 1);+ if (innerClose >= 0 && innerClose + 1 < tokens.size()+ && tokens.get(innerClose + 1).type() == TokenType.RPAREN) {+ throw new AwsException("ValidationException",+ "Invalid " + exprType + ": The expression has redundant parentheses;", 400);+ }+ }+ }+ }++ // Index of the RPAREN that matches the LPAREN at openIdx (function-call parens included).+ private static int matchingParen(List<Token> tokens, int openIdx) {+ int depth = 0;+ for (int i = openIdx; i < tokens.size(); i++) {+ if (tokens.get(i).type() == TokenType.LPAREN) depth++;+ else if (tokens.get(i).type() == TokenType.RPAREN) {+ if (--depth == 0) return i;+ }+ }+ return -1;+ }++ private static void validateSemantics(Expr expr, String exprType,+ JsonNode names, JsonNode values) {+ if (expr == null) return;+ switch (expr) {+ case AndExpr a -> a.operands().forEach(o -> validateSemantics(o, exprType, names, values));+ case OrExpr o -> o.operands().forEach(x -> validateSemantics(x, exprType, names, values));+ case NotExpr n -> validateSemantics(n.operand(), exprType, names, values);+ case FunctionCallExpr f -> validateFunction(f, exprType, names, values);+ default -> {}+ }+ }++ private static void validateFunction(FunctionCallExpr f, String exprType,+ JsonNode names, JsonNode values) {+ String name = f.functionName().toLowerCase();+ if (name.equals("contains") && f.args().size() >= 2+ && operandsIdentical(f.args().get(0), f.args().get(1), names)) {+ throw new AwsException("ValidationException",+ "Invalid " + exprType + ": The first operand must be distinct from the remaining operands "+ + "for this operator or function; operator: contains, first operand: "+ + displayOperand(f.args().get(0), names), 400);+ }+ if (name.equals("begins_with") && f.args().size() >= 2) {+ String type = operandValueType(f.args().get(1), values);+ if (type != null && !type.equals("S") && !type.equals("B")) {+ throw new AwsException("ValidationException",+ "Invalid " + exprType + ": Incorrect operand type for operator or function; "+ + "operator or function: begins_with, operand type: " + type, 400);+ }+ }+ }++ private static boolean operandsIdentical(Operand a, Operand b, JsonNode names) {+ if (a instanceof PathOperand pa && b instanceof PathOperand pb) {+ return resolvePathString(pa, names).equals(resolvePathString(pb, names));+ }+ if (a instanceof PlaceholderOperand xa && b instanceof PlaceholderOperand xb) {+ return xa.name().equals(xb.name());+ }+ return false;+ }++ // The DynamoDB type code (S, N, B, ...) of a placeholder value operand, or null+ // when the operand is a document path whose type can only be known at runtime.+ private static String operandValueType(Operand operand, JsonNode values) {+ if (operand instanceof PlaceholderOperand p && values != null) {+ JsonNode v = values.get(p.name());+ if (v != null && v.isObject() && v.fieldNames().hasNext()) {+ return v.fieldNames().next();+ }+ }+ return null;+ }++ // Renders a path operand the way DynamoDB does in operand errors, e.g. "[data]" or "[a, b]".+ private static String displayOperand(Operand operand, JsonNode names) {+ if (operand instanceof PathOperand path) {+ var parts = new ArrayList<String>();+ for (String seg : path.segments()) {+ if (seg.startsWith("[")) {+ if (!parts.isEmpty()) parts.set(parts.size() - 1, parts.getLast() + seg);+ else parts.add(seg);+ } else {+ parts.add(resolveAttributeName(seg, names));+ }+ }+ return "[" + String.join(", ", parts) + "]";+ }+ if (operand instanceof PlaceholderOperand p) return p.name();+ return operand.toString();+ }+// ── Key condition splitting ──/**diff --git a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbFilterExpressionIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbFilterExpressionIntegrationTest.javaindex ba221677a9..203223f928 100644--- a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbFilterExpressionIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbFilterExpressionIntegrationTest.java@@ -223,14 +223,22 @@ class DynamoDbFilterExpressionIntegrationTest {@Testvoid scanFilterDoubleNestedParens() {- // ((category = :a)) should work like category = :a → u1, u3- scanWithFilter(- "((category = :a))",- """- {":a": {"S": "A"}}- """,- null,- 2);+ // AWS DynamoDB rejects redundant (doubled) parentheses such as ((category = :a))+ // with a ValidationException at parse time — verified against moto/AWS DDB parity,+ // where ((a < b)) fails but ((a = :b) OR (c = :d)) is allowed.+ given()+ .header("X-Amz-Target", "DynamoDB_20120810.Scan")+ .contentType(DYNAMODB_CONTENT_TYPE)+ .body("""+ {"TableName": "%s", "FilterExpression": "((category = :a))", \+"ExpressionAttributeValues": {":a": {"S": "A"}}}+ """.formatted(TABLE_NAME))+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", containsString("ValidationException"))+ .body(containsString("redundant parentheses"));}// ---- Parenthesized BETWEEN in KeyConditionExpression ----