Added opt-in features

src/HotChocolate/Core/src/Abstractions/WellKnownDirectives.cs

@@ -69,4 +69,29 @@ public static class WellKnownDirectives
     /// The name of the @tag argument name.
     /// </summary>
     public const string Name = "name";
+
+    /// <summary>
+    /// The name of the @requiresOptIn directive.
+    /// </summary>
+    public const string RequiresOptIn = "requiresOptIn";
+
+    /// <summary>
+    /// The name of the @requiresOptIn feature argument.
+    /// </summary>
+    public const string RequiresOptInFeatureArgument = "feature";
+
+    /// <summary>
+    /// The name of the @optInFeatureStability directive.
+    /// </summary>
+    public const string OptInFeatureStability = "optInFeatureStability";
+
+    /// <summary>
+    /// The name of the @optInFeatureStability feature argument.
+    /// </summary>
+    public const string OptInFeatureStabilityFeatureArgument = "feature";
+
+    /// <summary>
+    /// The name of the @optInFeatureStability stability argument.
+    /// </summary>
+    public const string OptInFeatureStabilityStabilityArgument = "stability";
 }

src/HotChocolate/Core/src/Types/Configuration/Validation/RequiresOptInValidationRule.cs

@@ -0,0 +1,67 @@
+using HotChocolate.Types;
+using HotChocolate.Types.Descriptors;
+using static HotChocolate.Utilities.ErrorHelper;
+
+namespace HotChocolate.Configuration.Validation;
+
+internal sealed class RequiresOptInValidationRule : ISchemaValidationRule
+{
+    public void Validate(
+        IDescriptorContext context,
+        ISchema schema,
+        ICollection<ISchemaError> errors)
+    {
+        if (!context.Options.EnableOptInFeatures)
+        {
+            return;
+        }
+
+        foreach (var type in schema.Types)
+        {
+            switch (type)
+            {
+                case IInputObjectType inputObjectType:
+                    foreach (var field in inputObjectType.Fields)
+                    {
+                        if (field.Type.IsNonNullType() && field.DefaultValue is null)
+                        {
+                            var requiresOptInDirectives = field.Directives
+                                .Where(d => d.Type is RequiresOptInDirectiveType);
+
+                            foreach (var _ in requiresOptInDirectives)
+                            {
+                                errors.Add(RequiresOptInOnRequiredInputField(
+                                    inputObjectType,
+                                    field));
+                            }
+                        }
+                    }
+
+                    break;
+
+                case IObjectType objectType:
+                    foreach (var field in objectType.Fields)
+                    {
+                        foreach (var argument in field.Arguments)
+                        {
+                            if (argument.Type.IsNonNullType() && argument.DefaultValue is null)
+                            {
+                                var requiresOptInDirectives = argument.Directives
+                                    .Where(d => d.Type is RequiresOptInDirectiveType);
+
+                                foreach (var _ in requiresOptInDirectives)
+                                {
+                                    errors.Add(RequiresOptInOnRequiredArgument(
+                                        objectType,
+                                        field,
+                                        argument));
+                                }
+                            }
+                        }
+                    }
+
+                    break;
+            }
+        }
+    }
+}

src/HotChocolate/Core/src/Types/Configuration/Validation/SchemaValidator.cs

@@ -12,7 +12,8 @@ internal static class SchemaValidator
         new DirectiveValidationRule(),
         new InterfaceHasAtLeastOneImplementationRule(),
         new IsSelectedPatternValidation(),
