Skip to content

Commit 0fd866b

Browse files
author
Viktor Tochonov
committed
PR fixes
1 parent f4fa72a commit 0fd866b

File tree

3 files changed

+75
-85
lines changed

3 files changed

+75
-85
lines changed

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

Lines changed: 3 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -217,11 +217,9 @@ module ObjectListFilter =
217217
| _ -> Expression.Call (``member``, StringContainsMethod, Expression.Constant (f.Value))
218218
| In f ->
219219
let ``member`` = Expression.PropertyOrField (param, f.FieldName)
220-
let values =
221-
f.Value
222-
|> List.map (fun v -> Expression.Equal (``member``, Expression.Constant (v)))
223-
(values
224-
|> List.reduce (fun acc expr -> Expression.OrElse (acc, expr)))
220+
f.Value
221+
|> Seq.map (fun v -> Expression.Equal (``member``, Expression.Constant (v)))
222+
|> Seq.reduce (fun acc expr -> Expression.OrElse (acc, expr))
225223
:> Expression
226224
| OfTypes types ->
227225
types

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

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -13,14 +13,14 @@ open FSharp.Data.GraphQL.Ast
1313
let internal removeNoFilter = Seq.where (fun filter -> filter <> NoFilter)
1414

1515
type private ComparisonOperator =
16-
| EndsWith of string
17-
| StartsWith of string
18-
| Contains of string
19-
| Equals of string
20-
| GreaterThan of string
21-
| GreaterThanOrEqual of string
22-
| LessThan of string
23-
| LessThanOrEqual of string
16+
| EndsWith of string
17+
| StartsWith of string
18+
| Contains of string
19+
| Equals of string
20+
| GreaterThan of string
21+
| GreaterThanOrEqual of string
22+
| LessThan of string
23+
| LessThanOrEqual of string
2424

2525
let rec private coerceObjectListFilterInput x : Result<ObjectListFilter, IGQLError list> =
2626

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

