Light, fluffy, and always free - The AWS Local Emulator alternative
fix(dynamodb): improve conformance across validation, expressions, and queries (#826)
Hector Ventura5ab178e10dff
diff --git a/compatibility-tests/sdk-test-awscli/test/dynamodb.bats b/compatibility-tests/sdk-test-awscli/test/dynamodb.batsindex 545813ecd6..9d82ff2fb1 100644--- a/compatibility-tests/sdk-test-awscli/test/dynamodb.bats+++ b/compatibility-tests/sdk-test-awscli/test/dynamodb.bats@@ -725,7 +725,8 @@ teardown() {run aws_cmd dynamodb scan \--table-name "$TABLE_NAME" \- --filter-expression 'contains(roles, :role)' \+ --filter-expression 'contains(#r, :role)' \+ --expression-attribute-names '{"#r":"roles"}' \--expression-attribute-values '{":role":{"S":"admin"}}'assert_successcount=$(json_get "$output" '.Count')diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/DynamoDbConformanceChangesTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/DynamoDbConformanceChangesTest.javanew file mode 100644index 0000000000..0c3871e4ed--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/DynamoDbConformanceChangesTest.java@@ -0,0 +1,637 @@+package com.floci.test;++import org.junit.jupiter.api.*;+import software.amazon.awssdk.services.dynamodb.DynamoDbClient;+import software.amazon.awssdk.services.dynamodb.model.AttributeAction;+import software.amazon.awssdk.services.dynamodb.model.AttributeDefinition;+import software.amazon.awssdk.services.dynamodb.model.AttributeValue;+import software.amazon.awssdk.services.dynamodb.model.AttributeValueUpdate;+import software.amazon.awssdk.services.dynamodb.model.BatchGetItemResponse;+import software.amazon.awssdk.services.dynamodb.model.BatchWriteItemRequest;+import software.amazon.awssdk.services.dynamodb.model.BillingMode;+import software.amazon.awssdk.services.dynamodb.model.ComparisonOperator;+import software.amazon.awssdk.services.dynamodb.model.Condition;+import software.amazon.awssdk.services.dynamodb.model.ConditionalCheckFailedException;+import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;+import software.amazon.awssdk.services.dynamodb.model.GetItemRequest;+import software.amazon.awssdk.services.dynamodb.model.GetItemResponse;+import software.amazon.awssdk.services.dynamodb.model.KeySchemaElement;+import software.amazon.awssdk.services.dynamodb.model.KeyType;+import software.amazon.awssdk.services.dynamodb.model.KeysAndAttributes;+import software.amazon.awssdk.services.dynamodb.model.ListTablesResponse;+import software.amazon.awssdk.services.dynamodb.model.LocalSecondaryIndex;+import software.amazon.awssdk.services.dynamodb.model.Projection;+import software.amazon.awssdk.services.dynamodb.model.ProjectionType;+import software.amazon.awssdk.services.dynamodb.model.Put;+import software.amazon.awssdk.services.dynamodb.model.PutItemResponse;+import software.amazon.awssdk.services.dynamodb.model.PutRequest;+import software.amazon.awssdk.services.dynamodb.model.QueryRequest;+import software.amazon.awssdk.services.dynamodb.model.QueryResponse;+import software.amazon.awssdk.services.dynamodb.model.ReturnItemCollectionMetrics;+import software.amazon.awssdk.services.dynamodb.model.ReturnValue;+import software.amazon.awssdk.services.dynamodb.model.ReturnValuesOnConditionCheckFailure;+import software.amazon.awssdk.services.dynamodb.model.ScalarAttributeType;+import software.amazon.awssdk.services.dynamodb.model.ScanRequest;+import software.amazon.awssdk.services.dynamodb.model.ScanResponse;+import software.amazon.awssdk.services.dynamodb.model.Select;+import software.amazon.awssdk.services.dynamodb.model.Tag;+import software.amazon.awssdk.services.dynamodb.model.TransactWriteItem;+import software.amazon.awssdk.services.dynamodb.model.UpdateItemRequest;+import software.amazon.awssdk.services.dynamodb.model.WriteRequest;++import java.util.*;++import static org.assertj.core.api.Assertions.*;++/**+ * Compatibility tests for the DynamoDB conformance improvements.+ *+ * Covers:+ * - Phase 1: ListTables (pagination, alphabetical order, Limit validation) + ValidationException rename+ * - Phase 2: ProjectionExpression on GetItem, Query, Scan, BatchGetItem+ * - Phase 3: Batch limits, transaction validations, empty-key rejection,+ * ReturnItemCollectionMetrics, idempotency token+ * - Phase 4: Select=COUNT, parallel scan, attribute_type() function, parenthesized key condition+ * - Phase 7: TagResource/ListTagsOfResource error cases+ * - Phase 8: ReturnValuesOnConditionCheckFailure+ * - Phase 10: Legacy API (AttributesToGet, AttributeUpdates, QueryFilter, ScanFilter)+ * - Phase 11: Enum validation before table lookup+ */+@DisplayName("DynamoDB Conformance Changes")+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class DynamoDbConformanceChangesTest {++ private static DynamoDbClient ddb;+ private static final String TABLE = "conformance-test-" + UUID.randomUUID().toString().substring(0, 8);+ private static final String TABLE_LSI = "conformance-lsi-" + UUID.randomUUID().toString().substring(0, 8);++ @BeforeAll+ static void setup() {+ ddb = TestFixtures.dynamoDbClient();++ ddb.createTable(r -> r+ .tableName(TABLE)+ .keySchema(+ KeySchemaElement.builder().attributeName("pk").keyType(KeyType.HASH).build(),+ KeySchemaElement.builder().attributeName("sk").keyType(KeyType.RANGE).build())+ .attributeDefinitions(+ AttributeDefinition.builder().attributeName("pk").attributeType(ScalarAttributeType.S).build(),+ AttributeDefinition.builder().attributeName("sk").attributeType(ScalarAttributeType.S).build())+ .billingMode(BillingMode.PAY_PER_REQUEST));++ ddb.createTable(r -> r+ .tableName(TABLE_LSI)+ .keySchema(+ KeySchemaElement.builder().attributeName("pk").keyType(KeyType.HASH).build(),+ KeySchemaElement.builder().attributeName("sk").keyType(KeyType.RANGE).build())+ .attributeDefinitions(+ AttributeDefinition.builder().attributeName("pk").attributeType(ScalarAttributeType.S).build(),+ AttributeDefinition.builder().attributeName("sk").attributeType(ScalarAttributeType.S).build(),+ AttributeDefinition.builder().attributeName("gsi_sk").attributeType(ScalarAttributeType.S).build())+ .localSecondaryIndexes(LocalSecondaryIndex.builder()+ .indexName("lsi-by-gsi-sk")+ .keySchema(+ KeySchemaElement.builder().attributeName("pk").keyType(KeyType.HASH).build(),+ KeySchemaElement.builder().attributeName("gsi_sk").keyType(KeyType.RANGE).build())+ .projection(Projection.builder().projectionType(ProjectionType.ALL).build())+ .build())+ .billingMode(BillingMode.PAY_PER_REQUEST));++ // Seed items+ for (int i = 0; i < 5; i++) {+ final int idx = i;+ ddb.putItem(r -> r.tableName(TABLE).item(Map.of(+ "pk", av("p1"),+ "sk", av("s" + idx),+ "name", av("Item-" + idx),+ "count", AttributeValue.builder().n(String.valueOf(idx * 10)).build(),+ "status", av("active"))));+ }+ }++ @AfterAll+ static void cleanup() {+ try { ddb.deleteTable(r -> r.tableName(TABLE)); } catch (Exception ignored) {}+ try { ddb.deleteTable(r -> r.tableName(TABLE_LSI)); } catch (Exception ignored) {}+ }++ // -----------------------------------------------------------------------+ // Phase 1 — ListTables: alphabetical order, Limit, ExclusiveStartTableName+ // -----------------------------------------------------------------------++ @Test @Order(10)+ void listTablesReturnsAlphabeticalOrder() {+ ListTablesResponse resp = ddb.listTables();+ List<String> names = resp.tableNames();+ List<String> sorted = new ArrayList<>(names);+ Collections.sort(sorted);+ assertThat(names).isEqualTo(sorted);+ }++ @Test @Order(11)+ void listTablesWithLimit() {+ ListTablesResponse first = ddb.listTables(r -> r.limit(1));+ assertThat(first.tableNames()).hasSize(1);+ assertThat(first.lastEvaluatedTableName()).isNotNull();++ ListTablesResponse second = ddb.listTables(r -> r+ .limit(1)+ .exclusiveStartTableName(first.lastEvaluatedTableName()));+ assertThat(second.tableNames()).isNotEmpty();+ assertThat(second.tableNames()).doesNotContain(first.tableNames().get(0));+ }++ @Test @Order(12)+ void listTablesLimitZeroThrowsValidationException() {+ assertThatThrownBy(() -> ddb.listTables(r -> r.limit(0)))+ .isInstanceOf(DynamoDbException.class)+ .satisfies(e -> assertThat(((DynamoDbException) e).awsErrorDetails().errorCode())+ .isEqualTo("ValidationException"));+ }++ @Test @Order(13)+ void listTablesLimitOver100ThrowsValidationException() {+ assertThatThrownBy(() -> ddb.listTables(r -> r.limit(101)))+ .isInstanceOf(DynamoDbException.class)+ .satisfies(e -> assertThat(((DynamoDbException) e).awsErrorDetails().errorCode())+ .isEqualTo("ValidationException"));+ }++ // -----------------------------------------------------------------------+ // Phase 1 — ValidationException for invalid table names+ // -----------------------------------------------------------------------++ @Test @Order(20)+ void putItemInvalidTableNameThrowsValidationException() {+ assertThatThrownBy(() -> ddb.putItem(r -> r.tableName("ab").item(Map.of("pk", av("x")))))+ .isInstanceOf(DynamoDbException.class)+ .satisfies(e -> assertThat(((DynamoDbException) e).awsErrorDetails().errorCode())+ .isEqualTo("ValidationException"));+ }++ // -----------------------------------------------------------------------+ // Phase 2 — ProjectionExpression+ // -----------------------------------------------------------------------++ @Test @Order(30)+ void getItemWithProjectionReturnsOnlyProjectedAttributes() {+ GetItemResponse resp = ddb.getItem(r -> r+ .tableName(TABLE)+ .key(Map.of("pk", av("p1"), "sk", av("s0")))+ .projectionExpression("#n")+ .expressionAttributeNames(Map.of("#n", "name")));++ assertThat(resp.item()).containsKey("name");+ assertThat(resp.item()).doesNotContainKey("count");+ assertThat(resp.item()).doesNotContainKey("status");+ }++ @Test @Order(31)+ void queryWithProjectionReturnsOnlyProjectedAttributes() {+ QueryResponse resp = ddb.query(r -> r+ .tableName(TABLE)+ .keyConditionExpression("pk = :pk")+ .expressionAttributeValues(Map.of(":pk", av("p1")))+ .projectionExpression("sk, #n")+ .expressionAttributeNames(Map.of("#n", "name")));++ assertThat(resp.items()).isNotEmpty();+ for (Map<String, AttributeValue> item : resp.items()) {+ assertThat(item).containsKeys("sk", "name");+ assertThat(item).doesNotContainKey("count");+ }+ }++ @Test @Order(32)+ void scanWithProjectionReturnsOnlyProjectedAttributes() {+ ScanResponse resp = ddb.scan(r -> r+ .tableName(TABLE)+ .filterExpression("pk = :pk")+ .expressionAttributeValues(Map.of(":pk", av("p1")))+ .projectionExpression("pk, sk"));++ assertThat(resp.items()).isNotEmpty();+ for (Map<String, AttributeValue> item : resp.items()) {+ assertThat(item).containsKeys("pk", "sk");+ assertThat(item).doesNotContainKey("name");+ }+ }++ @Test @Order(33)+ void batchGetItemWithProjectionReturnsOnlyProjectedAttributes() {+ BatchGetItemResponse resp = ddb.batchGetItem(r -> r+ .requestItems(Map.of(TABLE, KeysAndAttributes.builder()+ .keys(Map.of("pk", av("p1"), "sk", av("s0")))+ .projectionExpression("#n")+ .expressionAttributeNames(Map.of("#n", "name"))+ .build())));++ List<Map<String, AttributeValue>> items = resp.responses().get(TABLE);+ assertThat(items).isNotEmpty();+ assertThat(items.get(0)).containsKey("name");+ assertThat(items.get(0)).doesNotContainKey("count");+ }++ // -----------------------------------------------------------------------+ // Phase 3 — Batch limits and empty-key rejection+ // -----------------------------------------------------------------------++ @Test @Order(40)+ void batchWriteItemRejectsMoreThan25Items() {+ List<WriteRequest> writes = new ArrayList<>();+ for (int i = 0; i < 26; i++) {+ writes.add(WriteRequest.builder()+ .putRequest(PutRequest.builder()+ .item(Map.of("pk", av("excess-" + i), "sk", av("s")))+ .build())+ .build());+ }+ assertThatThrownBy(() -> ddb.batchWriteItem(r -> r.requestItems(Map.of(TABLE, writes))))+ .isInstanceOf(DynamoDbException.class)+ .satisfies(e -> assertThat(((DynamoDbException) e).awsErrorDetails().errorCode())+ .isEqualTo("ValidationException"));+ }++ @Test @Order(41)+ void batchGetItemRejectsMoreThan100Keys() {+ List<Map<String, AttributeValue>> keys = new ArrayList<>();+ for (int i = 0; i < 101; i++) {+ keys.add(Map.of("pk", av("k-" + i), "sk", av("s")));+ }+ assertThatThrownBy(() -> ddb.batchGetItem(r -> r+ .requestItems(Map.of(TABLE, KeysAndAttributes.builder().keys(keys).build()))))+ .isInstanceOf(DynamoDbException.class)+ .satisfies(e -> assertThat(((DynamoDbException) e).awsErrorDetails().errorCode())+ .isEqualTo("ValidationException"));+ }++ @Test @Order(42)+ void putItemRejectsEmptyStringPrimaryKey() {+ assertThatThrownBy(() -> ddb.putItem(r -> r+ .tableName(TABLE)+ .item(Map.of("pk", av(""), "sk", av("s1")))))+ .isInstanceOf(DynamoDbException.class)+ .satisfies(e -> assertThat(((DynamoDbException) e).awsErrorDetails().errorCode())+ .isEqualTo("ValidationException"));+ }++ @Test @Order(43)+ void transactWriteItemsRejectsDuplicateKeys() {+ assertThatThrownBy(() -> ddb.transactWriteItems(r -> r+ .transactItems(+ TransactWriteItem.builder().put(Put.builder()+ .tableName(TABLE)+ .item(Map.of("pk", av("dup"), "sk", av("s1")))+ .build()).build(),+ TransactWriteItem.builder().put(Put.builder()+ .tableName(TABLE)+ .item(Map.of("pk", av("dup"), "sk", av("s1")))+ .build()).build())))+ .isInstanceOf(DynamoDbException.class)+ .satisfies(e -> assertThat(((DynamoDbException) e).awsErrorDetails().errorCode())+ .isEqualTo("ValidationException"));+ }++ @Test @Order(44)+ void transactWriteItemsIdempotencyTokenRejectsConflict() {+ String token = UUID.randomUUID().toString();++ // First request succeeds+ ddb.transactWriteItems(r -> r+ .clientRequestToken(token)+ .transactItems(TransactWriteItem.builder()+ .put(Put.builder()+ .tableName(TABLE)+ .item(Map.of("pk", av("idem-test"), "sk", av("s")))+ .build())+ .build()));++ // Same token, different payload → IdempotentParameterMismatchException+ assertThatThrownBy(() -> ddb.transactWriteItems(r -> r+ .clientRequestToken(token)+ .transactItems(TransactWriteItem.builder()+ .put(Put.builder()+ .tableName(TABLE)+ .item(Map.of("pk", av("idem-different"), "sk", av("s")))+ .build())+ .build())))+ .isInstanceOf(DynamoDbException.class)+ .satisfies(e -> assertThat(((DynamoDbException) e).awsErrorDetails().errorCode())+ .isEqualTo("IdempotentParameterMismatchException"));+ }++ @Test @Order(45)+ void returnItemCollectionMetricsOnLsiTable() {+ PutItemResponse resp = ddb.putItem(r -> r+ .tableName(TABLE_LSI)+ .item(Map.of(+ "pk", av("m1"),+ "sk", av("sk-a"),+ "gsi_sk", av("g1")))+ .returnItemCollectionMetrics(ReturnItemCollectionMetrics.SIZE));++ assertThat(resp.itemCollectionMetrics()).isNotNull();+ assertThat(resp.itemCollectionMetrics().sizeEstimateRangeGB()).hasSize(2);+ }++ // -----------------------------------------------------------------------+ // Phase 4 — Select=COUNT, parallel scan, attribute_type(), parenthesized key condition+ // -----------------------------------------------------------------------++ @Test @Order(50)+ void querySelectCountReturnsCountNotItems() {+ QueryResponse resp = ddb.query(r -> r+ .tableName(TABLE)+ .keyConditionExpression("pk = :pk")+ .expressionAttributeValues(Map.of(":pk", av("p1")))+ .select(Select.COUNT));++ assertThat(resp.count()).isEqualTo(5);+ assertThat(resp.items()).isEmpty();+ }++ @Test @Order(51)+ void scanSelectCountReturnsCountNotItems() {+ ScanResponse resp = ddb.scan(r -> r+ .tableName(TABLE)+ .filterExpression("pk = :pk")+ .expressionAttributeValues(Map.of(":pk", av("p1")))+ .select(Select.COUNT));++ assertThat(resp.count()).isGreaterThan(0);+ assertThat(resp.items()).isEmpty();+ }++ @Test @Order(52)+ void parallelScanPartitionsResultsCorrectly() {+ int totalSegments = 2;+ List<Map<String, AttributeValue>> segment0 = ddb.scan(r -> r+ .tableName(TABLE)+ .segment(0).totalSegments(totalSegments)).items();+ List<Map<String, AttributeValue>> segment1 = ddb.scan(r -> r+ .tableName(TABLE)+ .segment(1).totalSegments(totalSegments)).items();++ // Key each item by pk#sk to handle multiple items sharing the same sk+ Set<String> keys0 = new HashSet<>(), keys1 = new HashSet<>();+ segment0.forEach(i -> keys0.add(i.get("pk").s() + "#" + i.get("sk").s()));+ segment1.forEach(i -> keys1.add(i.get("pk").s() + "#" + i.get("sk").s()));++ // No overlap between segments+ assertThat(keys0).doesNotContainAnyElementsOf(keys1);+ // Union covers all items in the table+ int totalCount = ddb.scan(r -> r.tableName(TABLE)).count();+ Set<String> combined = new HashSet<>(keys0);+ combined.addAll(keys1);+ assertThat(combined).hasSize(totalCount);+ }++ @Test @Order(53)+ void parallelScanRequiresBothSegmentAndTotalSegments() {+ assertThatThrownBy(() -> ddb.scan(r -> r.tableName(TABLE).segment(0)))+ .isInstanceOf(DynamoDbException.class)+ .satisfies(e -> assertThat(((DynamoDbException) e).awsErrorDetails().errorCode())+ .isEqualTo("ValidationException"));+ }++ @Test @Order(54)+ void queryWithAttributeTypeFunction() {+ QueryResponse resp = ddb.query(r -> r+ .tableName(TABLE)+ .keyConditionExpression("pk = :pk")+ .filterExpression("attribute_type(#n, :t)")+ .expressionAttributeValues(Map.of(+ ":pk", av("p1"),+ ":t", av("S")))+ .expressionAttributeNames(Map.of("#n", "name")));++ assertThat(resp.items()).hasSize(5);+ }++ @Test @Order(55)+ void queryWithParenthesizedKeyCondition() {+ QueryResponse resp = ddb.query(r -> r+ .tableName(TABLE)+ .keyConditionExpression("(pk = :pk AND sk = :sk)")+ .expressionAttributeValues(Map.of(":pk", av("p1"), ":sk", av("s0"))));++ assertThat(resp.items()).hasSize(1);+ assertThat(resp.items().get(0).get("sk").s()).isEqualTo("s0");+ }++ @Test @Order(56)+ void queryRequiresKeyCondition() {+ assertThatThrownBy(() -> ddb.query(r -> r.tableName(TABLE)))+ .isInstanceOf(DynamoDbException.class)+ .satisfies(e -> assertThat(((DynamoDbException) e).awsErrorDetails().errorCode())+ .isEqualTo("ValidationException"));+ }++ // -----------------------------------------------------------------------+ // Phase 7 — Tags: ARN validation and non-existent ARN behaviour+ // -----------------------------------------------------------------------++ @Test @Order(60)+ void tagResourceWithInvalidArnThrowsValidationException() {+ assertThatThrownBy(() -> ddb.tagResource(r -> r+ .resourceArn("not-an-arn")+ .tags(Tag.builder().key("k").value("v").build())))+ .isInstanceOf(DynamoDbException.class)+ .satisfies(e -> assertThat(((DynamoDbException) e).awsErrorDetails().errorCode())+ .isEqualTo("ValidationException"));+ }++ @Test @Order(61)+ void listTagsOfResourceWithValidFormatNonExistentArnThrowsAccessDeniedException() {+ assertThatThrownBy(() -> ddb.listTagsOfResource(r -> r+ .resourceArn("arn:aws:dynamodb:us-east-1:000000000000:table/does-not-exist")))+ .isInstanceOf(DynamoDbException.class)+ .satisfies(e -> assertThat(((DynamoDbException) e).awsErrorDetails().errorCode())+ .isEqualTo("AccessDeniedException"));+ }++ // -----------------------------------------------------------------------+ // Phase 8 — ReturnValuesOnConditionCheckFailure+ // -----------------------------------------------------------------------++ @Test @Order(70)+ void putItemConditionFailureReturnsOldItemWhenRequested() {+ // Seed an existing item+ ddb.putItem(r -> r.tableName(TABLE).item(Map.of(+ "pk", av("cond-test"), "sk", av("s"), "val", av("old"))));++ DynamoDbException ex = (DynamoDbException) catchThrowable(() ->+ ddb.putItem(r -> r+ .tableName(TABLE)+ .item(Map.of("pk", av("cond-test"), "sk", av("s"), "val", av("new")))+ .conditionExpression("attribute_not_exists(pk)")+ .returnValuesOnConditionCheckFailure(ReturnValuesOnConditionCheckFailure.ALL_OLD)));++ assertThat(ex).isNotNull();+ assertThat(ex.awsErrorDetails().errorCode()).isEqualTo("ConditionalCheckFailedException");+ }++ @Test @Order(71)+ void updateItemConditionFailureReturnsOldItemWhenRequested() {+ ddb.putItem(r -> r.tableName(TABLE).item(Map.of(+ "pk", av("cond-upd"), "sk", av("s"), "val", av("original"))));++ DynamoDbException ex = (DynamoDbException) catchThrowable(() ->+ ddb.updateItem(r -> r+ .tableName(TABLE)+ .key(Map.of("pk", av("cond-upd"), "sk", av("s")))+ .updateExpression("SET val = :new")+ .conditionExpression("val = :expected")+ .expressionAttributeValues(Map.of(":new", av("new"), ":expected", av("wrong")))+ .returnValuesOnConditionCheckFailure(ReturnValuesOnConditionCheckFailure.ALL_OLD)));++ assertThat(ex).isNotNull();+ assertThat(ex.awsErrorDetails().errorCode()).isEqualTo("ConditionalCheckFailedException");+ }++ // -----------------------------------------------------------------------+ // Phase 10 — Legacy API: AttributesToGet, AttributeUpdates, QueryFilter, ScanFilter+ // -----------------------------------------------------------------------++ @Test @Order(80)+ void getItemAttributesToGet() {+ GetItemResponse resp = ddb.getItem(r -> r+ .tableName(TABLE)+ .key(Map.of("pk", av("p1"), "sk", av("s0")))+ .attributesToGet("name", "count"));++ assertThat(resp.item()).containsKeys("name", "count");+ assertThat(resp.item()).doesNotContainKey("status");+ // AttributesToGet does NOT auto-include key attributes+ assertThat(resp.item()).doesNotContainKey("pk");+ }++ @Test @Order(81)+ void attributesToGetAndProjectionExpressionAreMutuallyExclusive() {+ assertThatThrownBy(() -> ddb.getItem(r -> r+ .tableName(TABLE)+ .key(Map.of("pk", av("p1"), "sk", av("s0")))+ .attributesToGet("name")+ .projectionExpression("name")))+ .isInstanceOf(DynamoDbException.class)+ .satisfies(e -> assertThat(((DynamoDbException) e).awsErrorDetails().errorCode())+ .isEqualTo("ValidationException"));+ }++ @Test @Order(82)+ @SuppressWarnings("deprecation")+ void updateItemWithAttributeUpdates() {+ ddb.putItem(r -> r.tableName(TABLE).item(Map.of(+ "pk", av("legacy-upd"), "sk", av("s"), "color", av("red"))));++ ddb.updateItem(UpdateItemRequest.builder()+ .tableName(TABLE)+ .key(Map.of("pk", av("legacy-upd"), "sk", av("s")))+ .attributeUpdates(Map.of(+ "color", AttributeValueUpdate.builder()+ .value(av("blue"))+ .action(AttributeAction.PUT)+ .build()))+ .build());++ GetItemResponse resp = ddb.getItem(r -> r+ .tableName(TABLE)+ .key(Map.of("pk", av("legacy-upd"), "sk", av("s"))));+ assertThat(resp.item().get("color").s()).isEqualTo("blue");+ }++ @Test @Order(83)+ @SuppressWarnings("deprecation")+ void queryWithQueryFilter() {+ QueryResponse resp = ddb.query(QueryRequest.builder()+ .tableName(TABLE)+ .keyConditionExpression("pk = :pk")+ .expressionAttributeValues(Map.of(":pk", av("p1")))+ .queryFilter(Map.of("name", Condition.builder()+ .comparisonOperator(ComparisonOperator.EQ)+ .attributeValueList(av("Item-0"))+ .build()))+ .build());++ assertThat(resp.items()).hasSize(1);+ assertThat(resp.items().get(0).get("name").s()).isEqualTo("Item-0");+ }++ @Test @Order(84)+ @SuppressWarnings("deprecation")+ void scanWithScanFilter() {+ ScanResponse resp = ddb.scan(ScanRequest.builder()+ .tableName(TABLE)+ .scanFilter(Map.of("name", Condition.builder()+ .comparisonOperator(ComparisonOperator.EQ)+ .attributeValueList(av("Item-2"))+ .build()))+ .build());++ assertThat(resp.items()).hasSize(1);+ assertThat(resp.items().get(0).get("name").s()).isEqualTo("Item-2");+ }++ // -----------------------------------------------------------------------+ // Phase 11 — Enum validation fires before table lookup+ // -----------------------------------------------------------------------++ @Test @Order(90)+ void enumValidationFiresBeforeTableLookupOnPutItem() {+ DynamoDbException ex = (DynamoDbException) catchThrowable(() ->+ ddb.putItem(r -> r+ .tableName("nonexistent-table-xyz")+ .item(Map.of("pk", av("x")))+ .returnValues(ReturnValue.UPDATED_NEW))); // invalid for PutItem++ assertThat(ex).isNotNull();+ assertThat(ex.awsErrorDetails().errorCode()).isEqualTo("ValidationException");+ assertThat(ex.awsErrorDetails().errorMessage()).doesNotContain("ResourceNotFoundException");+ }++ @Test @Order(91)+ void enumValidationFiresBeforeTableLookupOnDeleteItem() {+ DynamoDbException ex = (DynamoDbException) catchThrowable(() ->+ ddb.deleteItem(r -> r+ .tableName("nonexistent-table-xyz")+ .key(Map.of("pk", av("x"), "sk", av("y")))+ .returnValues(ReturnValue.UPDATED_NEW))); // invalid for DeleteItem++ assertThat(ex).isNotNull();+ assertThat(ex.awsErrorDetails().errorCode()).isEqualTo("ValidationException");+ }++ // -----------------------------------------------------------------------+ // Phase 9 — Reserved word rejection in expressions+ // -----------------------------------------------------------------------++ @Test @Order(100)+ void reservedWordAsAttributeNameInConditionThrowsValidationException() {+ assertThatThrownBy(() -> ddb.putItem(r -> r+ .tableName(TABLE)+ .item(Map.of("pk", av("rw-test"), "sk", av("s")))+ .conditionExpression("attribute_not_exists(status)"))) // 'status' is a bare reserved word+ .isInstanceOf(DynamoDbException.class)+ .satisfies(e -> assertThat(((DynamoDbException) e).awsErrorDetails().errorCode())+ .isEqualTo("ValidationException"));+ }++ @Test @Order(101)+ void reservedWordWithAliasPasses() {+ // Using #status alias should work fine+ assertThatCode(() -> ddb.putItem(r -> r+ .tableName(TABLE)+ .item(Map.of("pk", av("rw-alias"), "sk", av("s"), "status", av("ok")))+ .conditionExpression("attribute_not_exists(pk)")+ .expressionAttributeNames(Map.of("#st", "status"))))+ .doesNotThrowAnyException();+ }++ // -----------------------------------------------------------------------+ // Helpers+ // -----------------------------------------------------------------------++ private static AttributeValue av(String s) {+ return AttributeValue.builder().s(s).build();+ }+}diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/DynamoDbExpressionTests.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/DynamoDbExpressionTests.javaindex 7da7a49c6e..89cb478e51 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/DynamoDbExpressionTests.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/DynamoDbExpressionTests.java@@ -126,7 +126,8 @@ class DynamoDbExpressionTests {void filterInSingle() {ScanResponse resp = ddb.scan(ScanRequest.builder().tableName(FILTER_TABLE)- .filterExpression("status IN (:v0)")+ .filterExpression("#s IN (:v0)")+ .expressionAttributeNames(Map.of("#s", "status")).expressionAttributeValues(Map.of(":v0", AttributeValue.fromN("1"))).build());assertThat(resp.count()).isEqualTo(2);@@ -138,7 +139,8 @@ class DynamoDbExpressionTests {void filterInMultiple() {ScanResponse resp = ddb.scan(ScanRequest.builder().tableName(FILTER_TABLE)- .filterExpression("status IN (:v0, :v1)")+ .filterExpression("#s IN (:v0, :v1)")+ .expressionAttributeNames(Map.of("#s", "status")).expressionAttributeValues(Map.of(":v0", AttributeValue.fromN("1"),":v1", AttributeValue.fromN("3")))@@ -154,7 +156,8 @@ class DynamoDbExpressionTests {void filterOr() {ScanResponse resp = ddb.scan(ScanRequest.builder().tableName(FILTER_TABLE)- .filterExpression("status = :v1 OR status = :v2")+ .filterExpression("#s = :v1 OR #s = :v2")+ .expressionAttributeNames(Map.of("#s", "status")).expressionAttributeValues(Map.of(":v1", AttributeValue.fromN("1"),":v2", AttributeValue.fromN("2")))@@ -184,7 +187,8 @@ class DynamoDbExpressionTests {void filterParenthesizedAndOr() {ScanResponse resp = ddb.scan(ScanRequest.builder().tableName(FILTER_TABLE)- .filterExpression("(status = :v1 OR status = :v3) AND category = :catA")+ .filterExpression("(#s = :v1 OR #s = :v3) AND category = :catA")+ .expressionAttributeNames(Map.of("#s", "status")).expressionAttributeValues(Map.of(":v1", AttributeValue.fromN("1"),":v3", AttributeValue.fromN("3"),@@ -334,7 +338,8 @@ class DynamoDbExpressionTests {ddb.updateItem(UpdateItemRequest.builder().tableName(table).key(Map.of("pk", AttributeValue.fromS("k1")))- .updateExpression("SET counter = if_not_exists(counter, :start) + :inc")+ .updateExpression("SET #cnt = if_not_exists(#cnt, :start) + :inc")+ .expressionAttributeNames(Map.of("#cnt", "counter")).expressionAttributeValues(Map.of(":start", AttributeValue.builder().n("0").build(),":inc", AttributeValue.builder().n("1").build()))@@ -350,7 +355,8 @@ class DynamoDbExpressionTests {ddb.updateItem(UpdateItemRequest.builder().tableName(table).key(Map.of("pk", AttributeValue.fromS("k1")))- .updateExpression("SET counter = if_not_exists(counter, :start) + :inc")+ .updateExpression("SET #cnt = if_not_exists(#cnt, :start) + :inc")+ .expressionAttributeNames(Map.of("#cnt", "counter")).expressionAttributeValues(Map.of(":start", AttributeValue.builder().n("0").build(),":inc", AttributeValue.builder().n("1").build()))@@ -366,7 +372,8 @@ class DynamoDbExpressionTests {ddb.updateItem(UpdateItemRequest.builder().tableName(table).key(Map.of("pk", AttributeValue.fromS("k1")))- .updateExpression("SET counter = counter - :dec")+ .updateExpression("SET #cnt = #cnt - :dec")+ .expressionAttributeNames(Map.of("#cnt", "counter")).expressionAttributeValues(Map.of(":dec", AttributeValue.builder().n("1").build())).build());diff --git a/compatibility-tests/sdk-test-node/tests/dynamodb-conformance.test.ts b/compatibility-tests/sdk-test-node/tests/dynamodb-conformance.test.tsnew file mode 100644index 0000000000..a1b79897e6--- /dev/null+++ b/compatibility-tests/sdk-test-node/tests/dynamodb-conformance.test.ts@@ -0,0 +1,783 @@+/**+ * DynamoDB conformance change tests.+ *+ * Covers:+ * - Phase 1: ListTables (alphabetical order, Limit pagination, Limit validation)+ * + ValidationException rename for invalid table names+ * - Phase 2: ProjectionExpression on GetItem, Query, Scan, BatchGetItem+ * - Phase 3: Batch limits (BatchWrite >25, BatchGet >100), empty PK rejection,+ * TransactWriteItems duplicate key + idempotency token,+ * ReturnItemCollectionMetrics=SIZE on LSI table+ * - Phase 4: Select=COUNT on Query/Scan, parallel scan, attribute_type() function,+ * parenthesized key condition, missing key condition validation+ * - Phase 7: TagResource invalid ARN, ListTagsOfResource non-existent ARN+ * - Phase 8: ReturnValuesOnConditionCheckFailure on PutItem/UpdateItem+ * - Phase 9: Reserved word rejection in expressions; alias passes+ * - Phase 10: AttributesToGet, AttributeUpdates, QueryFilter, ScanFilter (legacy API)+ * - Phase 11: Enum validation fires before table lookup+ */++import { describe, it, expect, beforeAll, afterAll } from 'vitest';+import {+ DynamoDBClient,+ BatchGetItemCommand,+ BatchWriteItemCommand,+ CreateTableCommand,+ DeleteItemCommand,+ DeleteTableCommand,+ GetItemCommand,+ ListTablesCommand,+ ListTagsOfResourceCommand,+ PutItemCommand,+ QueryCommand,+ ScanCommand,+ TagResourceCommand,+ TransactWriteItemsCommand,+ UpdateItemCommand,+} from '@aws-sdk/client-dynamodb';+import { makeClient, uniqueName } from './setup';++// ─── helpers ────────────────────────────────────────────────────────────────++function s(v: string) {+ return { S: v };+}+function n(v: number) {+ return { N: String(v) };+}++async function expectError(promise: Promise<unknown>, expectedName: string): Promise<void> {+ let caught: unknown;+ try {+ await promise;+ } catch (e) {+ caught = e;+ }+ expect(caught, `expected ${expectedName} to be thrown`).toBeDefined();+ expect((caught as Error).name).toBe(expectedName);+}++// ─── Phase 1: ListTables ────────────────────────────────────────────────────++describe('DynamoDB — Phase 1: ListTables', () => {+ let ddb: DynamoDBClient;+ const tables: string[] = [];++ beforeAll(async () => {+ ddb = makeClient(DynamoDBClient);+ // Create three tables with deterministic alphabetical names+ for (const suffix of ['aaa', 'bbb', 'ccc']) {+ const name = `lt-${suffix}-${uniqueName()}`;+ tables.push(name);+ await ddb.send(new CreateTableCommand({+ TableName: name,+ KeySchema: [{ AttributeName: 'pk', KeyType: 'HASH' }],+ AttributeDefinitions: [{ AttributeName: 'pk', AttributeType: 'S' }],+ BillingMode: 'PAY_PER_REQUEST',+ }));+ }+ tables.sort(); // ensure our expectation baseline is sorted+ });++ afterAll(async () => {+ for (const t of tables) {+ try { await ddb.send(new DeleteTableCommand({ TableName: t })); } catch { /* ignore */ }+ }+ });++ it('returns tables in alphabetical order', async () => {+ const resp = await ddb.send(new ListTablesCommand({}));+ const names = resp.TableNames ?? [];+ const sorted = [...names].sort();+ expect(names).toEqual(sorted);+ });++ it('respects Limit and returns LastEvaluatedTableName', async () => {+ const first = await ddb.send(new ListTablesCommand({ Limit: 1 }));+ expect(first.TableNames).toHaveLength(1);+ expect(first.LastEvaluatedTableName).toBeDefined();++ const second = await ddb.send(new ListTablesCommand({+ Limit: 1,+ ExclusiveStartTableName: first.LastEvaluatedTableName,+ }));+ expect(second.TableNames).toHaveLength(1);+ expect(second.TableNames![0]).not.toBe(first.TableNames![0]);+ });++ it('rejects Limit=0 with ValidationException', async () => {+ await expectError(ddb.send(new ListTablesCommand({ Limit: 0 })), 'ValidationException');+ });++ it('rejects Limit=101 with ValidationException', async () => {+ await expectError(ddb.send(new ListTablesCommand({ Limit: 101 })), 'ValidationException');+ });+});++// ─── Phase 1: ValidationException for invalid table names ───────────────────++describe('DynamoDB — Phase 1: ValidationException rename', () => {+ let ddb: DynamoDBClient;++ beforeAll(() => { ddb = makeClient(DynamoDBClient); });++ it('rejects a 2-char table name with ValidationException', async () => {+ await expectError(+ ddb.send(new PutItemCommand({ TableName: 'ab', Item: { pk: s('x') } })),+ 'ValidationException',+ );+ });++ it('rejects empty table name with ValidationException', async () => {+ await expectError(+ ddb.send(new GetItemCommand({ TableName: '', Key: { pk: s('x') } })),+ 'ValidationException',+ );+ });+});++// ─── Phase 2: ProjectionExpression ──────────────────────────────────────────++describe('DynamoDB — Phase 2: ProjectionExpression', () => {+ let ddb: DynamoDBClient;+ const table = `proj-${uniqueName()}`;++ beforeAll(async () => {+ ddb = makeClient(DynamoDBClient);+ await ddb.send(new CreateTableCommand({+ TableName: table,+ KeySchema: [+ { AttributeName: 'pk', KeyType: 'HASH' },+ { AttributeName: 'sk', KeyType: 'RANGE' },+ ],+ AttributeDefinitions: [+ { AttributeName: 'pk', AttributeType: 'S' },+ { AttributeName: 'sk', AttributeType: 'S' },+ ],+ BillingMode: 'PAY_PER_REQUEST',+ }));+ for (let i = 0; i < 3; i++) {+ await ddb.send(new PutItemCommand({+ TableName: table,+ Item: { pk: s('p1'), sk: s(`s${i}`), name: s(`Item-${i}`), count: n(i * 10), status: s('active') },+ }));+ }+ });++ afterAll(async () => {+ try { await ddb.send(new DeleteTableCommand({ TableName: table })); } catch { /* ignore */ }+ });++ it('GetItem: returns only projected attributes', async () => {+ const resp = await ddb.send(new GetItemCommand({+ TableName: table,+ Key: { pk: s('p1'), sk: s('s0') },+ ProjectionExpression: '#n',+ ExpressionAttributeNames: { '#n': 'name' },+ }));+ expect(resp.Item).toHaveProperty('name');+ expect(resp.Item).not.toHaveProperty('count');+ expect(resp.Item).not.toHaveProperty('status');+ });++ it('Query: returns only projected attributes', async () => {+ const resp = await ddb.send(new QueryCommand({+ TableName: table,+ KeyConditionExpression: 'pk = :pk',+ ExpressionAttributeValues: { ':pk': s('p1') },+ ProjectionExpression: 'sk, #n',+ ExpressionAttributeNames: { '#n': 'name' },+ }));+ expect(resp.Items!.length).toBeGreaterThan(0);+ for (const item of resp.Items!) {+ expect(item).toHaveProperty('sk');+ expect(item).toHaveProperty('name');+ expect(item).not.toHaveProperty('count');+ }+ });++ it('Scan: returns only projected attributes', async () => {+ const resp = await ddb.send(new ScanCommand({+ TableName: table,+ FilterExpression: 'pk = :pk',+ ExpressionAttributeValues: { ':pk': s('p1') },+ ProjectionExpression: 'pk, sk',+ }));+ expect(resp.Items!.length).toBeGreaterThan(0);+ for (const item of resp.Items!) {+ expect(item).toHaveProperty('pk');+ expect(item).toHaveProperty('sk');+ expect(item).not.toHaveProperty('name');+ }+ });++ it('BatchGetItem: returns only projected attributes', async () => {+ const resp = await ddb.send(new BatchGetItemCommand({+ RequestItems: {+ [table]: {+ Keys: [{ pk: s('p1'), sk: s('s0') }],+ ProjectionExpression: '#n',+ ExpressionAttributeNames: { '#n': 'name' },+ },+ },+ }));+ const items = resp.Responses?.[table] ?? [];+ expect(items.length).toBeGreaterThan(0);+ expect(items[0]).toHaveProperty('name');+ expect(items[0]).not.toHaveProperty('count');+ });++ it('rejects AttributesToGet combined with ProjectionExpression', async () => {+ await expectError(+ ddb.send(new GetItemCommand({+ TableName: table,+ Key: { pk: s('p1'), sk: s('s0') },+ AttributesToGet: ['name'],+ ProjectionExpression: 'name',+ })),+ 'ValidationException',+ );+ });+});++// ─── Phase 3: Validation limits ─────────────────────────────────────────────++describe('DynamoDB — Phase 3: Batch limits & key validation', () => {+ let ddb: DynamoDBClient;+ const table = `val-${uniqueName()}`;+ const lsiTable = `val-lsi-${uniqueName()}`;++ beforeAll(async () => {+ ddb = makeClient(DynamoDBClient);+ await ddb.send(new CreateTableCommand({+ TableName: table,+ KeySchema: [+ { AttributeName: 'pk', KeyType: 'HASH' },+ { AttributeName: 'sk', KeyType: 'RANGE' },+ ],+ AttributeDefinitions: [+ { AttributeName: 'pk', AttributeType: 'S' },+ { AttributeName: 'sk', AttributeType: 'S' },+ ],+ BillingMode: 'PAY_PER_REQUEST',+ }));+ await ddb.send(new CreateTableCommand({+ TableName: lsiTable,+ KeySchema: [+ { AttributeName: 'pk', KeyType: 'HASH' },+ { AttributeName: 'sk', KeyType: 'RANGE' },+ ],+ AttributeDefinitions: [+ { AttributeName: 'pk', AttributeType: 'S' },+ { AttributeName: 'sk', AttributeType: 'S' },+ { AttributeName: 'lsi_sk', AttributeType: 'S' },+ ],+ LocalSecondaryIndexes: [{+ IndexName: 'lsi-by-lsi-sk',+ KeySchema: [+ { AttributeName: 'pk', KeyType: 'HASH' },+ { AttributeName: 'lsi_sk', KeyType: 'RANGE' },+ ],+ Projection: { ProjectionType: 'ALL' },+ }],+ BillingMode: 'PAY_PER_REQUEST',+ }));+ });++ afterAll(async () => {+ try { await ddb.send(new DeleteTableCommand({ TableName: table })); } catch { /* ignore */ }+ try { await ddb.send(new DeleteTableCommand({ TableName: lsiTable })); } catch { /* ignore */ }+ });++ it('BatchWriteItem rejects more than 25 items', async () => {+ const writes = Array.from({ length: 26 }, (_, i) => ({+ PutRequest: { Item: { pk: s(`excess-${i}`), sk: s('s') } },+ }));+ await expectError(+ ddb.send(new BatchWriteItemCommand({ RequestItems: { [table]: writes } })),+ 'ValidationException',+ );+ });++ it('BatchGetItem rejects more than 100 keys', async () => {+ const keys = Array.from({ length: 101 }, (_, i) => ({ pk: s(`k${i}`), sk: s('s') }));+ await expectError(+ ddb.send(new BatchGetItemCommand({ RequestItems: { [table]: { Keys: keys } } })),+ 'ValidationException',+ );+ });++ it('PutItem rejects empty string as PK', async () => {+ await expectError(+ ddb.send(new PutItemCommand({ TableName: table, Item: { pk: s(''), sk: s('s') } })),+ 'ValidationException',+ );+ });++ it('TransactWriteItems rejects duplicate keys', async () => {+ await expectError(+ ddb.send(new TransactWriteItemsCommand({+ TransactItems: [+ { Put: { TableName: table, Item: { pk: s('dup'), sk: s('s') } } },+ { Put: { TableName: table, Item: { pk: s('dup'), sk: s('s') } } },+ ],+ })),+ 'ValidationException',+ );+ });++ it('TransactWriteItems idempotency token conflict throws IdempotentParameterMismatchException', async () => {+ const token = uniqueName('tok');+ // First call succeeds+ await ddb.send(new TransactWriteItemsCommand({+ ClientRequestToken: token,+ TransactItems: [{ Put: { TableName: table, Item: { pk: s('idem-node'), sk: s('s') } } }],+ }));+ // Same token, different payload+ await expectError(+ ddb.send(new TransactWriteItemsCommand({+ ClientRequestToken: token,+ TransactItems: [{ Put: { TableName: table, Item: { pk: s('idem-other'), sk: s('s') } } }],+ })),+ 'IdempotentParameterMismatchException',+ );+ });++ it('PutItem with ReturnItemCollectionMetrics=SIZE returns metrics on LSI table', async () => {+ const resp = await ddb.send(new PutItemCommand({+ TableName: lsiTable,+ Item: { pk: s('m1'), sk: s('sk-a'), lsi_sk: s('l1') },+ ReturnItemCollectionMetrics: 'SIZE',+ }));+ expect(resp.ItemCollectionMetrics).toBeDefined();+ expect(resp.ItemCollectionMetrics!.SizeEstimateRangeGB).toHaveLength(2);+ });+});++// ─── Phase 4: Query/Scan behaviour ──────────────────────────────────────────++describe('DynamoDB — Phase 4: Query/Scan behaviour', () => {+ let ddb: DynamoDBClient;+ const table = `qscan-${uniqueName()}`;++ beforeAll(async () => {+ ddb = makeClient(DynamoDBClient);+ await ddb.send(new CreateTableCommand({+ TableName: table,+ KeySchema: [+ { AttributeName: 'pk', KeyType: 'HASH' },+ { AttributeName: 'sk', KeyType: 'RANGE' },+ ],+ AttributeDefinitions: [+ { AttributeName: 'pk', AttributeType: 'S' },+ { AttributeName: 'sk', AttributeType: 'S' },+ ],+ BillingMode: 'PAY_PER_REQUEST',+ }));+ for (let i = 0; i < 5; i++) {+ await ddb.send(new PutItemCommand({+ TableName: table,+ Item: { pk: s('p1'), sk: s(`s${i}`), name: s(`Item-${i}`), count: n(i) },+ }));+ }+ });++ afterAll(async () => {+ try { await ddb.send(new DeleteTableCommand({ TableName: table })); } catch { /* ignore */ }+ });++ it('Query Select=COUNT returns Count without Items', async () => {+ const resp = await ddb.send(new QueryCommand({+ TableName: table,+ KeyConditionExpression: 'pk = :pk',+ ExpressionAttributeValues: { ':pk': s('p1') },+ Select: 'COUNT',+ }));+ expect(resp.Count).toBe(5);+ expect(resp.Items).toBeUndefined();+ });++ it('Scan Select=COUNT returns Count without Items', async () => {+ const resp = await ddb.send(new ScanCommand({+ TableName: table,+ FilterExpression: 'pk = :pk',+ ExpressionAttributeValues: { ':pk': s('p1') },+ Select: 'COUNT',+ }));+ expect(resp.Count).toBeGreaterThan(0);+ expect(resp.Items).toBeUndefined();+ });++ it('parallel scan partitions with no overlap and full coverage', async () => {+ const totalSegments = 2;+ const [seg0, seg1] = await Promise.all([+ ddb.send(new ScanCommand({ TableName: table, Segment: 0, TotalSegments: totalSegments })),+ ddb.send(new ScanCommand({ TableName: table, Segment: 1, TotalSegments: totalSegments })),+ ]);++ const keys0 = new Set((seg0.Items ?? []).map(i => i.sk.S!));+ const keys1 = new Set((seg1.Items ?? []).map(i => i.sk.S!));++ // No overlap+ for (const k of keys0) expect(keys1.has(k)).toBe(false);+ // Full coverage+ expect(keys0.size + keys1.size).toBe(5);+ });++ it('parallel scan requires both Segment and TotalSegments', async () => {+ await expectError(+ ddb.send(new ScanCommand({ TableName: table, Segment: 0 })),+ 'ValidationException',+ );+ await expectError(+ ddb.send(new ScanCommand({ TableName: table, TotalSegments: 2 })),+ 'ValidationException',+ );+ });++ it('attribute_type() function in FilterExpression', async () => {+ const resp = await ddb.send(new QueryCommand({+ TableName: table,+ KeyConditionExpression: 'pk = :pk',+ FilterExpression: 'attribute_type(#n, :t)',+ ExpressionAttributeValues: { ':pk': s('p1'), ':t': s('S') },+ ExpressionAttributeNames: { '#n': 'name' },+ }));+ expect(resp.Count).toBe(5);+ });++ it('parenthesized key condition expression works', async () => {+ const resp = await ddb.send(new QueryCommand({+ TableName: table,+ KeyConditionExpression: '(pk = :pk AND sk = :sk)',+ ExpressionAttributeValues: { ':pk': s('p1'), ':sk': s('s0') },+ }));+ expect(resp.Count).toBe(1);+ expect(resp.Items![0].sk.S).toBe('s0');+ });++ it('Query without KeyConditionExpression throws ValidationException', async () => {+ await expectError(+ ddb.send(new QueryCommand({ TableName: table })),+ 'ValidationException',+ );+ });+});++// ─── Phase 7: Tags API errors ────────────────────────────────────────────────++describe('DynamoDB — Phase 7: Tags API errors', () => {+ let ddb: DynamoDBClient;++ beforeAll(() => { ddb = makeClient(DynamoDBClient); });++ it('TagResource with invalid ARN throws ValidationException', async () => {+ await expectError(+ ddb.send(new TagResourceCommand({+ ResourceArn: 'not-an-arn',+ Tags: [{ Key: 'k', Value: 'v' }],+ })),+ 'ValidationException',+ );+ });++ it('ListTagsOfResource with valid-format non-existent ARN throws AccessDeniedException', async () => {+ await expectError(+ ddb.send(new ListTagsOfResourceCommand({+ ResourceArn: 'arn:aws:dynamodb:us-east-1:000000000000:table/does-not-exist',+ })),+ 'AccessDeniedException',+ );+ });+});++// ─── Phase 8: ReturnValuesOnConditionCheckFailure ────────────────────────────++describe('DynamoDB — Phase 8: ReturnValuesOnConditionCheckFailure', () => {+ let ddb: DynamoDBClient;+ const table = `cond-${uniqueName()}`;++ beforeAll(async () => {+ ddb = makeClient(DynamoDBClient);+ await ddb.send(new CreateTableCommand({+ TableName: table,+ KeySchema: [+ { AttributeName: 'pk', KeyType: 'HASH' },+ { AttributeName: 'sk', KeyType: 'RANGE' },+ ],+ AttributeDefinitions: [+ { AttributeName: 'pk', AttributeType: 'S' },+ { AttributeName: 'sk', AttributeType: 'S' },+ ],+ BillingMode: 'PAY_PER_REQUEST',+ }));+ await ddb.send(new PutItemCommand({+ TableName: table,+ Item: { pk: s('existing'), sk: s('s'), val: s('old') },+ }));+ });++ afterAll(async () => {+ try { await ddb.send(new DeleteTableCommand({ TableName: table })); } catch { /* ignore */ }+ });++ it('PutItem condition failure throws ConditionalCheckFailedException', async () => {+ await expectError(+ ddb.send(new PutItemCommand({+ TableName: table,+ Item: { pk: s('existing'), sk: s('s'), val: s('new') },+ ConditionExpression: 'attribute_not_exists(pk)',+ ReturnValuesOnConditionCheckFailure: 'ALL_OLD',+ })),+ 'ConditionalCheckFailedException',+ );+ });++ it('UpdateItem condition failure throws ConditionalCheckFailedException', async () => {+ await expectError(+ ddb.send(new UpdateItemCommand({+ TableName: table,+ Key: { pk: s('existing'), sk: s('s') },+ UpdateExpression: 'SET val = :new',+ ConditionExpression: 'val = :expected',+ ExpressionAttributeValues: { ':new': s('new'), ':expected': s('wrong') },+ ReturnValuesOnConditionCheckFailure: 'ALL_OLD',+ })),+ 'ConditionalCheckFailedException',+ );+ });++ it('DeleteItem condition failure throws ConditionalCheckFailedException', async () => {+ await expectError(+ ddb.send(new DeleteItemCommand({+ TableName: table,+ Key: { pk: s('existing'), sk: s('s') },+ ConditionExpression: 'val = :expected',+ ExpressionAttributeValues: { ':expected': s('wrong') },+ ReturnValuesOnConditionCheckFailure: 'ALL_OLD',+ })),+ 'ConditionalCheckFailedException',+ );+ });+});++// ─── Phase 9: Reserved words ─────────────────────────────────────────────────++describe('DynamoDB — Phase 9: Reserved words', () => {+ let ddb: DynamoDBClient;+ const table = `rw-${uniqueName()}`;++ beforeAll(async () => {+ ddb = makeClient(DynamoDBClient);+ await ddb.send(new CreateTableCommand({+ TableName: table,+ KeySchema: [+ { AttributeName: 'pk', KeyType: 'HASH' },+ { AttributeName: 'sk', KeyType: 'RANGE' },+ ],+ AttributeDefinitions: [+ { AttributeName: 'pk', AttributeType: 'S' },+ { AttributeName: 'sk', AttributeType: 'S' },+ ],+ BillingMode: 'PAY_PER_REQUEST',+ }));+ });++ afterAll(async () => {+ try { await ddb.send(new DeleteTableCommand({ TableName: table })); } catch { /* ignore */ }+ });++ it('bare reserved word in ConditionExpression throws ValidationException', async () => {+ await expectError(+ ddb.send(new PutItemCommand({+ TableName: table,+ Item: { pk: s('rw1'), sk: s('s') },+ // 'status' is a DynamoDB reserved word+ ConditionExpression: 'attribute_not_exists(status)',+ })),+ 'ValidationException',+ );+ });++ it('bare reserved word in FilterExpression throws ValidationException', async () => {+ await expectError(+ ddb.send(new ScanCommand({+ TableName: table,+ FilterExpression: 'name = :v',+ ExpressionAttributeValues: { ':v': s('x') },+ // 'name' is a reserved word used bare+ })),+ 'ValidationException',+ );+ });++ it('reserved word aliased via ExpressionAttributeNames passes', async () => {+ // Using #st alias for the reserved word 'status'+ await ddb.send(new PutItemCommand({+ TableName: table,+ Item: { pk: s('rw-ok'), sk: s('s'), status: s('active') },+ ConditionExpression: 'attribute_not_exists(pk)',+ ExpressionAttributeNames: { '#st': 'status' },+ }));++ const resp = await ddb.send(new ScanCommand({+ TableName: table,+ FilterExpression: '#st = :v',+ ExpressionAttributeNames: { '#st': 'status' },+ ExpressionAttributeValues: { ':v': s('active') },+ }));+ expect(resp.Count).toBe(1);+ });+});++// ─── Phase 10: Legacy API ────────────────────────────────────────────────────++describe('DynamoDB — Phase 10: Legacy API', () => {+ let ddb: DynamoDBClient;+ const table = `legacy-${uniqueName()}`;++ beforeAll(async () => {+ ddb = makeClient(DynamoDBClient);+ await ddb.send(new CreateTableCommand({+ TableName: table,+ KeySchema: [+ { AttributeName: 'pk', KeyType: 'HASH' },+ { AttributeName: 'sk', KeyType: 'RANGE' },+ ],+ AttributeDefinitions: [+ { AttributeName: 'pk', AttributeType: 'S' },+ { AttributeName: 'sk', AttributeType: 'S' },+ ],+ BillingMode: 'PAY_PER_REQUEST',+ }));+ for (let i = 0; i < 3; i++) {+ await ddb.send(new PutItemCommand({+ TableName: table,+ Item: { pk: s('p1'), sk: s(`s${i}`), name: s(`Item-${i}`), color: s('red') },+ }));+ }+ });++ afterAll(async () => {+ try { await ddb.send(new DeleteTableCommand({ TableName: table })); } catch { /* ignore */ }+ });++ it('AttributesToGet returns only listed attributes (no auto-key-include)', async () => {+ const resp = await ddb.send(new GetItemCommand({+ TableName: table,+ Key: { pk: s('p1'), sk: s('s0') },+ AttributesToGet: ['name', 'color'],+ }));+ expect(resp.Item).toHaveProperty('name');+ expect(resp.Item).toHaveProperty('color');+ expect(resp.Item).not.toHaveProperty('pk');+ expect(resp.Item).not.toHaveProperty('sk');+ });++ it('AttributeUpdates (legacy) applies PUT action', async () => {+ await ddb.send(new UpdateItemCommand({+ TableName: table,+ Key: { pk: s('p1'), sk: s('s0') },+ AttributeUpdates: {+ color: { Value: s('blue'), Action: 'PUT' },+ },+ }));+ const resp = await ddb.send(new GetItemCommand({+ TableName: table,+ Key: { pk: s('p1'), sk: s('s0') },+ }));+ expect(resp.Item!.color.S).toBe('blue');+ });++ it('AttributeUpdates (legacy) applies DELETE action to remove attribute', async () => {+ await ddb.send(new UpdateItemCommand({+ TableName: table,+ Key: { pk: s('p1'), sk: s('s1') },+ AttributeUpdates: {+ color: { Action: 'DELETE' },+ },+ }));+ const resp = await ddb.send(new GetItemCommand({+ TableName: table,+ Key: { pk: s('p1'), sk: s('s1') },+ }));+ expect(resp.Item).not.toHaveProperty('color');+ });++ it('QueryFilter (legacy) filters query results', async () => {+ const resp = await ddb.send(new QueryCommand({+ TableName: table,+ KeyConditionExpression: 'pk = :pk',+ ExpressionAttributeValues: { ':pk': s('p1') },+ QueryFilter: {+ name: { ComparisonOperator: 'EQ', AttributeValueList: [s('Item-0')] },+ },+ }));+ expect(resp.Count).toBe(1);+ expect(resp.Items![0].name.S).toBe('Item-0');+ });++ it('ScanFilter (legacy) filters scan results', async () => {+ const resp = await ddb.send(new ScanCommand({+ TableName: table,+ ScanFilter: {+ name: { ComparisonOperator: 'EQ', AttributeValueList: [s('Item-2')] },+ },+ }));+ expect(resp.Count).toBe(1);+ expect(resp.Items![0].name.S).toBe('Item-2');+ });++ it('KeyConditions and KeyConditionExpression are mutually exclusive', async () => {+ await expectError(+ ddb.send(new QueryCommand({+ TableName: table,+ KeyConditionExpression: 'pk = :pk',+ ExpressionAttributeValues: { ':pk': s('p1') },+ KeyConditions: { pk: { ComparisonOperator: 'EQ', AttributeValueList: [s('p1')] } },+ })),+ 'ValidationException',+ );+ });+});++// ─── Phase 11: Enum validation ordering ──────────────────────────────────────++describe('DynamoDB — Phase 11: Enum validation before table lookup', () => {+ let ddb: DynamoDBClient;++ beforeAll(() => { ddb = makeClient(DynamoDBClient); });++ it('invalid ReturnValues on PutItem throws ValidationException even for non-existent table', async () => {+ const err = await ddb.send(new PutItemCommand({+ TableName: 'nonexistent-table-xyz',+ Item: { pk: s('x') },+ ReturnValues: 'UPDATED_NEW', // invalid for PutItem+ })).catch(e => e);++ expect(err.name).toBe('ValidationException');+ // Must NOT be ResourceNotFoundException+ expect(err.name).not.toBe('ResourceNotFoundException');+ });++ it('invalid ReturnValues on DeleteItem throws ValidationException even for non-existent table', async () => {+ const err = await ddb.send(new DeleteItemCommand({+ TableName: 'nonexistent-table-xyz',+ Key: { pk: s('x'), sk: s('y') },+ ReturnValues: 'UPDATED_NEW', // invalid for DeleteItem+ })).catch(e => e);++ expect(err.name).toBe('ValidationException');+ });++ it('invalid ReturnConsumedCapacity throws ValidationException even for non-existent table', async () => {+ const err = await ddb.send(new GetItemCommand({+ TableName: 'nonexistent-table-xyz',+ Key: { pk: s('x'), sk: s('y') },+ // @ts-expect-error invalid enum value+ ReturnConsumedCapacity: 'INVALID_VALUE',+ })).catch(e => e);++ expect(err.name).toBe('ValidationException');+ });+});diff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbItemSize.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbItemSize.javanew file mode 100644index 0000000000..a493a0a233--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbItemSize.java@@ -0,0 +1,94 @@+package io.github.hectorvent.floci.services.dynamodb;++import com.fasterxml.jackson.databind.JsonNode;+import io.github.hectorvent.floci.core.common.AwsException;++import java.nio.charset.StandardCharsets;+import java.util.Base64;++/**+ * Calculates DynamoDB item size and enforces the 400KB limit.+ */+final class DynamoDbItemSize {++ static final int MAX_ITEM_SIZE = 400 * 1024; // 400 KB = 409,600 bytes++ private DynamoDbItemSize() {}++ /**+ * Validates the item fits within 400KB. Throws ValidationException if not.+ */+ static void validateSize(JsonNode item) {+ int size = calculateItemSize(item);+ if (size > MAX_ITEM_SIZE) {+ throw new AwsException("ValidationException",+ "Item size has exceeded the maximum allowed size", 400);+ }+ }++ static int calculateItemSize(JsonNode item) {+ if (item == null || !item.isObject()) return 0;+ int total = 0;+ var fields = item.fields();+ while (fields.hasNext()) {+ var entry = fields.next();+ total += utf8Length(entry.getKey());+ total += attributeValueSize(entry.getValue());+ }+ return total;+ }++ private static int attributeValueSize(JsonNode attr) {+ if (attr == null) return 0;+ if (attr.has("S")) return utf8Length(attr.get("S").asText());+ if (attr.has("N")) return attr.get("N").asText().length();+ if (attr.has("B")) return binarySize(attr.get("B").asText());+ if (attr.has("BOOL")) return 1;+ if (attr.has("NULL")) return 1;+ if (attr.has("SS")) {+ int size = 0;+ for (JsonNode e : attr.get("SS")) size += utf8Length(e.asText()) + 1;+ return size;+ }+ if (attr.has("NS")) {+ int size = 0;+ for (JsonNode e : attr.get("NS")) size += e.asText().length() + 1;+ return size;+ }+ if (attr.has("BS")) {+ int size = 0;+ for (JsonNode e : attr.get("BS")) size += binarySize(e.asText()) + 1;+ return size;+ }+ if (attr.has("L")) {+ int size = 0;+ for (JsonNode e : attr.get("L")) size += attributeValueSize(e) + 3;+ return size;+ }+ if (attr.has("M")) {+ int size = 0;+ var fields = attr.get("M").fields();+ while (fields.hasNext()) {+ var entry = fields.next();+ size += utf8Length(entry.getKey()) + 1 + attributeValueSize(entry.getValue()) + 3;+ }+ return size;+ }+ return 0;+ }++ private static int utf8Length(String s) {+ if (s == null) return 0;+ return s.getBytes(StandardCharsets.UTF_8).length;+ }++ private static int binarySize(String base64) {+ if (base64 == null || base64.isEmpty()) return 0;+ try {+ return Base64.getDecoder().decode(base64).length;+ } catch (Exception e) {+ // Fallback: estimate from base64 length+ return (int) (base64.length() * 3L / 4);+ }+ }+}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 3243716ec7..e0b014ee3c 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@@ -9,6 +9,7 @@ import com.fasterxml.jackson.databind.node.ObjectNode;import io.github.hectorvent.floci.core.common.AwsJsonController;import io.github.hectorvent.floci.services.dynamodb.model.*;import io.github.hectorvent.floci.services.kinesis.KinesisService;+import io.github.hectorvent.floci.services.dynamodb.TransactionCanceledException;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import jakarta.ws.rs.core.Response;@@ -74,7 +75,10 @@ public class DynamoDbJsonHandler {}private Response handleCreateTable(JsonNode request, String region) {- String tableName = DynamoDbTableNames.requireShortName(request.path("TableName").asText());+ // Distinguish missing (undefined) from empty ("") for TableName+ String tableNameRaw = (request.has("TableName") && !request.path("TableName").isNull())+ ? request.path("TableName").asText() : null;+ String tableName = DynamoDbTableNames.requireShortName(tableNameRaw);List<KeySchemaElement> keySchema = new ArrayList<>();request.path("KeySchema").forEach(ks ->@@ -135,7 +139,12 @@ public class DynamoDbJsonHandler {ks.path("AttributeName").asText(),ks.path("KeyType").asText())));String projectionType = lsiNode.path("Projection").path("ProjectionType").asText("ALL");- lsis.add(new LocalSecondaryIndex(indexName, lsiKeySchema, null, projectionType));+ JsonNode lsiNonKeyAttrArray = lsiNode.path("Projection").path("NonKeyAttributes");+ List<String> lsiNonKeyAttributes = new ArrayList<>();+ if (!lsiNonKeyAttrArray.isMissingNode() && lsiNonKeyAttrArray.isArray()) {+ lsiNonKeyAttrArray.forEach(a -> lsiNonKeyAttributes.add(a.asText()));+ }+ lsis.add(new LocalSecondaryIndex(indexName, lsiKeySchema, null, projectionType, lsiNonKeyAttributes));}}@@ -205,17 +214,44 @@ public class DynamoDbJsonHandler {}private Response handleListTables(JsonNode request, String region) {- List<String> tables = dynamoDbService.listTables(region);+ Integer limit = request.has("Limit") ? request.get("Limit").asInt() : null;+ String exclusiveStart = request.has("ExclusiveStartTableName")+ ? request.get("ExclusiveStartTableName").asText() : null;++ if (limit != null) {+ if (limit < 1) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '" + limit+ + "' at 'limit' failed to satisfy constraint: "+ + "Member must have value greater than or equal to 1", 400);+ }+ if (limit > 100) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '" + limit+ + "' at 'limit' failed to satisfy constraint: "+ + "Member must have value less than or equal to 100", 400);+ }+ }++ DynamoDbService.ListTablesResult result = dynamoDbService.listTables(region, limit, exclusiveStart);ObjectNode response = objectMapper.createObjectNode();ArrayNode tableNames = objectMapper.createArrayNode();- tables.forEach(tableNames::add);+ result.tableNames().forEach(tableNames::add);response.set("TableNames", tableNames);+ if (result.lastEvaluatedTableName() != null) {+ response.put("LastEvaluatedTableName", result.lastEvaluatedTableName());+ }return Response.ok(response).build();}+ private static final Set<String> VALID_RETURN_VALUES_PUT = Set.of("NONE", "ALL_OLD");+ private static final Set<String> VALID_RETURN_CONSUMED_CAPACITY = Set.of("INDEXES", "TOTAL", "NONE");+ private static final Set<String> VALID_RETURN_ITEM_COLLECTION_METRICS = Set.of("SIZE", "NONE");+private Response handlePutItem(JsonNode request, String region) {- String tableName = request.path("TableName").asText();+ String tableName = request.has("TableName") ? request.path("TableName").asText() : null;+ DynamoDbTableNames.resolve(tableName); // validate tableName before other paramsJsonNode item = request.path("Item");String returnValues = request.path("ReturnValues").asText("NONE");String returnValuesOnConditionCheckFailure = request.path("ReturnValuesOnConditionCheckFailure").asText("NONE");@@ -226,18 +262,62 @@ public class DynamoDbJsonHandler {JsonNode exprAttrValues = request.has("ExpressionAttributeValues")? request.get("ExpressionAttributeValues") : null;+ List<String> validationErrors = new ArrayList<>();+ String rcc = request.has("ReturnConsumedCapacity") ? request.get("ReturnConsumedCapacity").asText() : null;+ if (rcc != null && !VALID_RETURN_CONSUMED_CAPACITY.contains(rcc)) {+ validationErrors.add("Value '" + rcc + "' at 'returnConsumedCapacity' failed to satisfy constraint: "+ + "Member must satisfy enum value set: [INDEXES, TOTAL, NONE]");+ }+ String ricm = request.has("ReturnItemCollectionMetrics") ? request.get("ReturnItemCollectionMetrics").asText() : null;+ if (ricm != null && !VALID_RETURN_ITEM_COLLECTION_METRICS.contains(ricm)) {+ validationErrors.add("Value '" + ricm + "' at 'returnItemCollectionMetrics' failed to satisfy constraint: "+ + "Member must satisfy enum value set: [SIZE, NONE]");+ }+ if (!VALID_RETURN_VALUES_PUT.contains(returnValues)) {+ validationErrors.add("Value '" + returnValues + "' at 'returnValues' failed to satisfy constraint: "+ + "Member must satisfy enum value set: [NONE, ALL_OLD]");+ }+ if (!validationErrors.isEmpty()) {+ int n = validationErrors.size();+ throw new AwsException("ValidationException",+ n + " validation error" + (n > 1 ? "s" : "") + " detected: "+ + String.join("; ", validationErrors), 400);+ }++ JsonNode expected = request.has("Expected") ? request.get("Expected") : null;+ String conditionalOperator = request.has("ConditionalOperator")+ ? request.get("ConditionalOperator").asText() : "AND";++ if (conditionExpression != null && expected != null) {+ throw new AwsException("ValidationException",+ "Can not use both expression and non-expression parameters in the same request: "+ + "Non-expression parameters: {Expected} Expression parameters: {ConditionExpression}", 400);+ }++ if (exprAttrValues != null && conditionExpression == null) {+ throw new AwsException("ValidationException",+ "ExpressionAttributeValues can only be specified when using expressions: ConditionExpression is null", 400);+ }++ validateItemSets(item);+JsonNode oldItem = null;- if ("ALL_OLD" .equals(returnValues)) {+ if ("ALL_OLD".equals(returnValues) || expected != null) {dynamoDbService.describeTable(tableName, region);oldItem = dynamoDbService.getItem(tableName, item, region);}+ if (expected != null) {+ evaluateLegacyExpected(oldItem, expected, conditionalOperator, returnValuesOnConditionCheckFailure);+ }+dynamoDbService.putItem(tableName, item, conditionExpression, exprAttrNames, exprAttrValues, region, returnValuesOnConditionCheckFailure);ObjectNode response = objectMapper.createObjectNode();if ("ALL_OLD" .equals(returnValues) && oldItem != null) {response.set("Attributes", oldItem);}+ addItemCollectionMetrics(response, request, tableName, item, region);addConsumedCapacity(response, request, tableName, 1, true);return Response.ok(response).build();}@@ -245,8 +325,40 @@ public class DynamoDbJsonHandler {private Response handleGetItem(JsonNode request, String region) {String tableName = request.path("TableName").asText();JsonNode key = request.path("Key");+ String projectionExpression = request.has("ProjectionExpression")+ ? request.get("ProjectionExpression").asText() : null;+ JsonNode exprAttrNames = request.has("ExpressionAttributeNames")+ ? request.get("ExpressionAttributeNames") : null;+ JsonNode attributesToGet = request.has("AttributesToGet") ? request.get("AttributesToGet") : null;++ if (attributesToGet != null && projectionExpression != null) {+ throw new AwsException("ValidationException",+ "Can not use both expression and non-expression parameters in the same request: "+ + "Non-expression parameters: {AttributesToGet} Expression parameters: {ProjectionExpression}", 400);+ }++ // Validate enums before table lookup+ String rccGet = request.has("ReturnConsumedCapacity") ? request.get("ReturnConsumedCapacity").asText() : null;+ if (rccGet != null && !VALID_RETURN_CONSUMED_CAPACITY.contains(rccGet)) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '" + rccGet + "' at 'returnConsumedCapacity' failed to satisfy constraint: "+ + "Member must satisfy enum value set: [INDEXES, TOTAL, NONE]", 400);+ }++ // Validate ProjectionExpression syntax and reserved words before item lookup+ if (projectionExpression != null) {+ ProjectionEvaluator.validateSyntax(projectionExpression, "ProjectionExpression");+ DynamoDbReservedWords.check(projectionExpression, "ProjectionExpression");+ }JsonNode item = dynamoDbService.getItem(tableName, key, region);+ if (item != null && projectionExpression != null) {+ item = ProjectionEvaluator.project(item, projectionExpression, exprAttrNames);+ } else if (item != null && attributesToGet != null) {+ Set<String> keep = new HashSet<>();+ attributesToGet.forEach(n -> keep.add(n.asText()));+ item = ProjectionEvaluator.trimToAttributes((ObjectNode) item, keep);+ }ObjectNode response = objectMapper.createObjectNode();if (item != null) {@@ -256,10 +368,15 @@ public class DynamoDbJsonHandler {return Response.ok(response).build();}+ private static final Set<String> VALID_RETURN_VALUES_DELETE = Set.of("NONE", "ALL_OLD");+ private static final Set<String> VALID_RETURN_VALUES_UPDATE =+ Set.of("NONE", "ALL_OLD", "ALL_NEW", "UPDATED_OLD", "UPDATED_NEW");+private Response handleDeleteItem(JsonNode request, String region) {String tableName = request.path("TableName").asText();+ DynamoDbTableNames.resolve(tableName); // validate tableName firstJsonNode key = request.path("Key");- String returnValues = request.path("ReturnValues").asText("NONE");+ String returnValues = request.path("ReturnValues").asText("NONE");String returnValuesOnConditionCheckFailure = request.path("ReturnValuesOnConditionCheckFailure").asText("NONE");String conditionExpression = request.has("ConditionExpression")? request.get("ConditionExpression").asText() : null;@@ -268,6 +385,32 @@ public class DynamoDbJsonHandler {JsonNode exprAttrValues = request.has("ExpressionAttributeValues")? request.get("ExpressionAttributeValues") : null;+ // Validate ReturnValues + ReturnConsumedCapacity together+ List<String> delValidationErrors = new ArrayList<>();+ String rccDel = request.has("ReturnConsumedCapacity") ? request.get("ReturnConsumedCapacity").asText() : null;+ if (rccDel != null && !VALID_RETURN_CONSUMED_CAPACITY.contains(rccDel)) {+ delValidationErrors.add("Value '" + rccDel + "' at 'returnConsumedCapacity' failed to satisfy constraint: "+ + "Member must satisfy enum value set: [INDEXES, TOTAL, NONE]");+ }+ if (!VALID_RETURN_VALUES_DELETE.contains(returnValues)) {+ delValidationErrors.add("Value '" + returnValues + "' at 'returnValues' failed to satisfy constraint: "+ + "Member must satisfy enum value set: [NONE, ALL_OLD]");+ }+ if (!delValidationErrors.isEmpty()) {+ int n = delValidationErrors.size();+ throw new AwsException("ValidationException",+ n + " validation error" + (n > 1 ? "s" : "") + " detected: "+ + String.join("; ", delValidationErrors), 400);+ }++ JsonNode expectedDel = request.has("Expected") ? request.get("Expected") : null;+ String condOpDel = request.has("ConditionalOperator")+ ? request.get("ConditionalOperator").asText() : "AND";+ if (expectedDel != null) {+ JsonNode existingForDel = dynamoDbService.getItem(tableName, key, region);+ evaluateLegacyExpected(existingForDel, expectedDel, condOpDel, returnValuesOnConditionCheckFailure);+ }+JsonNode oldItem = dynamoDbService.deleteItem(tableName, key, conditionExpression,exprAttrNames, exprAttrValues, region, returnValuesOnConditionCheckFailure);@@ -275,12 +418,14 @@ public class DynamoDbJsonHandler {if ("ALL_OLD" .equals(returnValues) && oldItem != null) {response.set("Attributes", oldItem);}+ addItemCollectionMetrics(response, request, tableName, key, region);addConsumedCapacity(response, request, tableName, 1, true);return Response.ok(response).build();}private Response handleUpdateItem(JsonNode request, String region) {String tableName = request.path("TableName").asText();+ DynamoDbTableNames.resolve(tableName); // validate tableName firstJsonNode key = request.path("Key");JsonNode attributeUpdates = request.path("AttributeUpdates");JsonNode exprAttrNames = request.has("ExpressionAttributeNames")@@ -294,8 +439,61 @@ public class DynamoDbJsonHandler {String returnValues = request.path("ReturnValues").asText("NONE");String returnValuesOnConditionCheckFailure = request.path("ReturnValuesOnConditionCheckFailure").asText("NONE");+ // Validate ReturnValues + ReturnConsumedCapacity together before table lookup+ List<String> updValidationErrors = new ArrayList<>();+ String rccUpd = request.has("ReturnConsumedCapacity") ? request.get("ReturnConsumedCapacity").asText() : null;+ if (rccUpd != null && !VALID_RETURN_CONSUMED_CAPACITY.contains(rccUpd)) {+ updValidationErrors.add("Value '" + rccUpd + "' at 'returnConsumedCapacity' failed to satisfy constraint: "+ + "Member must satisfy enum value set: [INDEXES, TOTAL, NONE]");+ }+ if (!VALID_RETURN_VALUES_UPDATE.contains(returnValues)) {+ updValidationErrors.add("Value '" + returnValues + "' at 'returnValues' failed to satisfy constraint: "+ + "Member must satisfy enum value set: [NONE, ALL_OLD, ALL_NEW, UPDATED_OLD, UPDATED_NEW]");+ }+ if (!updValidationErrors.isEmpty()) {+ int n = updValidationErrors.size();+ throw new AwsException("ValidationException",+ n + " validation error" + (n > 1 ? "s" : "") + " detected: "+ + String.join("; ", updValidationErrors), 400);+ }+JsonNode updateData = attributeUpdates.isMissingNode() ? null : attributeUpdates;+ if (updateData != null && updateExpression != null) {+ throw new AwsException("ValidationException",+ "Can not use both expression and non-expression parameters in the same request: "+ + "Non-expression parameters: {AttributeUpdates} Expression parameters: {UpdateExpression}", 400);+ }++ // Validate EAN/EAV usage across UpdateExpression + ConditionExpression+ if (updateExpression != null) {+ // Pre-validate syntax: expression must start with a valid clause keyword+ String ue = updateExpression.trim();+ if (!ue.isEmpty()) {+ String upper = ue.toUpperCase();+ if (!upper.startsWith("SET ") && !upper.startsWith("REMOVE ") && !upper.startsWith("ADD ") && !upper.startsWith("DELETE ")) {+ String[] parts = ue.split("\\s+", 3);+ String token = parts[0];+ String near = parts.length >= 2+ ? (token + " " + parts[1]).substring(0, Math.min(token.length() + 1 + parts[1].length(), 20))+ : token;+ throw new AwsException("ValidationException",+ "Invalid UpdateExpression: Syntax error; token: \"" + token + "\", near: \"" + near + "\"", 400);+ }+ }+ Set<String> colonTokens = extractColonTokens(updateExpression);+ for (String token : colonTokens) {+ if (exprAttrValues == null || !exprAttrValues.has(token)) {+ throw new AwsException("ValidationException",+ "Invalid UpdateExpression: An expression attribute value used in expression is not defined; attribute value: " + token, 400);+ }+ }+ Set<String> hashTokens = extractHashTokens(updateExpression, conditionExpression);+ checkUnusedEan(exprAttrNames, hashTokens);+ Set<String> colonTokensAll = extractColonTokens(updateExpression, conditionExpression);+ checkUnusedEav(exprAttrValues, colonTokensAll);+ }+DynamoDbService.UpdateResult result = dynamoDbService.updateItem(tableName, key, updateData, updateExpression, exprAttrNames, exprAttrValues,returnValues, conditionExpression, region, returnValuesOnConditionCheckFailure);@@ -314,10 +512,63 @@ public class DynamoDbJsonHandler {} else if ("UPDATED_OLD".equals(returnValues) && result.oldItem() != null) {response.set("Attributes", getChangedAttributes(result.oldItem(), result.newItem()));}+ addItemCollectionMetrics(response, request, tableName, key, region);addConsumedCapacity(response, request, tableName, 1, true);return Response.ok(response).build();}+ private void evaluateLegacyExpected(JsonNode existing, JsonNode expected, String conditionalOperator,+ String returnValuesOnConditionCheckFailure) {+ if (expected == null) return;+ boolean useOr = "OR".equals(conditionalOperator);+ boolean overall = !useOr;+ var fields = expected.fields();+ while (fields.hasNext()) {+ var entry = fields.next();+ String attrName = entry.getKey();+ JsonNode condition = entry.getValue();+ JsonNode attrValue = existing != null ? existing.get(attrName) : null;+ boolean condResult;+ if (condition.has("Exists")) {+ boolean exists = condition.get("Exists").asBoolean();+ condResult = exists ? attrValue != null : attrValue == null;+ } else {+ condResult = dynamoDbService.matchesKeyConditionPublic(attrValue, condition);+ }+ if (useOr) overall = overall || condResult;+ else overall = overall && condResult;+ }+ if (!overall) {+ if ("ALL_OLD".equals(returnValuesOnConditionCheckFailure)) {+ throw new ConditionalCheckFailedException(existing);+ } else {+ throw new ConditionalCheckFailedException(null);+ }+ }+ }++ private void addItemCollectionMetrics(ObjectNode response, JsonNode request, String tableName,+ JsonNode itemOrKey, String region) {+ String ricm = request.has("ReturnItemCollectionMetrics")+ ? request.get("ReturnItemCollectionMetrics").asText() : null;+ if (!"SIZE".equals(ricm) || itemOrKey == null) return;+ try {+ TableDefinition table = dynamoDbService.describeTable(tableName, region);+ String pkName = table.getPartitionKeyName();+ JsonNode pkValue = itemOrKey.get(pkName);+ if (pkValue == null) return;+ ObjectNode metrics = objectMapper.createObjectNode();+ ObjectNode collKey = objectMapper.createObjectNode();+ collKey.set(pkName, pkValue);+ metrics.set("ItemCollectionKey", collKey);+ ArrayNode sizeRange = objectMapper.createArrayNode();+ sizeRange.add(0.0);+ sizeRange.add(1.0);+ metrics.set("SizeEstimateRangeGB", sizeRange);+ response.set("ItemCollectionMetrics", metrics);+ } catch (Exception ignored) {}+ }+private JsonNode getChangedAttributes(JsonNode preferredItem, JsonNode secondaryItem){ObjectNode changedAttributes = objectMapper.createObjectNode();Iterator<Map.Entry<String, JsonNode>> fields = preferredItem.fields();@@ -339,8 +590,12 @@ public class DynamoDbJsonHandler {return changedAttributes;}+ private static final Set<String> VALID_SELECT = Set.of(+ "ALL_ATTRIBUTES", "ALL_PROJECTED_ATTRIBUTES", "SPECIFIC_ATTRIBUTES", "COUNT");+private Response handleQuery(JsonNode request, String region) {String tableName = request.path("TableName").asText();+ DynamoDbTableNames.resolve(tableName); // validate tableName firstJsonNode keyConditions = request.has("KeyConditions") ? request.get("KeyConditions") : null;JsonNode exprAttrValues = request.has("ExpressionAttributeValues")? request.get("ExpressionAttributeValues") : null;@@ -350,27 +605,136 @@ public class DynamoDbJsonHandler {? request.get("KeyConditionExpression").asText() : null;String filterExpr = request.has("FilterExpression")? request.get("FilterExpression").asText() : null;+ JsonNode queryFilter = request.has("QueryFilter") ? request.get("QueryFilter") : null;+ JsonNode attributesToGet = request.has("AttributesToGet") ? request.get("AttributesToGet") : null;Integer limit = request.has("Limit") ? request.get("Limit").asInt() : null;Boolean scanIndexForward = request.has("ScanIndexForward")? request.get("ScanIndexForward").asBoolean() : null;String indexName = request.has("IndexName") ? request.get("IndexName").asText() : null;JsonNode exclusiveStartKey = request.has("ExclusiveStartKey")? request.get("ExclusiveStartKey") : null;+ String select = request.has("Select") ? request.get("Select").asText() : null;+ String projectionExpression = request.has("ProjectionExpression")+ ? request.get("ProjectionExpression").asText() : null;++ // Validate Limit+ if (limit != null && limit < 1) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value at 'Limit' failed to satisfy constraint: "+ + "Member must have value greater than or equal to 1", 400);+ }++ // Validate ReturnConsumedCapacity before Select+ String rccQuery = request.has("ReturnConsumedCapacity") ? request.get("ReturnConsumedCapacity").asText() : null;+ if (rccQuery != null && !VALID_RETURN_CONSUMED_CAPACITY.contains(rccQuery)) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '" + rccQuery + "' at 'returnConsumedCapacity' failed to satisfy constraint: "+ + "Member must satisfy enum value set: [INDEXES, TOTAL, NONE]", 400);+ }++ if (keyConditionExpr != null && keyConditions != null) {+ throw new AwsException("ValidationException",+ "Can not use both expression and non-expression parameters in the same request: "+ + "Non-expression parameters: {KeyConditions} Expression parameters: {KeyConditionExpression}", 400);+ }+ if (filterExpr != null && queryFilter != null) {+ throw new AwsException("ValidationException",+ "Can not use both expression and non-expression parameters in the same request: "+ + "Non-expression parameters: {QueryFilter} Expression parameters: {FilterExpression}", 400);+ }++ if (keyConditionExpr == null && keyConditions == null) {+ throw new AwsException("ValidationException",+ "Either KeyConditions or KeyConditionExpression must be provided", 400);+ }++ // Validate empty KCE+ if (keyConditionExpr != null && keyConditionExpr.isEmpty()) {+ throw new AwsException("ValidationException",+ "Invalid KeyConditionExpression: The expression can not be empty;", 400);+ }++ if (select != null && !VALID_SELECT.contains(select)) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '" + select + "' at 'select' failed to satisfy constraint: "+ + "Member must satisfy enum value set: [SPECIFIC_ATTRIBUTES, COUNT, ALL_ATTRIBUTES, ALL_PROJECTED_ATTRIBUTES]", 400);+ }++ if ("SPECIFIC_ATTRIBUTES".equals(select) && projectionExpression == null) {+ throw new AwsException("ValidationException",+ "Select type SPECIFIC_ATTRIBUTES requires the ProjectionExpression to be provided.", 400);+ }++ // ConsistentRead on GSI check+ boolean consistentRead = request.path("ConsistentRead").asBoolean(false);+ if (consistentRead && indexName != null) {+ TableDefinition queryTable = dynamoDbService.describeTable(tableName, region);+ if (queryTable.findGsi(indexName).isPresent()) {+ throw new AwsException("ValidationException",+ "Consistent reads are not supported on global secondary indexes", 400);+ }+ }++ // Validate EAN/EAV usage when using expression format+ if (keyConditionExpr != null) {+ // Check undefined #tokens in FilterExpression+ if (filterExpr != null) {+ for (String token : extractHashTokens(filterExpr)) {+ if (exprAttrNames == null || !exprAttrNames.has(token)) {+ throw new AwsException("ValidationException",+ "Invalid FilterExpression: An expression attribute name used in the document path is not defined; attribute name: " + token, 400);+ }+ }+ }+ // Check unused EAN across all expressions (KCE + FE + PE)+ Set<String> hashTokens = extractHashTokens(keyConditionExpr, filterExpr, projectionExpression);+ checkUnusedEan(exprAttrNames, hashTokens);+ }DynamoDbService.QueryResult result = dynamoDbService.query(tableName, keyConditions,exprAttrValues, keyConditionExpr, filterExpr, limit, scanIndexForward, indexName,exclusiveStartKey, exprAttrNames, region);+ List<JsonNode> queryItems = result.items();+ // Apply QueryFilter (legacy API)+ if (queryFilter != null) {+ final JsonNode qf = queryFilter;+ queryItems = queryItems.stream()+ .filter(i -> dynamoDbService.matchesScanFilterPublic(i, qf))+ .toList();+ }+ // Apply index projection (KEYS_ONLY / INCLUDE) when querying a secondary index+ if (indexName != null && projectionExpression == null && attributesToGet == null) {+ TableDefinition queryTable = dynamoDbService.describeTable(tableName, region);+ queryItems = applyIndexProjection(queryItems, indexName, queryTable, select);+ }+ if (projectionExpression != null) {+ queryItems = queryItems.stream()+ .map(i -> (JsonNode) ProjectionEvaluator.project(i, projectionExpression, exprAttrNames))+ .toList();+ } else if (attributesToGet != null) {+ Set<String> keep = new HashSet<>();+ attributesToGet.forEach(n -> keep.add(n.asText()));+ queryItems = queryItems.stream()+ .map(i -> (JsonNode) ProjectionEvaluator.trimToAttributes((ObjectNode) i, keep))+ .toList();+ }+ObjectNode response = objectMapper.createObjectNode();- ArrayNode itemsArray = objectMapper.createArrayNode();- result.items().forEach(itemsArray::add);- response.set("Items", itemsArray);- response.put("Count", result.items().size());- response.put("ScannedCount", result.scannedCount());+ if ("COUNT".equals(select)) {+ response.put("Count", result.items().size());+ response.put("ScannedCount", result.scannedCount());+ } else {+ ArrayNode itemsArray = objectMapper.createArrayNode();+ queryItems.forEach(itemsArray::add);+ response.set("Items", itemsArray);+ response.put("Count", queryItems.size());+ response.put("ScannedCount", result.scannedCount());+ }if (result.lastEvaluatedKey() != null) {response.set("LastEvaluatedKey", result.lastEvaluatedKey());}- addConsumedCapacity(response, request, tableName, result.items().size(), false);+ addConsumedCapacity(response, request, tableName, queryItems.size(), false);return Response.ok(response).build();}@@ -387,28 +751,95 @@ public class DynamoDbJsonHandler {Integer limit = request.has("Limit") ? request.get("Limit").asInt() : null;JsonNode exclusiveStartKey = request.has("ExclusiveStartKey")? request.get("ExclusiveStartKey") : null;+ String select = request.has("Select") ? request.get("Select").asText() : null;+ String indexNameScan = request.has("IndexName") ? request.get("IndexName").asText() : null;+ Integer segment = request.has("Segment") ? request.get("Segment").asInt() : null;+ Integer totalSegments = request.has("TotalSegments") ? request.get("TotalSegments").asInt() : null;++ if (filterExpr != null && scanFilter != null) {+ throw new AwsException("ValidationException",+ "Can not use both expression and non-expression parameters in the same request: "+ + "Non-expression parameters: {ScanFilter} Expression parameters: {FilterExpression}", 400);+ }++ if (limit != null && limit < 1) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '" + limit + "' at 'limit' failed to satisfy constraint: "+ + "Member must have value greater than or equal to 1", 400);+ }++ if (segment != null && totalSegments == null) {+ throw new AwsException("ValidationException",+ "The TotalSegments parameter is required but was not present in the request when Segment parameter is present", 400);+ }+ if (totalSegments != null && segment == null) {+ throw new AwsException("ValidationException",+ "The Segment parameter is required but was not present in the request when parameter TotalSegments is present", 400);+ }+ if (segment != null && totalSegments != null && segment >= totalSegments) {+ throw new AwsException("ValidationException",+ "The Segment parameter is zero-based and must be less than parameter TotalSegments: "+ + "Segment: " + segment + " is not less than TotalSegments: " + totalSegments, 400);+ }++ String projectionExpressionScan = request.has("ProjectionExpression")+ ? request.get("ProjectionExpression").asText() : null;DynamoDbService.ScanResult result = dynamoDbService.scan(tableName, filterExpr, exprAttrNames, exprAttrValues, scanFilter, limit, exclusiveStartKey, region);+ List<JsonNode> scanItems = result.items();+ // Apply parallel scan segment partitioning+ if (segment != null && totalSegments != null && totalSegments > 1) {+ final int seg = segment, total = totalSegments;+ final List<JsonNode> allItems = scanItems;+ scanItems = new ArrayList<>();+ for (int si = 0; si < allItems.size(); si++) {+ if (si % total == seg) scanItems.add(allItems.get(si));+ }+ }+ // Apply index projection (KEYS_ONLY / INCLUDE) when scanning a secondary index+ if (indexNameScan != null && projectionExpressionScan == null) {+ TableDefinition scanTable = dynamoDbService.describeTable(tableName, region);+ scanItems = applyIndexProjection(scanItems, indexNameScan, scanTable, select);+ }+ JsonNode attributesToGetScan = request.has("AttributesToGet") ? request.get("AttributesToGet") : null;+ if (projectionExpressionScan != null) {+ scanItems = scanItems.stream()+ .map(i -> (JsonNode) ProjectionEvaluator.project(i, projectionExpressionScan, exprAttrNames))+ .toList();+ } else if (attributesToGetScan != null) {+ Set<String> keep = new HashSet<>();+ attributesToGetScan.forEach(n -> keep.add(n.asText()));+ scanItems = scanItems.stream()+ .map(i -> (JsonNode) ProjectionEvaluator.trimToAttributes((ObjectNode) i, keep))+ .toList();+ }+ObjectNode response = objectMapper.createObjectNode();- ArrayNode itemsArray = objectMapper.createArrayNode();- result.items().forEach(itemsArray::add);- response.set("Items", itemsArray);- response.put("Count", result.items().size());- response.put("ScannedCount", result.scannedCount());+ if ("COUNT".equals(select)) {+ response.put("Count", result.items().size());+ response.put("ScannedCount", result.scannedCount());+ } else {+ ArrayNode itemsArray = objectMapper.createArrayNode();+ scanItems.forEach(itemsArray::add);+ response.set("Items", itemsArray);+ response.put("Count", scanItems.size());+ response.put("ScannedCount", result.scannedCount());+ }if (result.lastEvaluatedKey() != null) {response.set("LastEvaluatedKey", result.lastEvaluatedKey());}- addConsumedCapacity(response, request, tableName, result.items().size(), false);+ addConsumedCapacity(response, request, tableName, scanItems.size(), false);return Response.ok(response).build();}private Response handleBatchWriteItem(JsonNode request, String region) {JsonNode requestItems = request.get("RequestItems");- if (requestItems == null || requestItems.isNull() || requestItems.isMissingNode()) {- return Response.ok(objectMapper.createObjectNode()- .set("UnprocessedItems", objectMapper.createObjectNode())).build();+ if (requestItems == null || requestItems.isNull() || requestItems.isMissingNode()+ || !requestItems.fields().hasNext()) {+ throw new AwsException("ValidationException",+ "The requestItems parameter is required for BatchWriteItem", 400);}Map<String, List<JsonNode>> items = new HashMap<>();Iterator<Map.Entry<String, JsonNode>> tables = requestItems.fields();@@ -421,6 +852,39 @@ public class DynamoDbJsonHandler {items.put(entry.getKey(), writes);}+ // Per-table check: max 25 write requests+ for (Map.Entry<String, List<JsonNode>> entry : items.entrySet()) {+ if (entry.getValue().size() > 25) {+ // Build a representation of the requestItems+ StringBuilder sb = new StringBuilder("{");+ sb.append(entry.getKey()).append("=[");+ List<String> reprs = new ArrayList<>();+ for (JsonNode w : entry.getValue()) {+ reprs.add(w.toString());+ }+ sb.append(String.join(", ", reprs)).append("]}");+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '" + sb + "' at 'requestItems' failed to satisfy constraint: "+ + "Map value must satisfy constraint: [Member must have length less than or equal to 25, "+ + "Member must have length greater than or equal to 1]", 400);+ }+ }++ for (Map.Entry<String, List<JsonNode>> entry : items.entrySet()) {+ TableDefinition bwTable = dynamoDbService.describeTable(entry.getKey(), region);+ Set<String> seen = new HashSet<>();+ for (JsonNode writeReq : entry.getValue()) {+ JsonNode keyNode = writeReq.has("PutRequest")+ ? writeReq.get("PutRequest").get("Item")+ : writeReq.get("DeleteRequest").get("Key");+ String key = dynamoDbService.buildItemKey(bwTable, keyNode);+ if (!seen.add(key)) {+ throw new AwsException("ValidationException",+ "Provided list of item keys contains duplicates", 400);+ }+ }+ }+dynamoDbService.batchWriteItem(items, region);ObjectNode response = objectMapper.createObjectNode();@@ -431,11 +895,10 @@ public class DynamoDbJsonHandler {private Response handleBatchGetItem(JsonNode request, String region) {JsonNode requestItems = request.get("RequestItems");- if (requestItems == null || requestItems.isNull() || requestItems.isMissingNode()) {- ObjectNode response = objectMapper.createObjectNode();- response.set("Responses", objectMapper.createObjectNode());- response.set("UnprocessedKeys", objectMapper.createObjectNode());- return Response.ok(response).build();+ if (requestItems == null || requestItems.isNull() || requestItems.isMissingNode()+ || !requestItems.fields().hasNext()) {+ throw new AwsException("ValidationException",+ "The requestItems parameter is required for BatchGetItem", 400);}Map<String, JsonNode> items = new HashMap<>();Iterator<Map.Entry<String, JsonNode>> tables = requestItems.fields();@@ -444,14 +907,59 @@ public class DynamoDbJsonHandler {items.put(entry.getKey(), entry.getValue());}+ // Per-table check: max 100 keys+ for (Map.Entry<String, JsonNode> entry : items.entrySet()) {+ JsonNode keysNode = entry.getValue().has("Keys") ? entry.getValue().get("Keys") : null;+ if (keysNode != null && keysNode.size() > 100) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value at 'RequestItems." + entry.getKey()+ + ".member.Keys' failed to satisfy constraint: "+ + "Member must have length less than or equal to 100", 400);+ }+ }++ for (Map.Entry<String, JsonNode> entry : items.entrySet()) {+ TableDefinition bgTable = dynamoDbService.describeTable(entry.getKey(), region);+ JsonNode keys = entry.getValue().get("Keys");+ if (keys == null || !keys.isArray()) continue;+ Set<String> seen = new HashSet<>();+ for (JsonNode key : keys) {+ String itemKey = dynamoDbService.buildItemKey(bgTable, key);+ if (!seen.add(itemKey)) {+ throw new AwsException("ValidationException",+ "Provided list of item keys contains duplicates", 400);+ }+ }+ }+DynamoDbService.BatchGetResult result = dynamoDbService.batchGetItem(items, region);ObjectNode response = objectMapper.createObjectNode();ObjectNode responses = objectMapper.createObjectNode();for (Map.Entry<String, List<JsonNode>> entry : result.responses().entrySet()) {+ String tblName = entry.getKey();+ JsonNode tableRequest = requestItems.get(tblName);+ String projExpr = tableRequest != null && tableRequest.has("ProjectionExpression")+ ? tableRequest.get("ProjectionExpression").asText() : null;+ JsonNode exprNames = tableRequest != null && tableRequest.has("ExpressionAttributeNames")+ ? tableRequest.get("ExpressionAttributeNames") : null;+ JsonNode attrToGet = tableRequest != null && tableRequest.has("AttributesToGet")+ ? tableRequest.get("AttributesToGet") : null;ArrayNode tableItems = objectMapper.createArrayNode();- entry.getValue().forEach(tableItems::add);- responses.set(entry.getKey(), tableItems);+ for (JsonNode item : entry.getValue()) {+ JsonNode projected;+ if (projExpr != null) {+ projected = ProjectionEvaluator.project(item, projExpr, exprNames);+ } else if (attrToGet != null) {+ Set<String> keep = new HashSet<>();+ attrToGet.forEach(n -> keep.add(n.asText()));+ projected = ProjectionEvaluator.trimToAttributes((ObjectNode) item, keep);+ } else {+ projected = item;+ }+ tableItems.add(projected);+ }+ responses.set(tblName, tableItems);}response.set("Responses", responses);response.set("UnprocessedKeys", objectMapper.createObjectNode());@@ -469,6 +977,12 @@ public class DynamoDbJsonHandler {writeCapacity = pt.has("WriteCapacityUnits") ? pt.get("WriteCapacityUnits").asLong() : null;}+ String billingModeCheck = request.has("BillingMode") ? request.get("BillingMode").asText() : null;+ if ("PAY_PER_REQUEST".equals(billingModeCheck) && !pt.isMissingNode()) {+ throw new AwsException("ValidationException",+ "ProvisionedThroughput cannot be specified when BillingMode is PAY_PER_REQUEST", 400);+ }+List<GlobalSecondaryIndex> gsiCreates = new ArrayList<>();List<String> gsiDeletes = new ArrayList<>();JsonNode gsiUpdates = request.path("GlobalSecondaryIndexUpdates");@@ -574,6 +1088,10 @@ public class DynamoDbJsonHandler {String tableName = request.path("TableName").asText();JsonNode spec = request.path("TimeToLiveSpecification");String ttlAttributeName = spec.path("AttributeName").asText();+ if (ttlAttributeName == null || ttlAttributeName.isBlank()) {+ throw new AwsException("ValidationException",+ "TimeToLiveSpecification.AttributeName must not be empty", 400);+ }boolean enabled = spec.path("Enabled").asBoolean(false);dynamoDbService.updateTimeToLive(tableName, ttlAttributeName, enabled, region);@@ -617,11 +1135,61 @@ public class DynamoDbJsonHandler {private Response handleTransactWriteItems(JsonNode request, String region) {JsonNode transactItemsNode = request.path("TransactItems");- List<JsonNode> transactItems = new ArrayList<>();- if (transactItemsNode.isArray()) {- transactItemsNode.forEach(transactItems::add);+ if (transactItemsNode.isMissingNode() || transactItemsNode.isNull() || !transactItemsNode.isArray()) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value null at 'transactItems' failed to satisfy constraint: "+ + "Member must have length greater than or equal to 1", 400);+ }+ if (transactItemsNode.isEmpty()) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '[]' at 'transactItems' failed to satisfy constraint: "+ + "Member must have length greater than or equal to 1", 400);+ }+ if (transactItemsNode.size() > 100) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '" + transactItemsNode + "' at 'transactItems' failed to satisfy constraint: "+ + "Member must have length less than or equal to 100", 400);+ }++ // Check 4MB total item size limit+ final int MAX_TRANSACTION_BYTES = 4 * 1024 * 1024;+ int totalSize = 0;+ for (JsonNode txItem : transactItemsNode) {+ JsonNode item = txItem.has("Put") ? txItem.get("Put").get("Item")+ : txItem.has("Update") ? txItem.get("Update").get("Key")+ : txItem.has("Delete") ? txItem.get("Delete").get("Key")+ : txItem.has("ConditionCheck") ? txItem.get("ConditionCheck").get("Key")+ : null;+ if (item != null) totalSize += DynamoDbItemSize.calculateItemSize(item);+ }+ if (totalSize > MAX_TRANSACTION_BYTES) {+ throw new AwsException("ValidationException",+ "Transaction failed: The total size of all items in the transaction request cannot exceed 4 MB", 400);+ }++ Map<String, TableDefinition> tableCache = new HashMap<>();+ Set<String> seen = new HashSet<>();+ for (JsonNode txItem : transactItemsNode) {+ JsonNode op = txItem.has("Put") ? txItem.get("Put")+ : txItem.has("Delete") ? txItem.get("Delete")+ : txItem.has("Update") ? txItem.get("Update")+ : txItem.has("ConditionCheck") ? txItem.get("ConditionCheck") : null;+ if (op == null) continue;+ String opTable = op.path("TableName").asText();+ TableDefinition txTable = tableCache.computeIfAbsent(opTable,+ tn -> dynamoDbService.describeTable(tn, region));+ JsonNode keyNode = op.has("Item") ? op.get("Item") : op.get("Key");+ if (keyNode == null) continue;+ String key = region + "::" + opTable + "::" + dynamoDbService.buildItemKey(txTable, keyNode);+ if (!seen.add(key)) {+ throw new AwsException("ValidationException",+ "Transaction request cannot include multiple operations on one item", 400);+ }}+ List<JsonNode> transactItems = new ArrayList<>();+ transactItemsNode.forEach(transactItems::add);+// ClientRequestToken makes TransactWriteItems idempotent within ~10 minutes.// Forward the token and the raw request body so the service can hash the body// and reject replays whose parameters changed.@@ -637,10 +1205,13 @@ public class DynamoDbJsonHandler {body.put("__type", "TransactionCanceledException");body.put("message", e.getMessage());ArrayNode reasons = body.putArray("CancellationReasons");- for (String reason : e.getCancellationReasons()) {+ for (TransactionCanceledException.CancellationReason reason : e.getCancellationReasons()) {ObjectNode r = objectMapper.createObjectNode();- r.put("Code", reason.isEmpty() ? "None" : "ConditionalCheckFailed");- r.put("Message", reason);+ r.put("Code", reason.code().isEmpty() ? "None" : reason.code());+ r.put("Message", reason.code().isEmpty() ? "" : "The conditional request failed");+ if (reason.item() != null) {+ r.set("Item", reason.item());+ }reasons.add(r);}return Response.status(400).entity(body).build();@@ -649,12 +1220,80 @@ public class DynamoDbJsonHandler {private Response handleTransactGetItems(JsonNode request, String region) {JsonNode transactItemsNode = request.path("TransactItems");- List<JsonNode> transactItems = new ArrayList<>();- if (transactItemsNode.isArray()) {- transactItemsNode.forEach(transactItems::add);+ if (transactItemsNode.isMissingNode() || transactItemsNode.isNull() || !transactItemsNode.isArray()) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value null at 'transactItems' failed to satisfy constraint: "+ + "Member must have length greater than or equal to 1", 400);+ }+ if (transactItemsNode.isEmpty()) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '[]' at 'transactItems' failed to satisfy constraint: "+ + "Member must have length greater than or equal to 1", 400);+ }+ if (transactItemsNode.size() > 100) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '" + transactItemsNode + "' at 'transactItems' failed to satisfy constraint: "+ + "Member must have length less than or equal to 100", 400);+ }++ Map<String, TableDefinition> tableCache = new HashMap<>();+ Set<String> seenGet = new HashSet<>();+ for (JsonNode txItem : transactItemsNode) {+ JsonNode get = txItem.has("Get") ? txItem.get("Get") : null;+ if (get == null) continue;+ String opTable = get.path("TableName").asText();+ TableDefinition txTable = tableCache.computeIfAbsent(opTable,+ tn -> dynamoDbService.describeTable(tn, region));+ JsonNode keyNode = get.get("Key");+ if (keyNode == null) continue;+ try {+ String key = region + "::" + opTable + "::" + dynamoDbService.buildItemKey(txTable, keyNode);+ if (!seenGet.add(key)) {+ throw new AwsException("ValidationException",+ "Transaction request cannot include multiple operations on one item", 400);+ }+ } catch (AwsException e) {+ if ("Transaction request cannot include multiple operations on one item".equals(e.getMessage())) {+ throw e;+ }+ // Per-action validation error - will be surfaced via TransactionCanceledException in transactGetItems+ }+ }++ // Validate ProjectionExpression syntax in each Get action before executing+ for (JsonNode txItem : transactItemsNode) {+ JsonNode get = txItem.has("Get") ? txItem.get("Get") : null;+ if (get == null) continue;+ String pe = get.has("ProjectionExpression") ? get.get("ProjectionExpression").asText() : null;+ if (pe != null) {+ ProjectionEvaluator.validateSyntax(pe, "ProjectionExpression");+ }}- List<JsonNode> results = dynamoDbService.transactGetItems(transactItems, region);+ List<JsonNode> transactItems = new ArrayList<>();+ transactItemsNode.forEach(transactItems::add);++ List<JsonNode> results;+ try {+ results = dynamoDbService.transactGetItems(transactItems, region);+ } catch (TransactionCanceledException e) {+ ObjectNode body = objectMapper.createObjectNode();+ body.put("__type", "TransactionCanceledException");+ body.put("message", e.getMessage());+ ArrayNode reasons = body.putArray("CancellationReasons");+ for (TransactionCanceledException.CancellationReason reason : e.getCancellationReasons()) {+ ObjectNode r = objectMapper.createObjectNode();+ r.put("Code", reason.code().isEmpty() ? "None" : reason.code());+ if (!reason.code().isEmpty()) {+ r.put("Message", "");+ }+ if (reason.item() != null) {+ r.set("Item", reason.item());+ }+ reasons.add(r);+ }+ return Response.status(400).entity(body).build();+ }ObjectNode response = objectMapper.createObjectNode();ArrayNode responsesArray = objectMapper.createArrayNode();@@ -669,8 +1308,20 @@ public class DynamoDbJsonHandler {return Response.ok(response).build();}+ private static final java.util.regex.Pattern DYNAMODB_TABLE_ARN_PATTERN =+ java.util.regex.Pattern.compile(+ "^arn:aws:dynamodb:[a-z0-9-]+:\\d{12}:table/[a-zA-Z0-9._-]+$");++ private static boolean isValidDynamoDbTableArn(String arn) {+ return arn != null && DYNAMODB_TABLE_ARN_PATTERN.matcher(arn).matches();+ }+private Response handleTagResource(JsonNode request, String region) {String resourceArn = request.path("ResourceArn").asText();+ if (!isValidDynamoDbTableArn(resourceArn)) {+ throw new AwsException("ValidationException",+ "Invalid ResourceArn: " + resourceArn, 400);+ }Map<String, String> tags = new HashMap<>();JsonNode tagsNode = request.path("Tags");if (tagsNode.isArray()) {@@ -697,7 +1348,17 @@ public class DynamoDbJsonHandler {private Response handleListTagsOfResource(JsonNode request, String region) {String resourceArn = request.path("ResourceArn").asText();- Map<String, String> tags = dynamoDbService.listTagsOfResource(resourceArn, region);+ Map<String, String> tags;+ try {+ tags = dynamoDbService.listTagsOfResource(resourceArn, region);+ } catch (AwsException e) {+ if ("ResourceNotFoundException".equals(e.getErrorCode())) {+ throw new AwsException("AccessDeniedException",+ "User is not authorized to perform: dynamodb:ListTagsOfResource on resource: "+ + resourceArn, 400);+ }+ throw e;+ }ObjectNode response = objectMapper.createObjectNode();ArrayNode tagsArray = objectMapper.createArrayNode();@@ -812,6 +1473,164 @@ public class DynamoDbJsonHandler {* Builds a ConsumedCapacity node if the request includes ReturnConsumedCapacity.* Uses simple estimates: 0.5 RCU per item read, 1.0 WCU per item written.*/+ private void validateItemSets(JsonNode item) {+ if (item == null || !item.isObject()) return;+ item.fields().forEachRemaining(entry -> {+ JsonNode attr = entry.getValue();+ checkAttrSets(attr);+ });+ }++ private void checkAttrSets(JsonNode attr) {+ if (attr == null) return;+ if (attr.has("NULL") && !attr.get("NULL").asBoolean()) {+ throw new AwsException("ValidationException",+ "One or more parameter values were invalid: Null attribute value types must have the value of true", 400);+ }+ if (attr.has("SS")) {+ JsonNode ss = attr.get("SS");+ if (ss.isEmpty()) throw new AwsException("ValidationException",+ "One or more parameter values were invalid: An string set may not be empty", 400);+ Set<String> seen = new HashSet<>();+ for (JsonNode e : ss) {+ if (!seen.add(e.asText())) throw new AwsException("ValidationException",+ "One or more parameter values were invalid: Input collection " + formatSetForError(ss) + " contains duplicates.", 400);+ }+ } else if (attr.has("NS")) {+ JsonNode ns = attr.get("NS");+ if (ns.isEmpty()) throw new AwsException("ValidationException",+ "One or more parameter values were invalid: An number set may not be empty", 400);+ Set<String> seen = new HashSet<>();+ for (JsonNode e : ns) {+ if (!seen.add(e.asText())) throw new AwsException("ValidationException",+ "One or more parameter values were invalid: Input collection " + formatSetForError(ns) + " contains duplicates.", 400);+ }+ } else if (attr.has("BS")) {+ JsonNode bs = attr.get("BS");+ if (bs.isEmpty()) throw new AwsException("ValidationException",+ "One or more parameter values were invalid: Binary sets should not be empty", 400);+ Set<String> seen = new HashSet<>();+ for (JsonNode e : bs) {+ if (!seen.add(e.asText())) throw new AwsException("ValidationException",+ "One or more parameter values were invalid: Input collection " + formatSetForError(bs) + " contains duplicates.", 400);+ }+ } else if (attr.has("M")) {+ attr.get("M").fields().forEachRemaining(e -> checkAttrSets(e.getValue()));+ } else if (attr.has("L")) {+ attr.get("L").forEach(this::checkAttrSets);+ }+ }++ // ── Expression token utilities ──++ private static void extractPrefixedTokens(String expr, char prefix, Set<String> out) {+ if (expr == null) return;+ int i = 0;+ while (i < expr.length()) {+ if (expr.charAt(i) == prefix) {+ int start = i++;+ while (i < expr.length() && (Character.isLetterOrDigit(expr.charAt(i)) || expr.charAt(i) == '_')) i++;+ if (i > start + 1) out.add(expr.substring(start, i));+ } else {+ i++;+ }+ }+ }++ private static Set<String> extractHashTokens(String... expressions) {+ Set<String> tokens = new LinkedHashSet<>();+ for (String expr : expressions) extractPrefixedTokens(expr, '#', tokens);+ return tokens;+ }++ private static Set<String> extractColonTokens(String... expressions) {+ Set<String> tokens = new LinkedHashSet<>();+ for (String expr : expressions) extractPrefixedTokens(expr, ':', tokens);+ return tokens;+ }++ private static void checkUnusedEan(JsonNode exprAttrNames, Set<String> usedHashTokens) {+ if (exprAttrNames == null) return;+ List<String> unused = new ArrayList<>();+ exprAttrNames.fieldNames().forEachRemaining(k -> {+ if (!usedHashTokens.contains(k)) unused.add(k);+ });+ if (!unused.isEmpty()) {+ throw new AwsException("ValidationException",+ "Value provided in ExpressionAttributeNames unused in expressions: keys: {"+ + String.join(", ", unused) + "}", 400);+ }+ }++ private static void checkUnusedEav(JsonNode exprAttrValues, Set<String> usedColonTokens) {+ if (exprAttrValues == null) return;+ List<String> unused = new ArrayList<>();+ exprAttrValues.fieldNames().forEachRemaining(k -> {+ if (!usedColonTokens.contains(k)) unused.add(k);+ });+ if (!unused.isEmpty()) {+ throw new AwsException("ValidationException",+ "Value provided in ExpressionAttributeValues unused in expressions: keys: {"+ + String.join(", ", unused) + "}", 400);+ }+ }++ private String formatSetForError(JsonNode arr) {+ StringBuilder sb = new StringBuilder("[");+ boolean first = true;+ for (JsonNode e : arr) {+ if (!first) sb.append(", ");+ sb.append(e.asText());+ first = false;+ }+ sb.append("]");+ return sb.toString();+ }++ // Filters items to only include the attributes projected into the given index.+ // Returns items unchanged when projectionType is ALL or no matching index is found.+ private List<JsonNode> applyIndexProjection(List<JsonNode> items, String indexName,+ TableDefinition table, String select) {+ if (indexName == null || "ALL_ATTRIBUTES".equals(select)) return items;++ String projectionType = "ALL";+ List<String> nonKeyAttributes = new ArrayList<>();+ Set<String> indexKeyNames = new HashSet<>();++ for (GlobalSecondaryIndex gsi : table.getGlobalSecondaryIndexes()) {+ if (gsi.getIndexName().equals(indexName)) {+ projectionType = gsi.getProjectionType() != null ? gsi.getProjectionType() : "ALL";+ nonKeyAttributes = gsi.getNonKeyAttributes() != null ? gsi.getNonKeyAttributes() : List.of();+ gsi.getKeySchema().forEach(k -> indexKeyNames.add(k.getAttributeName()));+ break;+ }+ }+ for (LocalSecondaryIndex lsi : table.getLocalSecondaryIndexes()) {+ if (lsi.getIndexName().equals(indexName)) {+ projectionType = lsi.getProjectionType() != null ? lsi.getProjectionType() : "ALL";+ nonKeyAttributes = lsi.getNonKeyAttributes() != null ? lsi.getNonKeyAttributes() : List.of();+ lsi.getKeySchema().forEach(k -> indexKeyNames.add(k.getAttributeName()));+ break;+ }+ }++ if ("ALL".equals(projectionType)) return items;++ Set<String> allowed = new HashSet<>(indexKeyNames);+ allowed.add(table.getPartitionKeyName());+ String sortKeyName = table.getSortKeyName();+ if (sortKeyName != null) allowed.add(sortKeyName);+ if ("INCLUDE".equals(projectionType)) allowed.addAll(nonKeyAttributes);++ return items.stream().map(item -> {+ ObjectNode filtered = objectMapper.createObjectNode();+ item.fields().forEachRemaining(e -> {+ if (allowed.contains(e.getKey())) filtered.set(e.getKey(), e.getValue());+ });+ return (JsonNode) filtered;+ }).toList();+ }+private void addConsumedCapacity(ObjectNode response, JsonNode request, String tableName,int itemCount, boolean isWrite) {String returnCC = request.path("ReturnConsumedCapacity").asText("NONE");diff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbNumberUtils.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbNumberUtils.javanew file mode 100644index 0000000000..7f95327ed7--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbNumberUtils.java@@ -0,0 +1,132 @@+package io.github.hectorvent.floci.services.dynamodb;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.node.ArrayNode;+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.Iterator;+import java.util.Map;++/**+ * DynamoDB number validation and normalization.+ * Numbers must have <= 38 significant digits, be within range, and are stored+ * in normalized form (no leading zeros, no trailing decimal zeros, -0 -> 0).+ */+final class DynamoDbNumberUtils {++ private static final BigDecimal MAX_ABS = new BigDecimal("1E+126");+ private static final BigDecimal MIN_ABS_NONZERO = new BigDecimal("1E-130");++ private DynamoDbNumberUtils() {}++ /**+ * Validates and normalizes a DynamoDB number string.+ * Throws ValidationException if the number is out of range or has too many significant digits.+ * Returns the normalized string (no leading zeros, no trailing decimal zeros).+ */+ static String validateAndNormalize(String numStr) {+ if (numStr == null || numStr.isEmpty()) {+ throw new AwsException("ValidationException",+ "The parameter cannot be converted to a numeric value", 400);+ }+ BigDecimal bd;+ try {+ bd = new BigDecimal(numStr);+ } catch (NumberFormatException e) {+ throw new AwsException("ValidationException",+ "The parameter cannot be converted to a numeric value: " + numStr, 400);+ }++ BigDecimal stripped = bd.stripTrailingZeros();++ // Check significant digits after normalization+ if (stripped.precision() > 38) {+ throw new AwsException("ValidationException",+ "Number too many significant digits; first supported is 1E-130 last supported is 1E+126", 400);+ }++ // Check range (only for nonzero values)+ BigDecimal abs = stripped.abs();+ if (abs.compareTo(BigDecimal.ZERO) > 0) {+ if (abs.compareTo(MAX_ABS) >= 0) {+ throw new AwsException("ValidationException",+ "Number overflow. Attempting to store a value that is too large. "+ + "The maximum allowed positive value is 9.9999999999999999999999999999999999999E+125", 400);+ }+ if (abs.compareTo(MIN_ABS_NONZERO) < 0) {+ throw new AwsException("ValidationException",+ "Number underflow. Attempting to store a value that is too small. "+ + "The minimum allowed positive value is 1E-130", 400);+ }+ }++ return toNormalizedString(stripped);+ }++ private static String toNormalizedString(BigDecimal bd) {+ // -0 -> 0+ if (bd.compareTo(BigDecimal.ZERO) == 0) {+ return "0";+ }+ // Use plain string to expand scientific notation to decimal form when reasonable+ return bd.toPlainString();+ }++ /**+ * Recursively normalizes all N-type number attribute values in the given item.+ * Returns a new ObjectNode with normalized values. Input must be a DynamoDB item+ * where attribute values are DynamoDB typed values (e.g. {S: "x"}, {N: "42"}).+ */+ static ObjectNode normalizeNumbersInItem(JsonNode item) {+ if (item == null || !item.isObject()) return (ObjectNode) item;+ ObjectNode result = JsonNodeFactory.instance.objectNode();+ item.fields().forEachRemaining(entry -> {+ result.set(entry.getKey(), normalizeAttrValue(entry.getValue()));+ });+ return result;+ }++ private static JsonNode normalizeAttrValue(JsonNode attr) {+ if (attr == null) return null;++ if (attr.has("N")) {+ String raw = attr.get("N").asText();+ String normalized = validateAndNormalize(raw);+ ObjectNode result = JsonNodeFactory.instance.objectNode();+ result.put("N", normalized);+ return result;+ }++ if (attr.has("NS")) {+ // Normalize and validate each element+ ObjectNode result = JsonNodeFactory.instance.objectNode();+ ArrayNode ns = JsonNodeFactory.instance.arrayNode();+ for (JsonNode elem : attr.get("NS")) {+ ns.add(validateAndNormalize(elem.asText()));+ }+ result.set("NS", ns);+ return result;+ }++ if (attr.has("M")) {+ ObjectNode result = JsonNodeFactory.instance.objectNode();+ result.set("M", normalizeNumbersInItem(attr.get("M")));+ return result;+ }++ if (attr.has("L")) {+ ObjectNode result = JsonNodeFactory.instance.objectNode();+ ArrayNode list = JsonNodeFactory.instance.arrayNode();+ for (JsonNode elem : attr.get("L")) {+ list.add(normalizeAttrValue(elem));+ }+ result.set("L", list);+ return result;+ }++ return attr;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbReservedWords.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbReservedWords.javanew file mode 100644index 0000000000..8df79537ad--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbReservedWords.java@@ -0,0 +1,161 @@+package io.github.hectorvent.floci.services.dynamodb;++import io.github.hectorvent.floci.core.common.AwsException;++import java.util.ArrayList;+import java.util.List;+import java.util.Set;++/**+ * Validates that DynamoDB expressions do not use reserved words as bare attribute names.+ */+final class DynamoDbReservedWords {++ private DynamoDbReservedWords() {}++ // Expression clause/operator keywords that are syntactically valid as operators+ // and should not be treated as attribute name tokens.+ private static final Set<String> CLAUSE_KEYWORDS = Set.of(+ "SET", "REMOVE", "ADD", "DELETE",+ "AND", "OR", "NOT", "BETWEEN", "IN",+ "TRUE", "FALSE"+ );++ // Full DynamoDB reserved words list (uppercase)+ private static final Set<String> RESERVED = Set.of(+ "ABORT", "ABSOLUTE", "ACTION", "ADD", "AFTER", "AGENT", "ALL", "ALLOCATE",+ "ALTER", "ANALYZE", "AND", "ANY", "ARCHIVE", "ARE", "ARRAY", "AS", "ASC",+ "ASCII", "ASENSITIVE", "ASSERTION", "ASYMMETRIC", "AT", "ATOMIC", "ATTACH",+ "ATTRIBUTE", "AUTH", "AUTHORIZATION", "AUTHORIZE", "AUTO",+ "BETWEEN", "BIGINT", "BINARY", "BIT", "BLOB", "BLOCK", "BOOLEAN", "BOTH",+ "BREADTH", "BUCKET", "BULK", "BY",+ "CALL", "CALLED", "CANCEL", "CASCADE", "CASE", "CAST", "CATALOG", "CHAR",+ "CHARACTER", "CHECK", "CLASS", "CLOB", "CLOSE", "CLUSTER", "CLUSTERED",+ "CLUSTERING", "CLUSTERS", "COALESCE", "COLLATE", "COLLATION", "COLUMN",+ "COLUMNS", "COMBINE", "COMMENT", "COMMIT", "COMPACT", "COMPILE", "COMPRESS",+ "CONDITION", "CONFLICT", "CONNECT", "CONNECTION", "CONSISTENCY", "CONSISTENT",+ "CONSTRAINT", "CONSTRAINTS", "CONSTRUCTOR", "CONSUMED", "CONTINUE", "CONVERT",+ "COPY", "CORRESPONDING", "COUNT", "COUNTER", "CREATE", "CROSS", "CUBE",+ "CURRENT", "CURSOR", "CYCLE",+ "DATA", "DATABASE", "DATE", "DATETIME", "DAY", "DEALLOCATE", "DEC", "DECIMAL",+ "DECLARE", "DEFAULT", "DEFERRABLE", "DEFERRED", "DEFINE", "DEFINED",+ "DEFINITION", "DELETE", "DELIMITED", "DEPTH", "DEREF", "DESC", "DESCRIBE",+ "DESCRIPTOR", "DETACH", "DETERMINISTIC", "DIAGNOSTICS", "DIRECTORIES",+ "DISABLE", "DISCONNECT", "DISTINCT", "DISTRIBUTE", "DO", "DOMAIN", "DOUBLE",+ "DROP", "DUMP", "DURATION", "DYNAMIC",+ "EACH", "ELEMENT", "ELSE", "ELSEIF", "EMPTY", "ENABLE", "END", "EQUALS",+ "ERROR", "ESCAPE", "EVALUATED", "EXCEPT", "EXCEPTION", "EXCEPTIONS",+ "EXCLUSIVE", "EXEC", "EXECUTE", "EXISTS", "EXIT", "EXPLAIN", "EXPLODE",+ "EXPORT", "EXTENDED", "EXTERNAL",+ "FALSE", "FETCH", "FILTER", "FIRST", "FIXED", "FLATTERN", "FLOAT", "FOR",+ "FORCE", "FOREIGN", "FORMAT", "FORWARD", "FOUND", "FREE", "FROM", "FULL",+ "FUNCTION", "FUNCTIONS",+ "GENERAL", "GENERATE", "GET", "GLOB", "GO", "GOTO", "GRANT", "GREATER",+ "GROUP", "GROUPING",+ "HANDLER", "HASH", "HAVE", "HAVING", "HEAP", "HIDDEN", "HOLD", "HOW",+ "IDENTIFIED", "IDENTITY", "IF", "IGNORE", "IMMEDIATE", "IN", "INCLUDING",+ "INCLUSIVE", "INCREMENT", "INCREMENTAL", "INDEX", "INDEXES", "INDICATOR",+ "INFINITE", "INITIALLY", "INLINE", "INNER", "INNTER", "INOUT", "INSERT",+ "INSTEAD", "INT", "INTEGER", "INTERSECT", "INTERVAL", "INTO", "INVALIDATE",+ "IS", "ISOLATION", "ITEM", "ITEMS", "ITERATE",+ "JOIN",+ "KEY", "KEYS",+ "LAG", "LANGUAGE", "LARGE", "LAST", "LATERAL", "LEAD", "LEADING", "LEAVE",+ "LEFT", "LENGTH", "LESS", "LEVEL", "LIKE", "LIMIT", "LIMITED", "LINES",+ "LIST", "LOAD", "LOCAL", "LOCALTIME", "LOCALTIMESTAMP", "LOCATION", "LOCATOR",+ "LOCK", "LOCKS", "LOG", "LOGED", "LONG", "LOOP", "LOWER",+ "MAP", "MATCH", "MATERIALIZED", "MAX", "MAXLEN", "MERGE", "METADATA", "MIN",+ "MINUS", "MODIFIES", "MODIFY", "MODULE", "MONTH", "MULTI", "MULTISET",+ "NAME", "NAMES", "NATIONAL", "NATURAL", "NCHAR", "NCLOB", "NEW", "NEXT",+ "NO", "NONE", "NOT", "NULL", "NULLIF", "NUMBER", "NUMERIC",+ "OBJECT", "OF", "OFFLINE", "OFFSET", "OLD", "ON", "ONLINE", "ONLY",+ "OPAQUE", "OPEN", "OPERATOR", "OPTION", "OR", "ORDER", "ORDINALITY",+ "OTHER", "OTHERS", "OUT", "OUTER", "OVER", "OVERLAPS", "OVERRIDE", "OWNER",+ "PAD", "PARALLEL", "PARAMETER", "PARAMETERS", "PARTIAL", "PARTITION",+ "PASSWORD", "PATH", "PERCENT", "PERCENTILE", "PERMISSION", "PERMISSIONS",+ "PIPE", "PIPELINED", "PLAN", "POOL", "POSITION", "PRECISION", "PREPARE",+ "PRIMARY", "PRIOR", "PRIVILEGES", "PROCEDURE", "PROCESSED", "PROJECT",+ "PROJECTION", "PROJECTIONS", "PROTO", "PULL", "PUT",+ "QUERY", "QUIT", "QUORUM",+ "RAISE", "RANDOM", "RANGE", "RANK", "RAW", "READ", "READS", "REAL",+ "REBUILD", "RECORD", "RECURSIVE", "REDUCE", "REF", "REFERENCE", "REFERENCES",+ "REFERENCING", "REGEXP", "REGION", "REINDEX", "RELATIVE", "RELEASE",+ "REMAINDER", "RENAME", "REPEAT", "REPLACE", "REQUEST", "RESET", "RESIGNAL",+ "RESOURCE", "RESPONSE", "RESTORE", "RESTRICT", "RESULT", "RETURN",+ "RETURNING", "RETURNS", "REVERSE", "REVOKE", "RIGHT", "ROLE", "ROLES",+ "ROLLBACK", "ROLLUP", "ROUTINE", "ROW", "ROWS", "RULE",+ "SAVEPOINT", "SCAN", "SCHEMA", "SCOPE", "SCROLL", "SEARCH", "SECOND",+ "SECTION", "SEGMENT", "SEGMENTS", "SELECT", "SELF", "SEMI", "SENSITIVE",+ "SEQUENCE", "SERIALIZABLE", "SESSION", "SET", "SETS", "SIGNAL", "SIMILAR",+ "SIZE", "SKEWED", "SMALLINT", "SNAPSHOT", "SOME", "SOURCE", "SPACE",+ "SPACES", "SPARSE", "SPECIFIC", "SPECIFICTYPE", "SPLIT", "SQL", "SQLCODE",+ "SQLERROR", "SQLEXCEPTION", "SQLSTATE", "SQLWARNING", "START", "STATE",+ "STATIC", "STATUS", "STORAGE", "STORE", "STORED", "STREAM", "STRING",+ "STRUCT", "STYLE", "SUB", "SUBMULTISET", "SUBPAGES", "SUBSTRING", "SUM",+ "SYMMETRIC", "SYSTEM",+ "TABLE", "TABLESAMPLE", "TEMP", "TEMPORARY", "TERMINATED", "TEXT", "THAN",+ "THEN", "THROUGHPUT", "TINYINT", "TO", "TOKEN", "TOTAL", "TOUCH",+ "TRAILING", "TRANSACTION", "TRANSFORM", "TRANSLATE", "TRANSLATION", "TREAT",+ "TRIGGER", "TRIM", "TRUE", "TRUNCATE", "TTL", "TUPLE", "TYPE",+ "UNDER", "UNDO", "UNION", "UNIQUE", "UNIT", "UNKNOWN", "UNLOGGED",+ "UNNEST", "UNPROCESSED", "UNSIGNED", "UNTIL", "UPDATE", "UPPER", "URL",+ "USAGE", "USE", "USER", "UUID",+ "VACUUM", "VALUE", "VALUED", "VALUES", "VARCHAR", "VARIABLE", "VARIANCE",+ "VARYING", "VIEW", "VIEWS", "VIRTUAL", "VOID",+ "WAIT", "WHEN", "WHERE", "WHILE", "WINDOW", "WITH", "WITHIN", "WITHOUT",+ "WRITE",+ "YEAR",+ "ZONE"+ );++ /**+ * Validates that the expression does not use any reserved words as bare attribute names.+ * Throws ValidationException if a reserved word is found without a # alias.+ */+ static void check(String expression, String expressionType) {+ if (expression == null || expression.isBlank()) return;+ List<String> bareIdents = extractBareIdentifiers(expression);+ for (String ident : bareIdents) {+ String upper = ident.toUpperCase();+ if (CLAUSE_KEYWORDS.contains(upper)) continue;+ if (RESERVED.contains(upper)) {+ throw new AwsException("ValidationException",+ "Invalid " + expressionType + ": Attribute name is a reserved keyword; "+ + "reserved word: " + ident, 400);+ }+ }+ }++ private static List<String> extractBareIdentifiers(String expr) {+ List<String> result = new ArrayList<>();+ int i = 0;+ int len = expr.length();+ while (i < len) {+ char c = expr.charAt(i);+ if (c == '#' || c == ':') {+ // Skip alias or value ref+ i++;+ while (i < len && isIdentChar(expr.charAt(i))) i++;+ } else if (Character.isLetter(c) || c == '_') {+ int start = i;+ while (i < len && isIdentChar(expr.charAt(i))) i++;+ String word = expr.substring(start, i);+ // Skip whitespace to check if followed by '('+ int j = i;+ while (j < len && expr.charAt(j) == ' ') j++;+ if (j < len && expr.charAt(j) == '(') {+ // Function call — skip+ } else {+ result.add(word);+ }+ } else {+ i++;+ }+ }+ return result;+ }++ private static boolean isIdentChar(char c) {+ return Character.isLetterOrDigit(c) || c == '_';+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbService.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbService.javaindex ea9d22cfba..b37fb50a43 100644--- a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbService.java+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbService.java@@ -34,10 +34,13 @@ import java.util.ArrayList;import java.util.Collections;import java.util.Comparator;import java.util.HashMap;+import java.util.HashSet;import java.util.HexFormat;+import java.util.LinkedHashSet;import java.util.Iterator;import java.util.List;import java.util.Map;+import java.util.Set;import java.util.TreeMap;import java.util.UUID;import java.util.concurrent.ConcurrentHashMap;@@ -194,6 +197,98 @@ public class DynamoDbService {"Table already exists: " + tableName, 400);}+ if (keySchema == null || keySchema.isEmpty()) {+ throw new AwsException("ValidationException",+ "No defined attribute for index key schema: hash or range", 400);+ }++ // Validate KeyType values+ for (int i = 0; i < keySchema.size(); i++) {+ String keyType = keySchema.get(i).getKeyType();+ if (!"HASH".equals(keyType) && !"RANGE".equals(keyType)) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '" + keyType+ + "' at 'keySchema." + (i + 1) + ".member.keyType' failed to satisfy constraint: "+ + "Member must satisfy enum value set: [HASH, RANGE]", 400);+ }+ }++ // Validate keySchema size <= 2+ if (keySchema.size() > 2) {+ String repr = "[" + keySchema.stream()+ .map(k -> "KeySchemaElement(attributeName=" + k.getAttributeName() + ", keyType=" + k.getKeyType() + ")")+ .collect(java.util.stream.Collectors.joining(", ")) + "]";+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '" + repr + "' at 'keySchema' failed to satisfy constraint: "+ + "Member must have length less than or equal to 2", 400);+ }++ // Validate no duplicate attribute names in keySchema+ Set<String> keySchemaAttrNames = new HashSet<>();+ for (KeySchemaElement k : keySchema) {+ if (!keySchemaAttrNames.add(k.getAttributeName())) {+ throw new AwsException("ValidationException",+ "Invalid KeySchema: Some index key attribute have no definition", 400);+ }+ }++ // Validate AttributeType values+ if (attributeDefinitions != null) {+ for (int i = 0; i < attributeDefinitions.size(); i++) {+ String attrType = attributeDefinitions.get(i).getAttributeType();+ if (!"B".equals(attrType) && !"N".equals(attrType) && !"S".equals(attrType)) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '" + attrType+ + "' at 'attributeDefinitions." + (i + 1) + ".member.attributeType' failed to satisfy constraint: "+ + "Member must satisfy enum value set: [B, N, S]", 400);+ }+ }+ }++ Set<String> referencedAttrs = new HashSet<>();+ keySchema.forEach(k -> referencedAttrs.add(k.getAttributeName()));+ if (gsis != null) {+ gsis.forEach(g -> g.getKeySchema().forEach(k -> referencedAttrs.add(k.getAttributeName())));+ }+ if (lsis != null) {+ lsis.forEach(l -> l.getKeySchema().forEach(k -> referencedAttrs.add(k.getAttributeName())));+ }+ if (attributeDefinitions != null) {+ for (AttributeDefinition ad : attributeDefinitions) {+ if (!referencedAttrs.contains(ad.getAttributeName())) {+ throw new AwsException("ValidationException",+ "Invalid attribute: " + ad.getAttributeName()+ + " is defined in AttributeDefinitions but is not used in any key schema", 400);+ }+ }+ }++ boolean tableHasSortKey = keySchema.stream().anyMatch(k -> "RANGE".equals(k.getKeyType()));+ if (lsis != null && !lsis.isEmpty() && !tableHasSortKey) {+ throw new AwsException("ValidationException",+ "One or more parameter values were invalid: Table KeySchema does not have a range key, "+ + "which is required when specifying a LocalSecondaryIndex", 400);+ }++ // Validate no duplicate index names+ Set<String> indexNames = new HashSet<>();+ if (gsis != null) {+ for (GlobalSecondaryIndex gsi : gsis) {+ if (!indexNames.add(gsi.getIndexName())) {+ throw new AwsException("ValidationException",+ "One or more parameter values were invalid: Duplicate index name: " + gsi.getIndexName(), 400);+ }+ }+ }+ if (lsis != null) {+ for (LocalSecondaryIndex lsi : lsis) {+ if (!indexNames.add(lsi.getIndexName())) {+ throw new AwsException("ValidationException",+ "One or more parameter values were invalid: Duplicate index name: " + lsi.getIndexName(), 400);+ }+ }+ }+TableDefinition table = new TableDefinition(tableName, keySchema, attributeDefinitions,region, regionResolver.getAccountId());if (readCapacity != null && writeCapacity != null) {@@ -280,9 +375,34 @@ public class DynamoDbService {String prefix = region + "::";return tableStore.scan(k -> k.startsWith(prefix)).stream().map(TableDefinition::getTableName)+ .sorted().toList();}+ public ListTablesResult listTables(String region, Integer limit, String exclusiveStartTableName) {+ List<String> all = listTables(region);++ int startIdx = 0;+ if (exclusiveStartTableName != null && !exclusiveStartTableName.isBlank()) {+ int pos = Collections.binarySearch(all, exclusiveStartTableName);+ if (pos >= 0) {+ startIdx = pos + 1;+ } else {+ startIdx = -(pos + 1);+ }+ }++ List<String> page = all.subList(startIdx, all.size());+ String lastEvaluatedTableName = null;+ if (limit != null && limit > 0 && page.size() > limit) {+ lastEvaluatedTableName = page.get(limit - 1);+ page = page.subList(0, limit);+ }+ return new ListTablesResult(List.copyOf(page), lastEvaluatedTableName);+ }++ public record ListTablesResult(List<String> tableNames, String lastEvaluatedTableName) {}+public void putItem(String tableName, JsonNode item) {putItem(tableName, item, null, null, null, regionResolver.getDefaultRegion(), "NONE");}@@ -300,7 +420,10 @@ public class DynamoDbService {TableDefinition table = tableStore.get(storageKey).orElseThrow(() -> resourceNotFoundException(canonicalTableName));- String itemKey = buildItemKey(table, item);+ // Validate and normalize all number attributes before storage+ final JsonNode normalizedItem = DynamoDbNumberUtils.normalizeNumbersInItem(item);+ DynamoDbItemSize.validateSize(normalizedItem);+ String itemKey = buildItemKey(table, normalizedItem);withItemLock(storageKey, itemKey, () -> {var tableItems = itemsByTable.computeIfAbsent(storageKey, k -> new ConcurrentSkipListMap<>());@@ -311,7 +434,7 @@ public class DynamoDbService {evaluateCondition(existing, conditionExpression, exprAttrNames, exprAttrValues, returnValuesOnConditionCheckFailure);}- tableItems.put(itemKey, item);+ tableItems.put(itemKey, normalizedItem);persistItems(storageKey);LOG.debugv("Put item in {0}: key={1}", canonicalTableName, itemKey);LOG.tracev("Put item in {0}: key={1} item={2}", canonicalTableName, itemKey, item);@@ -336,7 +459,7 @@ public class DynamoDbService {TableDefinition table = tableStore.get(storageKey).orElseThrow(() -> resourceNotFoundException(canonicalTableName));- String itemKey = buildItemKey(table, key);+ String itemKey = buildItemKey(table, key, true);var items = itemsByTable.get(storageKey);if (items == null) {LOG.tracev("Got item from {0}: key={1} item=<not found>", canonicalTableName, itemKey);@@ -368,7 +491,7 @@ public class DynamoDbService {TableDefinition table = tableStore.get(storageKey).orElseThrow(() -> resourceNotFoundException(canonicalTableName));- String itemKey = buildItemKey(table, key);+ String itemKey = buildItemKey(table, key, true);return withItemLock(storageKey, itemKey, () -> {var items = itemsByTable.get(storageKey);@@ -423,7 +546,7 @@ public class DynamoDbService {TableDefinition table = tableStore.get(storageKey).orElseThrow(() -> resourceNotFoundException(canonicalTableName));- String itemKey = buildItemKey(table, key);+ String itemKey = buildItemKey(table, key, true);return withItemLock(storageKey, itemKey, () -> {var items = itemsByTable.computeIfAbsent(storageKey, k -> new ConcurrentSkipListMap<>());@@ -458,15 +581,86 @@ public class DynamoDbService {switch (action) {case "PUT" -> { if (value != null) item.set(attrName, value); }- case "DELETE" -> item.remove(attrName);+ case "DELETE" -> {+ if (value == null) {+ item.remove(attrName);+ } else {+ // Remove elements from a set+ JsonNode curAttr = item.get(attrName);+ if (curAttr != null) {+ for (String setType : new String[]{"SS", "NS", "BS"}) {+ if (curAttr.has(setType) && value.has(setType)) {+ Set<String> removeSet = new HashSet<>();+ for (JsonNode v : value.get(setType)) removeSet.add(v.asText());+ com.fasterxml.jackson.databind.node.ArrayNode newArr = objectMapper.createArrayNode();+ for (JsonNode v : curAttr.get(setType)) {+ if (!removeSet.contains(v.asText())) newArr.add(v);+ }+ if (newArr.isEmpty()) {+ item.remove(attrName);+ } else {+ ((com.fasterxml.jackson.databind.node.ObjectNode) curAttr).set(setType, newArr);+ }+ break;+ }+ }+ }+ }+ }case "ADD" -> {- // Simple ADD for numeric values- if (value != null) item.set(attrName, value);+ if (value != null) {+ JsonNode curAttr = item.get(attrName);+ if (value.has("N")) {+ java.math.BigDecimal delta = new java.math.BigDecimal(value.get("N").asText());+ java.math.BigDecimal current = curAttr != null && curAttr.has("N")+ ? new java.math.BigDecimal(curAttr.get("N").asText()) : java.math.BigDecimal.ZERO;+ com.fasterxml.jackson.databind.node.ObjectNode numNode = objectMapper.createObjectNode();+ numNode.put("N", current.add(delta).stripTrailingZeros().toPlainString());+ item.set(attrName, numNode);+ } else {+ // Add elements to a set+ for (String setType : new String[]{"SS", "NS", "BS"}) {+ if (value.has(setType)) {+ if (curAttr == null || !curAttr.has(setType)) {+ item.set(attrName, value);+ } else {+ Set<String> existingSet = new LinkedHashSet<>();+ for (JsonNode v : curAttr.get(setType)) existingSet.add(v.asText());+ for (JsonNode v : value.get(setType)) existingSet.add(v.asText());+ com.fasterxml.jackson.databind.node.ArrayNode newArr = objectMapper.createArrayNode();+ for (String s : existingSet) newArr.add(s);+ ((com.fasterxml.jackson.databind.node.ObjectNode) curAttr).set(setType, newArr);+ }+ break;+ }+ }+ }+ }}}}}+ // Reject any attempt to modify a key attribute+ String pkName = table.getPartitionKeyName();+ JsonNode origPk = key.get(pkName);+ JsonNode newPk = item.get(pkName);+ if (origPk != null && newPk != null && !origPk.equals(newPk)) {+ throw new AwsException("ValidationException",+ "One or more parameter values were invalid: Cannot update attribute " + pkName+ + ". This attribute is part of the key", 400);+ }+ String skName = table.getSortKeyName();+ if (skName != null) {+ JsonNode origSk = key.get(skName);+ JsonNode newSk = item.get(skName);+ if (origSk != null && newSk != null && !origSk.equals(newSk)) {+ throw new AwsException("ValidationException",+ "One or more parameter values were invalid: Cannot update attribute " + skName+ + ". This attribute is part of the key", 400);+ }+ }+items.put(itemKey, item);persistItems(storageKey);LOG.tracev("Updated item in {0}: key={1} updateExpression={2} item={3}",@@ -574,12 +768,12 @@ public class DynamoDbService {String finalSkName = skName;results = new ArrayList<>(results);results.sort((a, b) -> {- String aVal = extractScalarValue(a.get(finalSkName));- String bVal = extractScalarValue(b.get(finalSkName));- if (aVal == null && bVal == null) return 0;- if (aVal == null) return -1;- if (bVal == null) return 1;- return compareValues(aVal, bVal);+ JsonNode aAttr = a.get(finalSkName);+ JsonNode bAttr = b.get(finalSkName);+ if (aAttr == null && bAttr == null) return 0;+ if (aAttr == null) return -1;+ if (bAttr == null) return 1;+ return ExpressionEvaluator.compareAttributeValues(aAttr, bAttr);});if (Boolean.FALSE.equals(scanIndexForward)) {Collections.reverse(results);@@ -614,12 +808,28 @@ public class DynamoDbService {List<JsonNode> evaluatedItems = results;JsonNode lastEvaluatedKey = null;+ // Apply Limit (stops at N items)if (limit != null && limit > 0 && evaluatedItems.size() > limit) {JsonNode lastItem = evaluatedItems.get(limit - 1);lastEvaluatedKey = buildKeyNode(table, lastItem, pkName, skName, indexName != null);evaluatedItems = new ArrayList<>(evaluatedItems.subList(0, limit));}+ // Apply 1MB response size limit (DynamoDB stops reading when scanned data exceeds 1MB)+ if (lastEvaluatedKey == null) {+ final int MAX_RESPONSE_BYTES = 1024 * 1024;+ int accSize = 0;+ for (int i = 0; i < evaluatedItems.size(); i++) {+ int sz = DynamoDbItemSize.calculateItemSize(evaluatedItems.get(i));+ if (accSize > 0 && accSize + sz > MAX_RESPONSE_BYTES) {+ lastEvaluatedKey = buildKeyNode(table, evaluatedItems.get(i - 1), pkName, skName, indexName != null);+ evaluatedItems = new ArrayList<>(evaluatedItems.subList(0, i));+ break;+ }+ accSize += sz;+ }+ }+int scannedCount = evaluatedItems.size();if (filterExpression != null) {@@ -644,6 +854,7 @@ public class DynamoDbService {public ScanResult scan(String tableName, String filterExpression,JsonNode expressionAttrNames, JsonNode expressionAttrValues,JsonNode scanFilter, Integer limit, JsonNode exclusiveStartKey, String region) {+ DynamoDbReservedWords.check(filterExpression, "FilterExpression");String canonicalTableName = canonicalTableName(region, tableName);String storageKey = regionKey(region, canonicalTableName);TableDefinition table = tableStore.get(storageKey)@@ -685,11 +896,34 @@ public class DynamoDbService {results = results.subList(0, limit);}+ // Apply 1MB response size limit+ if (lastEvaluatedKey == null) {+ final int MAX_RESPONSE_BYTES = 1024 * 1024;+ int accSize = 0;+ for (int i = 0; i < results.size(); i++) {+ int sz = DynamoDbItemSize.calculateItemSize(results.get(i));+ if (accSize > 0 && accSize + sz > MAX_RESPONSE_BYTES) {+ lastEvaluatedKey = buildKeyNode(table, results.get(i - 1), pkName, skName);+ results = new ArrayList<>(results.subList(0, i));+ break;+ }+ accSize += sz;+ }+ }+LOG.tracev("Scan on {0}: returned={1} scanned={2}",canonicalTableName, results.size(), totalScanned);return new ScanResult(results, totalScanned, lastEvaluatedKey);}+ public boolean matchesScanFilterPublic(JsonNode item, JsonNode scanFilter) {+ return matchesScanFilter(item, scanFilter);+ }++ public boolean matchesKeyConditionPublic(JsonNode attrValue, JsonNode condition) {+ return matchesKeyCondition(attrValue, condition);+ }+private boolean matchesScanFilter(JsonNode item, JsonNode scanFilter) {Iterator<Map.Entry<String, JsonNode>> fields = scanFilter.fields();while (fields.hasNext()) {@@ -803,6 +1037,7 @@ public class DynamoDbService {txIdempotency.entrySet().removeIf(e -> nowNanos - e.getValue().insertedAtNanos() > TX_IDEMPOTENCY_TTL_NANOS);}+// Acquire every participant's item lock in a deterministic (storageKey, itemKey)// order before evaluating conditions or applying writes. Total-ordered acquisition// prevents deadlock across concurrent transactions; ReentrantLock lets the inner@@ -826,15 +1061,15 @@ public class DynamoDbService {}// First pass: evaluate all conditions and collect failures.- List<String> cancellationReasons = new ArrayList<>();+ List<TransactionCanceledException.CancellationReason> cancellationReasons = new ArrayList<>();boolean hasFailed = false;for (JsonNode transactItem : transactItems) {- String failReason = evaluateTransactCondition(transactItem, region);+ TransactionCanceledException.CancellationReason failReason = evaluateTransactCondition(transactItem, region);if (failReason != null) {hasFailed = true;cancellationReasons.add(failReason);} else {- cancellationReasons.add("");+ cancellationReasons.add(new TransactionCanceledException.CancellationReason("", null));}}@@ -910,7 +1145,7 @@ public class DynamoDbService {return new TransactParticipant(storageKey, itemKey);}- private String evaluateTransactCondition(JsonNode transactItem, String region) {+ private TransactionCanceledException.CancellationReason evaluateTransactCondition(JsonNode transactItem, String region) {JsonNode target;if (transactItem.has("Put")) {target = transactItem.get("Put");@@ -949,23 +1184,45 @@ public class DynamoDbService {try {evaluateCondition(existing, conditionExpression, exprAttrNames, exprAttrValues, returnValuesOnConditionCheckFailure);return null;+ } catch (ConditionalCheckFailedException e) {+ return new TransactionCanceledException.CancellationReason("ConditionalCheckFailed", e.getItem());} catch (AwsException e) {- return e.getMessage();+ return new TransactionCanceledException.CancellationReason(e.getMessage(), null);}}public List<JsonNode> transactGetItems(List<JsonNode> transactItems, String region) {List<JsonNode> results = new ArrayList<>();+ List<TransactionCanceledException.CancellationReason> cancelReasons = new ArrayList<>();+ boolean hasCancelled = false;+for (JsonNode transactItem : transactItems) {if (transactItem.has("Get")) {JsonNode get = transactItem.get("Get");String tableName = get.path("TableName").asText();JsonNode key = get.get("Key");- results.add(getItem(tableName, key, region));+ try {+ results.add(getItem(tableName, key, region));+ cancelReasons.add(new TransactionCanceledException.CancellationReason("", null));+ } catch (AwsException e) {+ if ("ValidationException".equals(e.getErrorCode())) {+ hasCancelled = true;+ results.add(null);+ cancelReasons.add(new TransactionCanceledException.CancellationReason("ValidationError", null));+ } else {+ throw e;+ }+ }} else {results.add(null);+ cancelReasons.add(new TransactionCanceledException.CancellationReason("", null));}}++ if (hasCancelled) {+ throw new TransactionCanceledException(cancelReasons);+ }+return results;}@@ -983,6 +1240,50 @@ public class DynamoDbService {TableDefinition table = tableStore.get(storageKey).orElseThrow(() -> resourceNotFoundException(canonicalTableName));+ if (readCapacity != null && readCapacity <= 0) {+ throw new AwsException("ValidationException",+ "The parameter 'ProvisionedThroughput.ReadCapacityUnits' must be greater than 0", 400);+ }+ if (writeCapacity != null && writeCapacity <= 0) {+ throw new AwsException("ValidationException",+ "The parameter 'ProvisionedThroughput.WriteCapacityUnits' must be greater than 0", 400);+ }+ if (readCapacity != null && writeCapacity != null+ && "PROVISIONED".equals(table.getBillingMode())+ && readCapacity.equals(table.getProvisionedThroughput().getReadCapacityUnits())+ && writeCapacity.equals(table.getProvisionedThroughput().getWriteCapacityUnits())) {+ throw new AwsException("ValidationException",+ "The provisioned throughput for the table will not change. "+ + "The requested value equals the current value.", 400);+ }++ for (GlobalSecondaryIndex newGsi : gsiCreates) {+ if (table.findGsi(newGsi.getIndexName()).isPresent()) {+ throw new AwsException("ValidationException",+ "GSI " + newGsi.getIndexName() + " already exists", 400);+ }+ }++ Set<String> knownAttrs = table.getAttributeDefinitions().stream()+ .map(AttributeDefinition::getAttributeName)+ .collect(java.util.stream.Collectors.toSet());+ if (newAttrDefs != null) newAttrDefs.forEach(ad -> knownAttrs.add(ad.getAttributeName()));+ for (GlobalSecondaryIndex newGsi : gsiCreates) {+ for (KeySchemaElement k : newGsi.getKeySchema()) {+ if (!knownAttrs.contains(k.getAttributeName())) {+ throw new AwsException("ValidationException",+ "Attribute: " + k.getAttributeName() + " is not defined in AttributeDefinitions", 400);+ }+ }+ }++ for (String gsiName : gsiDeletes) {+ if (table.findGsi(gsiName).isEmpty()) {+ throw new AwsException("ResourceNotFoundException",+ "Global secondary index " + gsiName + " does not exist on the table", 400);+ }+ }+if (readCapacity != null) {table.getProvisionedThroughput().setReadCapacityUnits(readCapacity);}@@ -1146,6 +1447,7 @@ public class DynamoDbService {private void evaluateCondition(JsonNode existingItem, String conditionExpression,JsonNode exprAttrNames, JsonNode exprAttrValues, String returnValuesOnConditionCheckFailure) {+ DynamoDbReservedWords.check(conditionExpression, "ConditionExpression");if (!matchesFilterExpression(existingItem, conditionExpression, exprAttrNames, exprAttrValues)) {if ("ALL_OLD".equals(returnValuesOnConditionCheckFailure)){throw new ConditionalCheckFailedException(existingItem);@@ -1162,6 +1464,11 @@ public class DynamoDbService {JsonNode exprAttrNames, JsonNode exprAttrValues) {// Parse SET and REMOVE clauses from expressions like:// "SET #n = :newName, age = :newAge REMOVE oldField"+ if (expression.isBlank()) {+ throw new AwsException("ValidationException",+ "Invalid UpdateExpression: The expression can not be empty;", 400);+ }+ DynamoDbReservedWords.check(expression, "UpdateExpression");String remaining = expression.trim();while (!remaining.isEmpty()) {@@ -1179,7 +1486,14 @@ public class DynamoDbService {remaining = remaining.substring(7).trim();remaining = applyDeleteClause(item, remaining, exprAttrNames, exprAttrValues);} else {- break;+ // Unknown keyword — syntax error+ String[] parts = remaining.split("\\s+", 3);+ String token = parts[0];+ String near = parts.length >= 2+ ? (token + " " + parts[1]).substring(0, Math.min(token.length() + 1 + parts[1].length(), 20))+ : token;+ throw new AwsException("ValidationException",+ "Invalid UpdateExpression: Syntax error; token: \"" + token + "\", near: \"" + near + "\"", 400);}}}@@ -1633,132 +1947,233 @@ public class DynamoDbService {return nameOrPlaceholder;}- /**- * Sets a value at a potentially nested attribute path.- * Supports paths like "attr", "parent.child", "#alias.nested" etc.- * For nested paths, navigates into the DynamoDB Map structure (M field).- */- private void setValueAtPath(ObjectNode item, String path, JsonNode value, JsonNode exprAttrNames) {- // Resolve any # placeholders in the path segments- String[] segments = path.split("\\.");- for (int i = 0; i < segments.length; i++) {- segments[i] = resolveAttributeName(segments[i].trim(), exprAttrNames);+ // Tokenizes a DynamoDB path like "a.b[0].c" or "#l[5]" into a list of+ // String (attr name) and Integer (list index) tokens.+ private List<Object> parsePath(String path, JsonNode exprAttrNames) {+ List<Object> tokens = new ArrayList<>();+ for (String dotSeg : path.split("\\.")) {+ dotSeg = dotSeg.trim();+ if (dotSeg.isEmpty()) continue;+ int brk = dotSeg.indexOf('[');+ if (brk < 0) {+ tokens.add(resolveAttributeName(dotSeg, exprAttrNames));+ } else {+ String namePart = dotSeg.substring(0, brk);+ if (!namePart.isEmpty()) tokens.add(resolveAttributeName(namePart, exprAttrNames));+ String rest = dotSeg.substring(brk);+ int p = 0;+ while (p < rest.length() && rest.charAt(p) == '[') {+ int close = rest.indexOf(']', p);+ if (close < 0) break;+ tokens.add(Integer.parseInt(rest.substring(p + 1, close)));+ p = close + 1;+ }+ }}+ return tokens;+ }++ // Pads arr with NULL elements up to idx-1, then sets/appends value at idx.+ private void padAndSet(com.fasterxml.jackson.databind.node.ArrayNode arr, int idx, JsonNode value) {+ com.fasterxml.jackson.databind.node.ObjectNode nullNode =+ com.fasterxml.jackson.databind.node.JsonNodeFactory.instance.objectNode();+ nullNode.put("NULL", true);+ while (arr.size() < idx) arr.add(nullNode.deepCopy());+ if (idx < arr.size()) arr.set(idx, value);+ else arr.add(value);+ }++ private void setValueAtPath(ObjectNode item, String path, JsonNode value, JsonNode exprAttrNames) {+ List<Object> tokens = parsePath(path, exprAttrNames);+ if (tokens.isEmpty()) return;- if (segments.length == 1) {- // Simple top-level attribute- item.set(segments[0], value);+ if (tokens.size() == 1) {+ if (tokens.get(0) instanceof String attrName) item.set(attrName, value);return;}- // Navigate to the parent of the target attribute- ObjectNode current = item;- for (int i = 0; i < segments.length - 1; i++) {- String segment = segments[i];- JsonNode child = current.get(segment);-- if (child == null || !child.has("M")) {- // Create nested map structure if it doesn't exist- ObjectNode newMap = com.fasterxml.jackson.databind.node.JsonNodeFactory.instance.objectNode();- ObjectNode wrapper = com.fasterxml.jackson.databind.node.JsonNodeFactory.instance.objectNode();- wrapper.set("M", newMap);- current.set(segment, wrapper);- current = newMap;- } else {- // Navigate into existing map- JsonNode mapContent = child.get("M");- if (mapContent instanceof ObjectNode) {- current = (ObjectNode) mapContent;- } else {- // Cannot navigate further, structure mismatch+ JsonNode container = item;+ for (int i = 0; i < tokens.size() - 1; i++) {+ Object tok = tokens.get(i);+ Object nextTok = tokens.get(i + 1);+ boolean last = (i == tokens.size() - 2);++ if (tok instanceof String attrName) {+ if (!(container instanceof ObjectNode obj)) return;+ JsonNode child = obj.get(attrName);+ if (last) {+ if (nextTok instanceof String finalAttr) {+ if (child == null) {+ ObjectNode newMap = objectMapper.createObjectNode();+ newMap.set(finalAttr, value);+ ObjectNode wrapper = objectMapper.createObjectNode();+ wrapper.set("M", newMap);+ obj.set(attrName, wrapper);+ } else if (!child.has("M")) {+ throw new AwsException("ValidationException",+ "The document path provided in the update expression is invalid for update", 400);+ } else {+ ((ObjectNode) child.get("M")).set(finalAttr, value);+ }+ } else if (nextTok instanceof Integer finalIdx) {+ if (child == null || !child.has("L")) throw new AwsException("ValidationException",+ "The document path provided in the update expression is invalid for update", 400);+ padAndSet((com.fasterxml.jackson.databind.node.ArrayNode) child.get("L"), finalIdx, value);+ }+ return;+ }+ if (nextTok instanceof String) {+ if (child == null) {+ ObjectNode newMap = objectMapper.createObjectNode();+ ObjectNode wrapper = objectMapper.createObjectNode();+ wrapper.set("M", newMap);+ obj.set(attrName, wrapper);+ container = newMap;+ } else if (!child.has("M")) {+ throw new AwsException("ValidationException",+ "The document path provided in the update expression is invalid for update", 400);+ } else {+ container = child.get("M");+ }+ } else if (nextTok instanceof Integer) {+ if (child == null || !child.has("L")) throw new AwsException("ValidationException",+ "The document path provided in the update expression is invalid for update", 400);+ container = child.get("L");+ }+ } else if (tok instanceof Integer listIdx) {+ if (!(container instanceof com.fasterxml.jackson.databind.node.ArrayNode arr)) return;+ if (listIdx >= arr.size()) throw new AwsException("ValidationException",+ "The document path provided in the update expression is invalid for update", 400);+ JsonNode element = arr.get(listIdx);+ if (last) {+ if (nextTok instanceof String finalAttr) {+ if (!element.has("M")) throw new AwsException("ValidationException",+ "The document path provided in the update expression is invalid for update", 400);+ ((ObjectNode) element.get("M")).set(finalAttr, value);+ } else if (nextTok instanceof Integer finalIdx) {+ if (!element.has("L")) throw new AwsException("ValidationException",+ "The document path provided in the update expression is invalid for update", 400);+ padAndSet((com.fasterxml.jackson.databind.node.ArrayNode) element.get("L"), finalIdx, value);+ }return;}+ if (nextTok instanceof String) {+ if (!element.has("M")) throw new AwsException("ValidationException",+ "The document path provided in the update expression is invalid for update", 400);+ container = element.get("M");+ } else if (nextTok instanceof Integer) {+ if (!element.has("L")) throw new AwsException("ValidationException",+ "The document path provided in the update expression is invalid for update", 400);+ container = element.get("L");+ }}}-- // Set the final attribute- current.set(segments[segments.length - 1], value);}- /**- * Gets a value at a potentially nested attribute path.- * Returns null if the path doesn't exist.- */private JsonNode getValueAtPath(JsonNode item, String path, JsonNode exprAttrNames) {- // Resolve any # placeholders in the path segments- String[] segments = path.split("\\.");- for (int i = 0; i < segments.length; i++) {- segments[i] = resolveAttributeName(segments[i].trim(), exprAttrNames);- }-+ List<Object> tokens = parsePath(path, exprAttrNames);+ if (tokens.isEmpty()) return null;JsonNode current = item;- for (int i = 0; i < segments.length; i++) {+ for (int i = 0; i < tokens.size(); i++) {if (current == null) return null;-- String segment = segments[i];- JsonNode child = current.get(segment);-- if (child == null) return null;-- if (i < segments.length - 1) {- // Need to navigate deeper - check for Map structure- if (child.has("M")) {+ Object tok = tokens.get(i);+ boolean isLast = (i == tokens.size() - 1);+ if (tok instanceof String attrName) {+ JsonNode child = current.get(attrName);+ if (child == null) return null;+ if (isLast) return child;+ Object nextTok = tokens.get(i + 1);+ if (nextTok instanceof String) {+ if (!child.has("M")) return null;current = child.get("M");- } else {- return null;- }- } else {- // This is the final segment- return child;+ } else if (nextTok instanceof Integer) {+ if (!child.has("L")) return null;+ current = child.get("L");+ } else return null;+ } else if (tok instanceof Integer listIdx) {+ if (!current.isArray() || listIdx >= current.size()) return null;+ JsonNode element = current.get(listIdx);+ if (element == null) return null;+ if (isLast) return element;+ Object nextTok = tokens.get(i + 1);+ if (nextTok instanceof String) {+ if (!element.has("M")) return null;+ current = element.get("M");+ } else if (nextTok instanceof Integer) {+ if (!element.has("L")) return null;+ current = element.get("L");+ } else return null;}}return current;}- /**- * Checks if a value exists at a potentially nested attribute path.- */private boolean hasValueAtPath(JsonNode item, String path, JsonNode exprAttrNames) {return getValueAtPath(item, path, exprAttrNames) != null;}- /**- * Removes a value at a potentially nested attribute path.- * Supports paths like "attr", "parent.child", "#alias.nested" etc.- * For nested paths, navigates into the DynamoDB Map structure (M field)- * and removes the final key from its parent.- */private void removeValueAtPath(ObjectNode item, String path, JsonNode exprAttrNames) {- String[] segments = path.split("\\.");- for (int i = 0; i < segments.length; i++) {- segments[i] = resolveAttributeName(segments[i].trim(), exprAttrNames);- }+ List<Object> tokens = parsePath(path, exprAttrNames);+ if (tokens.isEmpty()) return;- if (segments.length == 1) {- item.remove(segments[0]);+ if (tokens.size() == 1) {+ if (tokens.get(0) instanceof String attrName) item.remove(attrName);return;}- // Navigate to the parent of the target attribute- ObjectNode current = item;- for (int i = 0; i < segments.length - 1; i++) {- String segment = segments[i];- JsonNode child = current.get(segment);-- if (child == null || !child.has("M")) {- // Path doesn't exist, nothing to remove- return;- }-- JsonNode mapContent = child.get("M");- if (mapContent instanceof ObjectNode) {- current = (ObjectNode) mapContent;- } else {- return;+ JsonNode container = item;+ for (int i = 0; i < tokens.size() - 1; i++) {+ Object tok = tokens.get(i);+ Object nextTok = tokens.get(i + 1);+ boolean last = (i == tokens.size() - 2);++ if (tok instanceof String attrName) {+ if (!(container instanceof ObjectNode obj)) return;+ JsonNode child = obj.get(attrName);+ if (last) {+ if (nextTok instanceof String finalAttr) {+ if (child == null || !child.has("M")) return;+ ((ObjectNode) child.get("M")).remove(finalAttr);+ } else if (nextTok instanceof Integer finalIdx) {+ if (child == null || !child.has("L")) return;+ com.fasterxml.jackson.databind.node.ArrayNode lArr =+ (com.fasterxml.jackson.databind.node.ArrayNode) child.get("L");+ if (finalIdx < lArr.size()) lArr.remove(finalIdx);+ }+ return;+ }+ if (nextTok instanceof String) {+ if (child == null || !child.has("M")) return;+ container = child.get("M");+ } else if (nextTok instanceof Integer) {+ if (child == null || !child.has("L")) return;+ container = child.get("L");+ }+ } else if (tok instanceof Integer listIdx) {+ if (!(container instanceof com.fasterxml.jackson.databind.node.ArrayNode arr)) return;+ if (listIdx >= arr.size()) return;+ JsonNode element = arr.get(listIdx);+ if (last) {+ if (nextTok instanceof String finalAttr) {+ if (!element.has("M")) return;+ ((ObjectNode) element.get("M")).remove(finalAttr);+ } else if (nextTok instanceof Integer finalIdx) {+ if (!element.has("L")) return;+ com.fasterxml.jackson.databind.node.ArrayNode lArr =+ (com.fasterxml.jackson.databind.node.ArrayNode) element.get("L");+ if (finalIdx < lArr.size()) lArr.remove(finalIdx);+ }+ return;+ }+ if (nextTok instanceof String) {+ if (!element.has("M")) return;+ container = element.get("M");+ } else if (nextTok instanceof Integer) {+ if (!element.has("L")) return;+ container = element.get("L");+ }}}-- current.remove(segments[segments.length - 1]);}private int findNextComma(String s) {@@ -1908,26 +2323,48 @@ public class DynamoDbService {}String buildItemKey(TableDefinition table, JsonNode item) {+ return buildItemKey(table, item, false);+ }++ String buildItemKey(TableDefinition table, JsonNode item, boolean isKeyArg) {String pkName = table.getPartitionKeyName();JsonNode pkAttr = item.get(pkName);if (pkAttr == null) {+ if (isKeyArg) {+ throw new AwsException("ValidationException",+ "The provided key element does not match the schema", 400);+ }throw new AwsException("ValidationException","One of the required keys was not given a value", 400);}+ validateKeyAttributeValue(pkAttr, pkName);String pk = extractScalarValue(pkAttr);String skName = table.getSortKeyName();if (skName != null) {JsonNode skAttr = item.get(skName);if (skAttr == null) {+ if (isKeyArg) {+ throw new AwsException("ValidationException",+ "The provided key element does not match the schema", 400);+ }throw new AwsException("ValidationException","One of the required keys was not given a value", 400);}+ validateKeyAttributeValue(skAttr, skName);return pk + "#" + extractScalarValue(skAttr);}return pk;}+ private void validateKeyAttributeValue(JsonNode attr, String keyName) {+ if (attr != null && attr.has("S") && attr.get("S").asText().isEmpty()) {+ throw new AwsException("ValidationException",+ "One or more parameter values were invalid: "+ + "The AttributeValue for a key attribute cannot contain an empty string value. Key: " + keyName, 400);+ }+ }+private String buildItemKeyFromNode(JsonNode item, String pkName, String skName) {JsonNode pkAttr = item.get(pkName);if (pkAttr == null) return "";@@ -1975,7 +2412,11 @@ public class DynamoDbService {private String extractScalarValue(JsonNode attrValue) {if (attrValue == null) return null;if (attrValue.has("S")) return attrValue.get("S").asText();- if (attrValue.has("N")) return attrValue.get("N").asText();+ if (attrValue.has("N")) {+ String raw = attrValue.get("N").asText();+ try { return DynamoDbNumberUtils.validateAndNormalize(raw); }+ catch (Exception e) { return raw; }+ }if (attrValue.has("B")) return attrValue.get("B").asText();if (attrValue.has("BOOL")) return attrValue.get("BOOL").asText();return attrValue.asText();@@ -1996,30 +2437,74 @@ public class DynamoDbService {return null;}- // NE, CONTAINS, NOT_CONTAINS, IN, NULL, NOT_NULL not yet supportedprivate boolean matchesKeyCondition(JsonNode attrValue, JsonNode condition) {if (condition == null) return true;String op = condition.has("ComparisonOperator") ? condition.get("ComparisonOperator").asText() : "EQ";- String compareValue = extractComparisonValue(condition);+ JsonNode avl = condition.get("AttributeValueList");+ JsonNode compareAttr = avl != null && avl.isArray() && !avl.isEmpty() ? avl.get(0) : null;+ String compareValue = extractScalarValue(compareAttr);String actual = extractScalarValue(attrValue);- if (actual == null) return false;return switch (op) {- case "EQ" -> actual.equals(compareValue);- case "BEGINS_WITH" -> actual.startsWith(compareValue);- case "GT" -> actual.compareTo(compareValue) > 0;- case "GE" -> actual.compareTo(compareValue) >= 0;- case "LT" -> actual.compareTo(compareValue) < 0;- case "LE" -> actual.compareTo(compareValue) <= 0;- case "BETWEEN" -> {- JsonNode list = condition.get("AttributeValueList");- if (list.size() >= 2) {- String low = extractScalarValue(list.get(0));- String high = extractScalarValue(list.get(1));- yield actual.compareTo(low) >= 0 && actual.compareTo(high) <= 0;+ case "EQ" -> {+ if (attrValue == null) yield false;+ yield ExpressionEvaluator.compareAttributeValues(attrValue, compareAttr != null ? compareAttr : attrValue) == 0+ && actual != null && actual.equals(compareValue);+ }+ case "NE" -> {+ if (attrValue == null) yield true;+ if (actual == null || compareValue == null) yield true;+ yield !actual.equals(compareValue);+ }+ case "NULL" -> attrValue == null;+ case "NOT_NULL" -> attrValue != null;+ case "BEGINS_WITH" -> actual != null && compareValue != null && actual.startsWith(compareValue);+ case "CONTAINS" -> {+ if (attrValue == null || compareAttr == null) yield false;+ if (attrValue.has("S") && compareAttr.has("S")) {+ yield attrValue.get("S").asText().contains(compareAttr.get("S").asText());+ }+ if (attrValue.has("SS") && compareAttr.has("S")) {+ String target = compareAttr.get("S").asText();+ for (JsonNode elem : attrValue.get("SS")) { if (target.equals(elem.asText())) yield true; }+ yield false;+ }+ if (attrValue.has("NS") && compareAttr.has("N")) {+ String target = compareAttr.get("N").asText();+ for (JsonNode elem : attrValue.get("NS")) { if (target.equals(elem.asText())) yield true; }+ yield false;}yield false;}+ case "NOT_CONTAINS" -> {+ if (attrValue == null || compareAttr == null) yield true;+ if (attrValue.has("S") && compareAttr.has("S"))+ yield !attrValue.get("S").asText().contains(compareAttr.get("S").asText());+ if (attrValue.has("SS") && compareAttr.has("S")) {+ String target = compareAttr.get("S").asText();+ for (JsonNode elem : attrValue.get("SS")) { if (target.equals(elem.asText())) yield false; }+ yield true;+ }+ yield true;+ }+ case "IN" -> {+ if (actual == null || avl == null) yield false;+ for (JsonNode v : avl) { if (actual.equals(extractScalarValue(v))) yield true; }+ yield false;+ }+ case "GT" -> actual != null && compareValue != null+ && ExpressionEvaluator.compareAttributeValues(attrValue, compareAttr) > 0;+ case "GE" -> actual != null && compareValue != null+ && ExpressionEvaluator.compareAttributeValues(attrValue, compareAttr) >= 0;+ case "LT" -> actual != null && compareValue != null+ && ExpressionEvaluator.compareAttributeValues(attrValue, compareAttr) < 0;+ case "LE" -> actual != null && compareValue != null+ && ExpressionEvaluator.compareAttributeValues(attrValue, compareAttr) <= 0;+ case "BETWEEN" -> {+ if (actual == null || avl == null || avl.size() < 2) yield false;+ yield ExpressionEvaluator.compareAttributeValues(attrValue, avl.get(0)) >= 0+ && ExpressionEvaluator.compareAttributeValues(attrValue, avl.get(1)) <= 0;+ }default -> true;};}@@ -2045,6 +2530,12 @@ public class DynamoDbService {String pkAttrInExpr = pkExprStripped.split("\\s*=\\s*")[0].trim();String resolvedPkName = resolveAttributeName(pkAttrInExpr, exprAttrNames);+ // Validate the PK attribute in the expression matches the actual table/index PK+ if (!resolvedPkName.equals(pkName)) {+ throw new AwsException("ValidationException",+ "Query condition missed key schema element: " + pkName, 400);+ }+// Extract pk value placeholderint colonIdx = pkExprStripped.indexOf(':');String pkPlaceholder = null;@@ -2078,8 +2569,7 @@ public class DynamoDbService {}private AwsException resourceNotFoundException(String tableName) {- return new AwsException("ResourceNotFoundException",- "Requested resource not found: Table: " + tableName + " not found", 400);+ return new AwsException("ResourceNotFoundException", "Requested resource not found", 400);}public record UpdateResult(JsonNode newItem, JsonNode oldItem) {}@@ -2113,8 +2603,7 @@ public class DynamoDbService {String storageKey = regionKey(tableRegion, tableName);TableDefinition table = tableStore.get(storageKey)- .orElseThrow(() -> new AwsException("ResourceNotFoundException",- "Requested resource not found: Table: " + tableName + " not found", 400));+ .orElseThrow(() -> resourceNotFoundException(tableName));long now = Instant.now().getEpochSecond();String exportId = System.currentTimeMillis() + "-" + UUID.randomUUID().toString().replace("-", "");diff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbTableNames.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbTableNames.javaindex 70210856c8..1d0cb98270 100644--- a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbTableNames.java+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbTableNames.java@@ -11,7 +11,7 @@ import java.util.regex.Pattern;*/public final class DynamoDbTableNames {- private static final Pattern TABLE_NAME_PATTERN = Pattern.compile("[a-zA-Z0-9_.-]{3,255}");+ private static final Pattern TABLE_NAME_CHARS = Pattern.compile("[a-zA-Z0-9_.\\-]+");private static final Pattern ACCOUNT_PATTERN = Pattern.compile("\\d{12}");private DynamoDbTableNames() {}@@ -23,18 +23,23 @@ public final class DynamoDbTableNames {}/**- * Validates a short table name. Rejects ARN-form input: callers (e.g. CreateTable)- * must persist a canonical short name, not an ARN that would produce ARN-on-ARN- * values when derived into {@code TableArn}.+ * Validates a short table name for use with CreateTable.+ * CreateTable requires min length 3 and missing TableName is a distinct error.*/public static String requireShortName(String input) {- if (input == null || input.isBlank()) {- throw invalid("TableName must not be blank");+ if (input == null) {+ throw new AwsException("ValidationException",+ "The parameter 'TableName' is required but was not present in the request", 400);+ }+ if (input.isEmpty()) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '" + input+ + "' at 'tableName' failed to satisfy constraint: Member must have length greater than or equal to 3", 400);}if (input.startsWith("arn:")) {throw invalid("TableName must be a short name, not an ARN: " + input);}- validateTableName(input);+ validateTableNameForCreate(input);return input;}@@ -47,13 +52,18 @@ public final class DynamoDbTableNames {}private static ResolvedTableRef resolveInternal(String input) {- if (input == null || input.isBlank()) {- throw invalid("TableName must not be blank");+ if (input == null) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value null at 'tableName' failed to satisfy constraint: Member must not be null", 400);+ }+ if (input.isEmpty()) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '' at 'tableName' failed to satisfy constraint: Member must have length greater than or equal to 1", 400);}if (input.startsWith("arn:")) {return parseArn(input);}- validateTableName(input);+ validateTableNameForOps(input);return new ResolvedTableRef(input, null);}@@ -94,17 +104,49 @@ public final class DynamoDbTableNames {throw invalid("Invalid table ARN: " + input);}- validateTableName(tableName);+ validateTableNameForOps(tableName);return new ResolvedTableRef(tableName, region);}- private static void validateTableName(String tableName) {- if (!TABLE_NAME_PATTERN.matcher(tableName).matches()) {- throw invalid("Invalid TableName: " + tableName);+ // Validation for CreateTable: min length 3, max 255, pattern+ private static void validateTableNameForCreate(String tableName) {+ if (tableName.length() < 3) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '" + tableName+ + "' at 'tableName' failed to satisfy constraint: Member must have length greater than or equal to 3", 400);+ }+ if (tableName.length() > 255) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '" + tableName+ + "' at 'tableName' failed to satisfy constraint: Member must have length less than or equal to 255", 400);+ }+ if (!TABLE_NAME_CHARS.matcher(tableName).matches()) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '" + tableName+ + "' at 'tableName' failed to satisfy constraint: Member must satisfy regular expression pattern: [a-zA-Z0-9_.-]+", 400);+ }+ }++ // Validation for other operations (PutItem, GetItem, etc.): min length 3, max 255, pattern+ private static void validateTableNameForOps(String tableName) {+ if (tableName.length() < 3) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '" + tableName+ + "' at 'tableName' failed to satisfy constraint: Member must have length greater than or equal to 3", 400);+ }+ if (tableName.length() > 255) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '" + tableName+ + "' at 'tableName' failed to satisfy constraint: Member must have length less than or equal to 255", 400);+ }+ if (!TABLE_NAME_CHARS.matcher(tableName).matches()) {+ throw new AwsException("ValidationException",+ "1 validation error detected: Value '" + tableName+ + "' at 'tableName' failed to satisfy constraint: Member must satisfy regular expression pattern: [a-zA-Z0-9_.-]+", 400);}}private static AwsException invalid(String message) {- return new AwsException("InvalidParameterValue", message, 400);+ return new AwsException("ValidationException", message, 400);}}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 1a7f1a6580..fccf76a978 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@@ -1,9 +1,12 @@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 java.math.BigDecimal;import java.util.ArrayList;+import java.util.Base64;import java.util.List;/**@@ -33,6 +36,7 @@ final class ExpressionEvaluator {GE, // >=// PunctuationLPAREN, RPAREN, COMMA, DOT,+ LIST_INDEX, // [n] — list element access// FunctionsFUNCTION, // attribute_exists, attribute_not_exists, begins_with, contains, size// End@@ -63,6 +67,21 @@ final class ExpressionEvaluator {if (c == ',') { tokens.add(new Token(TokenType.COMMA, ",", i)); i++; continue; }if (c == '.') { tokens.add(new Token(TokenType.DOT, ".", i)); i++; continue; }+ // List index [n]+ if (c == '[') {+ int start = i;+ i++; // skip '['+ while (i < len && Character.isDigit(expression.charAt(i))) i++;+ if (i < len && expression.charAt(i) == ']') {+ i++; // skip ']'+ tokens.add(new Token(TokenType.LIST_INDEX, expression.substring(start, i), start));+ } else {+ throw new IllegalArgumentException(+ "Expected ']' after list index at position " + i + " in: " + expression);+ }+ continue;+ }+// Comparators (must check <> and <= before <, >= before >)if (c == '<') {if (i + 1 < len && expression.charAt(i + 1) == '>') {@@ -120,7 +139,8 @@ final class ExpressionEvaluator {case "not" -> tokens.add(new Token(TokenType.NOT, word, start));case "in" -> tokens.add(new Token(TokenType.IN, word, start));case "between" -> tokens.add(new Token(TokenType.BETWEEN, word, start));- case "attribute_exists", "attribute_not_exists", "begins_with", "contains", "size" ->+ case "attribute_exists", "attribute_not_exists", "begins_with", "contains", "size",+ "attribute_type" ->tokens.add(new Token(TokenType.FUNCTION, word, start));default -> tokens.add(new Token(TokenType.IDENTIFIER, word, start));}@@ -291,15 +311,23 @@ final class ExpressionEvaluator {return new PlaceholderOperand(advance().value());}- // Path: identifier or #name, possibly dotted+ // Path: identifier or #name, possibly dotted with nested [n] list indicesif (current.type() == TokenType.IDENTIFIER || current.type() == TokenType.NAME_REF) {var segments = new ArrayList<String>();segments.add(advance().value());+ // Consume any immediately-following list indices (no dot needed before [n])+ while (peek().type() == TokenType.LIST_INDEX) {+ segments.add(advance().value());+ }+ // Consume .name and .name[n] sequenceswhile (peek().type() == TokenType.DOT) {advance(); // consume dotToken seg = peek();if (seg.type() == TokenType.IDENTIFIER || seg.type() == TokenType.NAME_REF) {segments.add(advance().value());+ while (peek().type() == TokenType.LIST_INDEX) {+ segments.add(advance().value());+ }} else {throw new IllegalArgumentException("Expected identifier after '.' at position %d".formatted(seg.pos()));@@ -355,6 +383,24 @@ final class ExpressionEvaluator {static String[] splitKeyCondition(String expression) {if (expression == null || expression.isBlank()) return new String[]{expression, null};+ // Strip a single layer of outer parens when they wrap the entire expression,+ // e.g. "(pk = :pk AND sk = :sk)" → "pk = :pk AND sk = :sk"+ String stripped = expression.strip();+ if (stripped.startsWith("(") && stripped.endsWith(")")) {+ int depth = 0;+ boolean wrapsAll = true;+ for (int i = 0; i < stripped.length() - 1; i++) {+ if (stripped.charAt(i) == '(') depth++;+ else if (stripped.charAt(i) == ')') {+ depth--;+ if (depth == 0) { wrapsAll = false; break; }+ }+ }+ if (wrapsAll) {+ expression = stripped.substring(1, stripped.length() - 1).strip();+ }+ }+var tokens = tokenize(expression.trim());// Find the top-level AND that separates PK from SK.// We need to skip AND tokens that are part of BETWEEN...AND.@@ -446,32 +492,37 @@ final class ExpressionEvaluator {private static boolean evaluateComparison(CompareExpr cmp, JsonNode item,JsonNode exprAttrNames, JsonNode exprAttrValues) {- String leftVal = resolveScalar(cmp.left(), item, exprAttrNames, exprAttrValues);- String rightVal = resolveScalar(cmp.right(), item, exprAttrNames, exprAttrValues);-- // DynamoDB: comparing a missing attribute with <> returns true- if (leftVal == null && cmp.op() == TokenType.NE) return true;- if (rightVal == null && cmp.op() == TokenType.NE) return true;- if (leftVal == null || rightVal == null) return false;+ // For EQ/NE, resolve full attribute values to support set comparison+ if (cmp.op() == TokenType.EQ || cmp.op() == TokenType.NE) {+ JsonNode leftNode = resolveAttributeValue(cmp.left(), item, exprAttrNames, exprAttrValues);+ JsonNode rightNode = resolveAttributeValue(cmp.right(), item, exprAttrNames, exprAttrValues);+ if (leftNode == null && cmp.op() == TokenType.NE) return true;+ if (rightNode == null && cmp.op() == TokenType.NE) return true;+ if (leftNode == null || rightNode == null) return false;+ boolean equal = attributeValuesEqual(leftNode, rightNode);+ return cmp.op() == TokenType.EQ ? equal : !equal;+ }+ JsonNode leftNode = resolveAttributeValue(cmp.left(), item, exprAttrNames, exprAttrValues);+ JsonNode rightNode = resolveAttributeValue(cmp.right(), item, exprAttrNames, exprAttrValues);+ if (leftNode == null || rightNode == null) return false;+ int cmpResult = compareAttributeValues(leftNode, rightNode);return switch (cmp.op()) {- case EQ -> leftVal.equals(rightVal);- case NE -> !leftVal.equals(rightVal);- case LT -> compareValues(leftVal, rightVal) < 0;- case LE -> compareValues(leftVal, rightVal) <= 0;- case GT -> compareValues(leftVal, rightVal) > 0;- case GE -> compareValues(leftVal, rightVal) >= 0;+ case LT -> cmpResult < 0;+ case LE -> cmpResult <= 0;+ case GT -> cmpResult > 0;+ case GE -> cmpResult >= 0;default -> false;};}private static boolean evaluateBetween(BetweenExpr bet, JsonNode item,JsonNode exprAttrNames, JsonNode exprAttrValues) {- String val = resolveScalar(bet.value(), item, exprAttrNames, exprAttrValues);- String low = resolveScalar(bet.low(), item, exprAttrNames, exprAttrValues);- String high = resolveScalar(bet.high(), item, exprAttrNames, exprAttrValues);+ JsonNode val = resolveAttributeValue(bet.value(), item, exprAttrNames, exprAttrValues);+ JsonNode low = resolveAttributeValue(bet.low(), item, exprAttrNames, exprAttrValues);+ JsonNode high = resolveAttributeValue(bet.high(), item, exprAttrNames, exprAttrValues);if (val == null || low == null || high == null) return false;- return compareValues(val, low) >= 0 && compareValues(val, high) <= 0;+ return compareAttributeValues(val, low) >= 0 && compareAttributeValues(val, high) <= 0;}private static boolean evaluateIn(InExpr in, JsonNode item,@@ -507,8 +558,19 @@ final class ExpressionEvaluator {if (func.args().size() < 2) yield false;String path = resolveAttributePath(func.args().get(0), exprAttrNames);JsonNode attrNode = item != null ? resolveNestedAttribute(item, path) : null;+ JsonNode prefixNode = resolveAttributeValue(func.args().get(1), item, exprAttrNames, exprAttrValues);+ if (attrNode == null || prefixNode == null) yield false;+ if (attrNode.has("B") && prefixNode.has("B")) {+ byte[] attrBytes = java.util.Base64.getDecoder().decode(attrNode.get("B").asText());+ byte[] prefixBytes = java.util.Base64.getDecoder().decode(prefixNode.get("B").asText());+ if (prefixBytes.length > attrBytes.length) yield false;+ for (int bi = 0; bi < prefixBytes.length; bi++) {+ if (attrBytes[bi] != prefixBytes[bi]) yield false;+ }+ yield true;+ }String actual = extractScalarValue(attrNode);- String prefix = resolveScalar(func.args().get(1), item, exprAttrNames, exprAttrValues);+ String prefix = extractScalarValue(prefixNode);yield actual != null && prefix != null && actual.startsWith(prefix);}case "contains" -> {@@ -516,6 +578,15 @@ final class ExpressionEvaluator {yield evaluateContains(func.args().get(0), func.args().get(1),item, exprAttrNames, exprAttrValues);}+ case "attribute_type" -> {+ if (func.args().size() < 2) yield false;+ String attrPath = resolveAttributePath(func.args().get(0), exprAttrNames);+ JsonNode attrVal = item != null ? resolveNestedAttribute(item, attrPath) : null;+ JsonNode typeNode = resolveAttributeValue(func.args().get(1), item, exprAttrNames, exprAttrValues);+ if (attrVal == null || typeNode == null) yield false;+ String typeCode = typeNode.has("S") ? typeNode.get("S").asText() : typeNode.asText();+ yield attrVal.has(typeCode);+ }default -> false;};}@@ -615,7 +686,18 @@ final class ExpressionEvaluator {String resolvedPath = resolvePathString(path, exprAttrNames);yield item != null ? resolveNestedAttribute(item, resolvedPath) : null;}- case FunctionOperand _ -> null;+ case FunctionOperand func -> {+ if ("size".equalsIgnoreCase(func.functionName()) && !func.args().isEmpty()) {+ String path = resolveAttributePath(func.args().getFirst(), exprAttrNames);+ JsonNode attrNode = item != null ? resolveNestedAttribute(item, path) : null;+ if (attrNode != null) {+ ObjectNode numNode = JsonNodeFactory.instance.objectNode();+ numNode.put("N", String.valueOf(computeSize(attrNode)));+ yield numNode;+ }+ }+ yield null;+ }};}@@ -631,14 +713,18 @@ final class ExpressionEvaluator {private static String resolvePathString(PathOperand path, JsonNode exprAttrNames) {var sb = new StringBuilder();for (int i = 0; i < path.segments().size(); i++) {- if (i > 0) sb.append(".");String segment = path.segments().get(i);- String resolved = resolveAttributeName(segment, exprAttrNames);- // If the resolved name contains dots, escape them so resolveNestedAttribute treats it as one key- if (segment.startsWith("#") && resolved != null) {- resolved = resolved.replace(".", DOT_ESCAPE);+ if (segment.startsWith("[")) {+ // List index: append directly without preceding dot+ sb.append(segment);+ } else {+ if (i > 0) sb.append(".");+ String resolved = resolveAttributeName(segment, exprAttrNames);+ if (segment.startsWith("#") && resolved != null) {+ resolved = resolved.replace(".", DOT_ESCAPE);+ }+ sb.append(resolved);}- sb.append(resolved);}return sb.toString();}@@ -664,13 +750,43 @@ final class ExpressionEvaluator {return attrValue.asText();}+ // Tokenizes a resolved path string (e.g. "a.b[0].c") into segments.+ // Each segment is either a plain attribute name or a "[n]" list index string.+ private static List<String> parsePathSegments(String path) {+ var segs = new ArrayList<String>();+ for (String dotPart : path.split("\\.")) {+ dotPart = dotPart.replace(DOT_ESCAPE, ".");+ int brk = dotPart.indexOf('[');+ if (brk < 0) {+ if (!dotPart.isEmpty()) segs.add(dotPart);+ } else {+ if (brk > 0) segs.add(dotPart.substring(0, brk));+ String rest = dotPart.substring(brk);+ int p = 0;+ while (p < rest.length() && rest.charAt(p) == '[') {+ int close = rest.indexOf(']', p);+ if (close < 0) break;+ segs.add(rest.substring(p, close + 1)); // "[n]"+ p = close + 1;+ }+ }+ }+ return segs;+ }+private static JsonNode resolveNestedAttribute(JsonNode item, String path) {- String[] segments = path.split("\\.");+ List<String> segments = parsePathSegments(path);JsonNode current = item;- for (int i = 0; i < segments.length; i++) {+ for (int i = 0; i < segments.size(); i++) {if (current == null) return null;- String segment = segments[i].replace(DOT_ESCAPE, ".");- if (i == 0) {+ String segment = segments.get(i);+ if (segment.matches("\\[\\d+\\]")) {+ // List index navigation+ int idx = Integer.parseInt(segment.substring(1, segment.length() - 1));+ JsonNode listNode = current.has("L") ? current.get("L") : (current.isArray() ? current : null);+ if (listNode == null || !listNode.isArray() || idx >= listNode.size()) return null;+ current = listNode.get(idx);+ } else if (i == 0) {current = current.get(segment);} else {if (current.has("M")) {@@ -721,6 +837,36 @@ final class ExpressionEvaluator {}return true;}+ // Set types: SS, NS, BS — order-independent comparison+ if (a.has("SS") && b.has("SS")) {+ JsonNode aArr = a.get("SS"), bArr = b.get("SS");+ if (aArr.size() != bArr.size()) return false;+ var aSet = new java.util.HashSet<String>();+ aArr.forEach(e -> aSet.add(e.asText()));+ for (JsonNode e : bArr) { if (!aSet.contains(e.asText())) return false; }+ return true;+ }+ if (a.has("SS") || b.has("SS")) return false;+ if (a.has("BS") && b.has("BS")) {+ JsonNode aArr = a.get("BS"), bArr = b.get("BS");+ if (aArr.size() != bArr.size()) return false;+ var aSet = new java.util.HashSet<String>();+ aArr.forEach(e -> aSet.add(e.asText()));+ for (JsonNode e : bArr) { if (!aSet.contains(e.asText())) return false; }+ return true;+ }+ if (a.has("BS") || b.has("BS")) return false;+ if (a.has("NS") && b.has("NS")) {+ JsonNode aArr = a.get("NS"), bArr = b.get("NS");+ if (aArr.size() != bArr.size()) return false;+ var aSet = new java.util.HashSet<BigDecimal>();+ try {+ aArr.forEach(e -> aSet.add(new BigDecimal(e.asText())));+ for (JsonNode e : bArr) { if (!aSet.contains(new BigDecimal(e.asText()))) return false; }+ } catch (NumberFormatException ex) { return false; }+ return true;+ }+ if (a.has("NS") || b.has("NS")) return false;return false;}@@ -732,6 +878,32 @@ final class ExpressionEvaluator {}}+ static int compareAttributeValues(JsonNode a, JsonNode b) {+ if (a.has("N") && b.has("N")) {+ try {+ return new BigDecimal(a.get("N").asText())+ .compareTo(new BigDecimal(b.get("N").asText()));+ } catch (NumberFormatException e) {+ return a.get("N").asText().compareTo(b.get("N").asText());+ }+ }+ if (a.has("B") && b.has("B")) {+ byte[] aBytes = Base64.getDecoder().decode(a.get("B").asText());+ byte[] bBytes = Base64.getDecoder().decode(b.get("B").asText());+ int minLen = Math.min(aBytes.length, bBytes.length);+ for (int i = 0; i < minLen; i++) {+ int diff = (aBytes[i] & 0xFF) - (bBytes[i] & 0xFF);+ if (diff != 0) return diff;+ }+ return Integer.compare(aBytes.length, bBytes.length);+ }+ String aStr = a.has("S") ? a.get("S").asText() : extractScalarValue(a);+ String bStr = b.has("S") ? b.get("S").asText() : extractScalarValue(b);+ if (aStr == null) aStr = "";+ if (bStr == null) bStr = "";+ return aStr.compareTo(bStr);+ }+private static int computeSize(JsonNode attrNode) {if (attrNode.has("S")) return attrNode.get("S").asText().length();if (attrNode.has("B")) return attrNode.get("B").asText().length(); // base64 lengthdiff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/ProjectionEvaluator.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/ProjectionEvaluator.javanew file mode 100644index 0000000000..d7a1e50136--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/ProjectionEvaluator.java@@ -0,0 +1,178 @@+package io.github.hectorvent.floci.services.dynamodb;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ArrayNode;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.core.common.AwsException;++import java.util.ArrayList;+import java.util.List;+import java.util.Set;++/**+ * Applies a DynamoDB ProjectionExpression to a result item, returning a new+ * ObjectNode containing only the projected attributes.+ */+final class ProjectionEvaluator {++ private static final ObjectMapper MAPPER = new ObjectMapper();++ private ProjectionEvaluator() {}++ /**+ * Returns a new ObjectNode containing only the paths named in the expression.+ * Resolves #alias references via exprAttrNames. Handles dot-path and [n] list index segments.+ */+ static ObjectNode project(JsonNode item, String projectionExpression, JsonNode exprAttrNames) {+ if (item == null || projectionExpression == null || projectionExpression.isBlank()) {+ return (ObjectNode) item;+ }+ validateProjectionExpression(projectionExpression);+ DynamoDbReservedWords.check(projectionExpression, "ProjectionExpression");+ ObjectNode result = MAPPER.createObjectNode();+ for (String rawPath : splitProjectionPaths(projectionExpression)) {+ List<String> segments = resolvePath(rawPath.trim(), exprAttrNames);+ if (segments.isEmpty()) continue;+ copyPath(item, result, segments, 0);+ }+ return result;+ }++ /**+ * Returns a new ObjectNode containing only the named top-level attributes.+ * Used by AttributesToGet (no alias resolution, no nested paths).+ */+ static ObjectNode trimToAttributes(ObjectNode item, Set<String> keep) {+ ObjectNode result = MAPPER.createObjectNode();+ item.fields().forEachRemaining(entry -> {+ if (keep.contains(entry.getKey())) {+ result.set(entry.getKey(), entry.getValue());+ }+ });+ return result;+ }++ static void validateSyntax(String expression, String expressionType) {+ if (expression == null || expression.isBlank()) return;+ char first = expression.charAt(0);+ if (!Character.isLetterOrDigit(first) && first != '#' && first != '_') {+ String token = String.valueOf(first);+ String near = expression.length() > 2 ? expression.substring(1, 3) : expression.substring(1);+ throw new AwsException("ValidationException",+ "Invalid " + expressionType + ": Syntax error; token: \"" + token + "\", near: \"" + near + "\"", 400);+ }+ }++ private static void validateProjectionExpression(String expression) {+ validateSyntax(expression, "ProjectionExpression");+ }++ // ── Path splitting ──++ private static List<String> splitProjectionPaths(String expression) {+ List<String> paths = new ArrayList<>();+ int depth = 0;+ int start = 0;+ for (int i = 0; i < expression.length(); i++) {+ char c = expression.charAt(i);+ if (c == '(') depth++;+ else if (c == ')') depth--;+ else if (c == ',' && depth == 0) {+ paths.add(expression.substring(start, i).trim());+ start = i + 1;+ }+ }+ if (start < expression.length()) {+ paths.add(expression.substring(start).trim());+ }+ return paths;+ }++ // ── Path resolution ──++ private static List<String> resolvePath(String path, JsonNode exprAttrNames) {+ List<String> segments = new ArrayList<>();+ // Tokenize on dots, preserving [n] bracket indices+ String[] parts = path.split("\\.");+ for (String part : parts) {+ // A part may end with [n] index(es) like "list[0]" or "[0]"+ int bracketIdx = part.indexOf('[');+ if (bracketIdx >= 0) {+ String name = part.substring(0, bracketIdx);+ if (!name.isEmpty()) {+ segments.add(resolveSegment(name, exprAttrNames));+ }+ // Parse each [n] suffix+ String rest = part.substring(bracketIdx);+ int i = 0;+ while (i < rest.length() && rest.charAt(i) == '[') {+ int close = rest.indexOf(']', i);+ if (close < 0) break;+ segments.add(rest.substring(i, close + 1)); // e.g. "[0]"+ i = close + 1;+ }+ } else {+ segments.add(resolveSegment(part, exprAttrNames));+ }+ }+ return segments;+ }++ private static String resolveSegment(String seg, JsonNode exprAttrNames) {+ if (seg.startsWith("#") && exprAttrNames != null) {+ JsonNode resolved = exprAttrNames.get(seg);+ return resolved != null ? resolved.asText() : seg;+ }+ return seg;+ }++ // ── Tree walking ──++ private static void copyPath(JsonNode src, ObjectNode dest, List<String> segments, int idx) {+ if (idx >= segments.size()) return;+ String seg = segments.get(idx);++ if (seg.matches("\\[\\d+\\]")) {+ // List index at root level — handled by the caller+ return;+ }++ JsonNode child = src.get(seg);+ if (child == null) return;++ if (idx == segments.size() - 1) {+ // Leaf: copy the whole attribute node+ dest.set(seg, child);+ } else {+ String nextSeg = segments.get(idx + 1);+ if (nextSeg.matches("\\[\\d+\\]")) {+ // Next is a list index — extract just that element+ int listIdx = Integer.parseInt(nextSeg.substring(1, nextSeg.length() - 1));+ JsonNode listNode = child.has("L") ? child.get("L") : child;+ if (listNode.isArray() && listIdx < listNode.size()) {+ JsonNode element = listNode.get(listIdx);+ // Build {"L": [element]} wrapper+ ObjectNode wrapper = MAPPER.createObjectNode();+ ArrayNode newList = MAPPER.createArrayNode();+ newList.add(element);+ wrapper.set("L", newList);+ dest.set(seg, wrapper);+ }+ } else if (child.has("M")) {+ // Nested map — recurse+ ObjectNode nestedDest = MAPPER.createObjectNode();+ copyPath(child.get("M"), nestedDest, segments, idx + 1);+ ObjectNode wrapper = MAPPER.createObjectNode();+ wrapper.set("M", nestedDest);+ dest.set(seg, wrapper);+ } else if (child.isObject()) {+ ObjectNode nestedDest = MAPPER.createObjectNode();+ copyPath(child, nestedDest, segments, idx + 1);+ dest.set(seg, nestedDest);+ } else {+ dest.set(seg, child);+ }+ }+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/TransactionCanceledException.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/TransactionCanceledException.javaindex 59f09741a6..489d90539c 100644--- a/src/main/java/io/github/hectorvent/floci/services/dynamodb/TransactionCanceledException.java+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/TransactionCanceledException.java@@ -1,26 +1,27 @@package io.github.hectorvent.floci.services.dynamodb;+import com.fasterxml.jackson.databind.JsonNode;import io.github.hectorvent.floci.core.common.AwsException;import java.util.List;-/**- * Thrown when a TransactWriteItems condition check fails.- * Carries per-item cancellation reasons for the AWS response.- */public class TransactionCanceledException extends AwsException {- private final List<String> cancellationReasons;+ public record CancellationReason(String code, JsonNode item) {}- public TransactionCanceledException(List<String> cancellationReasons) {+ private final List<CancellationReason> cancellationReasons;++ public TransactionCanceledException(List<CancellationReason> cancellationReasons) {super("TransactionCanceledException","Transaction cancelled, please refer cancellation reasons for specific reasons [" +- String.join(", ", cancellationReasons) + "]",+ cancellationReasons.stream()+ .map(r -> r.code().isEmpty() ? "None" : r.code())+ .reduce((a, b) -> a + ", " + b).orElse("") + "]",400);this.cancellationReasons = cancellationReasons;}- public List<String> getCancellationReasons() {+ public List<CancellationReason> getCancellationReasons() {return cancellationReasons;}}diff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/model/LocalSecondaryIndex.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/model/LocalSecondaryIndex.javaindex 77987e39ae..6ab4d3a132 100644--- a/src/main/java/io/github/hectorvent/floci/services/dynamodb/model/LocalSecondaryIndex.java+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/model/LocalSecondaryIndex.java@@ -18,17 +18,27 @@ public class LocalSecondaryIndex {private List<KeySchemaElement> keySchema;private String indexArn;private String projectionType;+ private List<String> nonKeyAttributes;private long indexSizeBytes;private long itemCount;- public LocalSecondaryIndex() {}+ public LocalSecondaryIndex() {+ this.nonKeyAttributes = new java.util.ArrayList<>();+ }public LocalSecondaryIndex(String indexName, List<KeySchemaElement> keySchema,String indexArn, String projectionType) {+ this(indexName, keySchema, indexArn, projectionType, null);+ }++ public LocalSecondaryIndex(String indexName, List<KeySchemaElement> keySchema,+ String indexArn, String projectionType, List<String> nonKeyAttributes) {this.indexName = indexName;this.keySchema = keySchema;this.indexArn = indexArn;this.projectionType = projectionType != null ? projectionType : "ALL";+ this.nonKeyAttributes = "INCLUDE".equals(this.projectionType) && nonKeyAttributes != null+ ? nonKeyAttributes : new java.util.ArrayList<>();}public String getIndexName() { return indexName; }@@ -43,6 +53,9 @@ public class LocalSecondaryIndex {public String getProjectionType() { return projectionType; }public void setProjectionType(String projectionType) { this.projectionType = projectionType; }+ public List<String> getNonKeyAttributes() { return nonKeyAttributes; }+ public void setNonKeyAttributes(List<String> nonKeyAttributes) { this.nonKeyAttributes = nonKeyAttributes; }+public long getIndexSizeBytes() { return indexSizeBytes; }public void setIndexSizeBytes(long indexSizeBytes) { this.indexSizeBytes = indexSizeBytes; }diff --git a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbConcurrencyIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbConcurrencyIntegrationTest.javaindex ae9aa5b567..4c359c9f16 100644--- a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbConcurrencyIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbConcurrencyIntegrationTest.java@@ -335,7 +335,7 @@ class DynamoDbConcurrencyIntegrationTest {ObjectNode tx2 = buildUpdateTx(pkB, exprValues);try {- service.transactWriteItems(List.of(tx1, tx2), "us-east-1");+ service.transactWriteItems(List.of(tx1, tx2), "us-east-1", null, null);committed.incrementAndGet();} catch (TransactionCanceledException e) {cancelled.incrementAndGet();@@ -392,7 +392,7 @@ class DynamoDbConcurrencyIntegrationTest {ObjectNode tx1 = buildUpdateTx(keyA, exprValues);ObjectNode tx2 = buildUpdateTx(keyB, exprValues);- service.transactWriteItems(List.of(tx1, tx2), "us-east-1");+ service.transactWriteItems(List.of(tx1, tx2), "us-east-1", null, null);});assertTrue(errors.isEmpty(),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 409dc2ac97..ba221677a9 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@@ -92,11 +92,13 @@ class DynamoDbFilterExpressionIntegrationTest {void scanFilterInOperator_singleValue() {// status IN (:v0) where v0=1 should return u1, u3scanWithFilter(- "status IN (:v0)",+ "#s IN (:v0)","""{":v0": {"N": "1"}}""",- null,+ """+ {"#s": "status"}+ """,2);}@@ -104,11 +106,13 @@ class DynamoDbFilterExpressionIntegrationTest {void scanFilterInOperator_multipleValues() {// status IN (:v0, :v1) where v0=1, v1=3 should return u1, u3, u4scanWithFilter(- "status IN (:v0, :v1)",+ "#s IN (:v0, :v1)","""{":v0": {"N": "1"}, ":v1": {"N": "3"}}""",- null,+ """+ {"#s": "status"}+ """,3);}@@ -132,11 +136,13 @@ class DynamoDbFilterExpressionIntegrationTest {void scanFilterOrOperator() {// status = :v1 OR status = :v2 should return u1, u2, u3 (status 1 or 2)scanWithFilter(- "status = :v1 OR status = :v2",+ "#s = :v1 OR #s = :v2","""{":v1": {"N": "1"}, ":v2": {"N": "2"}}""",- null,+ """+ {"#s": "status"}+ """,3);}@@ -159,11 +165,13 @@ class DynamoDbFilterExpressionIntegrationTest {// (status = :v1 OR status = :v3) AND category = :catA// status=1 OR status=3 → u1,u3,u4; AND category=A → u1,u3scanWithFilter(- "(status = :v1 OR status = :v3) AND category = :catA",+ "(#s = :v1 OR #s = :v3) AND category = :catA","""{":v1": {"N": "1"}, ":v3": {"N": "3"}, ":catA": {"S": "A"}}""",- null,+ """+ {"#s": "status"}+ """,2);}@@ -189,11 +197,13 @@ class DynamoDbFilterExpressionIntegrationTest {// (status 1 or 3) AND category A → u1,u3; OR deleted=true → u2// Total: u1, u2, u3scanWithFilter(- "((status = :v1 OR status = :v3) AND category = :catA) OR deleted = :del",+ "((#s = :v1 OR #s = :v3) AND category = :catA) OR deleted = :del","""{":v1": {"N": "1"}, ":v3": {"N": "3"}, ":catA": {"S": "A"}, ":del": {"BOOL": true}}""",- null,+ """+ {"#s": "status"}+ """,3);}@@ -201,11 +211,13 @@ class DynamoDbFilterExpressionIntegrationTest {void scanFilterNotWithParenthesizedAnd() {// NOT (deleted = :true AND status = :v2) — negate (u2 only) → u1, u3, u4scanWithFilter(- "NOT (deleted = :d AND status = :v2)",+ "NOT (deleted = :d AND #s = :v2)","""{":d": {"BOOL": true}, ":v2": {"N": "2"}}""",- null,+ """+ {"#s": "status"}+ """,3);}diff --git a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbIntegrationTest.javaindex 4b274a6e59..670b4b903c 100644--- a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbIntegrationTest.java@@ -959,7 +959,8 @@ class DynamoDbIntegrationTest {{"TableName": "ListAppendTable","Key": {"pk": {"S": "k1"}},- "UpdateExpression": "SET items = list_append(items, :val)",+ "UpdateExpression": "SET #i = list_append(#i, :val)",+ "ExpressionAttributeNames": {"#i": "items"},"ExpressionAttributeValues": {":val": {"L": [{"S": "b"}]}}}""")@@ -1645,7 +1646,8 @@ given(){"TableName": "%s","Key": {"GroupKey": {"S": "leader"}, "Id": {"S": "app1"}},- "UpdateExpression": "SET Owner = :1",+ "UpdateExpression": "SET #o = :1",+ "ExpressionAttributeNames": {"#o": "Owner"},"ExpressionAttributeValues": {":1": {"S": "owner-app1"}}}""".formatted(tableName))@@ -1659,7 +1661,8 @@ given(){"TableName": "%s","Key": {"GroupKey": {"S": "leader"}, "Id": {"S": "app2"}},- "UpdateExpression": "SET Owner = :1",+ "UpdateExpression": "SET #o = :1",+ "ExpressionAttributeNames": {"#o": "Owner"},"ExpressionAttributeValues": {":1": {"S": "owner-app2"}}}""".formatted(tableName))diff --git a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbJsonHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbJsonHandlerTest.javaindex 790da6f160..914247a99d 100644--- a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbJsonHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbJsonHandlerTest.java@@ -123,9 +123,12 @@ class DynamoDbJsonHandlerTest {exprValues.set(":start", startVal);exprValues.set(":inc", incVal);+ ObjectNode exprNames = mapper.createObjectNode();+ exprNames.put("#cnt", "counter");+JsonNode request = createRequest("Users", key,- "SET counter = if_not_exists(counter, :start) + :inc",- null, exprValues, "UPDATED_NEW");+ "SET #cnt = if_not_exists(#cnt, :start) + :inc",+ exprNames, exprValues, "UPDATED_NEW");Response response = handler.handle("UpdateItem", request, "us-east-1");assertNotNull(response);diff --git a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbServiceTest.javaindex 85330bd176..e295996dc0 100644--- a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbServiceTest.java@@ -94,7 +94,7 @@ class DynamoDbServiceTest {List.of(new KeySchemaElement("userId", "HASH")),List.of(new AttributeDefinition("userId", "S")),5L, 5L));- assertEquals("InvalidParameterValue", ex.getErrorCode());+ assertEquals("ValidationException", ex.getErrorCode());assertEquals(400, ex.getHttpStatus());}@@ -183,17 +183,21 @@ class DynamoDbServiceTest {ObjectNode exprValues = mapper.createObjectNode();exprValues.set(":name", attributeValue("S", "Alice"));+ ObjectNode exprNames = mapper.createObjectNode();+ exprNames.put("#n", "name");+ObjectNode update = mapper.createObjectNode();update.put("TableName", usersArn);update.set("Key", item("userId", "user-1"));- update.put("ConditionExpression", "name = :name");+ update.put("ConditionExpression", "#n = :name");update.put("UpdateExpression", "SET email = :name");+ update.set("ExpressionAttributeNames", exprNames);update.set("ExpressionAttributeValues", exprValues);ObjectNode transactItem = mapper.createObjectNode();transactItem.set("Update", update);- assertDoesNotThrow(() -> service.transactWriteItems(List.of(transactItem), "us-east-1"));+ assertDoesNotThrow(() -> service.transactWriteItems(List.of(transactItem), "us-east-1", null, null));assertEquals("Alice", service.getItem("Users", item("userId", "user-1")).get("email").get("S").asText());}@@ -203,7 +207,7 @@ class DynamoDbServiceTest {AwsException ex = assertThrows(AwsException.class,() -> service.describeTable(tableArn("eu-west-1", "Users")));- assertEquals("InvalidParameterValue", ex.getErrorCode());+ assertEquals("ValidationException", ex.getErrorCode());assertEquals(400, ex.getHttpStatus());}@@ -573,9 +577,12 @@ class DynamoDbServiceTest {exprValues.set(":name", nameVal);exprValues.set(":score", scoreVal);+ ObjectNode exprNames = mapper.createObjectNode();+ exprNames.put("#n", "name");+service.updateItem("Users", key, null,- "SET name = if_not_exists(name, :name), score = if_not_exists(score, :score)",- null, exprValues, null);+ "SET #n = if_not_exists(#n, :name), score = if_not_exists(score, :score)",+ exprNames, exprValues, null);JsonNode stored = service.getItem("Users", key);assertNotNull(stored, "item should have been created");@@ -604,10 +611,13 @@ class DynamoDbServiceTest {ObjectNode fallbackVal = mapper.createObjectNode(); fallbackVal.put("S", "fallback");exprValues.set(":v", fallbackVal);+ ObjectNode exprNames = mapper.createObjectNode();+ exprNames.put("#src", "source");+// target = if_not_exists(source, :v) — source exists, so target should receive source's valueservice.updateItem("Users", key, null,- "SET target = if_not_exists(source, :v)",- null, exprValues, null);+ "SET target = if_not_exists(#src, :v)",+ exprNames, exprValues, null);JsonNode stored = service.getItem("Users", key);assertNotNull(stored);@@ -630,9 +640,12 @@ class DynamoDbServiceTest {ObjectNode fallbackVal = mapper.createObjectNode(); fallbackVal.put("S", "fallback");exprValues.set(":v", fallbackVal);+ ObjectNode exprNames = mapper.createObjectNode();+ exprNames.put("#src", "source");+service.updateItem("Users", key, null,- "SET target = if_not_exists(source, :v)",- null, exprValues, null);+ "SET target = if_not_exists(#src, :v)",+ exprNames, exprValues, null);JsonNode stored = service.getItem("Users", key);assertNotNull(stored);@@ -659,9 +672,12 @@ class DynamoDbServiceTest {incVal.put("N", "1");exprValues.set(":inc", incVal);+ ObjectNode exprNames = mapper.createObjectNode();+ exprNames.put("#cnt", "counter");+service.updateItem("Users", key, null,- "SET counter = counter + :inc",- null, exprValues, null);+ "SET #cnt = #cnt + :inc",+ exprNames, exprValues, null);JsonNode stored = service.getItem("Users", key);assertNotNull(stored);@@ -686,9 +702,12 @@ class DynamoDbServiceTest {decVal.put("N", "3");exprValues.set(":dec", decVal);+ ObjectNode exprNames = mapper.createObjectNode();+ exprNames.put("#cnt", "counter");+service.updateItem("Users", key, null,- "SET counter = counter - :dec",- null, exprValues, null);+ "SET #cnt = #cnt - :dec",+ exprNames, exprValues, null);JsonNode stored = service.getItem("Users", key);assertNotNull(stored);@@ -709,9 +728,12 @@ class DynamoDbServiceTest {exprValues.set(":start", startVal);exprValues.set(":inc", incVal);+ ObjectNode exprNames = mapper.createObjectNode();+ exprNames.put("#cnt", "counter");+service.updateItem("Users", key, null,- "SET counter = if_not_exists(counter, :start) + :inc",- null, exprValues, null);+ "SET #cnt = if_not_exists(#cnt, :start) + :inc",+ exprNames, exprValues, null);JsonNode stored = service.getItem("Users", key);assertNotNull(stored);@@ -739,9 +761,12 @@ class DynamoDbServiceTest {exprValues.set(":start", startVal);exprValues.set(":inc", incVal);+ ObjectNode exprNames = mapper.createObjectNode();+ exprNames.put("#cnt", "counter");+service.updateItem("Users", key, null,- "SET counter = if_not_exists(counter, :start) + :inc",- null, exprValues, null);+ "SET #cnt = if_not_exists(#cnt, :start) + :inc",+ exprNames, exprValues, null);JsonNode stored = service.getItem("Users", key);assertNotNull(stored);@@ -762,11 +787,14 @@ class DynamoDbServiceTest {exprValues.set(":start", startVal);exprValues.set(":inc", incVal);+ ObjectNode exprNames = mapper.createObjectNode();+ exprNames.put("#cnt", "counter");+// Three consecutive incrementsfor (int i = 0; i < 3; i++) {service.updateItem("Users", key, null,- "SET counter = if_not_exists(counter, :start) + :inc",- null, exprValues, null);+ "SET #cnt = if_not_exists(#cnt, :start) + :inc",+ exprNames, exprValues, null);}JsonNode stored = service.getItem("Users", key);@@ -833,7 +861,10 @@ class DynamoDbServiceTest {ObjectNode exprValues = mapper.createObjectNode();exprValues.set(":r", attributeValue("S", "admin"));- DynamoDbService.ScanResult result = service.scan("Users", "contains(roles, :r)", null, exprValues, null, null, null);+ ObjectNode exprNames = mapper.createObjectNode();+ exprNames.put("#r", "roles");++ DynamoDbService.ScanResult result = service.scan("Users", "contains(#r, :r)", exprNames, exprValues, null, null, null);assertEquals(1, result.items().size());}@@ -966,9 +997,12 @@ class DynamoDbServiceTest {exprValues.set(":e", listAttributeValue());exprValues.set(":val", listAttributeValue("a"));+ ObjectNode exprNames = mapper.createObjectNode();+ exprNames.put("#items", "items");+service.updateItem("Users", key, null,- "SET items = list_append(if_not_exists(items, :e), :val)",- null, exprValues, null);+ "SET #items = list_append(if_not_exists(#items, :e), :val)",+ exprNames, exprValues, null);JsonNode stored = service.getItem("Users", key);assertNotNull(stored);@@ -990,9 +1024,12 @@ class DynamoDbServiceTest {exprValues.set(":e", listAttributeValue());exprValues.set(":val", listAttributeValue("b"));+ ObjectNode exprNames = mapper.createObjectNode();+ exprNames.put("#items", "items");+service.updateItem("Users", key, null,- "SET items = list_append(if_not_exists(items, :e), :val)",- null, exprValues, null);+ "SET #items = list_append(if_not_exists(#items, :e), :val)",+ exprNames, exprValues, null);JsonNode stored = service.getItem("Users", key);assertNotNull(stored);@@ -1025,7 +1062,10 @@ class DynamoDbServiceTest {ObjectNode exprValues = mapper.createObjectNode();exprValues.set(":v", attributeValue("N", "10.0"));- DynamoDbService.ScanResult result = service.scan("Users", "contains(values, :v)", null, exprValues, null, null, null);+ ObjectNode exprNames = mapper.createObjectNode();+ exprNames.put("#vals", "values");++ DynamoDbService.ScanResult result = service.scan("Users", "contains(#vals, :v)", exprNames, exprValues, null, null, null);assertEquals(1, result.items().size(), "contains() on List with N elements should use type-aware numeric comparison");}@@ -1305,16 +1345,18 @@ class DynamoDbServiceTest {ObjectNode key1 = item("customerId", "c1", "orderId", "app1");ObjectNode exprValues = mapper.createObjectNode();exprValues.set(":owner", attributeValue("S", "owner-1"));+ ObjectNode exprNames = mapper.createObjectNode();+ exprNames.put("#owner", "owner");service.updateItem("Orders", key1, null,- "SET owner = :owner", null, exprValues, null);+ "SET #owner = :owner", exprNames, exprValues, null);ObjectNode key2 = item("customerId", "c1", "orderId", "app2");exprValues = mapper.createObjectNode();exprValues.set(":owner", attributeValue("S", "owner-2"));service.updateItem("Orders", key2, null,- "SET owner = :owner", null, exprValues, null);+ "SET #owner = :owner", exprNames, exprValues, null);DynamoDbService.ScanResult scanResult = service.scan("Orders", null, null, null, null, null, null);assertEquals(2, scanResult.items().size(),@@ -1678,8 +1720,11 @@ class DynamoDbServiceTest {values.set(":v1", attributeValue("S", "one"));values.set(":v2", attributeValue("S", "two"));+ ObjectNode names = mapper.createObjectNode();+ names.put("#other", "other");+service.updateItem("Users", userIdKey("u11"), null,- "SET prefixSET = :v1, other = :v2", null, values, "ALL_NEW");+ "SET prefixSET = :v1, #other = :v2", names, values, "ALL_NEW");JsonNode stored = service.getItem("Users", userIdKey("u11"));assertEquals("one", stored.get("prefixSET").get("S").asText());@@ -2113,9 +2158,12 @@ class DynamoDbServiceTest {ObjectNode vNode = mapper.createObjectNode(); vNode.put("N", "3");exprValues.set(":v", vNode);+ ObjectNode exprNames = mapper.createObjectNode();+ exprNames.put("#cnt", "counter");+service.updateItem("Users", key, null,- "SET counter = ((counter - :v))",- null, exprValues, null);+ "SET #cnt = ((#cnt - :v))",+ exprNames, exprValues, null);JsonNode stored = service.getItem("Users", key);assertEquals("7", stored.get("counter").get("N").asText());diff --git a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbTableArnIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbTableArnIntegrationTest.javaindex 245e6c4db6..87fe83163b 100644--- a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbTableArnIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbTableArnIntegrationTest.java@@ -128,8 +128,9 @@ class DynamoDbTableArnIntegrationTest {"Update": {"TableName": "%s","Key": {"pk": {"S": "user-1"}},- "ConditionExpression": "name = :expected",+ "ConditionExpression": "#n = :expected","UpdateExpression": "SET email = :email",+ "ExpressionAttributeNames": {"#n": "name"},"ExpressionAttributeValues": {":expected": {"S": "Alice"},":email": {"S": "[email protected]"}@@ -250,7 +251,7 @@ class DynamoDbTableArnIntegrationTest {.post("/").then().statusCode(400)- .body("__type", equalTo("InvalidParameterValue"))+ .body("__type", equalTo("ValidationException")).body("message", containsString("does not match request region"));given()@@ -263,7 +264,7 @@ class DynamoDbTableArnIntegrationTest {.post("/").then().statusCode(400)- .body("__type", equalTo("InvalidParameterValue"))+ .body("__type", equalTo("ValidationException")).body("message", containsString("does not accept index or stream ARNs"));}@@ -409,7 +410,7 @@ class DynamoDbTableArnIntegrationTest {.post("/").then().statusCode(400)- .body("__type", equalTo("InvalidParameterValue"))+ .body("__type", equalTo("ValidationException")).body("message", containsString("must be a short name, not an ARN"));}diff --git a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbTableNamesTest.java b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbTableNamesTest.javaindex a82cd14db6..b1d947682c 100644--- a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbTableNamesTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbTableNamesTest.java@@ -41,7 +41,7 @@ class DynamoDbTableNamesTest {DynamoDbTableNames.resolveWithRegion("arn:aws:dynamodb:eu-west-1:000000000000:table/Orders","us-east-1"));- assertEquals("InvalidParameterValue", ex.getErrorCode());+ assertEquals("ValidationException", ex.getErrorCode());assertEquals(400, ex.getHttpStatus());}@@ -62,7 +62,7 @@ class DynamoDbTableNamesTest {})void resolveRejectsMalformedInputs(String input) {AwsException ex = assertThrows(AwsException.class, () -> DynamoDbTableNames.resolve(input));- assertEquals("InvalidParameterValue", ex.getErrorCode());+ assertEquals("ValidationException", ex.getErrorCode());assertEquals(400, ex.getHttpStatus());}@@ -85,7 +85,7 @@ class DynamoDbTableNamesTest {})void requireShortNameRejectsArnInput(String arn) {AwsException ex = assertThrows(AwsException.class, () -> DynamoDbTableNames.requireShortName(arn));- assertEquals("InvalidParameterValue", ex.getErrorCode());+ assertEquals("ValidationException", ex.getErrorCode());assertEquals(400, ex.getHttpStatus());}@@ -93,7 +93,7 @@ class DynamoDbTableNamesTest {@ValueSource(strings = {"", " ", "ab", "name with spaces"})void requireShortNameRejectsMalformedInput(String input) {AwsException ex = assertThrows(AwsException.class, () -> DynamoDbTableNames.requireShortName(input));- assertEquals("InvalidParameterValue", ex.getErrorCode());+ assertEquals("ValidationException", ex.getErrorCode());assertEquals(400, ex.getHttpStatus());}