chore: AOT support for Idempotency

libraries/src/AWS.Lambda.Powertools.Idempotency/Idempotency.cs

@@ -1,21 +1,23 @@
 /*
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License").
  * You may not use this file except in compliance with the License.
  * A copy of the License is located at
- * 
+ *
  *  http://aws.amazon.com/apache2.0
- * 
+ *
  * or in the "license" file accompanying this file. This file is distributed
  * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
  * express or implied. See the License for the specific language governing
  * permissions and limitations under the License.
  */
 
 using System;
+using System.Text.Json.Serialization;
 using Amazon.Lambda.Core;
 using AWS.Lambda.Powertools.Common;
+using AWS.Lambda.Powertools.Idempotency.Internal.Serializers;
 using AWS.Lambda.Powertools.Idempotency.Persistence;
 
 namespace AWS.Lambda.Powertools.Idempotency;
@@ -27,7 +29,7 @@ namespace AWS.Lambda.Powertools.Idempotency;
 /// Use it before the function handler get called.
 /// Example: Idempotency.Configure(builder => builder.WithPersistenceStore(...));
 /// </summary>
-public sealed class Idempotency 
+public sealed class Idempotency
 {
     /// <summary>
     /// The general configurations for the idempotency
@@ -47,6 +49,7 @@ internal Idempotency(IPowertoolsConfigurations powertoolsConfigurations)
     {
         powertoolsConfigurations.SetExecutionEnvironment(this);
     }
+
     /// <summary>
     /// Set Idempotency options
     /// </summary>
@@ -68,7 +71,7 @@ private void SetPersistenceStore(BasePersistenceStore persistenceStore)
     /// <summary>
     /// Holds the idempotency Instance:
     /// </summary>
-    public static Idempotency Instance { get; } = new(PowertoolsConfigurations.Instance);
+    internal static Idempotency Instance { get; } = new(PowertoolsConfigurations.Instance);
 
     /// <summary>
     /// Use this method to configure persistence layer (mandatory) and idempotency options (optional)
@@ -90,7 +93,7 @@ public static void Configure(Action<IdempotencyBuilder> configurationAction)
     /// Holds ILambdaContext
     /// </summary>
     public ILambdaContext LambdaContext { get; private set; }
-    
+
     /// <summary>
     /// Can be used in a method which is not the handler to capture the Lambda context,
     /// to calculate the remaining time before the invocation times out.
@@ -177,5 +180,18 @@ public IdempotencyBuilder WithOptions(IdempotencyOptions options)
             Options = options;
             return this;
         }
+
+#if NET8_0_OR_GREATER
+        /// <summary>
+        /// Set Customer JsonSerializerContext to append to IdempotencySerializationContext 
+        /// </summary>
+        /// <param name="context"></param>
+        /// <returns>IdempotencyBuilder</returns>
+        public IdempotencyBuilder WithJsonSerializationContext(JsonSerializerContext context)
+        {
+            IdempotencySerializer.AddTypeInfoResolver(context);
+            return this;
+        }
+#endif
     }
 }

libraries/src/AWS.Lambda.Powertools.Idempotency/IdempotencyOptionsBuilder.cs

@@ -11,26 +11,32 @@ public class IdempotencyOptionsBuilder
     /// Default maximum number of items in the local cache.
     /// </summary>
     private readonly int _localCacheMaxItems = 256;
+
     /// <summary>
     /// Local cache enabled
     /// </summary>
     private bool _useLocalCache;
+
     /// <summary>
     /// Default expiration in seconds.
     /// </summary>
     private long _expirationInSeconds = 60 * 60; // 1 hour
+
     /// <summary>
     /// Event key JMESPath expression.
     /// </summary>
     private string _eventKeyJmesPath;
+
     /// <summary>
     /// Payload validation JMESPath expression.
     /// </summary>
     private string _payloadValidationJmesPath;
+
     /// <summary>
     /// Throw exception if no idempotency key is found.
     /// </summary>
     private bool _throwOnNoIdempotencyKey;
+
     /// <summary>
     /// Default Hash function
     /// </summary>
@@ -107,7 +113,7 @@ public IdempotencyOptionsBuilder WithThrowOnNoIdempotencyKey(bool throwOnNoIdemp
     /// <returns>the instance of the builder (to chain operations)</returns>
     public IdempotencyOptionsBuilder WithExpiration(TimeSpan duration)
     {
-        _expirationInSeconds = (long) duration.TotalSeconds;
+        _expirationInSeconds = (long)duration.TotalSeconds;
         return this;
     }
 
@@ -116,9 +122,15 @@ public IdempotencyOptionsBuilder WithExpiration(TimeSpan duration)
     /// </summary>
     /// <param name="hashFunction">Can be any algorithm supported by HashAlgorithm.Create</param>
     /// <returns>the instance of the builder (to chain operations)</returns>
+#if NET8_0_OR_GREATER
+    [Obsolete("Idempotency uses MD5 and does not support other hash algorithms.")]
+#endif
     public IdempotencyOptionsBuilder WithHashFunction(string hashFunction)
     {
+#if NET6_0
+        // for backward compability keep this code in .net 6
         _hashFunction = hashFunction;
+#endif
         return this;
     }
 }

