[Fusion] Added source schema validation rule "InvalidShareableUsageRule" (#7968)

Author: glen-84

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/Extensions/DirectivesProviderExtensions.cs

@@ -66,4 +66,9 @@ public static bool HasRequireDirective(this IDirectivesProvider type)
     {
         return type.Directives.ContainsName(DirectiveNames.Require);
     }
+
+    public static bool HasShareableDirective(this IDirectivesProvider type)
+    {
+        return type.Directives.ContainsName(DirectiveNames.Shareable);
+    }
 }

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/Logging/LogEntryCodes.cs

@@ -13,6 +13,7 @@ public static class LogEntryCodes
     public const string InputFieldTypesNotMergeable = "INPUT_FIELD_TYPES_NOT_MERGEABLE";
     public const string InputWithMissingRequiredFields = "INPUT_WITH_MISSING_REQUIRED_FIELDS";
     public const string InvalidGraphQL = "INVALID_GRAPHQL";
+    public const string InvalidShareableUsage = "INVALID_SHAREABLE_USAGE";
     public const string KeyDirectiveInFieldsArg = "KEY_DIRECTIVE_IN_FIELDS_ARG";
     public const string KeyFieldsHasArgs = "KEY_FIELDS_HAS_ARGS";
     public const string KeyFieldsSelectInvalidType = "KEY_FIELDS_SELECT_INVALID_TYPE";

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/Logging/LogEntryHelper.cs

@@ -274,6 +274,22 @@ public static LogEntry InvalidGraphQL(string exceptionMessage)
             severity: LogSeverity.Error);
     }
 
+    public static LogEntry InvalidShareableUsage(
+        OutputFieldDefinition field,
+        INamedTypeDefinition type,
+        SchemaDefinition schema)
+    {
+        var coordinate = new SchemaCoordinate(type.Name, field.Name);
+
+        return new LogEntry(
+            string.Format(LogEntryHelper_InvalidShareableUsage, coordinate, schema.Name),
+            LogEntryCodes.InvalidShareableUsage,
+            LogSeverity.Error,
+            coordinate,
+            field,
+            schema);
+    }
+
     public static LogEntry KeyDirectiveInFieldsArgument(
         string entityTypeName,
         Directive keyDirective,

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/Properties/CompositionResources.Designer.cs

@@ -72,6 +72,9 @@
   <data name="LogEntryHelper_InvalidGraphQL" xml:space="preserve">
     <value>Invalid GraphQL in source schema. Exception message: {0}.</value>
   </data>
+  <data name="LogEntryHelper_InvalidShareableUsage" xml:space="preserve">
+    <value>The interface field '{0}' in schema '{1}' must not be marked as shareable.</value>
+  </data>
   <data name="LogEntryHelper_KeyDirectiveInFieldsArgument" xml:space="preserve">
     <value>A @key directive on type '{0}' in schema '{1}' references field '{2}', which must not include directive applications.</value>
   </data>

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/Properties/CompositionResources.resx

@@ -78,6 +78,7 @@ public CompositionResult<SchemaDefinition> Compose()
         new DisallowedInaccessibleElementsRule(),
         new ExternalOnInterfaceRule(),
         new ExternalUnusedRule(),
+        new InvalidShareableUsageRule(),
         new KeyDirectiveInFieldsArgumentRule(),
         new KeyFieldsHasArgumentsRule(),
         new KeyFieldsSelectInvalidTypeRule(),

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/SchemaComposer.cs

@@ -0,0 +1,35 @@
+using HotChocolate.Fusion.Events;
+using HotChocolate.Fusion.Extensions;
+using HotChocolate.Skimmed;
+using static HotChocolate.Fusion.Logging.LogEntryHelper;
+
+namespace HotChocolate.Fusion.SourceSchemaValidation.Rules;
+
+/// <summary>
+/// <para>
+/// The <c>@shareable</c> directive is intended to indicate that a field on an <b>object type</b>
+/// can be resolved by multiple schemas without conflict. As a result, it is only valid to use
+/// <c>@shareable</c> on fields <b>of object types</b> (or on the entire object type itself).
+/// </para>
+/// <para>
+/// Applying <c>@shareable</c> to interface fields is disallowed and violates the valid usage of the
+/// directive. This rule prevents schema composition errors and data conflicts by ensuring that
+/// <c>@shareable</c> is used only in contexts where shared field resolution is meaningful and
+/// unambiguous.
+/// </para>
+/// </summary>
+/// <seealso href="https://graphql.github.io/composite-schemas-spec/draft/#sec-Invalid-Shareable-Usage">
+/// Specification
+/// </seealso>
+internal sealed class InvalidShareableUsageRule : IEventHandler<OutputFieldEvent>
+{
+    public void Handle(OutputFieldEvent @event, CompositionContext context)
+    {
+        var (field, type, schema) = @event;
+
+        if (type is InterfaceTypeDefinition && field.HasShareableDirective())
+        {
+            context.Log.Write(InvalidShareableUsage(field, type, schema));
+        }
+    }
+}

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/SourceSchemaValidation/Rules/InvalidShareableUsageRule.cs

@@ -19,4 +19,5 @@ internal static class WellKnownDirectiveNames
     public const string Override = "override";
     public const string Provides = "provides";
     public const string Require = "require";
+    public const string Shareable = "shareable";
 }

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/WellKnownDirectiveNames.cs