-        new EnsureFieldResultsDeclareErrorsRule()
+        new EnsureFieldResultsDeclareErrorsRule(),
+        new RequiresOptInValidationRule()
     ];
 
     public static IReadOnlyList<ISchemaError> Validate(

src/HotChocolate/Core/src/Types/IReadOnlySchemaOptions.cs

@@ -185,6 +185,11 @@ public interface IReadOnlySchemaOptions
     /// </summary>
     bool EnableTag { get; }
 
+    /// <summary>
+    /// Specifies that the opt-in features functionality will be enabled.
+    /// </summary>
+    bool EnableOptInFeatures { get; }
+
     /// <summary>
     /// Specifies the default dependency injection scope for query fields.
     /// </summary>

src/HotChocolate/Core/src/Types/Properties/TypeResources.resx

@@ -1003,4 +1003,31 @@ Type: `{0}`</value>
   <data name="ObjectToDictionaryConverter_CycleInObjectGraph" xml:space="preserve">
     <value>Cycle in object graph detected.</value>
   </data>
+  <data name="RequiresOptInDirectiveType_TypeDescription" xml:space="preserve">
+    <value>Indicates that the given field, argument, input field, or enum value requires giving explicit consent before being used.</value>
+  </data>
+  <data name="RequiresOptInDirectiveType_FeatureDescription" xml:space="preserve">
+    <value>The name of the feature that requires opt in.</value>
+  </data>
+  <data name="RequiresOptInDirective_Descriptor_NotSupported" xml:space="preserve">
+    <value>RequiresOptIn is not supported on the specified descriptor.</value>
+  </data>
+  <data name="OptInFeatureStabilityDirectiveType_TypeDescription" xml:space="preserve">
+    <value>Sets the stability level of an opt-in feature.</value>
+  </data>
+  <data name="OptInFeatureStabilityDirectiveType_FeatureDescription" xml:space="preserve">
+    <value>The name of the feature for which to set the stability.</value>
+  </data>
+  <data name="OptInFeatureStabilityDirectiveType_StabilityDescription" xml:space="preserve">
+    <value>The stability level of the feature.</value>
+  </data>
+  <data name="OptInFeatureStability_Description" xml:space="preserve">
+    <value>An OptInFeatureStability object describes the stability level of an opt-in feature.</value>
+  </data>
+  <data name="ErrorHelper_RequiresOptInOnRequiredInputField" xml:space="preserve">
+    <value>The @requiresOptIn directive must not appear on required (non-null without a default) input object field definitions.</value>
+  </data>
+  <data name="ErrorHelper_RequiresOptInOnRequiredArgument" xml:space="preserve">
+    <value>The @requiresOptIn directive must not appear on required (non-null without a default) arguments.</value>
+  </data>
 </root>

src/HotChocolate/Core/src/Types/SchemaBuilder.cs

@@ -37,6 +37,7 @@ public partial class SchemaBuilder : ISchemaBuilder
         typeof(InterfaceCompletionTypeInterceptor),
         typeof(MiddlewareValidationTypeInterceptor),
         typeof(EnableTrueNullabilityTypeInterceptor),
+        typeof(OptInFeaturesTypeInterceptor)
     ];
 
     private SchemaOptions _options = new();

src/HotChocolate/Core/src/Types/SchemaOptions.cs

@@ -215,6 +215,11 @@ public FieldBindingFlags DefaultFieldBindingFlags
     /// </summary>
     public bool EnableTag { get; set; } = true;
 
+    /// <summary>
+    /// Specifies that the opt-in features functionality will be enabled.
+    /// </summary>
+    public bool EnableOptInFeatures { get; set; }
+
     /// <summary>
     /// Defines the default dependency injection scope for query fields.
     /// </summary>

src/HotChocolate/Core/src/Types/Types/Directives/Directives.cs

@@ -43,6 +43,15 @@ internal static IReadOnlyList<TypeReference> CreateReferences(
             directiveTypes.Add(typeInspector.GetTypeRef(typeof(Tag)));
         }
 
