DynamoDBEvents - LambdaSerializer - SourceGeneratorLambdaJsonSerializer - Amazon.DynamoDBv2.Model.Record.EventName exception

[Simonl9l]

Hi whilst I can probably set up my own POCO structure to model the event, it seem sensible to just use the one provided - is there an expectation that the should be easily serializable with a code generated serializer?

The DynamoDBEvents documentation does not indicate that any specific converters need to be registered.

I note that when using the LAMBDA_NET_SERIALIZER_DEBUG environment variable the Event is successful deserialized in the lambda runtime/bootstrap middleware.

Im using the following :

 <ItemGroup>
        <PackageReference Include="Amazon.Lambda.Core" Version="2.1.0" />
        <PackageReference Include="Amazon.Lambda.Serialization.SystemTextJson" Version="2.3.1" />
        <PackageReference Include="Amazon.Lambda.RuntimeSupport" Version="1.8.2" />
        <PackageReference Include="Amazon.Lambda.Annotations" Version="0.12.0" />
        <PackageReference Include="Amazon.Lambda.DynamoDBEvents" Version="2.1.1" />
    </ItemGroup>

I'm hooking serializer up in the main:

private static async Task Main(string[] args)
    {
        var handler = new Functions_Handler_Generated().Handler;
        await LambdaBootstrapBuilder.Create(handler, new SourceGeneratorLambdaJsonSerializer<DynamoDBEventSerializerContext>())
            .Build()
            .RunAsync();
    }

With the sterilizer configures as follows:

[assembly: LambdaSerializer(typeof(SourceGeneratorLambdaJsonSerializer<MyNamespace.DynamoDBEventSerializerContext>))]

namespace MyNamespace;

[JsonSerializable(typeof(DynamoDBEvent))]
public partial class DynamoDBEventSerializerContext : JsonSerializerContext
{
}

This is my Function Hander:

[LambdaFunction]
    public async Task Handler(
        DynamoDBEvent dynamoEvent, 
        ILambdaContext context)
    {
        
        foreach (var record in dynamoEvent.Records)
        {
            var before = tenantContext.BuildItem(record.Dynamodb.OldImage);
            var after = tenantContext.BuildItem(record.Dynamodb.NewImage);
            // TODO: Add business logic processing.
        }
    }

 public object? BuildItemDictionary<string, AttributeValue>? item)
    {
        if (item is null)
        {
            return null;
        }
        
        var document = Document.FromAttributeMap(item);
        var json = document.ToJson();
        return JsonSerializer.Deserialize<MyRecordType>(json);
    }

And get this exception when trying to use a code generated sterilizer as the event fires:

