Support primitive arguments (#72)

Author: inputfalken

src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs

@@ -86,18 +86,25 @@ internal static IEnumerable<string> CreateExpressionAttributeValue(IEnumerable<D
     }
     private static CodeFactory CreateStruct(ITypeSymbol typeSymbol, Func<ITypeSymbol, ImmutableArray<DynamoDbDataMember>> fn, MarshallerOptions options)
     {
-        var dataMembers = fn(typeSymbol)
-            .Select(x =>
-            {
-                return (
-                    IsUnknown: !options.IsConvertable(x.DataMember.Type) && x.DataMember.Type.TypeIdentifier() is UnknownType,
-                    DDB: x,
-                    ValueRef: $"_{x.DataMember.Name}ValueRef",
-                    AttributeReference: TypeName(x.DataMember.Type),
-                    AttributeInterfaceName: $"{Constants.DynamoDBGenerator.Marshaller.AttributeExpressionValueTrackerInterface}<{x.DataMember.Type.Representation().annotated}>"
-                );
-            })
-            .ToArray();
+        var dataMembers =
+            options.IsConvertable(typeSymbol)
+                ? Array
+                    .Empty<(bool IsUnknown, DynamoDbDataMember DDB, string ValueRef, string AttributeReference, string
+                        AttributeInterfaceName)>()
+                : fn(typeSymbol)
+                    .Select(x =>
+                    {
+                        return (
+                            IsUnknown: !options.IsConvertable(x.DataMember.Type) &&
+                                       x.DataMember.Type.TypeIdentifier() is UnknownType,
+                            DDB: x,
+                            ValueRef: $"_{x.DataMember.Name}ValueRef",
+                            AttributeReference: TypeName(x.DataMember.Type),
+                            AttributeInterfaceName:
+                            $"{Constants.DynamoDBGenerator.Marshaller.AttributeExpressionValueTrackerInterface}<{x.DataMember.Type.Representation().annotated}>"
+                        );
+                    })
+                    .ToArray();
 
         var structName = TypeName(typeSymbol);
         var interfaceName = $"{Constants.DynamoDBGenerator.Marshaller.AttributeExpressionValueTrackerInterface}<{typeSymbol.Representation().annotated}>";

tests/DynamoDBGenerator.SourceGenerator.Tests/DynamoDBDocumentTests/ExpressionAttributeTrackerTests.cs

@@ -8,10 +8,6 @@ namespace DynamoDBGenerator.SourceGenerator.Tests.DynamoDBDocumentTests;
 [DynamoDBMarshaller(typeof(InheritedClass))]
 public partial class ExpressionAttributeTrackerTests
 {
-    [Fact]
-    public void Test()
-    {
-    }
     [Fact]
     public void PersonWithTupleArgument_AccessingRootExpressionAttributeName_ShouldThrow()
     {

tests/DynamoDBGenerator.SourceGenerator.Tests/DynamoDBDocumentTests/PrimitiveArgumentTests.cs

@@ -0,0 +1,48 @@
+using Amazon.DynamoDBv2.Model;
+using DynamoDBGenerator.Attributes;
+using DynamoDBGenerator.Extensions;
+
+namespace DynamoDBGenerator.SourceGenerator.Tests.DynamoDBDocumentTests;
+
+[DynamoDBMarshaller(typeof((Guid, Guid)), PropertyName = "STRING", ArgumentType = typeof(string))]
+[DynamoDBMarshaller(typeof((Guid, Guid)), PropertyName = "GUID", ArgumentType = typeof(Guid))]
+[DynamoDBMarshaller(typeof((Guid, Guid)), PropertyName = "INT", ArgumentType = typeof(int))]
+public partial class PrimitiveArgumentTests
+{
+    [Fact]
+    public void ExpressionValueTracker_STRING_ShouldBeExpandedCorrectly()
+    {
+        IAttributeExpressionValueTracker<string> valueTracker = STRING.AttributeExpressionValueTracker();
+        valueTracker.ToString().Should().Be(":p1");
+
+        valueTracker.AccessedValues("hello").Should().BeEquivalentTo(new Dictionary<string, AttributeValue>
+        {
+            { ":p1", new AttributeValue { S = "hello" } }
+        });
+    }
+
+    [Fact]
+    public void ExpressionValueTracker_INT_ShouldBeExpandedCorrectly()
+    {
+        IAttributeExpressionValueTracker<int> valueTracker = INT.AttributeExpressionValueTracker();
+        valueTracker.ToString().Should().Be(":p1");
+
+        valueTracker.AccessedValues(2).Should().BeEquivalentTo(new Dictionary<string, AttributeValue>
+        {
+            { ":p1", new AttributeValue { N = "2" } }
+        });
+    }
+
+    [Fact]
+    public void ExpressionValueTracker_GUID_ShouldBeExpandedCorrectly()
+    {
+        IAttributeExpressionValueTracker<Guid> valueTracker = GUID.AttributeExpressionValueTracker();
+        valueTracker.ToString().Should().Be(":p1");
+
+        var guid = Guid.NewGuid();
+        valueTracker.AccessedValues(guid).Should().BeEquivalentTo(new Dictionary<string, AttributeValue>
+        {
+            { ":p1", new AttributeValue { S = guid.ToString() } }
+        });
+    }
+}