From 2fc932ba6ca7462183a573f61fad2a831ef79613 Mon Sep 17 00:00:00 2001
From: PascalSenn <senn.pasc@gmail.com>
Date: Sun, 5 Feb 2023 19:20:52 +0100
Subject: [PATCH] Extend documentation of scalar filter types (#5759)

Co-authored-by: Glen <glen.84@gmail.com>
---
 .../v13/fetching-data/filtering.md            | 89 +++++++++++++++----
 1 file changed, 70 insertions(+), 19 deletions(-)

diff --git a/website/src/docs/hotchocolate/v13/fetching-data/filtering.md b/website/src/docs/hotchocolate/v13/fetching-data/filtering.md
index caacb2cb508..48eff6c4988 100644
--- a/website/src/docs/hotchocolate/v13/fetching-data/filtering.md
+++ b/website/src/docs/hotchocolate/v13/fetching-data/filtering.md
@@ -647,7 +647,7 @@ type Query {
 
 ## Binding of FilterTypes
 
-`FilterInputType`'s **cannot** just be registered on the schema. You have to bind them to the runtime type on the convention.
+`FilterInputType`'s can be registered like any other type on the schema.
 
 **Configuration**
 
@@ -660,22 +660,27 @@ public class UserFilterInput : FilterInputType<User>
         descriptor.Field(x => x.Name).Description("This is the name");
     }
 }
+```
+
+```csharp
+services
+    .AddGraphQLServer()
+    .AddFiltering()
+    .AddType<UserFilterInput>()
+    ...;
+```
+
+In case you use custom conventions, you can also bind the filter types on your convention.
 
-public class CustomStringOperationFilterInput : StringOperationFilterInput
+```csharp
+public class CustomFilterConvention : FilterConvention
 {
-    protected override void Configure(IFilterInputTypeDescriptor descriptor)
+    protected override void Configure(IFilterConventionDescriptor descriptor)
     {
-        descriptor
-            .Operation(DefaultFilterOperations.Equals)
-            .Type<StringType>();
-        descriptor
-            .Operation(DefaultFilterOperations.NotEquals)
-            .Type<StringType>();
+        descriptor.BindRuntimeType<User, UserFilterInput>()
     }
 }
 
-descriptor.BindRuntimeType<string, CustomStringOperationFilterInput >();
-descriptor.BindRuntimeType<User, UserFilterInput>();
 ```
 
 **Result**
@@ -689,21 +694,67 @@ type User {
   name: String!
 }
 
-input CustomStringOperationFilterInput {
-  and: [CustomStringOperationFilterInput!]
-  or: [CustomStringOperationFilterInput!]
-  eq: String
-  neq: String
-}
-
 input UserFilterInput {
   and: [UserFilterInput!]
   or: [UserFilterInput!]
   "This is the name"
-  name: CustomStringOperationFilterInput
+  name: StringOperationFilterInput
+}
+
+# ... StringOperationFilterInput left out for brevity
+```
+
+**Scalars / Operation Input Types**
+
+> This is also required when you use `HotChocolate.Types.Scalars`!
+
+When you add custom scalars, you will have to create custom filter types.
+Scalars are mapped to a `FilterInputType` that defines the operations that are possible for this scalar.
+The built-in scalars are already mapped to matching filter types.
+For custom scalars, or scalars from `HotChocolate.Types.Scalars`, you have to create and bind types.
+
+```csharp
+public class EmailAddressOperationFilterInputType : FilterInputType
+{
+    protected override void Configure(IFilterInputTypeDescriptor descriptor)
+    {
+        descriptor.Operation(DefaultFilterOperations.Equals).Type<EmailAddressType>();
+        descriptor.Operation(DefaultFilterOperations.NotEquals).Type<EmailAddressType>();
+        descriptor.Operation(DefaultFilterOperations.Contains).Type<EmailAddressType>();
+        descriptor.Operation(DefaultFilterOperations.NotContains).Type<EmailAddressType>();
+        descriptor.Operation(DefaultFilterOperations.In).Type<ListType<EmailAddressType>>();
+        descriptor.Operation(DefaultFilterOperations.NotIn).Type<ListType<EmailAddressType>>();
+        descriptor.Operation(DefaultFilterOperations.StartsWith).Type<EmailAddressType>();
+        descriptor.Operation(DefaultFilterOperations.NotStartsWith).Type<EmailAddressType>();
+        descriptor.Operation(DefaultFilterOperations.EndsWith).Type<EmailAddressType>();
+        descriptor.Operation(DefaultFilterOperations.NotEndsWith).Type<EmailAddressType>();
+    }
+}
+```
+
+For comparable value types, you can use the `ComparableOperationFilterInputType<T>` base class.
+
+```csharp
+public class UnsignedIntOperationFilterInputType
+    : ComparableOperationFilterInputType<UnsignedIntType>
+{
+    protected override void Configure(IFilterInputTypeDescriptor descriptor)
+    {
+        descriptor.Name("UnsignedIntOperationFilterInputType");
+        base.Configure(descriptor);
+    }
 }
 ```
 
+These types have to be registered on the filter convention:
+
+```csharp
+services
+    .AddGraphQLServer()
+    .AddFiltering(x => x.AddDefaults().BindRuntimeType<uint, UnsignedIntOperationFilterInputType>())
+    ...;
+```
+
 ## Extend FilterTypes
 
 Instead of defining your own operation type, you can also just change the configuration of the built