feat: basic annotation processing

hll/dynamodb-mapper/dynamodb-mapper-codegen/src/main/kotlin/aws/sdk/kotlin/hll/dynamodbmapper/codegen/annotations/AnnotationsProcessor.kt

@@ -23,7 +23,6 @@ public class AnnotationsProcessor(private val environment: SymbolProcessorEnviro
     private var invoked = false
     private val logger = environment.logger
     private val codeGenerator = environment.codeGenerator
-    private val codeGeneratorFactory = CodeGeneratorFactory(codeGenerator, logger)
 
     override fun process(resolver: Resolver): List<KSAnnotated> {
         if (invoked) {
@@ -42,6 +41,9 @@ public class AnnotationsProcessor(private val environment: SymbolProcessorEnviro
             .filterIsInstance<KSClassDeclaration>()
             .filter { it.validate() }
 
+        val dependencies = Dependencies(aggregating = true, *(annotatedClasses.mapNotNull { it.containingFile }.toTypedArray()))
+        val codeGeneratorFactory = CodeGeneratorFactory(environment.codeGenerator, logger, dependencies)
+
         HighLevelRenderer(annotatedClasses, logger, codeGeneratorFactory, getCodegenAttributes()).render()
 
         return invalid

hll/dynamodb-mapper/dynamodb-mapper-codegen/src/main/kotlin/aws/sdk/kotlin/hll/dynamodbmapper/codegen/annotations/rendering/HighLevelRenderer.kt

@@ -6,11 +6,10 @@ package aws.sdk.kotlin.hll.dynamodbmapper.codegen.annotations.rendering
 
 import aws.sdk.kotlin.hll.codegen.core.CodeGeneratorFactory
 import aws.sdk.kotlin.hll.codegen.rendering.RenderContext
+import aws.sdk.kotlin.hll.codegen.util.plus
 import aws.sdk.kotlin.hll.dynamodbmapper.codegen.annotations.AnnotationsProcessorOptions
 import aws.sdk.kotlin.hll.dynamodbmapper.codegen.annotations.DestinationPackage
-import aws.smithy.kotlin.runtime.collections.Attributes
-import aws.smithy.kotlin.runtime.collections.emptyAttributes
-import aws.smithy.kotlin.runtime.collections.get
+import aws.smithy.kotlin.runtime.collections.*
 import com.google.devtools.ksp.processing.KSPLogger
 import com.google.devtools.ksp.symbol.KSClassDeclaration
 
@@ -25,24 +24,47 @@ internal class HighLevelRenderer(
     private val codegenAttributes: Attributes = emptyAttributes(),
 ) {
     internal fun render() {
-        annotatedClasses.forEach {
-            logger.info("Processing annotation on ${it.simpleName}")
+        annotatedClasses.forEach { annotated ->
+            logger.info("Processing annotation on ${annotated.simpleName}")
 
             val codegenPkg = when (val dstPkg = codegenAttributes[AnnotationsProcessorOptions.DestinationPackageAttribute]) {
-                is DestinationPackage.Relative -> "${it.packageName.asString()}.${dstPkg.pkg}"
+                is DestinationPackage.Relative -> "${annotated.packageName.asString()}.${dstPkg.pkg}"
                 is DestinationPackage.Absolute -> dstPkg.pkg
             }
 
+            val attributes = codegenAttributes + (SchemaAttributes.ShouldRenderValueConverterAttribute to annotated.shouldRenderValueConverter)
+
             val renderCtx = RenderContext(
                 logger,
                 codegenFactory,
                 codegenPkg,
                 "dynamodb-mapper-annotation-processor",
-                codegenAttributes,
+                attributes,
             )
 
-            val annotation = SchemaRenderer(it, renderCtx)
+            val annotation = SchemaRenderer(annotated, renderCtx)
             annotation.render()
         }
     }
+
+    // Value converters must be generated for any DynamoDbItem which is referenced by another DynamoDbItem
+    private val KSClassDeclaration.shouldRenderValueConverter: Boolean
+        get() = annotatedClasses.any { otherClass ->
+            val name = requireNotNull(qualifiedName).asString()
+
+            otherClass.getAllProperties().any { prop ->
+                val propType = prop.type.resolve()
+                val propName = requireNotNull(propType.declaration.qualifiedName).asString()
+
+                // If the property OR any of its arguments reference the annotated type
+                (propName == name) ||
+                    (
+                        propType.arguments.any { arg ->
+                            val argType = arg.type?.resolve()
+                            val argName = requireNotNull(argType?.declaration?.qualifiedName).asString()
+                            argName == name
+                        }
+                        )
+            }
+        }
 }

hll/dynamodb-mapper/dynamodb-mapper-codegen/src/main/kotlin/aws/sdk/kotlin/hll/dynamodbmapper/codegen/annotations/rendering/SchemaAttributes.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package aws.sdk.kotlin.hll.dynamodbmapper.codegen.annotations.rendering
+
+import aws.smithy.kotlin.runtime.collections.AttributeKey
+
+/**
+ * Internal schema code generation attributes
+ */
+internal object SchemaAttributes {
+    /**
+     * Whether a value converter should be generated for the class being processed
+     */
+    internal val ShouldRenderValueConverterAttribute: AttributeKey<Boolean> = AttributeKey("ShouldRenderValueConverter")
+}

hll/dynamodb-mapper/dynamodb-mapper-codegen/src/main/kotlin/aws/sdk/kotlin/hll/dynamodbmapper/codegen/annotations/rendering/SchemaRenderer.kt

@@ -19,10 +19,7 @@ import com.google.devtools.ksp.KspExperimental
 import com.google.devtools.ksp.getAnnotationsByType
 import com.google.devtools.ksp.getConstructors
 import com.google.devtools.ksp.isAnnotationPresent
-import com.google.devtools.ksp.symbol.KSClassDeclaration
-import com.google.devtools.ksp.symbol.KSName
-import com.google.devtools.ksp.symbol.KSPropertyDeclaration
-import com.google.devtools.ksp.symbol.Modifier
+import com.google.devtools.ksp.symbol.*
 
 /**
  * Renders the classes and objects required to make a class usable with the DynamoDbMapper such as schemas, builders, and converters.
@@ -57,19 +54,17 @@ internal class SchemaRenderer(
         .getAllProperties()
         .filterNot { it.modifiers.contains(Modifier.PRIVATE) || it.isAnnotationPresent(DynamoDbIgnore::class) }
 
-    private val annotatedProperties = properties.mapNotNull(AnnotatedClassProperty.Companion::from)
-
     init {
-        check(annotatedProperties.count { it.isPk } == 1) {
+        check(properties.count { it.isPk } == 1) {
             "Expected exactly one @DynamoDbPartitionKey annotation on a property"
         }
-        check(annotatedProperties.count { it.isSk } <= 1) {
+        check(properties.count { it.isSk } <= 1) {
             "Expected at most one @DynamoDbSortKey annotation on a property"
         }
     }
 
-    private val partitionKeyProp = annotatedProperties.single { it.isPk }
-    private val sortKeyProp = annotatedProperties.singleOrNull { it.isSk }
+    private val partitionKeyProp = properties.single { it.isPk }
+    private val sortKeyProp = properties.singleOrNull { it.isSk }
 
     /**
      * Skip rendering a class builder if:
@@ -94,6 +89,10 @@ internal class SchemaRenderer(
             renderItemConverter()
         }
 
+        if (ctx.attributes[SchemaAttributes.ShouldRenderValueConverterAttribute]) {
+            renderValueConverter()
+        }
+
         renderSchema()
 
         if (ctx.attributes[AnnotationsProcessorOptions.GenerateGetTableMethodAttribute]) {
@@ -117,15 +116,33 @@ internal class SchemaRenderer(
             }
 
             withBlock("descriptors = arrayOf(", "),") {
-                annotatedProperties.forEach {
+                properties.forEach {
                     renderAttributeDescriptor(it)
                 }
             }
         }
         blankLine()
     }
 
-    private fun renderAttributeDescriptor(prop: AnnotatedClassProperty) {
+    /**
+     * Render a [ValueConverter] for the current class by wrapping the generated/user-provided [ItemConverter]
+     * with our [ItemToValueConverter]
+     */
+    private fun renderValueConverter() {
+        // TODO Offer alternate serialization options besides AttributeValue.M?
+        write(
+            "#Lval #L : #T = #T.#T(#T)",
+            ctx.attributes.visibility,
+            "${className}ValueConverter",
+            MapperTypes.Values.valueConverter(classType),
+            itemConverter,
+            TypeRef("aws.sdk.kotlin.hll.mapping.core.converters", "andThenTo"),
+            MapperTypes.Values.ItemToValueConverter,
+        )
+        blankLine()
+    }
+
+    private fun renderAttributeDescriptor(prop: KSPropertyDeclaration) {
         withBlock("#T(", "),", MapperTypes.Items.AttributeDescriptor) {
             write("#S,", prop.ddbName) // key
             write("#L,", "$className::${prop.name}") // getter
@@ -137,18 +154,123 @@ internal class SchemaRenderer(
                 write("#L,", "$className::${prop.name}::set")
             }
 
-            write("#T", prop.valueConverter) // converter
+            // converter
+            prop.type.resolve().renderValueConverter(this)
+            write("")
+        }
+    }
+
+    /**
+     * Renders a ValueConverter for the [KSType].
+     *
+     * Note: The ValueConverter(s) will be rendered without a newline in order to support deep recursion.
+     * Callers are responsible for adding a newline after the top-level invocation of this function.
+     */
+    private fun KSType.renderValueConverter(writer: SchemaRenderer) {
+        writer.apply {
+            val ksType = this@renderValueConverter
+            val type = Type.from(ksType).copy(genericArgs = listOf())
+
+            when {
+                isEnum -> writeInline("#T()", MapperTypes.Values.Scalars.enumConverter(type))
+
+                // FIXME Handle multi-module codegen rather than assuming nested classes will be in the same [ctx.pkg]
+                isUserClass -> writeInline("#T", TypeRef(ctx.pkg, "${declaration.simpleName.asString()}ValueConverter"))
+
+                type == Types.Kotlin.Collections.List -> {
+                    val listElementType = singleArgument()
+                    writeInline("#T(", MapperTypes.Values.Collections.ListConverter)
+                    listElementType.renderValueConverter(this)
+                    writeInline(")")
+                }
+
+                type == Types.Kotlin.Collections.Map -> {
+                    check(arguments.size == 2) { "Expected map type ${declaration.qualifiedName?.asString()} to have 2 arguments, got ${arguments.size}" }
+
+                    val (keyType, valueType) = arguments.map {
+                        checkNotNull(it.type?.resolve()) { "Failed to resolved argument type for $it" }
+                    }
+
+                    writeInline("#T(#T, ", MapperTypes.Values.Collections.MapConverter, keyType.mapKeyConverter)
+                    valueType.renderValueConverter(this)
+                    writeInline(")")
+                }
+
+                else -> writeInline(
+                    "#T",
+                    when (type) {
+                        Types.Smithy.Instant -> MapperTypes.Values.SmithyTypes.DefaultInstantConverter
+                        Types.Smithy.Url -> MapperTypes.Values.SmithyTypes.UrlConverter
+                        Types.Smithy.Document -> MapperTypes.Values.SmithyTypes.DefaultDocumentConverter
+
+                        Types.Kotlin.Boolean -> MapperTypes.Values.Scalars.BooleanConverter
+                        Types.Kotlin.String -> MapperTypes.Values.Scalars.StringConverter
+                        Types.Kotlin.CharArray -> MapperTypes.Values.Scalars.CharArrayConverter
+                        Types.Kotlin.Char -> MapperTypes.Values.Scalars.CharConverter
+                        Types.Kotlin.Byte -> MapperTypes.Values.Scalars.ByteConverter
+                        Types.Kotlin.ByteArray -> MapperTypes.Values.Scalars.ByteArrayConverter
+                        Types.Kotlin.Short -> MapperTypes.Values.Scalars.ShortConverter
+                        Types.Kotlin.Int -> MapperTypes.Values.Scalars.IntConverter
+                        Types.Kotlin.Long -> MapperTypes.Values.Scalars.LongConverter
+                        Types.Kotlin.Double -> MapperTypes.Values.Scalars.DoubleConverter
+                        Types.Kotlin.Float -> MapperTypes.Values.Scalars.FloatConverter
+                        Types.Kotlin.UByte -> MapperTypes.Values.Scalars.UByteConverter
+                        Types.Kotlin.UInt -> MapperTypes.Values.Scalars.UIntConverter
+                        Types.Kotlin.UShort -> MapperTypes.Values.Scalars.UShortConverter
+                        Types.Kotlin.ULong -> MapperTypes.Values.Scalars.ULongConverter
+
+                        Types.Kotlin.Collections.Set -> singleArgument().setValueConverter
+                        else -> error("Unsupported attribute type $this")
+                    },
+                )
+            }
+        }
+    }
+
+    private val KSType.mapKeyConverter: Type
+        get() = when (val type = Type.from(this)) {
+            // String
+            Types.Kotlin.ByteArray -> MapperTypes.Values.Scalars.CharArrayToStringConverter
+            Types.Kotlin.Char -> MapperTypes.Values.Scalars.CharToStringConverter
+            Types.Kotlin.String -> MapperTypes.Values.Scalars.StringToStringConverter
+
+            // Number
+            Types.Kotlin.Byte -> MapperTypes.Values.Scalars.ByteToStringConverter
+            Types.Kotlin.Double -> MapperTypes.Values.Scalars.DoubleToStringConverter
+            Types.Kotlin.Float -> MapperTypes.Values.Scalars.FloatToStringConverter
+            Types.Kotlin.Int -> MapperTypes.Values.Scalars.IntToStringConverter
+            Types.Kotlin.Long -> MapperTypes.Values.Scalars.LongToStringConverter
+            Types.Kotlin.Short -> MapperTypes.Values.Scalars.ShortToStringConverter
+            Types.Kotlin.UByte -> MapperTypes.Values.Scalars.UByteToStringConverter
+            Types.Kotlin.UInt -> MapperTypes.Values.Scalars.UIntToStringConverter
+            Types.Kotlin.ULong -> MapperTypes.Values.Scalars.ULongToStringConverter
+            Types.Kotlin.UShort -> MapperTypes.Values.Scalars.UShortToStringConverter
+
+            // Boolean
+            Types.Kotlin.Boolean -> MapperTypes.Values.Scalars.BooleanToStringConverter
+            else -> error("Unsupported key type: $type")
         }
+
+    private fun KSType.singleArgument(): KSType = checkNotNull(arguments.single().type?.resolve()) {
+        "Failed to resolve single argument type for ${this.declaration.qualifiedName?.asString()}"
     }
 
-    private val AnnotatedClassProperty.valueConverter: Type
-        get() = when (typeName.asString()) {
-            "aws.smithy.kotlin.runtime.time.Instant" -> MapperTypes.Values.SmithyTypes.DefaultInstantConverter
-            "kotlin.Boolean" -> MapperTypes.Values.Scalars.BooleanConverter
-            "kotlin.Int" -> MapperTypes.Values.Scalars.IntConverter
-            "kotlin.String" -> MapperTypes.Values.Scalars.StringConverter
-            // TODO Add additional "standard" item converters
-            else -> error("Unsupported attribute type ${typeName.asString()}")
+    private val KSType.setValueConverter: Type
+        get() = when (Type.from(this)) {
+            Types.Kotlin.String -> MapperTypes.Values.Collections.StringSetConverter
+            Types.Kotlin.Char -> MapperTypes.Values.Collections.CharSetConverter
+            Types.Kotlin.CharArray -> MapperTypes.Values.Collections.CharArraySetConverter
+            Types.Kotlin.Byte -> MapperTypes.Values.Collections.ByteSetConverter
+            Types.Kotlin.Double -> MapperTypes.Values.Collections.DoubleSetConverter
+            Types.Kotlin.Float -> MapperTypes.Values.Collections.FloatSetConverter
+            Types.Kotlin.Int -> MapperTypes.Values.Collections.IntSetConverter
+            Types.Kotlin.Long -> MapperTypes.Values.Collections.LongSetConverter
+            Types.Kotlin.Short -> MapperTypes.Values.Collections.ShortSetConverter
+            Types.Kotlin.UByte -> MapperTypes.Values.Collections.UByteSetConverter
+            Types.Kotlin.UInt -> MapperTypes.Values.Collections.UIntSetConverter
+            Types.Kotlin.ULong -> MapperTypes.Values.Collections.ULongSetConverter
+            Types.Kotlin.UShort -> MapperTypes.Values.Collections.UShortSetConverter
+            else -> error("Unsupported set element $this")
         }
 
     private fun renderSchema() {
@@ -168,20 +290,20 @@ internal class SchemaRenderer(
         blankLine()
     }
 
-    private val AnnotatedClassProperty.keySpec: TypeRef
-        get() = when (typeName.asString()) {
+    private val KSPropertyDeclaration.keySpec: TypeRef
+        get() = when (typeName) {
+            "kotlin.ByteArray" -> Types.Kotlin.ByteArray
             "kotlin.Int" -> Types.Kotlin.Number
             "kotlin.String" -> Types.Kotlin.String
-            // TODO Handle ByteArray
-            else -> error("Unsupported key type ${typeName.asString()}, expected Int or String")
+            else -> error("Unsupported key type $typeName, expected ByteArray, Int, or String")
         }
 
-    private val AnnotatedClassProperty.keySpecType: TypeRef
-        get() = when (typeName.asString()) {
+    private val KSPropertyDeclaration.keySpecType: TypeRef
+        get() = when (typeName) {
+            "kotlin.ByteArray" -> MapperTypes.Items.KeySpecByteArray
             "kotlin.Int" -> MapperTypes.Items.KeySpecNumber
             "kotlin.String" -> MapperTypes.Items.KeySpecString
-            // TODO Handle ByteArray
-            else -> error("Unsupported key type ${typeName.asString()}, expected Int or String")
+            else -> error("Unsupported key type $typeName, expected ByteArray, Int, or String")
         }
 
     private fun renderGetTable() {
@@ -204,22 +326,30 @@ internal class SchemaRenderer(
     }
 }
 
-private data class AnnotatedClassProperty(val name: String, val typeRef: TypeRef, val ddbName: String, val typeName: KSName, val isPk: Boolean, val isSk: Boolean) {
-    companion object {
-        @OptIn(KspExperimental::class)
-        fun from(ksProperty: KSPropertyDeclaration) = ksProperty
-            .getter
-            ?.returnType
-            ?.resolve()
-            ?.declaration
-            ?.qualifiedName
-            ?.let { typeName ->
-                val isPk = ksProperty.isAnnotationPresent(DynamoDbPartitionKey::class)
-                val isSk = ksProperty.isAnnotationPresent(DynamoDbSortKey::class)
-                val name = ksProperty.simpleName.getShortName()
-                val typeRef = Type.from(checkNotNull(ksProperty.type) { "Failed to determine class type for $name" })
-                val ddbName = ksProperty.getAnnotationsByType(DynamoDbAttribute::class).singleOrNull()?.name ?: name
-                AnnotatedClassProperty(name, typeRef, ddbName, typeName, isPk, isSk)
-            }
-    }
-}
+@OptIn(KspExperimental::class)
+private val KSType.isUserClass: Boolean
+    get() = declaration.isAnnotationPresent(DynamoDbItem::class)
+
+private val KSPropertyDeclaration.typeName: String
+    get() = checkNotNull(getter?.returnType?.resolve()?.declaration?.qualifiedName?.asString()) { "Failed to determine type name for $this" }
+
+@OptIn(KspExperimental::class)
+private val KSPropertyDeclaration.isPk: Boolean
+    get() = isAnnotationPresent(DynamoDbPartitionKey::class)
+
+@OptIn(KspExperimental::class)
+private val KSPropertyDeclaration.isSk: Boolean
+    get() = isAnnotationPresent(DynamoDbSortKey::class)
+
+private val KSPropertyDeclaration.name: String
+    get() = simpleName.getShortName()
+
+private val KSPropertyDeclaration.typeRef: TypeRef
+    get() = Type.from(type)
+
+@OptIn(KspExperimental::class)
+private val KSPropertyDeclaration.ddbName: String
+    get() = getAnnotationsByType(DynamoDbAttribute::class).singleOrNull()?.name ?: name
+
+private val KSType.isEnum: Boolean
+    get() = (declaration as? KSClassDeclaration)?.classKind == ClassKind.ENUM_CLASS