@@ -0,0 +1,90 @@
+using System.Collections.Immutable;
+using HotChocolate.Fusion.Logging;
+
+namespace HotChocolate.Fusion.SourceSchemaValidation.Rules;
+
+public sealed class InvalidShareableUsageRuleTests : CompositionTestBase
+{
+    private static readonly object s_rule = new InvalidShareableUsageRule();
+    private static readonly ImmutableArray<object> s_rules = [s_rule];
+    private readonly CompositionLog _log = new();
+
+    [Theory]
+    [MemberData(nameof(ValidExamplesData))]
+    public void Examples_Valid(string[] sdl)
+    {
+        // arrange
+        var schemas = CreateSchemaDefinitions(sdl);
+        var validator = new SourceSchemaValidator(schemas, s_rules, _log);
+
+        // act
+        var result = validator.Validate();
+
+        // assert
+        Assert.True(result.IsSuccess);
+        Assert.True(_log.IsEmpty);
+    }
+
+    [Theory]
+    [MemberData(nameof(InvalidExamplesData))]
+    public void Examples_Invalid(string[] sdl, string[] errorMessages)
+    {
+        // arrange
+        var schemas = CreateSchemaDefinitions(sdl);
+        var validator = new SourceSchemaValidator(schemas, s_rules, _log);
+
+        // act
+        var result = validator.Validate();
+
+        // assert
+        Assert.True(result.IsFailure);
+        Assert.Equal(errorMessages, _log.Select(e => e.Message).ToArray());
+        Assert.True(_log.All(e => e.Code == "INVALID_SHAREABLE_USAGE"));
+        Assert.True(_log.All(e => e.Severity == LogSeverity.Error));
+    }
+
+    public static TheoryData<string[]> ValidExamplesData()
+    {
+        return new TheoryData<string[]>
+        {
+            // In this example, the field "orderStatus" on the "Order" object type is marked with
+            // @shareable, which is allowed. It signals that this field can be served from multiple
+            // schemas without creating a conflict.
+            {
+                [
+                    """
+                    type Order {
+                        id: ID!
+                        orderStatus: String @shareable
+                        total: Float
+                    }
+                    """
+                ]
+            }
+        };
+    }
+
+    public static TheoryData<string[], string[]> InvalidExamplesData()
+    {
+        return new TheoryData<string[], string[]>
+        {
+            // In this example, the "InventoryItem" interface has a field "sku" marked with
+            // @shareable, which is invalid usage. Marking an interface field as shareable leads to
+            // an INVALID_SHAREABLE_USAGE error.
+            {
+                [
+                    """
+                    interface InventoryItem {
+                        sku: ID! @shareable
+                        name: String
+                    }
+                    """
+                ],
+                [
+                    "The interface field 'InventoryItem.sku' in schema 'A' must not be marked as " +
+                    "shareable."
+                ]
+            }
+        };
+    }
+}