Lines changed: 64 additions & 72 deletions
Original file line numberDiff line numberDiff line change
@@ -71,9 +71,11 @@ let getExecutor (expectedFilter : ObjectListFilter voption) =
7171
.Field(
7272
"subjects",
7373
Nullable (ListOf (Nullable SubjectType)),
74-
resolve = fun ctx (a : A) ->
75-
expectedFilter |> ValueOption.iter (fun _ -> equals expectedFilter ctx.Filter)
76-
a.subjects |> List.map getSubject |> List.toSeq |> Some
74+
resolve =
75+
fun ctx (a : A) ->
76+
expectedFilter
77+
|> ValueOption.iter (fun _ -> equals expectedFilter ctx.Filter)
78+
a.subjects |> List.map getSubject |> List.toSeq |> Some
7779
)
7880
.WithQueryWeight (1.0)
7981
]
@@ -90,18 +92,19 @@ let getExecutor (expectedFilter : ObjectListFilter voption) =
9092
.Field(
9193
"subjects",
9294
Nullable (ListOf (Nullable SubjectType)),
93-
resolve = fun ctx (b : B) ->
94-
expectedFilter |> ValueOption.iter (fun _ -> equals expectedFilter ctx.Filter)
95-
b.subjects |> List.map getSubject |> List.toSeq |> Some
95+
resolve =
96+
fun ctx (b : B) ->
97+
expectedFilter
98+
|> ValueOption.iter (fun _ -> equals expectedFilter ctx.Filter)
99+
b.subjects |> List.map getSubject |> List.toSeq |> Some
96100
)
97101
.WithQueryWeight (1.0)
98102
]
99103
)
100104
let Query =
101105
Define.Object<Root> (
102106
name = "Query",
103-
fields = [ // Перетворити executor на getExecutor(ValueOption filter) *** executor = getExecutor(ValueNone) *** Перевіряти ValueSome на 99 і 100 рядках, дістаючи фільтри з контексту
104-
// Приклад - тести на інпутОбжекти - InputRecordTests: 122 - 150
107+
fields = [
105108
Define.Field ("A", Nullable AType, "A Field", [ Define.Input ("id", IntType) ], resolve = (fun ctx _ -> getA (ctx.Arg ("id"))))
106109
Define.Field ("B", Nullable BType, "B Field", [ Define.Input ("id", IntType) ], resolve = (fun ctx _ -> getB (ctx.Arg ("id"))))
107110
]
@@ -114,16 +117,17 @@ let getExecutor (expectedFilter : ObjectListFilter voption) =
114117
]
115118
Executor (schema, middleware)
116119

117-
let executor = getExecutor(ValueNone)
120+
let executor = getExecutor (ValueNone)
118121

119122
let execute (query : Document) = executor.AsyncExecute (query) |> sync
120123

121124
let executeWithVariables (query : Document, variables : ImmutableDictionary<string, JsonElement>) =
122-
executor.AsyncExecute (ast = query, variables = variables) |> sync
125+
executor.AsyncExecute (ast = query, variables = variables)
126+
|> sync
123127

124-
let executeWithCustomFilter (query: Document,variables : ImmutableDictionary<string, JsonElement>, customFilter : ObjectListFilter) =
125-
let ex = getExecutor(ValueSome customFilter)
126-
ex.AsyncExecute(ast = query, variables = variables) |> sync
128+
let executeWithCustomFilter (query : Document, variables : ImmutableDictionary<string, JsonElement>, customFilter : ObjectListFilter) =
129+
let ex = getExecutor (ValueSome customFilter)
130+
ex.AsyncExecute (ast = query, variables = variables) |> sync
127131

128132
let expectedErrors : GQLProblemDetails list = [
129133
GQLProblemDetails.Create ("Query complexity exceeds maximum threshold. Please reduce query complexity and try again.")
@@ -506,7 +510,7 @@ let ``Object list filter: must return filter information in Metadata`` () =
506510
]
507511
]
508512
]
509-
let expectedFilter : KeyValuePair<obj list, ObjectListFilter> =
513+
let expectedFilter : KeyValuePair<obj list, _> =
510514
kvp ([ "A"; "s" ]) (And (Equals { FieldName = "id"; Value = 2L }, StartsWith { FieldName = "value"; Value = "A" }))
511515
let result = execute query
512516
ensureDirect result <| fun data errors ->
@@ -555,7 +559,7 @@ let ``Object list filter: Must return AND filter information in Metadata`` () =
555559
]
556560
]
557561
]
558-
let expectedFilter : KeyValuePair<obj list, ObjectListFilter> =
562+
let expectedFilter : KeyValuePair<obj list, _> =
559563
kvp ([ "A"; "subjects" ]) (And (StartsWith { FieldName = "value"; Value = "3" }, Equals { FieldName = "id"; Value = 6L }))
560564
let result = execute query
561565
ensureDirect result <| fun data errors ->
@@ -602,7 +606,7 @@ let ``Object list filter: Must return OR filter information in Metadata`` () =
602606
]
603607
]
604608
]
605-
let expectedFilter : KeyValuePair<obj list, ObjectListFilter> =
609+
let expectedFilter : KeyValuePair<obj list, _> =
606610
kvp ([ "A"; "subjects" ]) (Or (StartsWith { FieldName = "value"; Value = "3" }, Equals { FieldName = "id"; Value = 6L }))
607611
let result = execute query
608612
ensureDirect result <| fun data errors ->
@@ -649,7 +653,7 @@ let ``Object list filter: Must return NOT filter information in Metadata`` () =
649653
]
650654
]
651655
]
652-
let expectedFilter : KeyValuePair<obj list, ObjectListFilter> =
656+
let expectedFilter : KeyValuePair<obj list, _> =
653657
kvp ([ "A"; "subjects" ]) (Not (StartsWith { FieldName = "value"; Value = "3" }))
654658
let result = execute query
655659
ensureDirect result <| fun data errors ->
@@ -660,7 +664,6 @@ let ``Object list filter: Must return NOT filter information in Metadata`` () =
660664
|> seqEquals [ expectedFilter ]
661665

662666
[<Fact>]
663-
// Перевірити всі кейси в одному тесті, якщо не вдасться обробити - поміняти Choice на Discriminated Union
664667
let ``Object list filter: Must parse all filter operators`` () =
665668
let query =
666669
parse
@@ -698,108 +701,97 @@ let ``Object list filter: Must parse all filter operators`` () =
698701
]
699702
]
700703

