diff --git a/.changes/next-release/feature-AmazonDynamoDBEnhancedClient-8fb589b.json b/.changes/next-release/feature-AmazonDynamoDBEnhancedClient-8fb589b.json new file mode 100644 index 000000000000..9af1fa1a25db --- /dev/null +++ b/.changes/next-release/feature-AmazonDynamoDBEnhancedClient-8fb589b.json @@ -0,0 +1,6 @@ +{ + "type": "feature", + "category": "Amazon DynamoDB Enhanced Client", + "contributor": "", + "description": "Improve missing converter error handling in DynamoDB Enhanced Client" +} diff --git a/services-custom/dynamodb-enhanced/src/main/java/software/amazon/awssdk/enhanced/dynamodb/DefaultAttributeConverterProvider.java b/services-custom/dynamodb-enhanced/src/main/java/software/amazon/awssdk/enhanced/dynamodb/DefaultAttributeConverterProvider.java index 88cfbe39e82f..3c10b0aa7b02 100644 --- a/services-custom/dynamodb-enhanced/src/main/java/software/amazon/awssdk/enhanced/dynamodb/DefaultAttributeConverterProvider.java +++ b/services-custom/dynamodb-enhanced/src/main/java/software/amazon/awssdk/enhanced/dynamodb/DefaultAttributeConverterProvider.java @@ -72,6 +72,7 @@ import software.amazon.awssdk.enhanced.dynamodb.internal.converter.attribute.ZoneIdAttributeConverter; import software.amazon.awssdk.enhanced.dynamodb.internal.converter.attribute.ZoneOffsetAttributeConverter; import software.amazon.awssdk.enhanced.dynamodb.internal.converter.attribute.ZonedDateTimeAsStringAttributeConverter; +import software.amazon.awssdk.utils.CollectionUtils; import software.amazon.awssdk.utils.Logger; import software.amazon.awssdk.utils.Validate; @@ -157,17 +158,21 @@ private Optional> findConverterInternal(EnhancedType innerType = (EnhancedType) type.rawClassParameters().get(0); - AttributeConverter innerConverter = findConverter(innerType) - .orElseThrow(() -> new IllegalStateException("Converter not found for " + type)); - return Optional.of((AttributeConverter) ListAttributeConverter.create(innerConverter)); - } else if (type.rawClass().isEnum()) { - return Optional.of(EnumAttributeConverter.create(((EnhancedType) type).rawClass())); + if (!Object.class.equals(type.rawClass())) { + if (type.rawClass().isAssignableFrom(Map.class)) { + requireTypeParameters(type); + converter = createMapConverter(type); + } else if (type.rawClass().isAssignableFrom(Set.class)) { + requireTypeParameters(type); + converter = createSetConverter(type); + } else if (type.rawClass().isAssignableFrom(List.class)) { + requireTypeParameters(type); + EnhancedType innerType = (EnhancedType) type.rawClassParameters().get(0); + AttributeConverter innerConverter = converterFor(innerType, type); + return Optional.of((AttributeConverter) ListAttributeConverter.create(innerConverter)); + } else if (type.rawClass().isEnum()) { + return Optional.of(EnumAttributeConverter.create(((EnhancedType) type).rawClass())); + } } if (type.tableSchema().isPresent()) { @@ -186,14 +191,34 @@ private boolean shouldCache(Class type) { return !type.isAnonymousClass(); } + private static void requireTypeParameters(EnhancedType type) { + if (CollectionUtils.isNullOrEmpty(type.rawClassParameters())) { + throw new IllegalStateException("Converter not found for " + type + ". Type parameters are required for this type."); + } + } + + private AttributeConverter converterFor(EnhancedType type, + EnhancedType containerType) { + return findConverter(type) + .orElseThrow(() -> converterNotFound(type, containerType)); + } + + private static IllegalStateException converterNotFound(EnhancedType type, + EnhancedType containerType) { + String elementOrValue = containerType.rawClass().isAssignableFrom(Map.class) ? "value" : "element"; + return new IllegalStateException("Converter not found for " + type + + " (" + elementOrValue + " of " + containerType + "). " + + "DefaultAttributeConverterProvider resolves collection " + elementOrValue + + " types only from its own converters."); + } + @SuppressWarnings("unchecked") private AttributeConverter createMapConverter(EnhancedType type) { EnhancedType keyType = type.rawClassParameters().get(0); EnhancedType valueType = (EnhancedType) type.rawClassParameters().get(1); StringConverter keyConverter = StringConverterProvider.defaultProvider().converterFor(keyType); - AttributeConverter valueConverter = findConverter(valueType) - .orElseThrow(() -> new IllegalStateException("Converter not found for " + type)); + AttributeConverter valueConverter = converterFor(valueType, type); return (AttributeConverter) MapAttributeConverter.mapConverter(keyConverter, valueConverter); } @@ -201,8 +226,7 @@ private AttributeConverter createMapConverter(EnhancedType type) { @SuppressWarnings("unchecked") private AttributeConverter createSetConverter(EnhancedType type) { EnhancedType innerType = (EnhancedType) type.rawClassParameters().get(0); - AttributeConverter innerConverter = findConverter(innerType) - .orElseThrow(() -> new IllegalStateException("Converter not found for " + type)); + AttributeConverter innerConverter = converterFor(innerType, type); return (AttributeConverter) SetAttributeConverter.setConverter(innerConverter); } diff --git a/services-custom/dynamodb-enhanced/src/main/java/software/amazon/awssdk/enhanced/dynamodb/internal/document/DefaultEnhancedDocument.java b/services-custom/dynamodb-enhanced/src/main/java/software/amazon/awssdk/enhanced/dynamodb/internal/document/DefaultEnhancedDocument.java index 8a9eb68f58f3..b8566d8dc945 100644 --- a/services-custom/dynamodb-enhanced/src/main/java/software/amazon/awssdk/enhanced/dynamodb/internal/document/DefaultEnhancedDocument.java +++ b/services-custom/dynamodb-enhanced/src/main/java/software/amazon/awssdk/enhanced/dynamodb/internal/document/DefaultEnhancedDocument.java @@ -45,6 +45,7 @@ import software.amazon.awssdk.protocols.jsoncore.JsonNode; import software.amazon.awssdk.protocols.jsoncore.JsonNodeParser; import software.amazon.awssdk.services.dynamodb.model.AttributeValue; +import software.amazon.awssdk.utils.CollectionUtils; import software.amazon.awssdk.utils.Lazy; import software.amazon.awssdk.utils.StringUtils; import software.amazon.awssdk.utils.Validate; @@ -89,14 +90,18 @@ public static Builder builder() { public static AttributeConverter converterForClass(EnhancedType type, ChainConverterProvider chainConverterProvider) { - if (type.rawClass().isAssignableFrom(List.class)) { - return (AttributeConverter) ListAttributeConverter - .create(converterForClass(type.rawClassParameters().get(0), chainConverterProvider)); - } - if (type.rawClass().isAssignableFrom(Map.class)) { - return (AttributeConverter) MapAttributeConverter.mapConverter( - StringConverterProvider.defaultProvider().converterFor(type.rawClassParameters().get(0)), - converterForClass(type.rawClassParameters().get(1), chainConverterProvider)); + if (!Object.class.equals(type.rawClass())) { + if (type.rawClass().isAssignableFrom(List.class)) { + requireTypeParameters(type); + return (AttributeConverter) ListAttributeConverter + .create(converterForClass(type.rawClassParameters().get(0), chainConverterProvider)); + } + if (type.rawClass().isAssignableFrom(Map.class)) { + requireTypeParameters(type); + return (AttributeConverter) MapAttributeConverter.mapConverter( + StringConverterProvider.defaultProvider().converterFor(type.rawClassParameters().get(0)), + converterForClass(type.rawClassParameters().get(1), chainConverterProvider)); + } } return Optional.ofNullable(chainConverterProvider.converterFor(type)) .orElseThrow(() -> new IllegalStateException( @@ -496,4 +501,12 @@ private static void checkAndValidateClass(Class type, boolean isPut) { String.format(VALIDATE_TYPE_ERROR, "Map", isPut ? "put" : "get", "Map")); } + + private static void requireTypeParameters(EnhancedType type) { + if (CollectionUtils.isNullOrEmpty(type.rawClassParameters())) { + throw new IllegalStateException( + "AttributeConverter not found for class " + type + + ". Type parameters are required for this type."); + } + } } \ No newline at end of file diff --git a/services-custom/dynamodb-enhanced/src/test/java/software/amazon/awssdk/enhanced/dynamodb/DefaultAttributeConverterProviderTest.java b/services-custom/dynamodb-enhanced/src/test/java/software/amazon/awssdk/enhanced/dynamodb/DefaultAttributeConverterProviderTest.java index 417c8fb24547..73b12ccca6d8 100644 --- a/services-custom/dynamodb-enhanced/src/test/java/software/amazon/awssdk/enhanced/dynamodb/DefaultAttributeConverterProviderTest.java +++ b/services-custom/dynamodb-enhanced/src/test/java/software/amazon/awssdk/enhanced/dynamodb/DefaultAttributeConverterProviderTest.java @@ -18,10 +18,20 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import java.util.HashMap; import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.function.Function; +import java.util.stream.Stream; import org.apache.logging.log4j.core.LogEvent; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import org.slf4j.event.Level; +import software.amazon.awssdk.enhanced.dynamodb.mapper.StaticTableSchema; +import software.amazon.awssdk.services.dynamodb.model.AttributeValue; public class DefaultAttributeConverterProviderTest { @@ -47,8 +57,7 @@ void findConverter_whenConverterNotFound_logsNoConverter() { assertThatThrownBy(() -> provider.converterFor(EnhancedType.of(CustomUnsupportedType.class))) .isInstanceOf(IllegalStateException.class) - .hasMessageContaining("Converter not found for EnhancedType(software.amazon.awssdk.enhanced.dynamodb" - + ".DefaultAttributeConverterProviderTest$CustomUnsupportedType)"); + .hasMessage("Converter not found for " + EnhancedType.of(CustomUnsupportedType.class)); List logEvents = logCaptor.loggedEvents(); assertThat(logEvents).hasSize(1); assertThat(logEvents.get(0).getLevel().name()).isEqualTo(Level.DEBUG.name()); @@ -58,9 +67,179 @@ void findConverter_whenConverterNotFound_logsNoConverter() { } } + @ParameterizedTest + @MethodSource("unsupportedTypes") + void converterFor_whenUnsupportedType_throwsConverterNotFound(EnhancedType type) { + DefaultAttributeConverterProvider provider = DefaultAttributeConverterProvider.create(); + + assertThatThrownBy(() -> provider.converterFor(type)) + .isInstanceOf(IllegalStateException.class) + .hasMessage("Converter not found for " + type); + } + + @ParameterizedTest + @MethodSource("customConverters") + void build_whenCustomProviderFirst_usesCustomConverter(AttributeConverter converter) { + AttributeConverterProvider customProvider = new CustomAttributeConverterProvider(converter); + StaticTableSchema> schema = + schemaWithAttribute(converter.type()) + .attributeConverterProviders(customProvider, DefaultAttributeConverterProvider.create()) + .build(); + + assertThat(schema.converterForAttribute("value")).isSameAs(converter); + } + + @ParameterizedTest + @MethodSource("rawCollectionTypes") + void findConverter_whenRawCollectionType_throwsConverterNotFound(EnhancedType type) { + DefaultAttributeConverterProvider provider = DefaultAttributeConverterProvider.create(); + + assertThatThrownBy(() -> provider.converterFor(type)) + .isInstanceOf(IllegalStateException.class) + .hasMessage("Converter not found for " + type + ". Type parameters are required for this type."); + } + + @ParameterizedTest + @MethodSource("unsupportedTypes") + void converterFor_whenMapValueHasNoConverter_throwsConverterNotFound(EnhancedType valueType) { + DefaultAttributeConverterProvider provider = DefaultAttributeConverterProvider.create(); + EnhancedType type = EnhancedType.mapOf(EnhancedType.of(String.class), valueType); + + assertThatThrownBy(() -> provider.converterFor(type)) + .isInstanceOf(IllegalStateException.class) + .hasMessage(missingNestedConverterMessage(valueType, type, "value")); + } + + @ParameterizedTest + @MethodSource("unsupportedTypes") + void converterFor_whenSetElementHasNoConverter_throwsConverterNotFound(EnhancedType elementType) { + DefaultAttributeConverterProvider provider = DefaultAttributeConverterProvider.create(); + EnhancedType type = EnhancedType.setOf(elementType); + + assertThatThrownBy(() -> provider.converterFor(type)) + .isInstanceOf(IllegalStateException.class) + .hasMessage(missingNestedConverterMessage(elementType, type, "element")); + } + + @ParameterizedTest + @MethodSource("unsupportedTypes") + void converterFor_whenListElementHasNoConverter_throwsConverterNotFound(EnhancedType elementType) { + DefaultAttributeConverterProvider provider = DefaultAttributeConverterProvider.create(); + EnhancedType type = EnhancedType.listOf(elementType); + + assertThatThrownBy(() -> provider.converterFor(type)) + .isInstanceOf(IllegalStateException.class) + .hasMessage(missingNestedConverterMessage(elementType, type, "element")); + } + + @Test + void build_whenSchemaAttributeIsObject_throwsConverterNotFound() { + EnhancedType type = EnhancedType.of(Object.class); + + assertThatThrownBy(() -> schemaWithAttribute(type).build()) + .isInstanceOf(IllegalStateException.class) + .hasMessage("Converter not found for " + type); + } + + @ParameterizedTest + @MethodSource("collectionsWithObjectMembers") + void build_whenCollectionMemberIsObject_throwsConverterNotFound(EnhancedType type, String role) { + assertThatThrownBy(() -> schemaWithAttribute(type).build()) + .isInstanceOf(IllegalStateException.class) + .hasMessage(missingNestedConverterMessage(EnhancedType.of(Object.class), type, role)); + } + + private static Stream collectionsWithObjectMembers() { + return Stream.of( + Arguments.of(EnhancedType.listOf(Object.class), "element"), + Arguments.of(EnhancedType.setOf(Object.class), "element"), + Arguments.of(EnhancedType.mapOf(String.class, Object.class), "value")); + } + + private static StaticTableSchema.Builder> schemaWithAttribute(EnhancedType attributeType) { + return StaticTableSchema.builder(EnhancedType.mapOf(EnhancedType.of(String.class), attributeType)) + .newItemSupplier(HashMap::new) + .addAttribute(attributeType, a -> a.name("value") + .getter(item -> item.get("value")) + .setter((item, value) -> item.put("value", value))); + } + + private static String missingNestedConverterMessage(EnhancedType nestedType, + EnhancedType collectionType, + String elementOrValue) { + return "Converter not found for " + nestedType + + " (" + elementOrValue + " of " + collectionType + "). " + + "DefaultAttributeConverterProvider resolves collection " + elementOrValue + + " types only from its own converters."; + } + + private static Stream> customConverters() { + return Stream.of(new CustomStringConverter<>(EnhancedType.of(Object.class), Object::toString, value -> value), + new CustomStringConverter<>(EnhancedType.of(CustomUnsupportedType.class), value -> value.value, + CustomUnsupportedType::new)); + } + + private static Stream> unsupportedTypes() { + return Stream.of(EnhancedType.of(Object.class), EnhancedType.of(CustomUnsupportedType.class)); + } + + private static Stream> rawCollectionTypes() { + return Stream.of(EnhancedType.of(Map.class), EnhancedType.of(Set.class), EnhancedType.of(List.class)); + } + + private static final class CustomAttributeConverterProvider implements AttributeConverterProvider { + private final AttributeConverter converter; + + private CustomAttributeConverterProvider(AttributeConverter converter) { + this.converter = converter; + } + + @Override + public AttributeConverter converterFor(EnhancedType type) { + return converter.type().equals(type) ? (AttributeConverter) converter : null; + } + } + + private static final class CustomStringConverter implements AttributeConverter { + private final EnhancedType type; + private final Function encoder; + private final Function decoder; + + private CustomStringConverter(EnhancedType type, Function encoder, Function decoder) { + this.type = type; + this.encoder = encoder; + this.decoder = decoder; + } + + @Override + public AttributeValue transformFrom(T input) { + return AttributeValue.fromS(encoder.apply(input)); + } + + @Override + public T transformTo(AttributeValue input) { + return decoder.apply(input.s()); + } + + @Override + public EnhancedType type() { + return type; + } + + @Override + public AttributeValueType attributeValueType() { + return AttributeValueType.S; + } + } + /** * A custom type with no converter registered for it. */ private static class CustomUnsupportedType { + private final String value; + + private CustomUnsupportedType(String value) { + this.value = value; + } } } diff --git a/services-custom/dynamodb-enhanced/src/test/java/software/amazon/awssdk/enhanced/dynamodb/document/EnhancedDocumentTest.java b/services-custom/dynamodb-enhanced/src/test/java/software/amazon/awssdk/enhanced/dynamodb/document/EnhancedDocumentTest.java index 18852dce08a8..6a2ac6933d2a 100644 --- a/services-custom/dynamodb-enhanced/src/test/java/software/amazon/awssdk/enhanced/dynamodb/document/EnhancedDocumentTest.java +++ b/services-custom/dynamodb-enhanced/src/test/java/software/amazon/awssdk/enhanced/dynamodb/document/EnhancedDocumentTest.java @@ -34,10 +34,13 @@ import java.time.LocalDate; import java.util.ArrayList; import java.util.Arrays; +import java.util.Collections; import java.util.HashMap; +import java.util.HashSet; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.Set; import java.util.UUID; import java.util.stream.Collectors; @@ -50,11 +53,14 @@ import org.junit.jupiter.params.provider.ValueSource; import software.amazon.awssdk.core.SdkBytes; import software.amazon.awssdk.core.SdkNumber; +import software.amazon.awssdk.enhanced.dynamodb.AttributeConverter; import software.amazon.awssdk.enhanced.dynamodb.AttributeConverterProvider; +import software.amazon.awssdk.enhanced.dynamodb.AttributeValueType; import software.amazon.awssdk.enhanced.dynamodb.DefaultAttributeConverterProvider; import software.amazon.awssdk.enhanced.dynamodb.EnhancedType; import software.amazon.awssdk.enhanced.dynamodb.converters.document.CustomAttributeForDocumentConverterProvider; import software.amazon.awssdk.enhanced.dynamodb.converters.document.CustomClassForDocumentAPI; +import software.amazon.awssdk.services.dynamodb.model.AttributeValue; class EnhancedDocumentTest { @@ -505,6 +511,72 @@ void error_when_usingClassGetPut_for_CollectionValues(){ .withMessage("Values of type List are not supported by this API, please use the getList API instead"); } + @ParameterizedTest + @MethodSource("rawCollectionCases") + void toMap_whenCollectionHasNoTypeParameters_throwsConverterNotFound( + EnhancedType type, Object value, String messagePrefix) { + EnhancedDocument document = documentWithRawCollection("values", value, type); + + assertThatIllegalStateException() + .isThrownBy(document::toMap) + .withMessage(messagePrefix + type + ". Type parameters are required for this type."); + } + + @Test + void toMap_whenObjectTypeWithCustomProviderFirst_storesCustomValue() { + EnhancedType type = EnhancedType.of(Object.class); + ObjectStringProvider provider = new ObjectStringProvider(); + + Map map = EnhancedDocument.builder() + .attributeConverterProviders(provider, defaultProvider()) + .put("value", new Object(), type) + .build() + .toMap(); + + assertThat(map.get("value")).isEqualTo(AttributeValue.fromS("custom")); + } + + @ParameterizedTest + @MethodSource("unsupportedValues") + void toMap_whenUnsupportedType_throwsConverterNotFound(EnhancedType type, T input) { + assertThatIllegalStateException() + .isThrownBy(() -> documentWithDefaultProvider().put("value", input, type).build().toMap()) + .withMessage("Converter not found for " + type); + } + + @ParameterizedTest + @MethodSource("unsupportedValues") + void toMap_whenListElementHasNoConverter_throwsConverterNotFound(EnhancedType elementType, T element) { + EnhancedType> type = EnhancedType.listOf(elementType); + List input = Collections.singletonList(element); + + assertThatIllegalStateException() + .isThrownBy(() -> documentWithDefaultProvider().put("value", input, type).build().toMap()) + .withMessage("Converter not found for " + elementType); + } + + @ParameterizedTest + @MethodSource("unsupportedValues") + void toMap_whenMapValueHasNoConverter_throwsConverterNotFound(EnhancedType valueType, T value) { + EnhancedType> type = EnhancedType.mapOf(EnhancedType.of(String.class), valueType); + Map input = Collections.singletonMap("key", value); + + assertThatIllegalStateException() + .isThrownBy(() -> documentWithDefaultProvider().put("value", input, type).build().toMap()) + .withMessage("Converter not found for " + valueType); + } + + @ParameterizedTest + @MethodSource("unsupportedValues") + void toMap_whenSetElementHasNoConverter_throwsConverterNotFound(EnhancedType elementType, T element) { + EnhancedType> type = EnhancedType.setOf(elementType); + Set input = Collections.singleton(element); + + assertThatIllegalStateException() + .isThrownBy(() -> documentWithDefaultProvider().put("value", input, type).build().toMap()) + .withMessage(missingNestedConverterMessage(elementType, type, "element")); + } + @Test void toJson_numberFormatting_veryLargeNumbers() throws JsonProcessingException { EnhancedDocument doc = EnhancedDocument.builder() @@ -713,4 +785,94 @@ void toJson_fixtureFile_binaryEdgeCases() throws IOException { assertThat(actualOutput).isEqualTo(goldenOutput); } + + private static Stream rawCollectionCases() { + return Stream.of( + Arguments.of(EnhancedType.of(List.class), new ArrayList<>(), "AttributeConverter not found for class "), + Arguments.of(EnhancedType.of(Map.class), new HashMap<>(), "AttributeConverter not found for class "), + Arguments.of(EnhancedType.of(Set.class), new HashSet<>(), "Converter not found for ")); + } + + private static Stream unsupportedValues() { + return Stream.of(Arguments.of(EnhancedType.of(Object.class), new Object()), + Arguments.of(EnhancedType.of(UnsupportedType.class), new UnsupportedType("a"))); + } + + private static EnhancedDocument.Builder documentWithDefaultProvider() { + return EnhancedDocument.builder().attributeConverterProviders(defaultProvider()); + } + + private static String missingNestedConverterMessage(EnhancedType nestedType, + EnhancedType collectionType, + String role) { + return "Converter not found for " + nestedType + + " (" + role + " of " + collectionType + "). " + + "DefaultAttributeConverterProvider resolves collection " + role + + " types only from its own converters."; + } + + private static EnhancedDocument documentWithRawCollection(String name, Object value, EnhancedType type) { + return EnhancedDocument.builder() + .attributeConverterProviders(defaultProvider()) + .put(name, value, type) + .build(); + } + + private static final class UnsupportedType { + private final String value; + + private UnsupportedType(String value) { + this.value = value; + } + + @Override + public boolean equals(Object other) { + if (this == other) { + return true; + } + if (!(other instanceof UnsupportedType)) { + return false; + } + return Objects.equals(value, ((UnsupportedType) other).value); + } + + @Override + public int hashCode() { + return Objects.hashCode(value); + } + } + + private static final class ObjectStringProvider implements AttributeConverterProvider { + private final ObjectStringConverter converter = new ObjectStringConverter(); + + @Override + public AttributeConverter converterFor(EnhancedType enhancedType) { + if (EnhancedType.of(Object.class).equals(enhancedType)) { + return (AttributeConverter) converter; + } + return null; + } + } + + private static final class ObjectStringConverter implements AttributeConverter { + @Override + public AttributeValue transformFrom(Object input) { + return AttributeValue.fromS("custom"); + } + + @Override + public Object transformTo(AttributeValue input) { + return input.s(); + } + + @Override + public EnhancedType type() { + return EnhancedType.of(Object.class); + } + + @Override + public AttributeValueType attributeValueType() { + return AttributeValueType.S; + } + } }