Implemented new tests for different cases of buildTypeDiscriminatorCheck

Author: Viktor Tochonov

src/FSharp.Data.GraphQL.Server.Middleware/ObjectListFilter.fs

@@ -1,9 +1,6 @@
 namespace FSharp.Data.GraphQL.Server.Middleware
 
 open System
-open System.Linq
-open System.Linq.Expressions
-open System.Runtime.InteropServices
 
 /// A filter definition for a field value.
 type FieldFilter<'Val> = { FieldName : string; Value : 'Val }
@@ -19,7 +16,7 @@ type ObjectListFilter =
     | StartsWith of FieldFilter<string>
     | EndsWith of FieldFilter<string>
     | Contains of FieldFilter<string>
-    | OfTypes of FieldFilter<Type list>
+    | OfTypes of Type list
     | FilterField of FieldFilter<ObjectListFilter>
     | NoFilter
 
@@ -57,9 +54,15 @@ module ObjectListFilter =
         /// Creates a new ObjectListFilter representing a NOT opreation for the existing one.
         let ( !!! ) filter = Not filter
 
+open System.Linq
+open System.Linq.Expressions
+open System.Runtime.InteropServices
+open System.Reflection
+
 [<AutoOpen>]
 module ObjectListFilterExtensions =
 
+
     //// discriminator custom condition
     //let a () =
     //    filter.Apply(
@@ -79,6 +82,31 @@ module ObjectListFilterExtensions =
     //        | t when Type.(=)(t, typeof<Building>) -> ResidentialPropertiesConstants.Discriminators.Building
     //    )
 