701-
let notStartsFilter = """{ "not": { "value_starts_with": "3" } }"""
702-
let notStartsFilterJsonElement = JsonDocument.Parse(notStartsFilter).RootElement
703-
let dict = ImmutableDictionary<string, JsonElement>.Empty.Add ("filter", notStartsFilterJsonElement)
704-
let expectedFilter : KeyValuePair<obj list, ObjectListFilter> =
705-
kvp ([ "A"; "subjects" ]) (Not (StartsWith { FieldName = "value"; Value = "3" }))
706-
let result = executeWithCustomFilter (query, dict, Not (StartsWith { FieldName = "value"; Value = "3" }))
704+
let notStartsFilter = """{ "not": { "value_starts_with": "3" } }""" |> JsonDocument.Parse |> _.RootElement
705+
let dict = ImmutableDictionary<string, JsonElement>.Empty.Add ("filter", notStartsFilter)
706+
let filter = Not (StartsWith { FieldName = "value"; Value = "3" })
707+
let expectedFilter : KeyValuePair<obj list, _> = kvp ([ "A"; "subjects" ]) (filter)
708+
let result = executeWithCustomFilter (query, dict, filter)
707709
ensureDirect result <| fun data errors ->
708710
empty errors
709711
data |> equals (upcast expected)
710712
result.Metadata.TryFind<ObjectListFilters> ("filters")
711713
|> wantValueSome
712714
|> seqEquals [ expectedFilter ]
713715

714-
let notEndsFilter = """{ "not": { "value_ends_with": "2" } }"""
715-
let notEndsFilterJsonElement = JsonDocument.Parse(notEndsFilter).RootElement
716-
let dict1 = ImmutableDictionary<string, JsonElement>.Empty.Add ("filter", notEndsFilterJsonElement)
717-
let expectedFilter1 : KeyValuePair<obj list, ObjectListFilter> =
718-
kvp ([ "A"; "subjects" ]) (Not (EndsWith { FieldName = "value"; Value = "2" }))
719-
let result1 = executeWithCustomFilter (query, dict1, Not (EndsWith { FieldName = "value"; Value = "2" }))
716+
let notEndsFilter = """{ "not": { "value_ends_with": "2" } }""" |> JsonDocument.Parse |> _.RootElement
717+
let dict1 = ImmutableDictionary<string, JsonElement>.Empty.Add ("filter", notEndsFilter)
718+
let filter1 = Not (EndsWith { FieldName = "value"; Value = "2" })
719+
let expectedFilter1 : KeyValuePair<obj list, _> = kvp ([ "A"; "subjects" ]) (filter1)
720+
let result1 = executeWithCustomFilter (query, dict1, filter1)
720721
ensureDirect result1 <| fun data errors1 ->
721722
empty errors1
722723
data |> equals (upcast expected)
723724
result1.Metadata.TryFind<ObjectListFilters> ("filters")
724725
|> wantValueSome
725726
|> seqEquals [ expectedFilter1 ]
726727

727-
let notGreaterThanOrEqualFilter = """{ "not": { "id_gte": 2 } }"""
728-
let notGreaterThanOrEqualFilterJsonElement = JsonDocument.Parse(notGreaterThanOrEqualFilter).RootElement
729-
let dict2 = ImmutableDictionary<string, JsonElement>.Empty.Add ("filter", notGreaterThanOrEqualFilterJsonElement)
730-
let expectedFilter2 : KeyValuePair<obj list, ObjectListFilter> =
731-
kvp ([ "A"; "subjects" ]) (Not (GreaterThanOrEqual { FieldName = "id"; Value = 2.0 }))
732-
let result2 = executeWithCustomFilter (query, dict2, Not (GreaterThanOrEqual { FieldName = "id"; Value = 2.0 }))
728+
let notGreaterThanOrEqualFilter = """{ "not": { "id_gte": 2 } }""" |> JsonDocument.Parse |> _.RootElement
729+
let dict2 = ImmutableDictionary<string, JsonElement>.Empty.Add ("filter", notGreaterThanOrEqualFilter)
730+
let filter2 = Not (GreaterThanOrEqual { FieldName = "id"; Value = 2.0 })
731+
let expectedFilter2 : KeyValuePair<obj list, _> = kvp ([ "A"; "subjects" ]) (filter2)
732+
let result2 = executeWithCustomFilter (query, dict2,filter2)
733733
ensureDirect result2 <| fun data errors2 ->
734734
empty errors2
735735
data |> equals (upcast expected)
736736
result2.Metadata.TryFind<ObjectListFilters> ("filters")
737737
|> wantValueSome
738738
|> seqEquals [ expectedFilter2 ]
739739

