[Fusion] Fixed basic lookup requirements (#8427)

Author: michaelstaib

src/CookieCrumble/src/CookieCrumble/Extensions/WriterExtensions.cs

@@ -35,13 +35,7 @@ public static void AppendLine(this IBufferWriter<byte> snapshot, bool appendWhen
     public static void AppendSeparator(this IBufferWriter<byte> snapshot)
     {
         const byte hyphen = (byte)'-';
-        var span = snapshot.GetSpan(15);
-
-        for (var i = 0; i < 15; i++)
-        {
-            span[i] = hyphen;
-        }
-
+        snapshot.GetSpan(15).Fill(hyphen);
         snapshot.Advance(15);
     }
 }

src/GreenDonut/src/GreenDonut/BatchDataLoader.cs

@@ -53,7 +53,7 @@ private static void CopyResults(
         {
             if (resultMap.TryGetValue(keys[i], out var value))
             {
-                results[i] = value;
+                results[i] = value!;
             }
             else
             {

src/GreenDonut/src/GreenDonut/CacheDataLoader.cs

@@ -27,8 +27,8 @@ protected internal sealed override async ValueTask FetchAsync(
         {
             try
             {
-                var value = await LoadSingleAsync(keys[i], cancellationToken).ConfigureAwait(false);
-                results.Span[i] = value;
+                var result = await LoadSingleAsync(keys[i], cancellationToken).ConfigureAwait(false);
+                results.Span[i] = result;
             }
             catch (Exception ex)
             {

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

@@ -0,0 +1,39 @@
+namespace HotChocolate.Types;
+
+/// <summary>
+/// <para>
+/// The @internal directive is used in combination with lookup fields and allows you
+/// to declare internal types and fields. Internal types and fields do not appear in
+/// the final client-facing composite schema and do not participate in the standard
+/// schema-merging process. This allows a source schema to define lookup fields for
+/// resolving entities that should not be accessible through the client-facing
+/// composite schema.
+/// </para>
+/// <para>
+/// <see href="https://graphql.github.io/composite-schemas-spec/draft/#sec--internal"/>
+/// </para>
+/// <code>
+/// type User @internal {
+///   id: ID!
+///   name: String!
+/// }
+///
+/// directive @internal on OBJECT | FIELD_DEFINITION
+/// </code>
+/// </summary>
+[DirectiveType(
+    DirectiveNames.Internal.Name,
+    DirectiveLocation.Object |
+    DirectiveLocation.FieldDefinition,
+    IsRepeatable = false)]
+public sealed class Internal
+{
+    private Internal()
+    {
+    }
+
+    /// <summary>
+    /// The singleton instance of the <see cref="Internal"/> directive.
+    /// </summary>
+    public static Internal Instance { get; } = new();
+}

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

@@ -0,0 +1,58 @@
+using System.Reflection;
+using HotChocolate.Types.Descriptors;
+
+namespace HotChocolate.Types;
+
+/// <summary>
+/// <para>
+/// The @internal directive is used in combination with lookup fields and allows you
+/// to declare internal types and fields. Internal types and fields do not appear in
+/// the final client-facing composite schema and do not participate in the standard
+/// schema-merging process. This allows a source schema to define lookup fields for
+/// resolving entities that should not be accessible through the client-facing
+/// composite schema.
+/// </para>
+/// <para>
+/// <see href="https://graphql.github.io/composite-schemas-spec/draft/#sec--internal"/>
+/// </para>
+/// <code>
+/// type User @internal {
+///   id: ID!
+///   name: String!
+/// }
+///
+/// directive @internal on OBJECT | FIELD_DEFINITION
+/// </code>
+/// </summary>
+[AttributeUsage(
+    AttributeTargets.Class |
+    AttributeTargets.Property |
+    AttributeTargets.Method,
+    AllowMultiple = false)]
+public sealed class InternalAttribute : DescriptorAttribute
+{
+    protected internal override void TryConfigure(
+        IDescriptorContext context,
+        IDescriptor descriptor,
+        ICustomAttributeProvider element)
+    {
+        switch (descriptor)
+        {
+            case IObjectTypeDescriptor desc:
+                desc.Internal();
+                break;
+
+            case IObjectFieldDescriptor desc:
+                desc.Internal();
+                break;
+
+            default:
+                throw new SchemaException(
+                    SchemaErrorBuilder.New()
+                        .SetMessage("Internal directive is only supported on object types and field definitions.")
+                        .SetExtension("member", element)
+                        .SetExtension("descriptor", descriptor)
+                        .Build());
+        }
+    }
+}

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

@@ -0,0 +1,61 @@
+namespace HotChocolate.Types;
+
+/// <summary>
+/// Provides extension methods to configure the <see cref="HotChocolate.Types.Internal"/> directive with the fluent API.
+/// </summary>
+public static class InternalDirectiveExtensions
+{
+    /// <summary>
+    /// <para>
+    /// The @internal directive is used in combination with lookup fields and allows you
+    /// to declare internal types and fields. Internal types and fields do not appear in
+    /// the final client-facing composite schema and do not participate in the standard
+    /// schema-merging process. This allows a source schema to define lookup fields for
+    /// resolving entities that should not be accessible through the client-facing
+    /// composite schema.
+    /// </para>
+    /// <para>
+    /// <see href="https://graphql.github.io/composite-schemas-spec/draft/#sec--internal"/>
+    /// </para>
+    /// <code>
+    /// type User @internal {
+    ///   id: ID!
+    ///   name: String!
+    /// }
+    ///
+    /// directive @internal on OBJECT | FIELD_DEFINITION
+    /// </code>
+    /// </summary>
+    public static IObjectTypeDescriptor Internal(this IObjectTypeDescriptor descriptor)
+    {
+        ArgumentNullException.ThrowIfNull(descriptor);
+        return descriptor.Directive(Types.Internal.Instance);
+    }
+
+    /// <summary>
+    /// <para>
+    /// The @internal directive is used in combination with lookup fields and allows you
+    /// to declare internal types and fields. Internal types and fields do not appear in
+    /// the final client-facing composite schema and do not participate in the standard
+    /// schema-merging process. This allows a source schema to define lookup fields for
+    /// resolving entities that should not be accessible through the client-facing
+    /// composite schema.
+    /// </para>
+    /// <para>
+    /// <see href="https://graphql.github.io/composite-schemas-spec/draft/#sec--internal"/>
+    /// </para>
+    /// <code>
+    /// type User @internal {
+    ///   id: ID!
+    ///   name: String!
+    /// }
+    ///
+    /// directive @internal on OBJECT | FIELD_DEFINITION
+    /// </code>
+    /// </summary>
+    public static IObjectFieldDescriptor Internal(this IObjectFieldDescriptor descriptor)
+    {
+        ArgumentNullException.ThrowIfNull(descriptor);
+        return descriptor.Directive(Types.Internal.Instance);
+    }
+}

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

@@ -0,0 +1,34 @@
+namespace HotChocolate.Types;
+
+/// <summary>
+/// <para>
+/// The @lookup directive is used within a source schema to specify output fields
+/// that can be used by the distributed GraphQL executor to resolve an entity by
+/// a stable key.
+/// </para>
+/// <para>
+/// <see href="https://graphql.github.io/composite-schemas-spec/draft/#sec--lookup"/>
+/// </para>
+/// <code>
+/// type Query {
+///   productById(id: ID!): Product @lookup
+/// }
+///
+/// directive @lookup on FIELD_DEFINITION
+/// </code>
+/// </summary>
+[DirectiveType(
+    DirectiveNames.Lookup.Name,
+    DirectiveLocation.FieldDefinition,
+    IsRepeatable = false)]
+public sealed class Lookup
+{
+    private Lookup()
+    {
+    }
+
+    /// <summary>
+    /// The singleton instance of the <see cref="Lookup"/> directive.
+    /// </summary>
+    public static Lookup Instance { get; } = new();
+}

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

@@ -0,0 +1,49 @@
+using System.Reflection;
+using HotChocolate.Types.Descriptors;
+
+namespace HotChocolate.Types;
+
+/// <summary>
+/// <para>
+/// The @lookup directive is used within a source schema to specify output fields
+/// that can be used by the distributed GraphQL executor to resolve an entity by
+/// a stable key.
+/// </para>
+/// <para>
+/// <see href="https://graphql.github.io/composite-schemas-spec/draft/#sec--lookup"/>
+/// </para>
+/// <code>
+/// type Query {
+///   productById(id: ID!): Product @lookup
+/// }
+///
+/// directive @lookup on FIELD_DEFINITION
+/// </code>
+/// </summary>
+[AttributeUsage(
+    AttributeTargets.Property |
+    AttributeTargets.Method,
+    AllowMultiple = false)]
+public sealed class LookupAttribute : DescriptorAttribute
+{
+    protected internal override void TryConfigure(
+        IDescriptorContext context,
+        IDescriptor descriptor,
+        ICustomAttributeProvider element)
+    {
+        switch (descriptor)
+        {
+            case IObjectFieldDescriptor desc:
+                desc.Lookup();
+                break;
+
+            default:
+                throw new SchemaException(
+                    SchemaErrorBuilder.New()
+                        .SetMessage("Lookup directive is only supported on field definitions of objects types.")
+                        .SetExtension("member", element)
+                        .SetExtension("descriptor", descriptor)
+                        .Build());
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+namespace HotChocolate.Types;
+
+/// <summary>
+/// Provides extension methods to configure the <see cref="Lookup"/> directive with the fluent API.
+/// </summary>
+public static class LookupDirectiveExtensions
+{
+    /// <summary>
+    /// <para>
+    /// The @lookup directive is used within a source schema to specify output fields
+    /// that can be used by the distributed GraphQL executor to resolve an entity by
+    /// a stable key.
+    /// </para>
+    /// <para>
+    /// <see href="https://graphql.github.io/composite-schemas-spec/draft/#sec--lookup"/>
+    /// </para>
+    /// <code>
+    /// type Query {
+    ///   productById(id: ID!): Product @lookup
+    /// }
+    ///
+    /// directive @lookup on FIELD_DEFINITION
+    /// </code>
+    /// </summary>
+    public static IObjectFieldDescriptor Lookup(this IObjectFieldDescriptor descriptor)
+    {
+        ArgumentNullException.ThrowIfNull(descriptor);
+        return descriptor.Directive(Types.Lookup.Instance);
+    }
+}

src/HotChocolate/Fusion-vnext/src/Fusion.Execution/Execution/FusionRequestExecutorManager.cs

@@ -41,7 +41,7 @@ internal sealed class FusionRequestExecutorManager
             SingleReader = true,
             SingleWriter = false
         });
-    private ImmutableArray<ObserverSession> _observers = ImmutableArray<ObserverSession>.Empty;
+    private ImmutableArray<ObserverSession> _observers = [];
 
     private bool _disposed;
 
@@ -429,14 +429,16 @@ public async ValueTask DisposeAsync()
             await registration.DisposeAsync().ConfigureAwait(false);
         }
 
-        while(_executorEvents.Reader.TryRead(out _)) { }
+        while (_executorEvents.Reader.TryRead(out _))
+        {
+        }
 
         foreach (var session in _observers)
         {
             session.OnCompleted();
         }
 
-        _observers = ImmutableArray<ObserverSession>.Empty;
+        _observers = [];
     }
 
     private sealed class RequestExecutorAccessor