Add new operators In, GreaterThanOrEqual, LessThanOrEqual

Author: Viktor Tochonov

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

@@ -59,10 +59,8 @@ open System.Reflection
 ///     )
 /// </code></example>
 [<Struct>]
-type ObjectListFilterLinqOptions<'T, 'D> (
-    [<Optional>] compareDiscriminator : Expression<Func<'T, 'D, bool>> | null,
-    [<Optional>] getDiscriminatorValue : (Type -> 'D) | null
-) =
+type ObjectListFilterLinqOptions<'T, 'D>
+    ([<Optional>] compareDiscriminator : Expression<Func<'T, 'D, bool>> | null, [<Optional>] getDiscriminatorValue : (Type -> 'D) | null) =
 
     member _.CompareDiscriminator = compareDiscriminator |> ValueOption.ofObj
     member _.GetDiscriminatorValue = getDiscriminatorValue |> ValueOption.ofObj
@@ -72,13 +70,16 @@ type ObjectListFilterLinqOptions<'T, 'D> (
     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)
+        let body = Expression.Equal (Expression.Invoke (getDiscriminatorValue, tParam), dParam)
         Expression.Lambda<Func<'T, 'D, bool>> (body, tParam, dParam)
 
-    new (getDiscriminator : Expression<Func<'T, 'D>>) = ObjectListFilterLinqOptions<'T, 'D> (ObjectListFilterLinqOptions.GetCompareDiscriminator getDiscriminator, null)
+    new (getDiscriminator : Expression<Func<'T, 'D>>) =
+        ObjectListFilterLinqOptions<'T, 'D> (ObjectListFilterLinqOptions.GetCompareDiscriminator getDiscriminator, null)
     new (compareDiscriminator : Expression<Func<'T, 'D, bool>>) = ObjectListFilterLinqOptions<'T, 'D> (compareDiscriminator, null)
-    new (getDiscriminatorValue : Type -> 'D) = ObjectListFilterLinqOptions<'T, 'D> (compareDiscriminator = null , getDiscriminatorValue = getDiscriminatorValue)
-    new (getDiscriminator : Expression<Func<'T, 'D>>, getDiscriminatorValue : Type -> 'D) = ObjectListFilterLinqOptions<'T, 'D> (ObjectListFilterLinqOptions.GetCompareDiscriminator getDiscriminator, getDiscriminatorValue)
+    new (getDiscriminatorValue : Type -> 'D) =
+        ObjectListFilterLinqOptions<'T, 'D> (compareDiscriminator = null, getDiscriminatorValue = getDiscriminatorValue)
+    new (getDiscriminator : Expression<Func<'T, 'D>>, getDiscriminatorValue : Type -> 'D) =
+        ObjectListFilterLinqOptions<'T, 'D> (ObjectListFilterLinqOptions.GetCompareDiscriminator getDiscriminator, getDiscriminatorValue)
 
 /// Contains tooling for working with ObjectListFilter.
 module ObjectListFilter =
@@ -94,10 +95,16 @@ module ObjectListFilter =
         let ( === ) fname value = Equals { FieldName = fname; Value = value }
 
         /// Creates a new ObjectListFilter representing a GREATER THAN operation of a comparable value.
-        let ( ==> ) fname value = GreaterThan { FieldName = fname; Value = value }
+        let ( >>> ) fname value = GreaterThan { FieldName = fname; Value = value }
+
+        /// Creates a new ObjectListFilter representing a GREATER THAN OR EQUAL operation of a comparable value.
+        let ( ==> ) fname value = GreaterThanOrEqual { FieldName = fname; Value = value }
 
         /// Creates a new ObjectListFilter representing a LESS THAN operation of a comparable value.
-        let ( <== ) fname value = LessThan { FieldName = fname; Value = value }
+        let ( <<< ) fname value = LessThan { FieldName = fname; Value = value }
+
+        /// Creates a new ObjectListFilter representing a LESS THAN OR EQUAL operation of a comparable value.
+        let ( <== ) fname value = LessThanOrEqual { FieldName = fname; Value = value }
 
         /// Creates a new ObjectListFilter representing a STARTS WITH operation of a string value.
         let ( =@@ ) fname value = StartsWith { FieldName = fname; Value = value }
@@ -108,6 +115,9 @@ module ObjectListFilter =
         /// Creates a new ObjectListFilter representing a CONTAINS operation.
         let ( @=@ ) fname value = Contains { FieldName = fname; Value = value }
 
+        /// Creates a new ObjectListFilter representing a IN operation.
+        let ( =~= ) fname value = In { FieldName = fname; Value = value }
+
         /// Creates a new ObjectListFilter representing a field sub comparison.
         let ( --> ) fname filter = FilterField { FieldName = fname; Value = filter }
 
@@ -131,15 +141,25 @@ module ObjectListFilter =
     let private StringEndsWithMethod = typeof<string>.GetMethod ("EndsWith", [| typeof<string> |])
     let private StringContainsMethod = typeof<string>.GetMethod ("Contains", [| typeof<string> |])
     let private getEnumerableContainsMethod (memberType : Type) =
-        match typeof<Enumerable>.GetMethods(BindingFlags.Static ||| BindingFlags.Public).FirstOrDefault(fun m -> m.Name = "Contains" && m.GetParameters().Length = 2) with
+        match
+            typeof<Enumerable>
+                .GetMethods(BindingFlags.Static ||| BindingFlags.Public)
+                .FirstOrDefault (fun m -> m.Name = "Contains" && m.GetParameters().Length = 2)
+        with
         | null -> raise (MissingMemberException "Static 'Contains' method with 2 parameters not found on 'Enumerable' class")
         | containsGenericStaticMethod ->
-            if memberType.IsGenericType && memberType.GenericTypeArguments.Length = 1 then
-                containsGenericStaticMethod.MakeGenericMethod(memberType.GenericTypeArguments)
+            if
+                memberType.IsGenericType
+                && memberType.GenericTypeArguments.Length = 1
+            then
+                containsGenericStaticMethod.MakeGenericMethod (memberType.GenericTypeArguments)
             else
-                let ienumerable = memberType.GetInterfaces().First(fun i -> i.FullName.StartsWith "System.Collections.Generic.IEnumerable`1")
-                containsGenericStaticMethod.MakeGenericMethod([| ienumerable.GenericTypeArguments[0] |])
-        
+                let ienumerable =
+                    memberType
+                        .GetInterfaces()
+                        .First (fun i -> i.FullName.StartsWith "System.Collections.Generic.IEnumerable`1")
+                containsGenericStaticMethod.MakeGenericMethod ([| ienumerable.GenericTypeArguments[0] |])
+
     let getField (param : ParameterExpression) fieldName = Expression.PropertyOrField (param, fieldName)
 
     [<Struct>]
@@ -161,31 +181,48 @@ module ObjectListFilter =
         | Equals f -> Expression.Equal (Expression.PropertyOrField (param, f.FieldName), Expression.Constant (f.Value))
         | GreaterThan f -> Expression.GreaterThan (Expression.PropertyOrField (param, f.FieldName), Expression.Constant (f.Value))
         | LessThan f -> Expression.LessThan (Expression.PropertyOrField (param, f.FieldName), Expression.Constant (f.Value))
-        | GreaterThanOrEqual f -> Expression.GreaterThanOrEqual(Expression.PropertyOrField (param, f.FieldName), Expression.Constant (f.Value))
+        | GreaterThanOrEqual f -> Expression.GreaterThanOrEqual (Expression.PropertyOrField (param, f.FieldName), Expression.Constant (f.Value))
         | LessThanOrEqual f -> Expression.LessThanOrEqual (Expression.PropertyOrField (param, f.FieldName), Expression.Constant (f.Value))
-        | StartsWith f ->
-            Expression.Call (Expression.PropertyOrField (param, f.FieldName), StringStartsWithMethod, Expression.Constant (f.Value))
-        | EndsWith f ->
-            Expression.Call (Expression.PropertyOrField (param, f.FieldName), StringEndsWithMethod, Expression.Constant (f.Value))
+        | StartsWith f -> Expression.Call (Expression.PropertyOrField (param, f.FieldName), StringStartsWithMethod, Expression.Constant (f.Value))
+        | EndsWith f -> Expression.Call (Expression.PropertyOrField (param, f.FieldName), StringEndsWithMethod, Expression.Constant (f.Value))
         | Contains f ->
             let ``member`` = Expression.PropertyOrField (param, f.FieldName)
-            let isEnumerable (memberType: Type) =
-                not (Type.(=)(memberType, typeof<string>))
-                && typeof<System.Collections.IEnumerable>.IsAssignableFrom(memberType)
-                && memberType.GetInterfaces().Any(fun i -> i.FullName.StartsWith "System.Collections.Generic.IEnumerable`1")
-            match ``member``.Member  with
+            let isEnumerable (memberType : Type) =
+                not (Type.(=) (memberType, typeof<string>))
+                && typeof<System.Collections.IEnumerable>.IsAssignableFrom (memberType)
+                && memberType
+                    .GetInterfaces()
+                    .Any (fun i -> i.FullName.StartsWith "System.Collections.Generic.IEnumerable`1")
+            match ``member``.Member with
             | :? PropertyInfo as prop when prop.PropertyType |> isEnumerable ->
-                match prop.PropertyType.GetMethods(BindingFlags.Instance ||| BindingFlags.Public).FirstOrDefault(fun m -> m.Name = "Contains" && m.GetParameters().Length = 1) with
-                | null -> Expression.Call (getEnumerableContainsMethod prop.PropertyType, Expression.PropertyOrField (param, f.FieldName), Expression.Constant (f.Value))
-                | instanceContainsMethod -> Expression.Call (Expression.PropertyOrField (param, f.FieldName),instanceContainsMethod, Expression.Constant (f.Value))    
+                match
+                    prop.PropertyType
+                        .GetMethods(BindingFlags.Instance ||| BindingFlags.Public)
+                        .FirstOrDefault (fun m -> m.Name = "Contains" && m.GetParameters().Length = 1)
+                with
+                | null ->
+                    Expression.Call (
+                        getEnumerableContainsMethod prop.PropertyType,
+                        Expression.PropertyOrField (param, f.FieldName),
+                        Expression.Constant (f.Value)
+                    )
+                | instanceContainsMethod ->
+                    Expression.Call (Expression.PropertyOrField (param, f.FieldName), instanceContainsMethod, Expression.Constant (f.Value))
             | :? FieldInfo as field when field.FieldType |> isEnumerable ->
-                Expression.Call (getEnumerableContainsMethod field.FieldType, Expression.PropertyOrField (param, f.FieldName), Expression.Constant (f.Value))
-            | _ ->
-                Expression.Call (``member``, StringContainsMethod, Expression.Constant (f.Value))
+                Expression.Call (
+                    getEnumerableContainsMethod field.FieldType,
+                    Expression.PropertyOrField (param, f.FieldName),
+                    Expression.Constant (f.Value)
+                )
+            | _ -> Expression.Call (``member``, StringContainsMethod, Expression.Constant (f.Value))
         | In f ->
             let ``member`` = Expression.PropertyOrField (param, f.FieldName)
-            let values = f.Value |> List.map (fun v -> Expression.Equal(``member``, Expression.Constant(v)))
-            (values |> List.reduce (fun acc expr -> Expression.OrElse(acc, expr))) :> Expression
+            let values =
+                f.Value
+                |> List.map (fun v -> Expression.Equal (``member``, Expression.Constant (v)))
+            (values
+             |> List.reduce (fun acc expr -> Expression.OrElse (acc, expr)))
+            :> Expression
         | OfTypes types ->
             types
             |> Seq.map (fun t -> buildTypeDiscriminatorCheck param t)
@@ -237,5 +274,4 @@ module ObjectListFilterExtensions =
 
     type IQueryable<'T> with
 
-        member inline query.Apply (filter : ObjectListFilter, [<Optional>] options : ObjectListFilterLinqOptions<'T, 'D>) =
-            apply options filter query
+        member inline query.Apply (filter : ObjectListFilter, [<Optional>] options : ObjectListFilterLinqOptions<'T, 'D>) = apply options filter query