Merge branch 'dev'

Author: quyvu01

.github/workflows/build.yml

@@ -2,7 +2,7 @@
 
 name: Build OfX and Publish
 env:
-  OFX_VERSION: 7.2.0-preview
+  OFX_VERSION: 7.2.0
 
 on:
   push:

src/OfX/Helpers/ReflectionHelpers.cs

@@ -71,21 +71,20 @@ IEnumerable<MappableDataProperty> IterateMappableProperties(IEnumerable<Property
                     continue;
                 }
 
-                var ofXAttribute = property.GetCustomAttributes(true).OfType<OfXAttribute>().FirstOrDefault();
-                if (ofXAttribute is not null)
+                var attribute = property.GetCustomAttribute<OfXAttribute>();
+                if (attribute is not null)
                 {
                     var paramExpression = Expression.Parameter(typeof(object), nameof(obj));
                     var castExpression = Expression.Convert(paramExpression, obj.GetType());
-                    var propExpression = Expression.Property(castExpression, ofXAttribute.PropertyName);
+                    var propExpression = Expression.Property(castExpression, attribute.PropertyName);
                     var convertToObject = Expression.Convert(propExpression, typeof(object));
                     var expression = Expression.Lambda<Func<object, object>>(convertToObject, paramExpression);
                     var func = expression.Compile();
                     var graph = Graphs.GetOrAdd(obj.GetType(), DependencyGraphBuilder.BuildDependencyGraph);
                     var order = graph.GetPropertyOrder(property);
-                    yield return new MappableDataProperty(property, obj, ofXAttribute, func, ofXAttribute.Expression,
-                        order);
+                    yield return new MappableDataProperty(property, obj, attribute, func, attribute.Expression, order);
                     OfXPropertiesCache.TryAdd(property,
-                        new MappableDataPropertyCache(ofXAttribute, func, ofXAttribute.Expression, order));
+                        new MappableDataPropertyCache(attribute, func, attribute.Expression, order));
                     continue;
                 }
 
