Implement SelectMany support (#320)

* Added SelectMany support

* Renamed ISpecification SelectManyExpression to SelectorMany to match existing Selector

* Added repository integration tests for SelectMany spec

Specification.EntityFramework6/src/Ardalis.Specification.EntityFramework6/Evaluators/SpecificationEvaluator.cs

@@ -33,11 +33,14 @@ public SpecificationEvaluator(IEnumerable<IEvaluator> evaluators)
     public virtual IQueryable<TResult> GetQuery<T, TResult>(IQueryable<T> query, ISpecification<T, TResult> specification) where T : class
     {
       if (specification is null) throw new ArgumentNullException("Specification is required");
-      if (specification.Selector is null) throw new SelectorNotFoundException();
+      if (specification.Selector is null && specification.SelectorMany is null) throw new SelectorNotFoundException();
+      if (specification.Selector != null && specification.SelectorMany != null) throw new ConcurrentSelectorsException();
 
       query = GetQuery(query, (ISpecification<T>)specification);
 
-      return query.Select(specification.Selector);
+      return specification.Selector != null
+        ? query.Select(specification.Selector)
+        : query.SelectMany(specification.SelectorMany);
     }
 
     /// <inheritdoc/>

Specification.EntityFramework6/tests/Ardalis.Specification.EntityFramework6.IntegrationTests/RepositoryOfT_ListAsync.cs

@@ -170,5 +170,15 @@ public async Task ReturnsStoreContainingCity1_GivenStoreIncludeProductsSpec()
       result[0].Id.Should().Be(StoreSeed.VALID_Search_ID);
       result[0].City.Should().Contain(StoreSeed.VALID_Search_City_Key);
     }
+
+    [Fact]
+    public virtual async Task ReturnsAllProducts_GivenStoreSelectManyProductsSpec()
+    {
+      var result = await storeRepository.ListAsync(new StoreProductNamesSpec());
+
+      result.Should().NotBeNull();
+      result.Should().HaveCount(ProductSeed.TOTAL_PRODUCT_COUNT);
+      result.OrderBy(x => x).First().Should().Be(ProductSeed.VALID_PRODUCT_NAME);
+    }
   }
 }

Specification.EntityFrameworkCore/src/Ardalis.Specification.EntityFrameworkCore/Evaluators/SpecificationEvaluator.cs

@@ -47,11 +47,14 @@ public SpecificationEvaluator(IEnumerable<IEvaluator> evaluators)
     public virtual IQueryable<TResult> GetQuery<T, TResult>(IQueryable<T> query, ISpecification<T, TResult> specification) where T : class
     {
       if (specification is null) throw new ArgumentNullException("Specification is required");
-      if (specification.Selector is null) throw new SelectorNotFoundException();
+      if (specification.Selector is null && specification.SelectorMany is null) throw new SelectorNotFoundException();
+      if (specification.Selector != null && specification.SelectorMany != null) throw new ConcurrentSelectorsException();
 
       query = GetQuery(query, (ISpecification<T>)specification);
 
-      return query.Select(specification.Selector);
+      return specification.Selector is not null
+        ? query.Select(specification.Selector)
+        : query.SelectMany(specification.SelectorMany!);
     }
 
     /// <inheritdoc/>

Specification.EntityFrameworkCore/tests/Ardalis.Specification.EntityFrameworkCore.IntegrationTests/RepositoryOfT_ListAsync.cs

@@ -196,5 +196,15 @@ public virtual async Task ReturnsStoreContainingCity1_GivenStoreIncludeProductsS
       result[0].Id.Should().Be(StoreSeed.VALID_Search_ID);
       result[0].City.Should().Contain(StoreSeed.VALID_Search_City_Key);
     }
+
+    [Fact]
+    public virtual async Task ReturnsAllProducts_GivenStoreSelectManyProductsSpec()
+    {
+      var result = await storeRepository.ListAsync(new StoreProductNamesSpec());
+
+      result.Should().NotBeNull();
+      result.Should().HaveCount(ProductSeed.TOTAL_PRODUCT_COUNT);
+      result.OrderBy(x => x).First().Should().Be(ProductSeed.VALID_PRODUCT_NAME);
+    }
   }
 }

Specification/src/Ardalis.Specification/Builder/SpecificationBuilderExtensions.cs

@@ -291,6 +291,19 @@ public static ISpecificationBuilder<T, TResult> Select<T, TResult>(
       return specificationBuilder;
     }
 
