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,45 @@ 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")
+}