Use CurrentCulture as default string filter fallback

Co-authored-by: xperiandri <2365592+xperiandri@users.noreply.github.com>

Author: Copilot

README.md

@@ -403,7 +403,7 @@ This filter is mapped by the middleware into the `ObjectListFilter` discriminate
 - `Equals` and `Contains` keep the non-generic `System.Collections.IComparer` because they also support non-string comparable values in the public discriminated union.
 - When filters come from GraphQL input, suffix casing selects the string comparer automatically: lowercase suffixes use case-insensitive matching and capitalized suffixes use case-sensitive matching.
 - When the filtered field is a string and you construct the DU cases directly, pass a `StringComparer` instance in that comparer slot. `StringComparer` is accepted there because it also implements `System.Collections.IComparer`. Use `StringComparer.Ordinal` for case-sensitive matching and `StringComparer.OrdinalIgnoreCase` for case-insensitive matching.
-- The built-in case-sensitive operators (`===`, `=@@`, `@@=`, `@=@`) still use the default comparer behavior for you.
+- The built-in `=@@`, `@@=`, and string `@=@` operators keep the existing case-sensitive `CurrentCulture` behavior when no comparer is supplied. `===` continues to use the normal equality translation.
 - `Contains` is also used for collection membership checks, so the wrapped value type inside `FieldFilter<_>` stays `System.IComparable` instead of being limited to `string`.
 - If you were previously constructing `Equals`, `StartsWith`, `EndsWith`, or `Contains` directly, update those call sites to provide the comparer argument explicitly.
 

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

@@ -12,7 +12,8 @@ type FieldFilter<'Val> = { FieldName : string; Value : 'Val }
 /// </summary>
 /// <remarks>
 /// String-based filters can carry a comparer. When the comparer is not provided by the default
-/// case-sensitive operators, the behavior is equivalent to using `StringComparer.Ordinal`.
+/// string operators, `StartsWith`, `EndsWith`, and string `Contains` preserve the existing
+/// case-sensitive `StringComparison.CurrentCulture` behavior.
 /// `StringComparer.OrdinalIgnoreCase` enables case-insensitive matching.
 /// When filters are provided through GraphQL input, lowercase string suffixes are interpreted
 /// as case-insensitive and capitalized suffixes are interpreted as case-sensitive.
@@ -230,7 +231,7 @@ module ObjectListFilter =
         |> Seq.head
 
     /// Maps an IComparer to a StringComparison value.
-    /// Returns ValueNone for null or Ordinal comparers (use default Expression.Equal path).
+    /// Returns ValueNone only when the comparer is null or is not a recognized StringComparer.
     let private comparerToStringComparison (comparer : IComparer) =
         match comparer with
         | null -> ValueNone
@@ -324,11 +325,11 @@ module ObjectListFilter =
             | NonEnumerableCast ``type`` -> Expression.LessThanOrEqual ((unsafeConvertTo ``type`` ``member``), Expression.Constant f.Value)
         | StartsWith (f, comparer) ->
             let ``member`` = Expression.PropertyOrField (param, f.FieldName)
-            let comparison = comparerToStringComparison (comparer :> IComparer) |> ValueOption.defaultValue StringComparison.Ordinal
+            let comparison = comparerToStringComparison (comparer :> IComparer) |> ValueOption.defaultValue StringComparison.CurrentCulture
             Expression.Call (normalizeStringMemberExpr ``member``, StringStartsWithMethod, Expression.Constant f.Value, Expression.Constant comparison)
         | EndsWith (f, comparer) ->
             let ``member`` = Expression.PropertyOrField (param, f.FieldName)
-            let comparison = comparerToStringComparison (comparer :> IComparer) |> ValueOption.defaultValue StringComparison.Ordinal
+            let comparison = comparerToStringComparison (comparer :> IComparer) |> ValueOption.defaultValue StringComparison.CurrentCulture
             Expression.Call (normalizeStringMemberExpr ``member``, StringEndsWithMethod, Expression.Constant f.Value, Expression.Constant comparison)
 
         | Contains (f, comparer) ->
@@ -367,7 +368,7 @@ module ObjectListFilter =
             | :? FieldInfo as field when field.FieldType |> isEnumerable -> callContains field.FieldType
             | _ ->
                 let unwrappedValue = Helpers.unwrap f.Value
-                let comparison = comparerToStringComparison comparer |> ValueOption.defaultValue StringComparison.Ordinal
+                let comparison = comparerToStringComparison comparer |> ValueOption.defaultValue StringComparison.CurrentCulture
                 Expression.Call (normalizeStringMemberExpr ``member``, StringContainsMethod, Expression.Constant (unwrappedValue :?> string, typeof<string>), Expression.Constant comparison)
         | In f when not (f.Value.IsEmpty) ->
             let ``member`` = Expression.PropertyOrField (param, f.FieldName)