+    type DiscriminatorExpression<'T, 'D> =
+        | GetDiscriminatorValue of ('T -> 'D)
+        | CompareDiscriminator of Expression<Func<'T, 'D, bool>>
+
+    [<Struct>]
+    type ObjectListFilterLinqOptions<'T, 'D> (
+        discriminatorExpression : DiscriminatorExpression<'T, 'D> | null,
+        [<Optional>] getDiscriminatorValue: (Type -> 'D) | null,
+        [<Optional>] serializeMemberName: (MemberInfo -> string) | null) =
+
+        member _.DiscriminatorExpression = discriminatorExpression |> ValueOption.ofObj
+        member _.GetDiscriminatorValue = getDiscriminatorValue |> ValueOption.ofObj
+        member _.SerializeMemberName = serializeMemberName |> ValueOption.ofObj
+
+        static member None = ObjectListFilterLinqOptions<'T, 'D> (null, null, null)
+
+        new (getDiscriminatorValue : 'T -> 'D) = ObjectListFilterLinqOptions<'T, 'D> (GetDiscriminatorValue getDiscriminatorValue, null, null)
+        new (compareDiscriminator : Expression<Func<'T, 'D, bool>>) = ObjectListFilterLinqOptions<'T, 'D> (CompareDiscriminator compareDiscriminator, null, null)
+        new (getDiscriminatorValue : Type -> 'D) = ObjectListFilterLinqOptions<'T, 'D> (null, getDiscriminatorValue, null)
+        new (serializeMemberName : MemberInfo -> string) = ObjectListFilterLinqOptions<'T, 'D> (null, null, serializeMemberName)
+
+        new (getDiscriminatorValue : 'T -> 'D, serializeMemberName : MemberInfo -> string) = ObjectListFilterLinqOptions<'T, 'D> (GetDiscriminatorValue getDiscriminatorValue, null, serializeMemberName)
+        new (compareDiscriminator : Expression<Func<'T, 'D, bool>>, serializeMemberName : MemberInfo -> string) = ObjectListFilterLinqOptions<'T, 'D> (CompareDiscriminator compareDiscriminator, null, serializeMemberName)
+        new (getDiscriminatorValue : Type -> 'D, serializeMemberName : MemberInfo -> string) = ObjectListFilterLinqOptions<'T, 'D> (null, getDiscriminatorValue, serializeMemberName)
+
     // Helper to create lambda from body expression
     let makeLambda<'T> (param : ParameterExpression) (body : Expression) =
         let delegateType = typedefof<Func<_, _>>.MakeGenericType ([| typeof<'T>; body.Type |])
@@ -129,7 +157,7 @@ module ObjectListFilterExtensions =
         | Contains f ->
             Expression.Call (Expression.PropertyOrField (param, f.FieldName), StringContainsMethod, Expression.Constant (f.Value))
         | OfTypes types ->
-            types.Value
+            types
             |> Seq.map (fun t -> buildTypeDiscriminatorCheck param t)
             |> Seq.reduce (fun acc expr -> Expression.Or (acc, expr))
         | FilterField f ->
@@ -181,19 +209,22 @@ type ObjectListFilter with
             // Helper for discriminator comparison
             let buildTypeDiscriminatorCheck (param : SourceExpression) (t : Type) =
                 match getDiscriminator, getDiscriminatorValue with
-                | null, discValueFn when obj.Equals (discValueFn, null) ->
+                | null, discValueFn when obj.Equals(discValueFn, null) ->
                     // use __typename from filter and do type.ToSting() for values
-                    Unchecked.defaultof<Expression>
-                | discExpr, discValueFn when obj.Equals (discValueFn, null) ->
+                    let typename = t.FullName
+                    Expression.Equal(Expression.PropertyOrField(param, "__typename"), Expression.Constant(typename)) :> Expression
+                | discExpr, discValueFn when obj.Equals(discValueFn, null) ->
                     // use discriminator and do type.ToSting() for values
-                    Unchecked.defaultof<Expression>
+                    let typename = t.FullName
+                    Expression.Equal(Expression.Invoke(discExpr, param), Expression.Constant(typename)) :> Expression
                 | null, discValueFn ->
                     // use __typename from filter and execute discValueFn for values
-                    Unchecked.defaultof<Expression>
+                    let discriminatorValue = discValueFn t
+                    Expression.Equal(Expression.PropertyOrField(param, "__typename"), Expression.Constant(discriminatorValue)) :> Expression
                 | discExpr, discValueFn ->
                     // use discriminator and execute discValueFn for values
                     let discriminatorValue = discValueFn t
-                    Expression.Equal (Expression.PropertyOrField (param, "__discriminator"), Expression.Constant (discriminatorValue))
+                    Expression.Equal (Expression.Invoke(discExpr, param), Expression.Constant (discriminatorValue))
 
             let queryExpr =
                 let param = Expression.Parameter (typeof<'T>, "x")

src/FSharp.Data.GraphQL.Server.Middleware/TypeSystemExtensions.fs

@@ -40,7 +40,7 @@ module TypeSystemExtensions =
                         | ValueNone -> raise (MalformedGQLQueryException ($"Type '{name}' not found in schema."))
                     match typeFields.Keys |> Seq.map getType |> Seq.toList with
                     | [] -> ValueNone
-                    | filters -> ValueSome (f &&& (OfTypes { FieldName = "__typename"; Value = filters }))
+                    | filters -> ValueSome (f &&& (OfTypes filters))
                 | _ -> ValueSome f
             | false, _ -> ValueNone
             | true, _ -> raise (InvalidOperationException "Invalid filter argument type.")

tests/FSharp.Data.GraphQL.Tests/LinqTests.fs

@@ -12,6 +12,7 @@ open FSharp.Data.GraphQL.Execution
 open FSharp.Data.GraphQL.Server.Middleware
 open FSharp.Data.GraphQL.Server.Middleware.ObjectListFilter
 open FSharp.Data.GraphQL.Server.Middleware.ObjectListFilterExtensions
+open System.Linq.Expressions
 
 type Contact =
     { Email : string }
@@ -54,6 +55,7 @@ let data =
         Contact = { Email = "[email protected]" }
         Friends = [ { Email = "[email protected]" } ] } ]
 
+
 let internal undefined<'t> = Unchecked.defaultof<'t>
 
 let resolveRoot ctx () =
@@ -352,7 +354,7 @@ let ``ObjectListFilter works with Contains operator``() =
     result.FirstName |> equals "Ben"
     result.LastName |> equals "Adams"
     result.Contact  |> equals { Email = "[email protected]" }
-    result.Friends  |> equals [ { Email = "[email protected]" }; { Email = "[email protected]" } ] 
+    result.Friends  |> equals [ { Email = "[email protected]" }; { Email = "[email protected]" } ]
 
 [<Fact>]
 let ``ObjectListFilter works with EndsWith operator``() =
@@ -365,11 +367,11 @@ let ``ObjectListFilter works with EndsWith operator``() =
     result.FirstName |> equals "Ben"
     result.LastName |> equals "Adams"
     result.Contact  |> equals { Email = "[email protected]" }
-    result.Friends  |> equals [ { Email = "[email protected]" }; { Email = "[email protected]" } ] 
+    result.Friends  |> equals [ { Email = "[email protected]" }; { Email = "[email protected]" } ]
 
 [<Fact>]
 let ``ObjectListFilter works with AND operator``() =
-    let filter = 
+    let filter =
         And (
             Contains { FieldName = "firstName"; Value = "en" },
             Equals { FieldName = "lastName"; Value = "Adams" }
@@ -386,7 +388,7 @@ let ``ObjectListFilter works with AND operator``() =
 
 [<Fact>]
 let ``ObjectListFilter works with OR operator``() =
-    let filter = 
+    let filter =
         Or (
             GreaterThan { FieldName = "id"; Value = 4 },
             Equals { FieldName = "lastName"; Value = "Adams" }
@@ -403,7 +405,7 @@ let ``ObjectListFilter works with OR operator``() =
 
 //[<Fact>]
 //let ``ObjectListFilter works with FilterField operator``() =
-//    let filter = 
+//    let filter =
 //        FilterField { FieldName = "Friends"; Value = Contains { FieldName = "Email"; Value = "[email protected]" } }
 //    let queryable = data.AsQueryable()
 //    let filteredData = filter.Apply(queryable) |> Seq.toList
@@ -417,7 +419,7 @@ let ``ObjectListFilter works with OR operator``() =
 
 [<Fact>]
 let ``ObjectListFilter works with NOT operator``() =
-    let filter = 
+    let filter =
         Not (Equals { FieldName = "lastName"; Value = "Adams" })
     let queryable = data.AsQueryable()
     let filteredData = filter.Apply(queryable) |> Seq.toList
@@ -429,3 +431,140 @@ let ``ObjectListFilter works with NOT operator``() =
     result1.Contact |> equals { Email = "[email protected]" }
     result1.Friends |> equals []
 
+type Complex =
+    { ID : int
+      Name : string
+      Discriminator : string }
+
+type Building =
+    { ID : int
+      Name : string
+      Discriminator : string }
+
+type Community =
+    { ID : int
+      Name : string
+      Discriminator : string
+      Complexes : int list
+      Buildings : int list }
+
+type Property =
+    | Complex of Complex
+    | Building of Building
+    | Community of Community
+
+[<Fact>]
+let ``ObjectListFilter works with getDiscriminator for Complex``() =
+    let propertyData: Property list =
+        [
+            Complex { ID = 1; Name = "Complex A"; Discriminator = typeof<Complex>.FullName}
+            Building { ID = 2; Name = "Building B"; Discriminator = typeof<Building>.FullName }
+            Community { ID = 3; Name = "Community C"; Discriminator = typeof<Community>.FullName; Complexes = [1]; Buildings = [2] }
+            Complex { ID = 4; Name = "Complex AA"; Discriminator =  typeof<Complex>.FullName }
+            Building { ID = 5; Name = "Building BB"; Discriminator =  typeof<Building>.FullName }
+            Community { ID = 6; Name = "Community CC"; Discriminator = typeof<Community>.FullName; Complexes = [4]; Buildings = [5] }
+        ]
+    let queryable = propertyData.AsQueryable()
+    let filter = OfTypes [typeof<Complex>]
+    let filteredData =
+        filter.Apply(
+            queryable,
+            getDiscriminator =
+                fun p ->
+                    match p with
+                    | Complex c -> c.Discriminator
+                    | Building b -> b.Discriminator
+                    | Community c -> c.Discriminator
+        )
+        |> Seq.toList
+    List.length filteredData |> equals 2
+    let result1 = List.head filteredData
+    match result1 with
+    | Complex c ->
+        c.ID |> equals 1
+        c.Name |> equals "Complex A"
+    | _ -> failwith "Expected Complex"
+    let result2 = List.last filteredData
+    match result2 with
+    | Complex c ->
+        c.ID |> equals 4
+        c.Name |> equals "Complex AA"
+    | _ -> failwith "Expected Complex"
+
+
+[<Fact>]
+let ``ObjectListFilter works with getDiscriminator and getDiscriminatorValue for Complex``() =
+    let propertyData: Property list =
+        [
+            Complex { ID = 1; Name = "Complex A"; Discriminator = "Complex" }
+            Building { ID = 2; Name = "Building B"; Discriminator = "Building" }
+            Community { ID = 3; Name = "Community C"; Discriminator = "Community"; Complexes = [1]; Buildings = [2] }
+            Complex { ID = 4; Name = "Complex AA"; Discriminator =  "Complex" }
+            Building { ID = 5; Name = "Building BB"; Discriminator =  "Building" }
+            Community { ID = 6; Name = "Community CC"; Discriminator = "Community"; Complexes = [4]; Buildings = [5] }
+        ]
+    let queryable = propertyData.AsQueryable()
+    let filter = OfTypes [typeof<Complex>]
+    let filteredData =
+        filter.Apply(
+            queryable,
+            (fun p ->
+                match p with
+                | Complex c -> c.Discriminator
+                | Building b -> b.Discriminator
+                | Community c -> c.Discriminator),
+            (function
+            | t when t = typeof<Complex> -> "Complex"
+            | t when t = typeof<Building> -> "Building"
+            | t when t = typeof<Community> -> "Community"
+            | _ -> raise (NotSupportedException "Type not supported"))
+        )
+        |> Seq.toList
+    List.length filteredData |> equals 2
+    let result1 = List.head filteredData
+    match result1 with
+    | Complex c ->
+        c.ID |> equals 1
+        c.Name |> equals "Complex A"
+    | _ -> failwith "Expected Complex"
+    let result2 = List.last filteredData
+    match result2 with
+    | Complex c ->
+        c.ID |> equals 4
+        c.Name |> equals "Complex AA"
+    | _ -> failwith "Expected Complex"
+
+
+
+[<Fact>]
+let ``ObjectListFilter works with getDiscriminatorValue for Complex``() =
+    let propertyData: Property list =
+        [
+            Complex { ID = 1; Name = "Complex A"; Discriminator = typeof<Complex>.FullName}
+            Building { ID = 2; Name = "Building B"; Discriminator = typeof<Building>.FullName }
+            Community { ID = 3; Name = "Community C"; Discriminator = typeof<Community>.FullName; Complexes = [1]; Buildings = [2] }
+            Complex { ID = 4; Name = "Complex AA"; Discriminator =  typeof<Complex>.FullName }
+            Building { ID = 5; Name = "Building BB"; Discriminator =  typeof<Building>.FullName }
+            Community { ID = 6; Name = "Community CC"; Discriminator = typeof<Community>.FullName; Complexes = [4]; Buildings = [5] }
+        ]
+    let queryable = propertyData.AsQueryable()
+    let filter = OfTypes [typeof<Complex>]
+    let filteredData =
+        filter.Apply(
+            queryable,
+            getDiscriminatorValue = (fun t -> t.FullName)
+        )
+        |> Seq.toList
+    List.length filteredData |> equals 2
+    let result1 = List.head filteredData
+    match result1 with
+    | Complex c ->
+        c.ID |> equals 1
+        c.Name |> equals "Complex A"
+    | _ -> failwith "Expected Complex"
+    let result2 = List.last filteredData
+    match result2 with
+    | Complex c ->
+        c.ID |> equals 4
+        c.Name |> equals "Complex AA"
+    | _ -> failwith "Expected Complex"