WIP implementing application of ObjectListFilter to IQueryable

Author: xperiandri

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

@@ -1,6 +1,10 @@
 namespace FSharp.Data.GraphQL.Server.Middleware
 
 open System
+open System.Linq
+open System.Linq.Expressions
+open System.Runtime.InteropServices
+open Microsoft.FSharp.Quotations
 
 /// A filter definition for a field value.
 type FieldFilter<'Val> =
@@ -55,3 +59,117 @@ module ObjectListFilter =
 
         /// Creates a new ObjectListFilter representing a NOT opreation for the existing one.
         let ( !!! ) filter = Not filter
+
+//[<AutoOpen>]
+//module ObjectListFilterExtensions =
+
+//    type ObjectListFilter with
+
+//        member filter.Apply<'T, 'D>(query : IQueryable<'T>,
+//                                   compareDiscriminator : Expr<'T -> 'D -> 'D> | null,
+//                                   getDiscriminatorValue : (Type -> 'D) | null) =
+//            filter.Apply(query, compareDiscriminator, getDiscriminatorValue)
+
+//        member filter.Apply<'T, 'D>(query : IQueryable<'T>,
+//                                   [<Optional>] getDiscriminator : Expr<'T -> 'D> | null,
+//                                   [<Optional>] getDiscriminatorValue : (Type -> 'D) | null) =
+//            // Helper to create parameter expression for the lambda
+//            let param = Expression.Parameter(typeof<'T>, "x")
+
+//            // Helper to get property value
+//            let getPropertyExpr fieldName =
+//                Expression.PropertyOrField(param, fieldName)
+
+//            // Helper to create lambda from body expression
+//            let makeLambda (body: Expression) =
+//                let delegateType = typedefof<Func<_,_>>.MakeGenericType([|typeof<'T>; body.Type|])
+//                Expression.Lambda(delegateType, body, param)
+
+//            // Helper to create Where expression
+//            let whereExpr predicate =
+//                let whereMethod =
+//                    typeof<Queryable>.GetMethods()
+//                    |> Seq.where (fun m -> m.Name = "Where")
+//                    |> Seq.find (fun m ->
+//                        let parameters = m.GetParameters()
+//                        parameters.Length = 2
+//                        && parameters[1].ParameterType.GetGenericTypeDefinition() = typedefof<Expression<Func<_,_>>>)
+//                    |> fun m -> m.MakeGenericMethod([|typeof<'T>|])
+//                Expression.Call(whereMethod, [|query.Expression; makeLambda predicate|])
+
+//            // Helper for discriminator comparison
+//            let buildTypeDiscriminatorCheck (t: Type) =
+//                match getDiscriminator, getDiscriminatorValue with
+//                | null, _ | _, null -> None
+//                | discExpr, discValueFn ->
+//                    let compiled = QuotationEvaluator.Eval(discExpr)
+//                    let discriminatorValue = discValueFn t
+//                    let discExpr = getPropertyExpr "__discriminator" // Assuming discriminator field name
+//                    let valueExpr = Expression.Constant(discriminatorValue)
+//                    Some(Expression.Equal(discExpr, valueExpr))
+
+//            // Main filter logic
+//            let rec buildFilterExpr filter =
+//                match filter with
+//                | NoFilter -> query.Expression
+//                | And (f1, f2) ->
+//                    let q1 = buildFilterExpr f1 |> Expression.Lambda<Func<IQueryable<'T>>>|> _.Compile().Invoke()
+//                    buildFilterExpr f2 |> Expression.Lambda<Func<IQueryable<'T>>> |> _.Compile().Invoke(q1).Expression
+//                | Or (f1, f2) ->
+//                    let expr1 = buildFilterExpr f1
+//                    let expr2 = buildFilterExpr f2
+//                    let unionMethod =
+//                        typeof<Queryable>.GetMethods()
+//                        |> Array.find (fun m -> m.Name = "Union")
+//                        |> fun m -> m.MakeGenericMethod([|typeof<'T>|])
+//                    Expression.Call(unionMethod, [|expr1; expr2|])
+//                | Not f ->
+//                    let exceptMethod =
+//                        typeof<Queryable>.GetMethods()
+//                        |> Array.find (fun m -> m.Name = "Except")
+//                        |> fun m -> m.MakeGenericMethod([|typeof<'T>|])
+//                    Expression.Call(exceptMethod, [|query.Expression; buildFilterExpr f|])
+//                | Equals f ->
+//                    Expression.Equal(getPropertyExpr f.FieldName, Expression.Constant(f.Value)) |> whereExpr
+//                | GreaterThan f ->
+//                    Expression.GreaterThan(getPropertyExpr f.FieldName, Expression.Constant(f.Value)) |> whereExpr
+//                | LessThan f ->
+//                    Expression.LessThan(getPropertyExpr f.FieldName, Expression.Constant(f.Value)) |> whereExpr
+//                | StartsWith f ->
+//                    let methodInfo = typeof<string>.GetMethod("StartsWith", [|typeof<string>|])
+//                    Expression.Call(getPropertyExpr f.FieldName, methodInfo, Expression.Constant(f.Value)) |> whereExpr
+//                | EndsWith f ->
+//                    let methodInfo = typeof<string>.GetMethod("EndsWith", [|typeof<string>|])
+//                    Expression.Call(getPropertyExpr f.FieldName, methodInfo, Expression.Constant(f.Value)) |> whereExpr
+//                | Contains f ->
+//                    let methodInfo = typeof<string>.GetMethod("Contains", [|typeof<string>|])
+//                    Expression.Call(getPropertyExpr f.FieldName, methodInfo, Expression.Constant(f.Value)) |> whereExpr
+//                | OfTypes types ->
+//                    match types.Value with
+//                    | [] -> query.Expression // No types specified, return original query
+//                    | types ->
+//                        let typeChecks =
+//                            types
+//                            |> List.choose buildTypeDiscriminatorCheck
+//                            |> List.fold (fun acc expr ->
+//                                match acc with
+//                                | None -> Some expr
+//                                | Some prevExpr -> Some(Expression.OrElse(prevExpr, expr))) None
+
+//                        match typeChecks with
+//                        | None -> query.Expression
+//                        | Some expr -> whereExpr expr
+//                | FilterField f ->
+//                    let propExpr = getPropertyExpr f.FieldName
+//                    match propExpr.Type.GetInterfaces()
+//                          |> Array.tryFind (fun t ->
+//                              t.IsGenericType && t.GetGenericTypeDefinition() = typedefof<IQueryable<_>>) with
+//                    | Some queryableType ->
+//                        let elementType = queryableType.GetGenericArguments().[0]
+//                        let subFilter = f.Value
+//                        let subQuery = Expression.Convert(propExpr, queryableType)
+//                        Expression.Call(typeof<Queryable>, "Any", [|elementType|], subQuery) |> whereExpr
+//                    | None -> query.Expression
+
+//            // Create and execute the final expression
+//            query.Provider.CreateQuery<'T>(buildFilterExpr filter)