Added predicates to DataLoader (#7589)

Co-authored-by: Michael Staib <[email protected]>
Co-authored-by: Glen <[email protected]>

Author: 3 people

global.json

@@ -1,6 +1,6 @@
 {
   "sdk": {
-    "version": "9.0.100-rc.1.24452.12",
+    "version": "9.0.100-rc.2.24474.11",
     "rollForward": "latestMinor"
   }
 }

src/GreenDonut/src/Core/DataLoaderFetchContext.cs

@@ -1,6 +1,7 @@
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
-using GreenDonut.Projections;
+using GreenDonut.Predicates;
+using GreenDonut.Selectors;
 
 namespace GreenDonut;
 
@@ -141,7 +142,7 @@ public TState GetStateOrDefault<TState>(string key, TState defaultValue)
     /// <returns>
     /// Returns the selector builder if it exists.
     /// </returns>
-    [Experimental(Experiments.Projections)]
+    [Experimental(Experiments.Selectors)]
     public ISelectorBuilder GetSelector()
     {
         if (ContextData.TryGetValue(typeof(ISelectorBuilder).FullName!, out var value)
@@ -154,4 +155,25 @@ public ISelectorBuilder GetSelector()
         // a new default selector builder.
         return new DefaultSelectorBuilder();
     }
+
+    /// <summary>
+    /// Gets the predicate builder from the DataLoader state snapshot.
+    /// The state builder can be used to create a predicate expression.
+    /// </summary>
+    /// <returns>
+    /// Returns the predicate builder if it exists.
+    /// </returns>
+    [Experimental(Experiments.Predicates)]
+    public IPredicateBuilder GetPredicate()
+    {
+        if (ContextData.TryGetValue(typeof(IPredicateBuilder).FullName!, out var value)
+            && value is DefaultPredicateBuilder casted)
+        {
+            return casted;
+        }
+
+        // if no predicate was found we will just return
+        // a new default predicate builder.
+        return new DefaultPredicateBuilder();
+    }
 }

src/GreenDonut/src/Core/Experiments.cs

@@ -2,5 +2,6 @@ namespace GreenDonut;
 
 internal static class Experiments
 {
-    public const string Projections = "GD0001";
+    public const string Selectors = "GD0001";
+    public const string Predicates = "GD0002";
 }

src/GreenDonut/src/Core/Projections/ExpressionHelpers.cs renamed to src/GreenDonut/src/Core/ExpressionHelpers.cs

@@ -1,7 +1,7 @@
 using System.Linq.Expressions;
 using System.Reflection;
 
-namespace GreenDonut.Projections;
+namespace GreenDonut;
 
 internal static class ExpressionHelpers
 {
@@ -16,6 +16,17 @@ public static Expression<Func<T, T>> Combine<T>(
         return Expression.Lambda<Func<T, T>>(combinedBody, parameter);
     }
 
+    public static Expression<Func<T, bool>> And<T>(
+        Expression<Func<T, bool>> first,
+        Expression<Func<T, bool>> second)
+    {
+        var parameter = Expression.Parameter(typeof(T), "entity");
+        var firstBody = ReplaceParameter(first.Body, first.Parameters[0], parameter);
+        var secondBody = ReplaceParameter(second.Body, second.Parameters[0], parameter);
+        var combinedBody = Expression.AndAlso(firstBody, secondBody);
+        return Expression.Lambda<Func<T, bool>>(combinedBody, parameter);
+    }
+
     private static Expression ReplaceParameter(
         Expression body,
         ParameterExpression toReplace,

src/GreenDonut/src/Core/Predicates/DefaultPredicateBuilder.cs

@@ -0,0 +1,51 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+
+namespace GreenDonut.Predicates;
+
+[Experimental(Experiments.Predicates)]
+internal sealed class DefaultPredicateBuilder : IPredicateBuilder
+{
+    private List<LambdaExpression>? _predicates;
+
+    /// <inheritdoc />
+    public void Add<T>(Expression<Func<T, bool>> selector)
+    {
+        _predicates ??= new List<LambdaExpression>();
+        if (!_predicates.Contains(selector))
+        {
+            _predicates.Add(selector);
+        }
+    }
+
+    /// <inheritdoc />
+    public Expression<Func<T, bool>>? TryCompile<T>()
+    {
+        if (_predicates is null)
+        {
+            return null;
+        }
+
+        if (_predicates.Count == 1)
+        {
+            return (Expression<Func<T, bool>>)_predicates[0];
+        }
+
+        if (_predicates.Count == 2)
+        {
+            return ExpressionHelpers.And(
+                (Expression<Func<T, bool>>)_predicates[0],
+                (Expression<Func<T, bool>>)_predicates[1]);
+        }
+
+        var expression = (Expression<Func<T, bool>>)_predicates[0];
+        for (var i = 1; i < _predicates.Count; i++)
+        {
+            expression = ExpressionHelpers.And(
+                expression,
+                (Expression<Func<T, bool>>)_predicates[i]);
+        }
+
+        return expression;
+    }
+}

src/GreenDonut/src/Core/Predicates/IPredicateBuilder.cs

@@ -0,0 +1,35 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+
+namespace GreenDonut.Predicates;
+
+/// <summary>
+/// The predicate builder helps you create a combined predicate expression
+/// by adding multiple expressions together.
+/// </summary>
+[Experimental(Experiments.Predicates)]
+public interface IPredicateBuilder
+{
+    /// <summary>
+    /// Adds a predicate expression to the builder.
+    /// </summary>
+    /// <param name="selector">
+    /// An expression that defines how to select data from the data source.
+    /// </param>
+    /// <typeparam name="T">
+    /// The type of the data source.
+    /// </typeparam>
+    void Add<T>(Expression<Func<T, bool>> selector);
+
+    /// <summary>
+    /// Combines all the added predicate expressions into one.
+    /// Returns null if no expressions were added.
+    /// </summary>
+    /// <typeparam name="T">
+    /// The type of the data source.
+    /// </typeparam>
+    /// <returns>
+    /// A combined predicate expression, or null if none were added.
+    /// </returns>
+    Expression<Func<T, bool>>? TryCompile<T>();
+}

src/GreenDonut/src/Core/Predicates/IPredicateDataLoader.cs

@@ -0,0 +1,23 @@
+namespace GreenDonut.Predicates;
+
+/// <summary>
+/// A predicate DataLoader is a specialized version of a DataLoader that
+/// selects a subset of data based on a given predicate from the original DataLoader.
+/// The data retrieved by this DataLoader is not shared with other DataLoaders and
+/// remains isolated within this instance.
+/// </summary>
+/// <typeparam name="TKey">
+/// The type of the key.
+/// </typeparam>
+/// <typeparam name="TValue">
+/// The type of the value.
+/// </typeparam>
+public interface IPredicateDataLoader<in TKey, TValue>
+    : IDataLoader<TKey, TValue>
+    where TKey : notnull
+{
+    /// <summary>
+    /// Gets the root DataLoader instance from which this instance was derived.
+    /// </summary>
+    IDataLoader<TKey, TValue> Root { get; }
+}

src/GreenDonut/src/Core/Predicates/PredicateDataLoader.cs

@@ -0,0 +1,34 @@
+namespace GreenDonut.Predicates;
+
+internal sealed class PredicateDataLoader<TKey, TValue>
+    : DataLoaderBase<TKey, TValue>
+    , IPredicateDataLoader<TKey, TValue>
+    where TKey : notnull
+{
+    private readonly DataLoaderBase<TKey, TValue> _root;
+
+    public PredicateDataLoader(
+        DataLoaderBase<TKey, TValue> root,
+        string predicateKey)
+        : base(root.BatchScheduler, root.Options)
+    {
+        _root = root;
+        CacheKeyType = $"{root.CacheKeyType}:{predicateKey}";
+        ContextData = root.ContextData;
+    }
+
+    public IDataLoader<TKey, TValue> Root => _root;
+
+    protected internal override string CacheKeyType { get; }
+
+    protected override bool AllowCachePropagation => false;
+
+    protected override bool AllowBranching => false;
+
+    protected internal override ValueTask FetchAsync(
+        IReadOnlyList<TKey> keys,
+        Memory<Result<TValue?>> results,
+        DataLoaderFetchContext<TValue> context,
+        CancellationToken cancellationToken)
+        => _root.FetchAsync(keys, results, context, cancellationToken);
+}

src/GreenDonut/src/Core/Predicates/PredicateDataLoaderExtensions.cs

@@ -0,0 +1,115 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+
+namespace GreenDonut.Predicates;
+
+/// <summary>
+/// Data loader extensions for predicates.
+/// </summary>
+[Experimental(Experiments.Predicates)]
+public static class PredicateDataLoaderExtensions
+{
+    /// <summary>
+    /// Branches a DataLoader and applies a predicate to filter the data.
+    /// </summary>
+    /// <param name="dataLoader">
+    /// The DataLoader to branch.
+    /// </param>
+    /// <param name="predicate">
+    /// The data predicate.
+    /// </param>
+    /// <typeparam name="TKey">
+    /// The key type.
+    /// </typeparam>
+    /// <typeparam name="TValue">
+    /// The value type.
+    /// </typeparam>
+    /// <returns>
+    /// Returns a branched DataLoader with the predicate applied.
+    /// </returns>
+    /// <exception cref="ArgumentNullException">
+    /// Throws if <paramref name="dataLoader"/> is <c>null</c>.
+    /// </exception>
+    public static IDataLoader<TKey, TValue> Where<TKey, TValue>(
+        this IDataLoader<TKey, TValue> dataLoader,
+        Expression<Func<TValue, bool>>? predicate)
+        where TKey : notnull
+    {
+        if (dataLoader is null)
+        {
+            throw new ArgumentNullException(nameof(dataLoader));
+        }
+
+        if (predicate is null)
+        {
+            return dataLoader;
+        }
+
+        if (dataLoader.ContextData.TryGetValue(typeof(IPredicateBuilder).FullName!, out var value))
+        {
+            var context = (DefaultPredicateBuilder)value!;
+            context.Add(predicate);
+            return dataLoader;
+        }
+
+        var branchKey = predicate.ToString();
+        return (IDataLoader<TKey, TValue>)dataLoader.Branch(branchKey, CreateBranch, predicate);
+
+        static IDataLoader CreateBranch(
+            string key,
+            IDataLoader<TKey, TValue> dataLoader,
+            Expression<Func<TValue, bool>> predicate)
+        {
+            var branch = new PredicateDataLoader<TKey, TValue>(
+                (DataLoaderBase<TKey, TValue>)dataLoader,
+                key);
+            var context = new DefaultPredicateBuilder();
+            branch.ContextData =
+                branch.ContextData.SetItem(typeof(IPredicateBuilder).FullName!, context);
+            context.Add(predicate);
+            return branch;
+        }
+    }
+
+    /// <summary>
+    /// Applies the predicate from the DataLoader state to a queryable.
+    /// </summary>
+    /// <param name="query">
+    /// The queryable to apply the predicate to.
+    /// </param>
+    /// <param name="builder">
+    /// The predicate builder.
+    /// </param>
+    /// <typeparam name="T">
+    /// The queryable type.
+    /// </typeparam>
+    /// <returns>
+    /// Returns a query with the predicate applied, ready to fetch data with the key.
+    /// </returns>
+    /// <exception cref="ArgumentNullException">
+    /// Throws if <paramref name="query"/> is <c>null</c>.
+    /// </exception>
+    public static IQueryable<T> Where<T>(
+        this IQueryable<T> query,
+        IPredicateBuilder builder)
+    {
+        if (query is null)
+        {
+            throw new ArgumentNullException(nameof(query));
+        }
+
+        if (builder is null)
+        {
+            throw new ArgumentNullException(nameof(builder));
+        }
+
+        var predicate = builder.TryCompile<T>();
+
+        if (predicate is not null)
+        {
+            query = query.Where(predicate);
+        }
+
+        return query;
+    }
+}

src/GreenDonut/src/Core/Projections/DefaultSelectorBuilder.cs renamed to src/GreenDonut/src/Core/Selectors/DefaultSelectorBuilder.cs

@@ -1,12 +1,12 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq.Expressions;
 
-namespace GreenDonut.Projections;
+namespace GreenDonut.Selectors;
 
 /// <summary>
 /// A default implementation of the <see cref="ISelectorBuilder"/>.
 /// </summary>
-[Experimental(Experiments.Projections)]
+[Experimental(Experiments.Selectors)]
 public sealed class DefaultSelectorBuilder : ISelectorBuilder
 {
     private List<LambdaExpression>? _selectors;