740-
let notLessThanOrEqualFilter = """{ "not": { "id_lte": 4 } }"""
741-
let notLessThanOrEqualFilterJsonElement = JsonDocument.Parse(notLessThanOrEqualFilter).RootElement
742-
let dict3 = ImmutableDictionary<string, JsonElement>.Empty.Add ("filter", notLessThanOrEqualFilterJsonElement)
743-
let expectedFilter3 : KeyValuePair<obj list, ObjectListFilter> =
744-
kvp ([ "A"; "subjects" ]) (Not (LessThanOrEqual { FieldName = "id"; Value = 4.0 }))
745-
let result3 = executeWithCustomFilter (query, dict3, Not (LessThanOrEqual { FieldName = "id"; Value = 4.0 }))
740+
let notLessThanOrEqualFilter = """{ "not": { "id_lte": 4 } }""" |> JsonDocument.Parse |> _.RootElement
741+
let dict3 = ImmutableDictionary<string, JsonElement>.Empty.Add ("filter", notLessThanOrEqualFilter)
742+
let filter3 = Not (LessThanOrEqual { FieldName = "id"; Value = 4.0 })
743+
let expectedFilter3 : KeyValuePair<obj list, _> = kvp ([ "A"; "subjects" ]) (filter3)
744+
let result3 = executeWithCustomFilter (query, dict3, filter3)
746745
ensureDirect result3 <| fun data errors3 ->
747746
empty errors3
748747
data |> equals (upcast expected)
749748
result3.Metadata.TryFind<ObjectListFilters> ("filters")
750749
|> wantValueSome
751750
|> seqEquals [ expectedFilter3 ]
752751

753-
let notGreaterThanFilter = """{ "not": { "id_gt": 2 } }"""
754-
let notGreaterThanFilterJsonElement = JsonDocument.Parse(notGreaterThanFilter).RootElement
755-
let dict4 = ImmutableDictionary<string, JsonElement>.Empty.Add ("filter", notGreaterThanFilterJsonElement)
756-
let expectedFilter4 : KeyValuePair<obj list, ObjectListFilter> =
757-
kvp ([ "A"; "subjects" ]) (Not (GreaterThan { FieldName = "id"; Value = 2.0 }))
758-
let result4 =
759-
executeWithCustomFilter (query, dict4, Not (GreaterThan { FieldName = "id"; Value = 2.0 }))
760-
ensureDirect result4
761-
<| fun data errors2 ->
752+
let notGreaterThanFilter = """{ "not": { "id_gt": 2 } }""" |> JsonDocument.Parse |> _.RootElement
753+
let dict4 = ImmutableDictionary<string, JsonElement>.Empty.Add ("filter", notGreaterThanFilter)
754+
let filter4 = Not (GreaterThan { FieldName = "id"; Value = 2.0 })
755+
let expectedFilter4 : KeyValuePair<obj list, _> = kvp ([ "A"; "subjects" ]) (filter4)
756+
let result4 = executeWithCustomFilter (query, dict4, filter4)
757+
ensureDirect result4 <| fun data errors2 ->
762758
empty errors2
763759
data |> equals (upcast expected)
764760
result4.Metadata.TryFind<ObjectListFilters> ("filters")
765761
|> wantValueSome
766762
|> seqEquals [ expectedFilter4 ]
767763