libraries/src/AWS.Lambda.Powertools.Idempotency/IdempotentAttribute.cs

@@ -23,6 +23,7 @@
 using AWS.Lambda.Powertools.Common;
 using AWS.Lambda.Powertools.Idempotency.Exceptions;
 using AWS.Lambda.Powertools.Idempotency.Internal;
+using AWS.Lambda.Powertools.Idempotency.Internal.Serializers;
 
 namespace AWS.Lambda.Powertools.Idempotency;
 
@@ -151,7 +152,7 @@ private static JsonDocument GetPayload<T>(AspectEventArgs eventArgs)
         // Use the first argument if IdempotentAttribute placed on handler or number of arguments is 1
         if (isPlacedOnRequestHandler || args.Count == 1)
         {
-            payload = args is not null && args.Any() ? JsonDocument.Parse(JsonSerializer.Serialize(args[0])) : null;
+            payload = args is not null && args.Any() ? JsonDocument.Parse(IdempotencySerializer.Serialize(args[0], typeof(object))) : null;
         }
         else
         {
@@ -160,7 +161,7 @@ private static JsonDocument GetPayload<T>(AspectEventArgs eventArgs)
             if (parameter != null)
             {
                 // set payload to the value of the parameter
-                payload = JsonDocument.Parse(JsonSerializer.Serialize(args[Array.IndexOf(eventArgsMethod.GetParameters(), parameter)]));
+                payload = JsonDocument.Parse(IdempotencySerializer.Serialize(args[Array.IndexOf(eventArgsMethod.GetParameters(), parameter)], typeof(object)));
             }
         }
 

libraries/src/AWS.Lambda.Powertools.Idempotency/Internal/IdempotencyAspectHandler.cs

@@ -18,6 +18,7 @@
 using System.Threading.Tasks;
 using Amazon.Lambda.Core;
 using AWS.Lambda.Powertools.Idempotency.Exceptions;
+using AWS.Lambda.Powertools.Idempotency.Internal.Serializers;
 using AWS.Lambda.Powertools.Idempotency.Persistence;
 
 namespace AWS.Lambda.Powertools.Idempotency.Internal;