+        if (descriptorContext.Options.EnableOptInFeatures)
+        {
+            directiveTypes.Add(
+                typeInspector.GetTypeRef(typeof(OptInFeatureStabilityDirectiveType)));
+
+            directiveTypes.Add(
+                typeInspector.GetTypeRef(typeof(RequiresOptInDirectiveType)));
+        }
+
         directiveTypes.Add(typeInspector.GetTypeRef(typeof(SkipDirectiveType)));
         directiveTypes.Add(typeInspector.GetTypeRef(typeof(IncludeDirectiveType)));
         directiveTypes.Add(typeInspector.GetTypeRef(typeof(DeprecatedDirectiveType)));

src/HotChocolate/Core/src/Types/Types/Directives/OptInFeatureStabilityDirective.cs

@@ -0,0 +1,37 @@
+namespace HotChocolate.Types;
+
+public sealed class OptInFeatureStabilityDirective
+{
+    /// <summary>
+    /// Creates a new instance of <see cref="OptInFeatureStabilityDirective"/>.
+    /// </summary>
+    /// <param name="feature">
+    /// The name of the feature for which to set the stability.
+    /// </param>
+    /// <param name="stability">
+    /// The stability level of the feature.
+    /// </param>
+    /// <exception cref="ArgumentNullException">
+    /// <paramref name="feature"/> is <c>null</c>.
+    /// </exception>
+    /// <exception cref="ArgumentNullException">
+    /// <paramref name="stability"/> is <c>null</c>.
+    /// </exception>
+    public OptInFeatureStabilityDirective(string feature, string stability)
+    {
+        Feature = feature ?? throw new ArgumentNullException(nameof(feature));
+        Stability = stability ?? throw new ArgumentNullException(nameof(stability));
+    }
+
+    /// <summary>
+    /// The name of the feature for which to set the stability.
+    /// </summary>
+    [GraphQLDescription("The name of the feature for which to set the stability.")]
+    public string Feature { get; }
+
+    /// <summary>
+    /// The stability level of the feature.
+    /// </summary>
+    [GraphQLDescription("The stability level of the feature.")]
+    public string Stability { get; }
+}

src/HotChocolate/Core/src/Types/Types/Directives/OptInFeatureStabilityDirectiveExtensions.cs

@@ -0,0 +1,12 @@
+namespace HotChocolate.Types;
+
+public static class OptInFeatureStabilityDirectiveExtensions
+{
+    public static ISchemaTypeDescriptor OptInFeatureStability(
+        this ISchemaTypeDescriptor descriptor,
+        string feature,
+        string stability)
+    {
+        return descriptor.Directive(new OptInFeatureStabilityDirective(feature, stability));
+    }
+}

src/HotChocolate/Core/src/Types/Types/Directives/OptInFeatureStabilityDirectiveType.cs

@@ -0,0 +1,32 @@
+using HotChocolate.Properties;
+
+namespace HotChocolate.Types;
+
+/// <summary>
+/// Sets the stability level of an opt-in feature.
+/// </summary>
+public sealed class OptInFeatureStabilityDirectiveType
+    : DirectiveType<OptInFeatureStabilityDirective>
+{
+    protected override void Configure(
+        IDirectiveTypeDescriptor<OptInFeatureStabilityDirective> descriptor)
+    {
+        descriptor
+            .Name(WellKnownDirectives.OptInFeatureStability)
+            .Description(TypeResources.OptInFeatureStabilityDirectiveType_TypeDescription)
+            .Location(DirectiveLocation.Schema)
+            .Repeatable();
+
+        descriptor
+            .Argument(t => t.Feature)
+            .Name(WellKnownDirectives.OptInFeatureStabilityFeatureArgument)
+            .Description(TypeResources.OptInFeatureStabilityDirectiveType_FeatureDescription)
+            .Type<NonNullType<StringType>>();
+
+        descriptor
+            .Argument(t => t.Stability)
+            .Name(WellKnownDirectives.OptInFeatureStabilityStabilityArgument)
+            .Description(TypeResources.OptInFeatureStabilityDirectiveType_StabilityDescription)
+            .Type<NonNullType<StringType>>();
+    }
+}