@@ -163,7 +162,6 @@ internal static void MapResponseData(IEnumerable<MappableDataProperty> mappableP
                 catch (Exception)
                 {
                     if (OfXStatics.ThrowIfExceptions) throw;
-                    // Ignore this field as well
                 }
 
                 return value;

src/OfX/Helpers/RegexHelpers.cs

@@ -8,6 +8,9 @@ public static partial class RegexHelpers
     public static string ResolvePlaceholders(string expression, IDictionary<string, string> parameters)
     {
         if (expression is null) return null;
+        parameters ??= new Dictionary<string, string>();
+        var lookupCache = new Dictionary<string, string>(parameters.Count, StringComparer.OrdinalIgnoreCase);
+        foreach (var kvp in parameters) lookupCache[kvp.Key] = kvp.Value;
         return ParametersRegex.Replace(expression, match =>
         {
             var hasParameter = match.Groups["parameter"].Success;
@@ -16,10 +19,7 @@ public static string ResolvePlaceholders(string expression, IDictionary<string,
             var hasDefault = match.Groups["default"].Success;
             if (!hasDefault) throw new OfXException.InvalidParameter(expression);
             var fallback = match.Groups["default"].Value;
-
-            if (parameters != null && parameters.TryGetValue(parameter, out var value) && value != null) return value;
-
-            return fallback;
+            return lookupCache.GetValueOrDefault(parameter, fallback);
         });
     }
 

src/OfX/Implementations/DataMappableService.cs

@@ -32,7 +32,7 @@ public async Task MapDataAsync(object value, object parameters = null, Cancellat
 
             var allPropertyDatas = ReflectionHelpers
                 .GetMappableProperties(value)
-                .ToList();
+                .ToArray();
 
             var ofXTypesData = ReflectionHelpers
                 .GetOfXTypesData(allPropertyDatas, OfXStatics.OfXAttributeTypes.Value);

src/OfX/Implementations/SendPipelinesOrchestrator.cs

@@ -14,7 +14,7 @@ internal abstract class SendPipelinesOrchestrator
     internal abstract Task<ItemsResponse<OfXDataResponse>> ExecuteAsync(OfXRequest message, IContext context);
 }
 
-internal sealed class SendPipelinesOrchestrator<TAttribute>(IServiceProvider serviceProvider) : 
+internal sealed class SendPipelinesOrchestrator<TAttribute>(IServiceProvider serviceProvider) :
     SendPipelinesOrchestrator where TAttribute : OfXAttribute
 {
     internal override async Task<ItemsResponse<OfXDataResponse>> ExecuteAsync(OfXRequest message, IContext context)
@@ -24,18 +24,23 @@ internal override async Task<ItemsResponse<OfXDataResponse>> ExecuteAsync(OfXReq
         using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
         cts.CancelAfter(OfXConstants.DefaultRequestTimeout);
         var expressions = JsonSerializer.Deserialize<string[]>(message.Expression);
-        var expressionsResolved = expressions.Select(originalExpression => new
-        {
-            originalExpression, resolvedExpression = context switch
+        var parameters = context is IExpressionParameters expressionParameters ? expressionParameters.Parameters : null;
+
+        // Resolve expressions and build lookup in one pass
+
+        var (expressionMap, resolvedExpressions) = expressions.Aggregate((
+                ExpressionMap: new Dictionary<ExpressionWrapper, string>(expressions.Length),
+                ResolvedExpressions: new List<string>(expressions.Length)),
+            (acc, originalExpression) =>
             {
-                IExpressionParameters expressionParameters => RegexHelpers
-                    .ResolvePlaceholders(originalExpression, expressionParameters.Parameters),
-                _ => RegexHelpers.ResolvePlaceholders(originalExpression, null)
-            }
-        }).ToArray();
+                var resolvedExpression = RegexHelpers.ResolvePlaceholders(originalExpression, parameters);
+                if (acc.ExpressionMap.TryAdd(new ExpressionWrapper(resolvedExpression), originalExpression))
+                    acc.ResolvedExpressions.Add(resolvedExpression);
+                return acc;
+            });
 
-        var expression = JsonSerializer.Serialize(expressionsResolved
-            .Select(a => a.resolvedExpression).Distinct());
+        // Serialize only the distinct resolved expressions
+        var expression = JsonSerializer.Serialize(resolvedExpressions);
 
         var request = new RequestOf<TAttribute>(message.SelectorIds, expression);
         var requestContext = new RequestContextImpl<TAttribute>(request, context?.Headers ?? [], cts.Token);
@@ -45,16 +50,28 @@ internal override async Task<ItemsResponse<OfXDataResponse>> ExecuteAsync(OfXReq
             .Aggregate(() => handler.RequestAsync(requestContext),
                 (acc, pipeline) => () => pipeline.HandleAsync(requestContext, acc)).Invoke();
 
-        result.Items.ForEach(it => it.OfXValues =
-        [
-            ..expressionsResolved.Select(ex =>
+        result.Items.ForEach(it =>
+        {
+            var valueLookup = it.OfXValues
+                .ToDictionary(v => new ExpressionWrapper(v.Expression), v => v);
+
+            var values = expressionMap.Select(ex =>
             {
-                var valueResult = it.OfXValues.FirstOrDefault(a => a.Expression == ex.resolvedExpression);
+                var valueResult = valueLookup.GetValueOrDefault(ex.Key, null);
                 return valueResult is null
                     ? null
-                    : new OfXValueResponse { Expression = ex.originalExpression, Value = valueResult.Value };
-            }).Where(a => a != null)
-        ]);
+                    : new OfXValueResponse { Expression = ex.Value, Value = valueResult.Value };
+            }).Where(a => a != null);
+            it.OfXValues = [..values];
+        });
         return result;
     }
+}
+
+internal readonly record struct ExpressionWrapper(string Expression)
+{
+    public bool Equals(ExpressionWrapper other) =>
+        string.Equals(Expression, other.Expression, StringComparison.Ordinal);
+
+    public override int GetHashCode() => Expression?.GetHashCode() ?? 0;
 }

test/Service1.Contract/Responses/MemberResponse.cs

@@ -41,7 +41,7 @@ public class MemberResponse
     [ProvinceOf(nameof(ProvinceId), Expression = "CountryId")]
     public string CountryId { get; set; }
 
-    [CountryOf(nameof(CountryId), Expression = "Provinces[asc Name]")]
+    [CountryOf(nameof(CountryId), Expression = "Provinces[${Skip|0} ${Take|1} asc Name]")]
     public List<ProvinceResponse> Provinces { get; set; }
 
     [CountryOf(nameof(CountryId), Expression = "Provinces[${index|0} ${order|asc} Name]")]

test/Service1.Contract/Responses/SimpleMemberResponse.cs

@@ -6,6 +6,6 @@ public class SimpleMemberResponse
 {
     public string UserId { get; set; }
 
-    [UserOf(nameof(UserId), Expression = "${UserAlias|Name}")]
+    [UserOf(nameof(UserId), Expression = "${userAlias|Name}")]
     public string UserAlias { get; set; }
 }

test/Service1/GraphQls/Query.cs

@@ -29,7 +29,7 @@ public List<SimpleMemberResponse> GetSimpleMembers([Parameters] GetMembersParame
     ];
 }
 
-public sealed record GetMembersParameters(string UserAlias = "Email");
+public sealed record GetMembersParameters(string UserAlias = "Email", int Skip = 0, int Take = 1);
 
 public sealed class MembersType : ObjectTypeExtension<MemberResponse>
 {