@@ -184,7 +185,7 @@ private Task<T> HandleForStatus(DataRecord record)
             default:
                 try
                 {
-                    var result = JsonSerializer.Deserialize<T>(record.ResponseData!);
+                    var result = IdempotencySerializer.Deserialize<T>(record.ResponseData!);
                     if (result is null)
                     {
                         throw new IdempotencyPersistenceLayerException("Unable to cast function response as " + typeof(T).Name);

libraries/src/AWS.Lambda.Powertools.Idempotency/Internal/Serializers/IdempotencySerializationContext.cs

@@ -0,0 +1,32 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ * 
+ *  http://aws.amazon.com/apache2.0
+ * 
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+using System.Text.Json.Serialization;
+
+namespace AWS.Lambda.Powertools.Idempotency.Internal.Serializers;
+
+#if NET8_0_OR_GREATER
+
+
+/// <summary>
+/// The source generated JsonSerializerContext to be used to Serialize Idempotency types 
+/// </summary>
+[JsonSerializable(typeof(string))]
+[JsonSerializable(typeof(object))]
+public partial class IdempotencySerializationContext : JsonSerializerContext
+{
+
+}
+#endif

libraries/src/AWS.Lambda.Powertools.Idempotency/Internal/Serializers/IdempotencySerializer.cs

@@ -0,0 +1,128 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+using System;
+using System.Runtime.Serialization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Text.Json.Serialization.Metadata;
+using AWS.Lambda.Powertools.Common.Utils;
+
+namespace AWS.Lambda.Powertools.Idempotency.Internal.Serializers;
+
+/// <summary>
+/// Serializer for Idempotency.
+/// </summary>
+internal static class IdempotencySerializer
+{
+    private static JsonSerializerOptions _jsonOptions;
+
+    static IdempotencySerializer()
+    {
+        BuildDefaultOptions();
+    }
+
+    /// <summary>
+    /// Builds the default JsonSerializerOptions.
+    /// </summary>
+    private static void BuildDefaultOptions()
+    {
+        _jsonOptions = new JsonSerializerOptions
+        {
+            PropertyNameCaseInsensitive = true
+        };
+#if NET8_0_OR_GREATER
+        if (!RuntimeFeatureWrapper.IsDynamicCodeSupported)
+        {
+            _jsonOptions.TypeInfoResolverChain.Add(IdempotencySerializationContext.Default);
+        }
+#endif
+    }
+
+#if NET8_0_OR_GREATER
+
+    /// <summary>
+    /// Adds a JsonTypeInfoResolver to the JsonSerializerOptions.
+    /// </summary>
+    /// <param name="context">The JsonTypeInfoResolver to add.</param>
+    /// <remarks>
+    /// This method is only available in .NET 8.0 and later versions.
+    /// </remarks>
+    internal static void AddTypeInfoResolver(JsonSerializerContext context)
+    {
+        BuildDefaultOptions();
+        _jsonOptions.TypeInfoResolverChain.Add(context);
+    }
+
+    /// <summary>
+    /// Gets the JsonTypeInfo for a given type.
+    /// </summary>
+    /// <param name="type">The type to get information for.</param>
+    /// <returns>The JsonTypeInfo for the specified type, or null if not found.</returns>
+    internal static JsonTypeInfo GetTypeInfo(Type type)
+    {
+        var typeInfo = _jsonOptions.TypeInfoResolver?.GetTypeInfo(type, _jsonOptions);
+        if (typeInfo == null)
+        {
+            throw new SerializationException(
+                $"Type {type} is not known to the serializer. Ensure it's included in the JsonSerializerContext.");
+        }
+
+        return typeInfo;
+    }
+#endif
+
+    /// <summary>
+    /// Serializes the specified object to a JSON string.
+    /// </summary>
+    /// <param name="value">The object to serialize.</param>
+    /// <param name="inputType">The type of the object to serialize.</param>
+    /// <returns>A JSON string representation of the object.</returns>
+    internal static string Serialize(object value, Type inputType)
+    {
+#if NET6_0
+        return JsonSerializer.Serialize(value, _jsonOptions);
+#else
+        if (RuntimeFeatureWrapper.IsDynamicCodeSupported)
+        {
+#pragma warning disable
+            return JsonSerializer.Serialize(value, _jsonOptions);
+        }
+
+        return JsonSerializer.Serialize(value, GetTypeInfo(inputType));
+#endif
+    }
+
+    /// <summary>
+    /// Deserializes the specified JSON string to an object of type T.
+    /// </summary>
+    /// <typeparam name="T">The type of the object to deserialize to.</typeparam>
+    /// <param name="value">The JSON string to deserialize.</param>
+    /// <returns>An object of type T represented by the JSON string.</returns>
+    internal static T Deserialize<T>(string value)
+    {
+#if NET6_0
+        return JsonSerializer.Deserialize<T>(value,_jsonOptions);
+#else
+        if (RuntimeFeatureWrapper.IsDynamicCodeSupported)
+        {
+#pragma warning disable
+            return JsonSerializer.Deserialize<T>(value, _jsonOptions);
+        }
+
+        return (T)JsonSerializer.Deserialize(value, GetTypeInfo(typeof(T)));
+#endif
+    }
+}

libraries/src/AWS.Lambda.Powertools.Idempotency/Persistence/BasePersistenceStore.cs

@@ -21,6 +21,7 @@
 using AWS.Lambda.Powertools.Common;
 using AWS.Lambda.Powertools.Idempotency.Exceptions;
 using AWS.Lambda.Powertools.Idempotency.Internal;
+using AWS.Lambda.Powertools.Idempotency.Internal.Serializers;
 using AWS.Lambda.Powertools.JMESPath;
 
 namespace AWS.Lambda.Powertools.Idempotency.Persistence;
@@ -95,7 +96,7 @@ internal void Configure(IdempotencyOptions options, string functionName, LRUCach
     /// <param name="now">The current date time</param>
     public virtual async Task SaveSuccess(JsonDocument data, object result, DateTimeOffset now)
     {
-        var responseJson = JsonSerializer.Serialize(result);
+        var responseJson = IdempotencySerializer.Serialize(result, typeof(object));
         var record = new DataRecord(
             GetHashedIdempotencyKey(data),
             DataRecord.DataRecordStatus.COMPLETED,
@@ -323,7 +324,13 @@ private static bool IsMissingIdempotencyKey(JsonElement data)
     /// <exception cref="ArgumentException"></exception>
     internal string GenerateHash(JsonElement data)
     {
+#if NET8_0_OR_GREATER
+        // starting .NET 8 no option to change hash algorithm
+        using var hashAlgorithm = MD5.Create();
+#else
+
         using var hashAlgorithm = HashAlgorithm.Create(_idempotencyOptions.HashFunction);
+#endif
         if (hashAlgorithm == null)
         {
             throw new ArgumentException("Invalid HashAlgorithm");