System.InvalidOperationException: The generic type of the converter for property 'Amazon.DynamoDBv2.Model.Record.EventName' must match with the specified converter type 'Amazon.DynamoDBv2.OperationType'. The converter must not be 'null'.
   at System.Text.Json.Serialization.Metadata.JsonMetadataServices.CreatePropertyInfo[T](JsonSerializerOptions options, JsonPropertyInfoValues`1 propertyInfo)
   at <my namesapce>.DynamoDBEventSerializerContext.DynamodbStreamRecordPropInit(JsonSerializerContext context) in /<my file path>/DynamoDBEventSerializerContext.DynamodbStreamRecord.g.cs:line 148
   at System.Text.Json.Serialization.Metadata.JsonTypeInfo.InitializePropCache()
   at System.Text.Json.Serialization.Converters.JsonMetadataServicesConverter`1.OnTryRead(Utf8JsonReader& reader, Type typeToConvert, JsonSerializerOptions options, ReadStack& state, T& value)
   at System.Text.Json.Serialization.JsonConverter`1.TryRead(Utf8JsonReader& reader, Type typeToConvert, JsonSerializerOptions options, ReadStack& state, T& value)
   at System.Text.Json.Serialization.JsonCollectionConverter`2.OnTryRead(Utf8JsonReader& reader, Type typeToConvert, JsonSerializerOptions options, ReadStack& state, TCollection& value)
   at System.Text.Json.Serialization.Converters.JsonMetadataServicesConverter`1.OnTryRead(Utf8JsonReader& reader, Type typeToConvert, JsonSerializerOptions options, ReadStack& state, T& value)
   at System.Text.Json.Serialization.JsonConverter`1.TryRead(Utf8JsonReader& reader, Type typeToConvert, JsonSerializerOptions options, ReadStack& state, T& value)
   at System.Text.Json.Serialization.Metadata.JsonPropertyInfo`1.ReadJsonAndSetMember(Object obj, ReadStack& state, Utf8JsonReader& reader)
   at System.Text.Json.Serialization.Converters.ObjectDefaultConverter`1.OnTryRead(Utf8JsonReader& reader, Type typeToConvert, JsonSerializerOptions options, ReadStack& state, T& value)
   at System.Text.Json.Serialization.Converters.JsonMetadataServicesConverter`1.OnTryRead(Utf8JsonReader& reader, Type typeToConvert, JsonSerializerOptions options, ReadStack& state, T& value)
   at System.Text.Json.Serialization.JsonConverter`1.TryRead(Utf8JsonReader& reader, Type typeToConvert, JsonSerializerOptions options, ReadStack& state, T& value)
   at System.Text.Json.Serialization.JsonConverter`1.ReadCore(Utf8JsonReader& reader, JsonSerializerOptions options, ReadStack& state)
   at System.Text.Json.JsonSerializer.ReadFromSpan[TValue](ReadOnlySpan`1 utf8Json, JsonTypeInfo jsonTypeInfo, Nullable`1 actualByteCount)
   at System.Text.Json.JsonSerializer.Deserialize[TValue](ReadOnlySpan`1 utf8Json, JsonTypeInfo`1 jsonTypeInfo)
   at Amazon.Lambda.Serialization.SystemTextJson.SourceGeneratorLambdaJsonSerializer`1.InternalDeserialize[T](Byte[] utf8Json)
   at Amazon.Lambda.Serialization.SystemTextJson.AbstractLambdaJsonSerializer.Deserialize[T](Stream requestStream)
   --- End of inner exception stack trace ---
   at Amazon.Lambda.Serialization.SystemTextJson.AbstractLambdaJsonSerializer.Deserialize[T](Stream requestStream)
   at Amazon.Lambda.RuntimeSupport.HandlerWrapper.<>c__DisplayClass14_0`1.<<GetHandlerWrapper>b__0>d.MoveNext()
--- End of stack trace from previous location ---
   at Amazon.Lambda.RuntimeSupport.LambdaBootstrap.InvokeOnceAsync(CancellationToken cancellationToken)

Any Recommendations?

[ashishdhingra]

@Simonl9l I think you are referring to add DynamoDbEvent support in Lambda annotations. There is a tracking PR #961 which lists that it is still pending. Please review.

[Simonl9l]

Hi @ashishdhingra - thanks for the reply - No, I don't thing so...as this is not Annotation support specific. I'm actually referring the the ability to code generation per Amazon.Lambda.Serialization.SystemTextJson to serialize the DynamoDBEvent per this repo and available from NuGet. Specifically this does not seem to support Code Generates serialization.

I'm not sure what the scope of for Add DynamoDB event support in regard to annotations, while I've constructed my own serialization POCO's to support Code Generated serialization, it seem pretty simple to set up a handler.

   var batchItemFailures = new List<StreamsEventResponse.BatchItemFailure?>();

        foreach (var record in dynamoEvent.Records)
        {
            var curRecordSequenceNumber = record.Dynamodb.SequenceNumber;

            try
            {
                var keys = Document.FromAttributeMap(record.Dynamodb.Keys);
                var json = keys.ToJson();
                var key = JsonSerializer.Deserialize<Key>(json);

              //Todo: process records

            }
            catch (Exception ex)
            {
                batchItemFailures.Add(new StreamsEventResponse.BatchItemFailure { ItemIdentifier = curRecordSequenceNumber });
                return new StreamsEventResponse { BatchItemFailures = batchItemFailures.Where(item => item is not null).ToList() };
            }
        }
        return new StreamsEventResponse { BatchItemFailures = batchItemFailures.Where(item => item is not null).ToList() };
    }

Is this what the "pending" scope covers - as there is limited detail in #961 as to that each items means.

[coderade]

Hi, I am having the same issue when trying to convert a json DynamoStream event to a DynamoDBEvent record.

[dscpinheiro]

It's been a few years, but we had made some changes to the DynamoDBEvent, see #1657 for more details.