+    /// <summary>
+    /// Specify a transform function to apply to the <typeparamref name="T"/> element 
+    /// to produce a flattened sequence of <typeparamref name="TResult"/> elements.
+    /// </summary>
+    public static ISpecificationBuilder<T, TResult> SelectMany<T, TResult>(
+        this ISpecificationBuilder<T, TResult> specificationBuilder,
+        Expression<Func<T, IEnumerable<TResult>>> selector)
+    {
+      specificationBuilder.Specification.SelectorMany = selector;
+
+      return specificationBuilder;
+    }
+
     /// <summary>
     /// Specify a transform function to apply to the result of the query 
     /// and returns the same <typeparamref name="T"/> type

Specification/src/Ardalis.Specification/Evaluators/InMemorySpecificationEvaluator.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
@@ -30,11 +31,14 @@ public InMemorySpecificationEvaluator(IEnumerable<IInMemoryEvaluator> evaluators
 
     public virtual IEnumerable<TResult> Evaluate<T, TResult>(IEnumerable<T> source, ISpecification<T, TResult> specification)
     {
-      _ = specification.Selector ?? throw new SelectorNotFoundException();
+      if (specification.Selector is null && specification.SelectorMany is null) throw new SelectorNotFoundException();
+      if (specification.Selector != null && specification.SelectorMany != null) throw new ConcurrentSelectorsException();
 
       var baseQuery = Evaluate(source, (ISpecification<T>)specification);
 
-      var resultQuery = baseQuery.Select(specification.Selector.Compile());
+      var resultQuery = specification.Selector != null
+        ? baseQuery.Select(specification.Selector.Compile())
+        : baseQuery.SelectMany(specification.SelectorMany!.Compile());
 
       return specification.PostProcessingAction == null
           ? resultQuery

Specification/src/Ardalis.Specification/Exceptions/ConcurrentSelectorsException.cs

@@ -0,0 +1,19 @@
+using System;
+
+namespace Ardalis.Specification
+{
+  public class ConcurrentSelectorsException : Exception
+  {
+    private const string message = "Concurrent specification selector transforms defined. Ensure only one of the Select() or SelectMany() transforms is used in the same specification!";
+
+    public ConcurrentSelectorsException()
+        : base(message)
+    {
+    }
+
+    public ConcurrentSelectorsException(Exception innerException)
+        : base(message, innerException)
+    {
+    }
+  }
+}

Specification/src/Ardalis.Specification/Exceptions/SelectorNotFoundException.cs

@@ -1,12 +1,10 @@
 using System;
-using System.Collections.Generic;
-using System.Text;
 
 namespace Ardalis.Specification
 {
   public class SelectorNotFoundException : Exception
   {
-    private const string message = "The specification must have Selector defined.";
+    private const string message = "The specification must have a selector transform defined. Ensure either Select() or SelectMany() is used in the specification!";
 
     public SelectorNotFoundException()
         : base(message)

Specification/src/Ardalis.Specification/ISpecification.cs

@@ -15,10 +15,15 @@ public interface ISpecification<T, TResult> : ISpecification<T>
     ISpecificationBuilder<T, TResult> Query { get; }
 
     /// <summary>
-    /// The transform function to apply to the <typeparamref name="T"/> element.
+    /// The Select transform function to apply to the <typeparamref name="T"/> element.
     /// </summary>
     Expression<Func<T, TResult>>? Selector { get; }
 
+    /// <summary>
+    /// The SelectMany transform function to apply to the <typeparamref name="T"/> element.
+    /// </summary>
+    Expression<Func<T, IEnumerable<TResult>>>? SelectorMany { get; }
+
     /// <summary>
     /// The transform function to apply to the result of the query encapsulated by the <see cref="ISpecification{T, TResult}"/>.
     /// </summary>

Specification/src/Ardalis.Specification/Specification.cs

@@ -28,6 +28,9 @@ protected Specification(IInMemorySpecificationEvaluator inMemorySpecificationEva
     /// <inheritdoc/>
     public Expression<Func<T, TResult>>? Selector { get; internal set; }
 
+    /// <inheritdoc/>
+    public Expression<Func<T, IEnumerable<TResult>>>? SelectorMany { get; internal set; }
+
     /// <inheritdoc/>
     public new Func<IEnumerable<TResult>, IEnumerable<TResult>>? PostProcessingAction { get; internal set; } = null;
   }

Specification/tests/Ardalis.Specification.UnitTests/BuilderTests/SpecificationBuilderExtensions_SelectMany.cs

@@ -0,0 +1,25 @@
+using Ardalis.Specification.UnitTests.Fixture.Specs;
+using FluentAssertions;
+using Xunit;
+
+namespace Ardalis.Specification.UnitTests
+{
+  public class SpecificationBuilderExtensions_SelectMany
+  {
+    [Fact]
+    public void SetsNothing_GivenNoSelectManyExpression()
+    {
+      var spec = new StoreProductNamesEmptySpec();
+
+      spec.SelectorMany.Should().BeNull();
+    }
+
+    [Fact]
+    public void SetsSelectorMany_GivenSelectManyExpression()
+    {
+      var spec = new StoreProductNamesSpec();
+
+      spec.SelectorMany.Should().NotBeNull();
+    }
+  }
+}

Specification/tests/Ardalis.Specification.UnitTests/ExceptionTests/ConcurrentSelectorsExceptionTests.cs

@@ -0,0 +1,28 @@
+using System;
+using FluentAssertions;
+using Xunit;
+
+namespace Ardalis.Specification.UnitTests
+{
+  public class ConcurrentSelectorsExceptionTests
+  {
+    private const string defaultMessage = "Concurrent specification selector transforms defined. Ensure only one of the Select() or SelectMany() transforms is used in the same specification!";
+
+    [Fact]
+    public void ThrowWithDefaultConstructor()
+    {
+      Action action = () => throw new ConcurrentSelectorsException();
+
+      action.Should().Throw<ConcurrentSelectorsException>().WithMessage(defaultMessage);
+    }
+
+    [Fact]
+    public void ThrowWithInnerException()
+    {
+      Exception inner = new Exception("test");
+      Action action = () => throw new ConcurrentSelectorsException(inner);
+
+      action.Should().Throw<ConcurrentSelectorsException>().WithMessage(defaultMessage).WithInnerException<Exception>().WithMessage("test");
+    }
+  }
+}

Specification/tests/Ardalis.Specification.UnitTests/ExceptionTests/SelectorNotFoundExceptionTests.cs

@@ -1,14 +1,12 @@
 using System;
-using System.Collections.Generic;
-using System.Text;
 using FluentAssertions;
 using Xunit;
 
 namespace Ardalis.Specification.UnitTests
 {
   public class SelectorNotFoundExceptionTests
   {
-    private const string defaultMessage = "The specification must have Selector defined.";
+    private const string defaultMessage = "The specification must have a selector transform defined. Ensure either Select() or SelectMany() is used in the specification!";
 
     [Fact]
     public void ThrowWithDefaultConstructor()

Specification/tests/Ardalis.Specification.UnitTests/Fixture/Entities/Seeds/ProductSeed.cs

@@ -1,16 +1,17 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
+using System.Collections.Generic;
 
 namespace Ardalis.Specification.UnitTests.Fixture.Entities.Seeds
 {
   public class ProductSeed
   {
+    public const int TOTAL_PRODUCT_COUNT = 100;
+    public const string VALID_PRODUCT_NAME = "Product 1";
+
     public static List<Product> Get()
     {
       var products = new List<Product>();
 
-      for (int i = 1; i < 100; i = i + 2)
+      for (int i = 1; i < TOTAL_PRODUCT_COUNT; i = i + 2)
       {
         products.Add(new Product()
         {

Specification/tests/Ardalis.Specification.UnitTests/Fixture/Specs/StoreProductNamesEmptySpec.cs

@@ -0,0 +1,12 @@
+using Ardalis.Specification.UnitTests.Fixture.Entities;
+
+namespace Ardalis.Specification.UnitTests.Fixture.Specs
+{
+  public class StoreProductNamesEmptySpec : Specification<Store, string?>
+  {
+    public StoreProductNamesEmptySpec()
+    {
+
+    }
+  }
+}

Specification/tests/Ardalis.Specification.UnitTests/Fixture/Specs/StoreProductNamesSpec.cs

@@ -0,0 +1,13 @@
+using System.Linq;
+using Ardalis.Specification.UnitTests.Fixture.Entities;
+
+namespace Ardalis.Specification.UnitTests.Fixture.Specs
+{
+  public class StoreProductNamesSpec : Specification<Store, string?>
+  {
+    public StoreProductNamesSpec()
+    {
+      Query.SelectMany(s => s.Products.Select(p => p.Name));
+    }
+  }
+}