Light, fluffy, and always free - The AWS Local Emulator alternative
fix(dynamodb): enforce composite query order (#2471)
Tom Longhurste4356def2450
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/DynamoDbAccessPathValidationTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/DynamoDbAccessPathValidationTest.javaindex 14003fd7d8..25fceb54dd 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/DynamoDbAccessPathValidationTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/DynamoDbAccessPathValidationTest.java@@ -41,7 +41,8 @@ class DynamoDbAccessPathValidationTest {attribute("createdAt"), attribute("alternate")).globalSecondaryIndexes(GlobalSecondaryIndex.builder().indexName("status-index")- .keySchema(key("status", KeyType.HASH), key("createdAt", KeyType.RANGE))+ .keySchema(key("status", KeyType.HASH), key("createdAt", KeyType.RANGE),+ key("alternate", KeyType.RANGE)).projection(Projection.builder().projectionType(ProjectionType.INCLUDE).nonKeyAttributes("summary")@@ -211,6 +212,45 @@ class DynamoDbAccessPathValidationTest {.exclusiveStartKey(invalidStartKey)));}+ @Test+ @SuppressWarnings("deprecation")+ void queryRejectsInvalidCompositeSortKeyConditions() {+ assertValidationException(() -> ddb.query(request -> request+ .tableName(TABLE)+ .indexName("status-index")+ .keyConditionExpression("#status = :status AND alternate = :alternate")+ .expressionAttributeNames(Map.of("#status", "status"))+ .expressionAttributeValues(Map.of(+ ":status", value("open"),+ ":alternate", value("a1")))));++ assertValidationException(() -> ddb.query(request -> request+ .tableName(TABLE)+ .indexName("status-index")+ .keyConditionExpression("#status = :status AND createdAt > :createdAt "+ + "AND alternate = :alternate")+ .expressionAttributeNames(Map.of("#status", "status"))+ .expressionAttributeValues(Map.of(+ ":status", value("open"),+ ":createdAt", value("2026-01-01"),+ ":alternate", value("a1")))));++ assertValidationException(() -> ddb.query(request -> request+ .tableName(TABLE)+ .indexName("status-index")+ .keyConditions(Map.of(+ "status", condition(ComparisonOperator.EQ, "open"),+ "alternate", condition(ComparisonOperator.EQ, "a1")))));++ assertValidationException(() -> ddb.query(request -> request+ .tableName(TABLE)+ .indexName("status-index")+ .keyConditions(Map.of(+ "status", condition(ComparisonOperator.EQ, "open"),+ "createdAt", condition(ComparisonOperator.GT, "2026-01-01"),+ "alternate", condition(ComparisonOperator.EQ, "a1")))));+ }+private static void assertValidationException(org.assertj.core.api.ThrowableAssert.ThrowingCallable call) {assertThatThrownBy(call).isInstanceOf(DynamoDbException.class)diff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbAccessPathValidator.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbAccessPathValidator.javaindex 93cf88c621..983d5df6d9 100644--- a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbAccessPathValidator.java+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbAccessPathValidator.java@@ -18,8 +18,10 @@ import io.github.hectorvent.floci.services.dynamodb.ExpressionEvaluator.TokenTypimport io.github.hectorvent.floci.services.dynamodb.model.AttributeDefinition;import io.github.hectorvent.floci.services.dynamodb.model.TableDefinition;+import java.util.HashMap;import java.util.HashSet;import java.util.List;+import java.util.Map;import java.util.Set;final class DynamoDbAccessPathValidator {@@ -98,10 +100,11 @@ final class DynamoDbAccessPathValidator {? and.operands() : List.of(root);List<String> partitionKeys = accessPath.partitionKeyNames();Set<String> partitionKeySet = Set.copyOf(partitionKeys);- Set<String> sortKeys = Set.copyOf(accessPath.sortKeyNames());+ List<String> sortKeys = accessPath.sortKeyNames();Set<String> conditionedPartitionKeys = new HashSet<>();String partitionKeyValuePlaceholder = null;Set<String> conditionedAttributes = new HashSet<>();+ Map<String, Boolean> sortKeyEqualities = new HashMap<>();for (Expr condition : conditions) {String attribute = conditionAttribute(condition, names);@@ -121,6 +124,7 @@ final class DynamoDbAccessPathValidator {if (!isSupportedSortKeyCondition(condition)) {throw new AwsException("ValidationException", "Query key condition not supported", 400);}+ sortKeyEqualities.put(attribute, isEqualityCondition(condition));} else {throw new AwsException("ValidationException", "Query key condition not supported", 400);}@@ -134,9 +138,32 @@ final class DynamoDbAccessPathValidator {throw new AwsException("ValidationException","Query condition missed key schema element: " + missing, 400);}+ validateCompositeSortKeyConditions(sortKeys, sortKeyEqualities);return partitionKeyValuePlaceholder;}+ private static void validateCompositeSortKeyConditions(List<String> sortKeys,+ Map<String, Boolean> equalities) {+ for (int laterIndex = 1; laterIndex < sortKeys.size(); laterIndex++) {+ String laterSortKey = sortKeys.get(laterIndex);+ if (!equalities.containsKey(laterSortKey)) {+ continue;+ }+ for (int priorIndex = 0; priorIndex < laterIndex; priorIndex++) {+ String priorSortKey = sortKeys.get(priorIndex);+ if (!Boolean.TRUE.equals(equalities.get(priorSortKey))) {+ throw validationException("RANGE key attributes " + priorSortKey+ + " must have equality conditions specified in the query because a condition is present "+ + "on key attribute " + laterSortKey);+ }+ }+ }+ }++ private static boolean isEqualityCondition(Expr condition) {+ return condition instanceof CompareExpr compare && compare.op() == TokenType.EQ;+ }+private static boolean isPartitionKeyEquality(Expr condition) {return condition instanceof CompareExpr compare&& compare.op() == TokenType.EQ@@ -216,7 +243,8 @@ final class DynamoDbAccessPathValidator {}Set<String> partitionKeySet = Set.copyOf(partitionKeys);- Set<String> sortKeys = Set.copyOf(accessPath.sortKeyNames());+ List<String> sortKeys = accessPath.sortKeyNames();+ Map<String, Boolean> sortKeyEqualities = new HashMap<>();keyConditions.fields().forEachRemaining(entry -> {String attribute = entry.getKey();String operator = entry.getValue().path("ComparisonOperator").asText();@@ -229,6 +257,8 @@ final class DynamoDbAccessPathValidator {|| !LEGACY_SORT_KEY_COMPARATORS.contains(operator)|| ("BETWEEN".equals(operator) ? values != 2 : values != 1)) {throw new AwsException("ValidationException", "Query key condition not supported", 400);+ } else {+ sortKeyEqualities.put(attribute, "EQ".equals(operator));}String expectedType = attributeType(table, attribute);entry.getValue().path("AttributeValueList").forEach(value -> {@@ -237,6 +267,7 @@ final class DynamoDbAccessPathValidator {}});});+ validateCompositeSortKeyConditions(sortKeys, sortKeyEqualities);}private static String attributeType(TableDefinition table, String attribute) {diff --git a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbAccessPathValidatorTest.java b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbAccessPathValidatorTest.javaindex dd0395f308..681692d5c7 100644--- a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbAccessPathValidatorTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbAccessPathValidatorTest.java@@ -38,6 +38,7 @@ class DynamoDbAccessPathValidatorTest {new AttributeDefinition("sk", "S"),new AttributeDefinition("status", "S"),new AttributeDefinition("createdAt", "S"),+ new AttributeDefinition("sequence", "S"),new AttributeDefinition("alternate", "S"),new AttributeDefinition("tenantId", "S"),new AttributeDefinition("region", "S")));@@ -45,7 +46,8 @@ class DynamoDbAccessPathValidatorTest {new GlobalSecondaryIndex("status-index",List.of(new KeySchemaElement("status", "HASH"),- new KeySchemaElement("createdAt", "RANGE")),+ new KeySchemaElement("createdAt", "RANGE"),+ new KeySchemaElement("sequence", "RANGE")),null, "INCLUDE", List.of("summary")),new GlobalSecondaryIndex("tenant-region-index",@@ -130,6 +132,33 @@ class DynamoDbAccessPathValidatorTest {null, null, names, expressionValues(":status", ":start", ":end")));}+ @Test+ void acceptsCompositeSortKeyPrefixWithInequalityLast() {+ assertDoesNotThrow(() -> validateExpression(gsiPath,+ "status = :status AND createdAt = :createdAt AND sequence >= :sequence"));+ assertDoesNotThrow(() -> validateExpression(gsiPath,+ "status = :status AND createdAt BETWEEN :start AND :end"));+ }++ @Test+ void rejectsSkippedCompositeSortKey() {+ AwsException error = assertThrows(AwsException.class,+ () -> validateExpression(gsiPath, "status = :status AND sequence = :sequence"));++ assertEquals("RANGE key attributes createdAt must have equality conditions specified in the query "+ + "because a condition is present on key attribute sequence", error.getMessage());+ }++ @Test+ void rejectsCompositeSortKeyConditionAfterInequality() {+ AwsException error = assertThrows(AwsException.class,+ () -> validateExpression(gsiPath,+ "status = :status AND createdAt > :createdAt AND sequence = :sequence"));++ assertEquals("RANGE key attributes createdAt must have equality conditions specified in the query "+ + "because a condition is present on key attribute sequence", error.getMessage());+ }+@Testvoid rejectsMissingPartitionKeyCondition() {AwsException error = assertThrows(AwsException.class,@@ -194,6 +223,30 @@ class DynamoDbAccessPathValidatorTest {table, tablePath, missingPartitionKey, null, null, null, null, null));}+ @Test+ void validatesLegacyCompositeSortKeyOrder() {+ ObjectNode valid = mapper.createObjectNode();+ valid.set("status", legacyCondition("EQ", attributeValues("open")));+ valid.set("createdAt", legacyCondition("EQ", attributeValues("2026-01-01")));+ valid.set("sequence", legacyCondition("GE", attributeValues("1")));+ assertDoesNotThrow(() -> DynamoDbAccessPathValidator.validateQuery(+ table, gsiPath, valid, null, null, null, null, null));++ ObjectNode skipped = mapper.createObjectNode();+ skipped.set("status", legacyCondition("EQ", attributeValues("open")));+ skipped.set("sequence", legacyCondition("EQ", attributeValues("1")));+ AwsException skippedError = assertThrows(AwsException.class,+ () -> DynamoDbAccessPathValidator.validateQuery(+ table, gsiPath, skipped, null, null, null, null, null));+ assertEquals("RANGE key attributes createdAt must have equality conditions specified in the query "+ + "because a condition is present on key attribute sequence", skippedError.getMessage());++ ObjectNode nonFinalInequality = valid.deepCopy();+ nonFinalInequality.set("createdAt", legacyCondition("GT", attributeValues("2026-01-01")));+ assertThrows(AwsException.class, () -> DynamoDbAccessPathValidator.validateQuery(+ table, gsiPath, nonFinalInequality, null, null, null, null, null));+ }+@Testvoid rejectsSelectedKeysInQueryFilters() {assertThrows(AwsException.class, () -> DynamoDbAccessPathValidator.validateQuery(diff --git a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbCompositeSortKeyQueryIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbCompositeSortKeyQueryIntegrationTest.javaindex 69fe17f130..8622d2693b 100644--- a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbCompositeSortKeyQueryIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbCompositeSortKeyQueryIntegrationTest.java@@ -280,4 +280,89 @@ class DynamoDbCompositeSortKeyQueryIntegrationTest {"2026-07-14T00:00:03Z"), collected,"Expected all rows once, in full composite order");}++ @Test+ @Order(7)+ void queryRejectsSkippedCompositeSortKey() {+ given()+ .header("X-Amz-Target", "DynamoDB_20120810.Query")+ .contentType(DYNAMODB_CONTENT_TYPE)+ .body("""+ {+ "TableName": "%s",+ "IndexName": "%s",+ "KeyConditionExpression": "memberName = :pk AND createdAt >= :from",+ "ExpressionAttributeValues": {+ ":pk": {"S": "alice"},+ ":from": {"S": "2026-01-01T00:00:00Z"}+ }+ }+ """.formatted(TABLE, INDEX))+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("ValidationException"))+ .body("message", equalTo("RANGE key attributes state must have equality conditions specified "+ + "in the query because a condition is present on key attribute createdAt"));+ }++ @Test+ @Order(8)+ void queryRejectsCompositeSortKeyConditionAfterInequality() {+ given()+ .header("X-Amz-Target", "DynamoDB_20120810.Query")+ .contentType(DYNAMODB_CONTENT_TYPE)+ .body("""+ {+ "TableName": "%s",+ "IndexName": "%s",+ "KeyConditionExpression": "memberName = :pk AND #st > :st AND createdAt = :createdAt",+ "ExpressionAttributeNames": {"#st": "state"},+ "ExpressionAttributeValues": {+ ":pk": {"S": "alice"},+ ":st": {"S": "ACTIVE"},+ ":createdAt": {"S": "2026-07-14T00:00:01Z"}+ }+ }+ """.formatted(TABLE, INDEX))+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("ValidationException"))+ .body("message", equalTo("RANGE key attributes state must have equality conditions specified "+ + "in the query because a condition is present on key attribute createdAt"));+ }++ @Test+ @Order(9)+ void legacyQueryRejectsInvalidCompositeSortKeyConditions() {+ given()+ .header("X-Amz-Target", "DynamoDB_20120810.Query")+ .contentType(DYNAMODB_CONTENT_TYPE)+ .body("""+ {+ "TableName": "%s",+ "IndexName": "%s",+ "KeyConditions": {+ "memberName": {+ "ComparisonOperator": "EQ",+ "AttributeValueList": [{"S": "alice"}]+ },+ "createdAt": {+ "ComparisonOperator": "GE",+ "AttributeValueList": [{"S": "2026-01-01T00:00:00Z"}]+ }+ }+ }+ """.formatted(TABLE, INDEX))+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("__type", equalTo("ValidationException"))+ .body("message", equalTo("RANGE key attributes state must have equality conditions specified "+ + "in the query because a condition is present on key attribute createdAt"));+ }}