768-
let notLessThanFilter = """{ "not": { "id_lt": 4 } }"""
769-
let notLessThanFilterJsonElement = JsonDocument.Parse(notLessThanFilter).RootElement
770-
let dict5 = ImmutableDictionary<string, JsonElement>.Empty.Add ("filter", notLessThanFilterJsonElement)
771-
772-
let expectedFilter5 : KeyValuePair<obj list, ObjectListFilter> =
773-
kvp ([ "A"; "subjects" ]) (Not (LessThan { FieldName = "id"; Value = 4.0 }))
774-
let result5 = executeWithCustomFilter (query, dict5, Not (LessThan { FieldName = "id"; Value = 4.0 }))
775-
ensureDirect result5 <| fun data errors5 ->
764+
let notLessThanFilter = """{ "not": { "id_lt": 4 } }""" |> JsonDocument.Parse |> _.RootElement
765+
let dict5 = ImmutableDictionary<string, JsonElement>.Empty.Add ("filter", notLessThanFilter)
766+
let filter5 = Not (LessThan { FieldName = "id"; Value = 4.0 })
767+
let expectedFilter5 : KeyValuePair<obj list, ObjectListFilter> = kvp ([ "A"; "subjects" ]) (filter5)
768+
let result5 = executeWithCustomFilter (query, dict5, filter5)
769+
ensureDirect result5
770+
<| fun data errors5 ->
776771
empty errors5
777772
data |> equals (upcast expected)
778773
result5.Metadata.TryFind<ObjectListFilters> ("filters")
779774
|> wantValueSome
780775
|> seqEquals [ expectedFilter5 ]
781776

782-
let notContainsFilter = """{ "not": { "value_contains": "A" } }"""
783-
let notContainsFilterJsonElement = JsonDocument.Parse(notContainsFilter).RootElement
784-
let dict6 = ImmutableDictionary<string, JsonElement>.Empty.Add ("filter", notContainsFilterJsonElement)
785-
786-
let expectedFilter6 : KeyValuePair<obj list, ObjectListFilter> =
787-
kvp ([ "A"; "subjects" ]) (Not (Contains { FieldName = "value"; Value = "A" }))
788-
let result6 = executeWithCustomFilter (query, dict6, Not (Contains { FieldName = "value"; Value = "A" }))
777+
let notContainsFilter = """{ "not": { "value_contains": "A" } }""" |> JsonDocument.Parse |> _.RootElement
778+
let dict6 = ImmutableDictionary<string, JsonElement>.Empty.Add ("filter", notContainsFilter)
779+
let filter6 = Not (Contains { FieldName = "value"; Value = "A" })
780+
let expectedFilter6 : KeyValuePair<obj list, ObjectListFilter> = kvp ([ "A"; "subjects" ]) (filter6)
781+
let result6 = executeWithCustomFilter (query, dict6, filter6)
789782
ensureDirect result6 <| fun data errors6 ->
790783
empty errors6
791784
data |> equals (upcast expected)
792785
result6.Metadata.TryFind<ObjectListFilters> ("filters")
793786
|> wantValueSome
794787
|> seqEquals [ expectedFilter6 ]
795788

796-
let notEqualsFilter = """{ "not": { "value": "A2" } }"""
797-
let notEqualsFilterJsonElement = JsonDocument.Parse(notEqualsFilter).RootElement
798-
let dict7 = ImmutableDictionary<string, JsonElement>.Empty.Add ("filter", notEqualsFilterJsonElement)
799-
789+
let notEqualsFilter = """{ "not": { "value": "A2" } }""" |> JsonDocument.Parse |> _.RootElement
790+
let dict7 = ImmutableDictionary<string, JsonElement>.Empty.Add ("filter", notEqualsFilter)
791+
let filter7 = Not (Equals { FieldName = "value"; Value = "A2" })
800792
let expectedFilter7 : KeyValuePair<obj list, ObjectListFilter> =
801-
kvp ([ "A"; "subjects" ]) (Not (Equals { FieldName = "value"; Value = "A2" }))
802-
let result7 = executeWithCustomFilter (query, dict7, Not (Equals { FieldName = "value"; Value = "A2" }))
793+
kvp ([ "A"; "subjects" ]) (filter7)
794+
let result7 = executeWithCustomFilter (query, dict7, filter7)
803795
ensureDirect result7 <| fun data errors7 ->
804796
empty errors7
805797
data |> equals (upcast expected)

0 commit comments

Comments
 (0)