Implemented tests for different discriminator cases

Author: Viktor Tochonov

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

@@ -82,36 +82,6 @@ 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 |])
-        Expression.Lambda (delegateType, body, param)
-
     let private genericWhereMethod =
         typeof<Queryable>.GetMethods ()
         |> Seq.where (fun m -> m.Name = "Where")
@@ -123,7 +93,7 @@ module ObjectListFilterExtensions =
     // Helper to create Where expression
     let whereExpr<'T> (query : IQueryable<'T>) (param : ParameterExpression) predicate =
         let whereMethod = genericWhereMethod.MakeGenericMethod ([| typeof<'T> |])
-        Expression.Call (whereMethod, [| query.Expression; makeLambda<'T> param predicate |])
+        Expression.Call (whereMethod, [| query.Expression; Expression.Lambda<Func<'T, bool>> (predicate, param) |])
 
     let private StringStartsWithMethod = typeof<string>.GetMethod ("StartsWith", [| typeof<string> |])
     let private StringEndsWithMethod = typeof<string>.GetMethod ("EndsWith", [| typeof<string> |])
@@ -164,67 +134,61 @@ module ObjectListFilterExtensions =
             let paramExpr = Expression.PropertyOrField (param, f.FieldName)
             buildFilterExpr (SourceExpression paramExpr) buildTypeDiscriminatorCheck f.Value
 
-type ObjectListFilter with
+    [<Struct>]
+    type ObjectListFilterLinqOptions<'T, 'D> (
+        [<Optional>] compareDiscriminator : Expression<Func<'T, 'D, bool>> | null,
+        [<Optional>] getDiscriminatorValue : (Type -> 'D) | null,
+        [<Optional>] serializeMemberName : (MemberInfo -> string) | null) =
 
-    member filter.Apply<'T, 'D>
-        (query : IQueryable<'T>, compareDiscriminator : Expression<Func<'T, 'D, bool>>, getDiscriminatorValue : (Type -> 'D))
-        =
+        member _.CompareDiscriminator = compareDiscriminator |> ValueOption.ofObj
+        member _.GetDiscriminatorValue = getDiscriminatorValue |> ValueOption.ofObj
+        //member _.SerializeMemberName = serializeMemberName |> ValueOption.ofObj
 
-        match filter with
-        | NoFilter -> query
-        | _ ->
+        static member None = ObjectListFilterLinqOptions<'T, 'D> (null, null, null)
 
-            // Helper for discriminator comparison
-            let buildTypeDiscriminatorCheck (param : SourceExpression) (t : Type) =
-                match compareDiscriminator, getDiscriminatorValue with
-                | 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) ->
-                    // use discriminator and do type.ToSting() for values
-                    Unchecked.defaultof<Expression>
-                | null, discValueFn ->
-                    // use __typename from filter and execute discValueFn for values
-                    Unchecked.defaultof<Expression>
-                | discExpr, discValueFn ->
-                    // use discriminator and execute discValueFn for values
+        static member GetCompareDiscriminator (getDiscriminatorValue : Expression<Func<'T, 'D>>) =
+            let tParam = Expression.Parameter (typeof<'T>, "x")
+            let dParam = Expression.Parameter (typeof<'D>, "d")
+            let body = Expression.Equal(Expression.Invoke(getDiscriminatorValue, tParam), dParam)
+            Expression.Lambda<Func<'T, 'D, bool>> (body, tParam, dParam)
 
-                    let discriminatorValue = discValueFn t
-                    Expression.Equal (Expression.PropertyOrField (param, "__discriminator"), Expression.Constant (discriminatorValue))
+        new (getDiscriminator : Expression<Func<'T, 'D>>) = ObjectListFilterLinqOptions<'T, 'D> (ObjectListFilterLinqOptions.GetCompareDiscriminator getDiscriminator, null, null)
+        new (compareDiscriminator : Expression<Func<'T, 'D, bool>>) = ObjectListFilterLinqOptions<'T, 'D> (compareDiscriminator, null, null)
+        new (getDiscriminatorValue : Type -> 'D) = ObjectListFilterLinqOptions<'T, 'D> (null, getDiscriminatorValue, null)
+        //new (serializeMemberName : MemberInfo -> string) = ObjectListFilterLinqOptions<'T, 'D> (null, null, serializeMemberName)
 
-            let queryExpr =
-                let param = Expression.Parameter (typeof<'T>, "x")
-                let body = buildFilterExpr (SourceExpression param) buildTypeDiscriminatorCheck filter
-                whereExpr<'T> query param body
-            // Create and execute the final expression
-            query.Provider.CreateQuery<'T> (queryExpr)
+        new (getDiscriminator : Expression<Func<'T, 'D>>, getDiscriminatorValue : Type -> 'D) = ObjectListFilterLinqOptions<'T, 'D> (ObjectListFilterLinqOptions.GetCompareDiscriminator getDiscriminator, getDiscriminatorValue, null)
+
+        //new (getDiscriminator : Expression<Func<'T, 'D>>, serializeMemberName : MemberInfo -> string) = ObjectListFilterLinqOptions<'T, 'D> (ObjectListFilterLinqOptions.GetCompareDiscriminator getDiscriminator, null, serializeMemberName)
+        //new (compareDiscriminator : Expression<Func<'T, 'D, bool>>, serializeMemberName : MemberInfo -> string) = ObjectListFilterLinqOptions<'T, 'D> (compareDiscriminator, null, serializeMemberName)
+        //new (getDiscriminatorValue : Type -> 'D, serializeMemberName : MemberInfo -> string) = ObjectListFilterLinqOptions<'T, 'D> (null, getDiscriminatorValue, serializeMemberName)
+
+type ObjectListFilter with
 
-    member filter.Apply<'T, 'D>
-        (query : IQueryable<'T>, [<Optional>] getDiscriminator : Expression<Func<'T, 'D>> | null, [<Optional>] getDiscriminatorValue : Type -> 'D)
-        =
+    member filter.Apply<'T, 'D> (query : IQueryable<'T>, [<Optional>] options : ObjectListFilterLinqOptions<'T, 'D>) =
 
         match filter with
         | NoFilter -> query
         | _ ->
             // Helper for discriminator comparison
             let buildTypeDiscriminatorCheck (param : SourceExpression) (t : Type) =
-                match getDiscriminator, getDiscriminatorValue with
-                | null, discValueFn when obj.Equals(discValueFn, null) ->
+                match options.CompareDiscriminator, options.GetDiscriminatorValue with
+                | ValueNone, ValueNone ->
                     // use __typename from filter and do type.ToSting() for values
                     let typename = t.FullName
                     Expression.Equal(Expression.PropertyOrField(param, "__typename"), Expression.Constant(typename)) :> Expression
-                | discExpr, discValueFn when obj.Equals(discValueFn, null) ->
+                | ValueSome discExpr, ValueNone ->
                     // use discriminator and do type.ToSting() for values
                     let typename = t.FullName
-                    Expression.Equal(Expression.Invoke(discExpr, param), Expression.Constant(typename)) :> Expression
-                | null, discValueFn ->
+                    Expression.Invoke(discExpr, param, Expression.Constant(typename)) :> Expression
+                | ValueNone, ValueSome discValueFn ->
                     // use __typename from filter and execute discValueFn for values
                     let discriminatorValue = discValueFn t
                     Expression.Equal(Expression.PropertyOrField(param, "__typename"), Expression.Constant(discriminatorValue)) :> Expression
-                | discExpr, discValueFn ->
+                | ValueSome discExpr, ValueSome discValueFn ->
                     // use discriminator and execute discValueFn for values
                     let discriminatorValue = discValueFn t
-                    Expression.Equal (Expression.Invoke(discExpr, param), Expression.Constant (discriminatorValue))
+                    Expression.Invoke(discExpr, param, Expression.Constant (discriminatorValue))
 
             let queryExpr =
                 let param = Expression.Parameter (typeof<'T>, "x")

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

@@ -23,6 +23,21 @@ module TypeSystemExtensions =
 
     open ObjectListFilter.Operators
 
+    type ExecutionInfo with
+
+        member this.ResolveAbstractionFilter (typeMap : TypeMap) =
+            match this.Kind with
+            | ResolveAbstraction typeFields ->
+                let getType name =
+                    match typeMap.TryFind name with
+                    | ValueSome tdef -> tdef.Type
+                    | ValueNone -> raise (MalformedGQLQueryException ($"Type '{name}' not found in schema."))
+                match typeFields.Keys |> Seq.map getType |> Seq.toList with
+                | [] -> ValueNone
+                | filters -> ValueSome (OfTypes filters)
+            | _ -> ValueNone
+
+
     type ResolveFieldContext with
 
         /// <summary>
@@ -32,16 +47,9 @@ module TypeSystemExtensions =
         member this.Filter =
             match this.Args.TryGetValue "filter" with
             | true, (:? ObjectListFilter as f) ->
-                match this.ExecutionInfo.Kind with
-                | ResolveAbstraction typeFields ->
-                    let getType name =
-                        match this.Context.Schema.TypeMap.TryFind name with
-                        | ValueSome tdef -> tdef.Type
-                        | ValueNone -> raise (MalformedGQLQueryException ($"Type '{name}' not found in schema."))
-                    match typeFields.Keys |> Seq.map getType |> Seq.toList with
-                    | [] -> ValueNone
-                    | filters -> ValueSome (f &&& (OfTypes filters))
-                | _ -> ValueSome f
+                match this.ExecutionInfo.ResolveAbstractionFilter (this.Context.Schema.TypeMap) with
+                | ValueSome ofTypes -> ValueSome (ofTypes &&& f)
+                | ValueNone -> ValueSome f
             | false, _ -> ValueNone
             | true, _ -> raise (InvalidOperationException "Invalid filter argument type.")
 

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

@@ -453,11 +453,12 @@ type Property =
     | 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}
+            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 }
@@ -466,17 +467,13 @@ let ``ObjectListFilter works with getDiscriminator for Complex``() =
         ]
     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
+    let options =
+        ObjectListFilterLinqOptions(
+            (function
+            | Complex c -> c.Discriminator
+            | Building b -> b.Discriminator
+            | Community c -> c.Discriminator))
+    let filteredData = filter.Apply(queryable,options) |> Seq.toList
     List.length filteredData |> equals 2
     let result1 = List.head filteredData
     match result1 with
@@ -496,30 +493,28 @@ let ``ObjectListFilter works with getDiscriminator for Complex``() =
 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] }
+            Complex { ID = 1; Name = "Complex A"; Discriminator = typeof<Complex>.Name}
+            Building { ID = 2; Name = "Building B"; Discriminator = typeof<Building>.Name }
+            Community { ID = 3; Name = "Community C"; Discriminator = typeof<Community>.Name; Complexes = [1]; Buildings = [2] }
+            Complex { ID = 4; Name = "Complex AA"; Discriminator =  typeof<Complex>.Name }
+            Building { ID = 5; Name = "Building BB"; Discriminator =  typeof<Building>.Name }
+            Community { ID = 6; Name = "Community CC"; Discriminator = typeof<Community>.Name; 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),
+    let options =
+        ObjectListFilterLinqOptions(
+            (function
+            | 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
+    let filteredData = filter.Apply(queryable,options) |> Seq.toList
     List.length filteredData |> equals 2
     let result1 = List.head filteredData
     match result1 with
@@ -534,37 +529,45 @@ let ``ObjectListFilter works with getDiscriminator and getDiscriminatorValue for
         c.Name |> equals "Complex AA"
     | _ -> failwith "Expected Complex"
 
+type Cow =
+    { ID : int
+      Name : string
+      __typename : string }
 
+type Horse =
+    { ID : int
+      Name : string
+      __typename : string }
+
+let animalData =
+    [
+        { ID = 1; Name = "Cow A"; __typename = typeof<Cow>.Name }
+        { ID = 2; Name = "Horse B"; __typename = typeof<Horse>.Name }
+        { ID = 3; Name = "Cow C"; __typename = typeof<Cow>.Name }
+        { ID = 4; Name = "Horse D"; __typename = typeof<Horse>.Name }
+    ]
 
 [<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
+let ``ObjectListFilter works with getDiscriminatorValue for Horse``() =
+    let queryable = animalData.AsQueryable()
+    let filter = OfTypes [typeof<Horse>]
+    let options =
+        ObjectListFilterLinqOptions(
+            getDiscriminatorValue = (function
+            | t when t = typeof<Cow> -> t.Name
+            | t when t = typeof<Horse> -> t.Name
+            | _ -> raise (NotSupportedException "Type not supported"))
+    )
+    let filteredData = filter.Apply(queryable, options) |> 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"
+    | h ->
+        h.ID |> equals 2
+        h.Name |> equals "Horse B"
+    | _ -> failwith "Expected Horse"
     let result2 = List.last filteredData
     match result2 with
-    | Complex c ->
-        c.ID |> equals 4
-        c.Name |> equals "Complex AA"
-    | _ -> failwith "Expected Complex"
+    | h ->
+        h.ID |> equals 4
+        h.Name |> equals "Horse D"