diff --git a/src/HotChocolate/Core/src/Abstractions/ModuleOptions.cs b/src/HotChocolate/Core/src/Abstractions/ModuleOptions.cs index 09a64fe7612..34e275713bc 100644 --- a/src/HotChocolate/Core/src/Abstractions/ModuleOptions.cs +++ b/src/HotChocolate/Core/src/Abstractions/ModuleOptions.cs @@ -19,5 +19,10 @@ public enum ModuleOptions /// /// Register DataLoader with the source generated module. /// - RegisterDataLoader = 2 + RegisterDataLoader = 2, + + /// + /// Include internal resolver members when discovering source generated types. + /// + IncludeInternalMembers = 4 } diff --git a/src/HotChocolate/Core/src/Types.Analyzers/Helpers/ModuleOptionsHelper.cs b/src/HotChocolate/Core/src/Types.Analyzers/Helpers/ModuleOptionsHelper.cs new file mode 100644 index 00000000000..d41790457b2 --- /dev/null +++ b/src/HotChocolate/Core/src/Types.Analyzers/Helpers/ModuleOptionsHelper.cs @@ -0,0 +1,34 @@ +using HotChocolate.Types.Analyzers.Models; +using Microsoft.CodeAnalysis; +using static System.StringComparison; +using static HotChocolate.Types.Analyzers.WellKnownAttributes; + +namespace HotChocolate.Types.Analyzers.Helpers; + +internal static class ModuleOptionsHelper +{ + public static bool IncludeInternalMembers(this Compilation compilation) + => (GetModuleOptions(compilation) & ModuleOptions.IncludeInternalMembers) + == ModuleOptions.IncludeInternalMembers; + + private static ModuleOptions GetModuleOptions(Compilation compilation) + { + foreach (var attribute in compilation.Assembly.GetAttributes()) + { + if (!string.Equals(attribute.AttributeClass?.ToDisplayString(), ModuleAttribute, Ordinal)) + { + continue; + } + + if (attribute.ConstructorArguments.Length > 1 + && attribute.ConstructorArguments[1].Value is int optionsValue) + { + return (ModuleOptions)optionsValue; + } + + return ModuleOptions.Default; + } + + return ModuleOptions.Default; + } +} diff --git a/src/HotChocolate/Core/src/Types.Analyzers/Inspectors/InterfaceTypeInfoInspector.cs b/src/HotChocolate/Core/src/Types.Analyzers/Inspectors/InterfaceTypeInfoInspector.cs index 71fc087a7b8..d15af112fed 100644 --- a/src/HotChocolate/Core/src/Types.Analyzers/Inspectors/InterfaceTypeInfoInspector.cs +++ b/src/HotChocolate/Core/src/Types.Analyzers/Inspectors/InterfaceTypeInfoInspector.cs @@ -19,6 +19,7 @@ public class InterfaceTypeInfoInspector : ISyntaxInspector public bool TryHandle(GeneratorSyntaxContext context, [NotNullWhen(true)] out SyntaxInfo? syntaxInfo) { var diagnostics = ImmutableArray.Empty; + var includeInternalMembers = context.SemanticModel.Compilation.IncludeInternalMembers(); if (!IsInterfaceType(context, out var possibleType, out var classSymbol, out var runtimeType)) { @@ -48,10 +49,7 @@ public bool TryHandle(GeneratorSyntaxContext context, [NotNullWhen(true)] out Sy foreach (var member in members) { - if (member.DeclaredAccessibility is - Accessibility.Public or - Accessibility.Internal or - Accessibility.ProtectedAndInternal) + if (IsVisibleResolverMember(member, includeInternalMembers)) { if (member is IMethodSymbol { MethodKind: MethodKind.Ordinary } methodSymbol) { @@ -99,6 +97,16 @@ Accessibility.Internal or return true; } + private static bool IsVisibleResolverMember(ISymbol member, bool includeInternalMembers) + => member.DeclaredAccessibility switch + { + Accessibility.Public => true, + Accessibility.Internal => includeInternalMembers, + Accessibility.ProtectedOrInternal => includeInternalMembers, + Accessibility.ProtectedAndInternal => includeInternalMembers, + _ => false + }; + private static bool IsInterfaceType( GeneratorSyntaxContext context, [NotNullWhen(true)] out ClassDeclarationSyntax? resolverTypeSyntax, diff --git a/src/HotChocolate/Core/src/Types.Analyzers/Inspectors/ObjectTypeInspector.cs b/src/HotChocolate/Core/src/Types.Analyzers/Inspectors/ObjectTypeInspector.cs index acd5f81cd6d..3407e412e8f 100644 --- a/src/HotChocolate/Core/src/Types.Analyzers/Inspectors/ObjectTypeInspector.cs +++ b/src/HotChocolate/Core/src/Types.Analyzers/Inspectors/ObjectTypeInspector.cs @@ -22,6 +22,7 @@ public bool TryHandle(GeneratorSyntaxContext context, [NotNullWhen(true)] out Sy { var diagnostics = ImmutableArray.Empty; var isOperationType = false; + var includeInternalMembers = context.SemanticModel.Compilation.IncludeInternalMembers(); OperationType? operationType = null; if (!IsObjectTypeExtension(context, out var possibleType, out var classSymbol, out var runtimeType)) @@ -58,44 +59,58 @@ public bool TryHandle(GeneratorSyntaxContext context, [NotNullWhen(true)] out Sy foreach (var member in members) { - if (member.DeclaredAccessibility is - Accessibility.Public or - Accessibility.Internal or - Accessibility.ProtectedAndInternal - && !member.IsIgnored()) + if (member.IsIgnored()) { - if (member is IMethodSymbol { MethodKind: MethodKind.Ordinary } methodSymbol) + continue; + } + + if (member is IMethodSymbol { MethodKind: MethodKind.Ordinary } methodSymbol) + { + var hasNodeResolverAttribute = methodSymbol.IsNodeResolver(); + var includeInternalNodeResolver = hasNodeResolverAttribute + && methodSymbol.DeclaredAccessibility is + Accessibility.Internal + or Accessibility.ProtectedOrInternal + or Accessibility.ProtectedAndInternal; + + if (!IsVisibleResolverMember(member, includeInternalMembers) && !includeInternalNodeResolver) { - if (methodSymbol.Skip()) - { - continue; - } + continue; + } - if (!isOperationType && methodSymbol.IsNodeResolver()) - { - nodeResolver = CreateNodeResolver(context, classSymbol, methodSymbol, ref diagnostics); - } - else - { - resolvers[i++] = CreateResolver(context, classSymbol, methodSymbol); - continue; - } + if (methodSymbol.Skip()) + { + continue; } - if (member is IPropertySymbol) + if (!isOperationType && hasNodeResolverAttribute) { - var compilation = context.SemanticModel.Compilation; - - resolvers[i++] = new Resolver( - classSymbol.Name, - member, - compilation.GetDescription(member, []), - compilation.GetDeprecationReason(member), - ResolverResultKind.Pure, - [], - member.GetMemberBindings(), - compilation.CreateTypeReference(member)); + nodeResolver = CreateNodeResolver(context, classSymbol, methodSymbol, ref diagnostics); + continue; } + + resolvers[i++] = CreateResolver(context, classSymbol, methodSymbol); + continue; + } + + if (member is IPropertySymbol) + { + if (!IsVisibleResolverMember(member, includeInternalMembers)) + { + continue; + } + + var compilation = context.SemanticModel.Compilation; + + resolvers[i++] = new Resolver( + classSymbol.Name, + member, + compilation.GetDescription(member, []), + compilation.GetDeprecationReason(member), + ResolverResultKind.Pure, + [], + member.GetMemberBindings(), + compilation.CreateTypeReference(member)); } } @@ -189,6 +204,16 @@ private static bool IsObjectTypeExtension( return false; } + private static bool IsVisibleResolverMember(ISymbol member, bool includeInternalMembers) + => member.DeclaredAccessibility switch + { + Accessibility.Public => true, + Accessibility.Internal => includeInternalMembers, + Accessibility.ProtectedOrInternal => includeInternalMembers, + Accessibility.ProtectedAndInternal => includeInternalMembers, + _ => false + }; + private static bool IsOperationType( GeneratorSyntaxContext context, [NotNullWhen(true)] out ClassDeclarationSyntax? resolverTypeSyntax, diff --git a/src/HotChocolate/Core/src/Types.Analyzers/Models/ModuleOptions.cs b/src/HotChocolate/Core/src/Types.Analyzers/Models/ModuleOptions.cs index e9ba0297d72..68c0b5c47e7 100644 --- a/src/HotChocolate/Core/src/Types.Analyzers/Models/ModuleOptions.cs +++ b/src/HotChocolate/Core/src/Types.Analyzers/Models/ModuleOptions.cs @@ -6,5 +6,6 @@ public enum ModuleOptions Default = RegisterDataLoader | RegisterTypes, RegisterTypes = 1, RegisterDataLoader = 2, - Disabled = 4 + IncludeInternalMembers = 4, + Disabled = 8 } diff --git a/src/HotChocolate/Core/test/Types.Analyzers.Tests/OperationTests.cs b/src/HotChocolate/Core/test/Types.Analyzers.Tests/OperationTests.cs index da89c367386..1f9011096ec 100644 --- a/src/HotChocolate/Core/test/Types.Analyzers.Tests/OperationTests.cs +++ b/src/HotChocolate/Core/test/Types.Analyzers.Tests/OperationTests.cs @@ -65,6 +65,80 @@ public static int GetTest(string arg) """).MatchMarkdownAsync(); } + [Fact] + public async Task Internal_Resolvers_Are_Ignored_By_Default() + { + await TestHelper.GetGeneratedSourceSnapshot( + """ + using HotChocolate.Types; + + namespace TestNamespace; + + [QueryType] + public static partial class Query + { + public static int GetPublic() + => 1; + + internal static int GetInternal() + => 2; + } + """).MatchMarkdownAsync(); + } + + [Fact] + public async Task Internal_Resolvers_Can_Be_Included_With_ModuleOptions() + { + await TestHelper.GetGeneratedSourceSnapshot( + """ + using HotChocolate; + using HotChocolate.Types; + + [assembly: Module("Test", ModuleOptions.Default | ModuleOptions.IncludeInternalMembers)] + + namespace TestNamespace; + + [QueryType] + public static partial class Query + { + public static int GetPublic() + => 1; + + internal static int GetInternal() + => 2; + } + """).MatchMarkdownAsync(); + } + + [Fact] + public async Task Internal_NodeResolver_Is_Added_Without_InternalMember_Option() + { + await TestHelper.GetGeneratedSourceSnapshot( + """ + using System.Threading.Tasks; + using HotChocolate.Types; + using HotChocolate.Types.Relay; + + namespace TestNamespace; + + [QueryType] + public static partial class Query + { + [NodeResolver] + internal static Task GetFooById(int id) + => Task.FromResult(null); + + internal static int GetHiddenValue() + => 123; + } + + public class Foo + { + public string Id { get; set; } + } + """).MatchMarkdownAsync(); + } + [Fact] public async Task Root_Projection_Single_Entity() { diff --git a/src/HotChocolate/Core/test/Types.Analyzers.Tests/__snapshots__/OperationTests.Internal_NodeResolver_Is_Added_Without_InternalMember_Option.md b/src/HotChocolate/Core/test/Types.Analyzers.Tests/__snapshots__/OperationTests.Internal_NodeResolver_Is_Added_Without_InternalMember_Option.md new file mode 100644 index 00000000000..bb22cf58acf --- /dev/null +++ b/src/HotChocolate/Core/test/Types.Analyzers.Tests/__snapshots__/OperationTests.Internal_NodeResolver_Is_Added_Without_InternalMember_Option.md @@ -0,0 +1,155 @@ +# Internal_NodeResolver_Is_Added_Without_InternalMember_Option + +## HotChocolateTypeModule.735550c.g.cs + +```csharp +// + +#nullable enable +#pragma warning disable + +using System; +using System.Runtime.CompilerServices; +using HotChocolate; +using HotChocolate.Types; +using HotChocolate.Execution.Configuration; + +namespace Microsoft.Extensions.DependencyInjection +{ + public static partial class TestsTypesRequestExecutorBuilderExtensions + { + public static IRequestExecutorBuilder AddTestsTypes(this IRequestExecutorBuilder builder) + { + builder.ConfigureDescriptorContext(ctx => ctx.TypeConfiguration.TryAdd( + "Tests::TestNamespace.Query", + global::HotChocolate.Types.OperationTypeNames.Query, + () => global::TestNamespace.Query.Initialize)); + builder.ConfigureSchema( + b => b.TryAddRootType( + () => new global::HotChocolate.Types.ObjectType( + d => d.Name(global::HotChocolate.Types.OperationTypeNames.Query)), + HotChocolate.Language.OperationType.Query)); + return builder; + } + } +} + +``` + +## Query.WaAdMHmlGJHjtEI4nqY7WA.hc.g.cs + +```csharp +// + +#nullable enable +#pragma warning disable + +using System; +using System.Runtime.CompilerServices; +using HotChocolate; +using HotChocolate.Types; +using HotChocolate.Execution.Configuration; +using Microsoft.Extensions.DependencyInjection; +using HotChocolate.Internal; + +namespace TestNamespace +{ + public static partial class Query + { + internal static void Initialize(global::HotChocolate.Types.IObjectTypeDescriptor descriptor) + { + var extension = descriptor.Extend(); + var configuration = extension.Configuration; + var thisType = typeof(global::TestNamespace.Query); + var bindingResolver = extension.Context.ParameterBindingResolver; + var resolvers = new __Resolvers(bindingResolver); + + HotChocolate.Internal.ConfigurationHelper.ApplyConfiguration( + extension.Context, + descriptor, + null, + new global::HotChocolate.Types.QueryTypeAttribute()); + configuration.ConfigurationsAreApplied = true; + + var naming = descriptor.Extend().Context.Naming; + + descriptor + .Field(naming.GetMemberName("FooById", global::HotChocolate.Types.MemberKind.ObjectField)) + .ExtendWith(static (field, context) => + { + var configuration = field.Configuration; + var typeInspector = field.Context.TypeInspector; + var bindingResolver = field.Context.ParameterBindingResolver; + var naming = field.Context.Naming; + + configuration.Type = typeInspector.GetTypeRef(typeof(global::TestNamespace.Foo), HotChocolate.Types.TypeContext.Output); + configuration.ResultType = typeof(global::TestNamespace.Foo); + + configuration.SetSourceGeneratorFlags(); + + var bindingInfo = field.Context.ParameterBindingResolver; + var parameter = context.Resolvers.CreateParameterDescriptor_GetFooById_id(); + var parameterInfo = bindingInfo.GetBindingInfo(parameter); + + if(parameterInfo.Kind is global::HotChocolate.Internal.ArgumentKind.Argument) + { + var argumentConfiguration = new global::HotChocolate.Types.Descriptors.Configurations.ArgumentConfiguration + { + Name = naming.GetMemberName("id", global::HotChocolate.Types.MemberKind.Argument), + Type = global::HotChocolate.Types.Descriptors.TypeReference.Create( + typeInspector.GetTypeRef(typeof(int), HotChocolate.Types.TypeContext.Input), + new global::HotChocolate.Language.NonNullTypeNode(new global::HotChocolate.Language.NamedTypeNode("int"))), + RuntimeType = typeof(int) + }; + + configuration.Arguments.Add(argumentConfiguration); + } + + configuration.Member = context.ThisType.GetMethod( + "GetFooById", + global::HotChocolate.Utilities.ReflectionUtils.StaticMemberFlags, + new global::System.Type[] + { + typeof(int) + })!; + + configuration.Resolvers = context.Resolvers.GetFooById(); + }, + (Resolvers: resolvers, ThisType: thisType)); + + Configure(descriptor); + } + + static partial void Configure(global::HotChocolate.Types.IObjectTypeDescriptor descriptor); + + private sealed class __Resolvers + { + private readonly global::HotChocolate.Internal.IParameterBinding _binding_GetFooById_id; + + public __Resolvers(global::HotChocolate.Resolvers.ParameterBindingResolver bindingResolver) + { + _binding_GetFooById_id = bindingResolver.GetBinding(CreateParameterDescriptor_GetFooById_id()); + } + + public global::HotChocolate.Internal.ParameterDescriptor CreateParameterDescriptor_GetFooById_id() + => new HotChocolate.Internal.ParameterDescriptor( + "id", + typeof(int), + isNullable: false, + []); + + public HotChocolate.Resolvers.FieldResolverDelegates GetFooById() + => new global::HotChocolate.Resolvers.FieldResolverDelegates(resolver: GetFooById); + + private async global::System.Threading.Tasks.ValueTask GetFooById(global::HotChocolate.Resolvers.IResolverContext context) + { + var args0 = _binding_GetFooById_id.Execute(context); + var result = await global::TestNamespace.Query.GetFooById(args0); + return result; + } + } + } +} + + +``` diff --git a/src/HotChocolate/Core/test/Types.Analyzers.Tests/__snapshots__/OperationTests.Internal_Resolvers_Are_Ignored_By_Default.md b/src/HotChocolate/Core/test/Types.Analyzers.Tests/__snapshots__/OperationTests.Internal_Resolvers_Are_Ignored_By_Default.md new file mode 100644 index 00000000000..f24f3923381 --- /dev/null +++ b/src/HotChocolate/Core/test/Types.Analyzers.Tests/__snapshots__/OperationTests.Internal_Resolvers_Are_Ignored_By_Default.md @@ -0,0 +1,118 @@ +# Internal_Resolvers_Are_Ignored_By_Default + +## HotChocolateTypeModule.735550c.g.cs + +```csharp +// + +#nullable enable +#pragma warning disable + +using System; +using System.Runtime.CompilerServices; +using HotChocolate; +using HotChocolate.Types; +using HotChocolate.Execution.Configuration; + +namespace Microsoft.Extensions.DependencyInjection +{ + public static partial class TestsTypesRequestExecutorBuilderExtensions + { + public static IRequestExecutorBuilder AddTestsTypes(this IRequestExecutorBuilder builder) + { + builder.ConfigureDescriptorContext(ctx => ctx.TypeConfiguration.TryAdd( + "Tests::TestNamespace.Query", + global::HotChocolate.Types.OperationTypeNames.Query, + () => global::TestNamespace.Query.Initialize)); + builder.ConfigureSchema( + b => b.TryAddRootType( + () => new global::HotChocolate.Types.ObjectType( + d => d.Name(global::HotChocolate.Types.OperationTypeNames.Query)), + HotChocolate.Language.OperationType.Query)); + return builder; + } + } +} + +``` + +## Query.WaAdMHmlGJHjtEI4nqY7WA.hc.g.cs + +```csharp +// + +#nullable enable +#pragma warning disable + +using System; +using System.Runtime.CompilerServices; +using HotChocolate; +using HotChocolate.Types; +using HotChocolate.Execution.Configuration; +using Microsoft.Extensions.DependencyInjection; +using HotChocolate.Internal; + +namespace TestNamespace +{ + public static partial class Query + { + internal static void Initialize(global::HotChocolate.Types.IObjectTypeDescriptor descriptor) + { + var extension = descriptor.Extend(); + var configuration = extension.Configuration; + var thisType = typeof(global::TestNamespace.Query); + var bindingResolver = extension.Context.ParameterBindingResolver; + var resolvers = new __Resolvers(); + + HotChocolate.Internal.ConfigurationHelper.ApplyConfiguration( + extension.Context, + descriptor, + null, + new global::HotChocolate.Types.QueryTypeAttribute()); + configuration.ConfigurationsAreApplied = true; + + var naming = descriptor.Extend().Context.Naming; + + descriptor + .Field(naming.GetMemberName("Public", global::HotChocolate.Types.MemberKind.ObjectField)) + .ExtendWith(static (field, context) => + { + var configuration = field.Configuration; + var typeInspector = field.Context.TypeInspector; + var bindingResolver = field.Context.ParameterBindingResolver; + var naming = field.Context.Naming; + + configuration.Type = global::HotChocolate.Types.Descriptors.TypeReference.Create( + typeInspector.GetTypeRef(typeof(int), HotChocolate.Types.TypeContext.Output), + new global::HotChocolate.Language.NonNullTypeNode(new global::HotChocolate.Language.NamedTypeNode("int"))); + configuration.ResultType = typeof(int); + + configuration.SetSourceGeneratorFlags(); + + configuration.Resolvers = context.Resolvers.GetPublic(); + }, + (Resolvers: resolvers, ThisType: thisType)); + + Configure(descriptor); + } + + static partial void Configure(global::HotChocolate.Types.IObjectTypeDescriptor descriptor); + + private sealed class __Resolvers + { + public HotChocolate.Resolvers.FieldResolverDelegates GetPublic() + { + return new global::HotChocolate.Resolvers.FieldResolverDelegates(pureResolver: GetPublic); + } + + private global::System.Object? GetPublic(global::HotChocolate.Resolvers.IResolverContext context) + { + var result = global::TestNamespace.Query.GetPublic(); + return result; + } + } + } +} + + +``` diff --git a/src/HotChocolate/Core/test/Types.Analyzers.Tests/__snapshots__/OperationTests.Internal_Resolvers_Can_Be_Included_With_ModuleOptions.md b/src/HotChocolate/Core/test/Types.Analyzers.Tests/__snapshots__/OperationTests.Internal_Resolvers_Can_Be_Included_With_ModuleOptions.md new file mode 100644 index 00000000000..f6a4bf6fdd5 --- /dev/null +++ b/src/HotChocolate/Core/test/Types.Analyzers.Tests/__snapshots__/OperationTests.Internal_Resolvers_Can_Be_Included_With_ModuleOptions.md @@ -0,0 +1,149 @@ +# Internal_Resolvers_Can_Be_Included_With_ModuleOptions + +## HotChocolateTypeModule.735550c.g.cs + +```csharp +// + +#nullable enable +#pragma warning disable + +using System; +using System.Runtime.CompilerServices; +using HotChocolate; +using HotChocolate.Types; +using HotChocolate.Execution.Configuration; + +namespace Microsoft.Extensions.DependencyInjection +{ + public static partial class TestRequestExecutorBuilderExtensions + { + public static IRequestExecutorBuilder AddTest(this IRequestExecutorBuilder builder) + { + builder.ConfigureDescriptorContext(ctx => ctx.TypeConfiguration.TryAdd( + "Tests::TestNamespace.Query", + global::HotChocolate.Types.OperationTypeNames.Query, + () => global::TestNamespace.Query.Initialize)); + builder.ConfigureSchema( + b => b.TryAddRootType( + () => new global::HotChocolate.Types.ObjectType( + d => d.Name(global::HotChocolate.Types.OperationTypeNames.Query)), + HotChocolate.Language.OperationType.Query)); + return builder; + } + } +} + +``` + +## Query.WaAdMHmlGJHjtEI4nqY7WA.hc.g.cs + +```csharp +// + +#nullable enable +#pragma warning disable + +using System; +using System.Runtime.CompilerServices; +using HotChocolate; +using HotChocolate.Types; +using HotChocolate.Execution.Configuration; +using Microsoft.Extensions.DependencyInjection; +using HotChocolate.Internal; + +namespace TestNamespace +{ + public static partial class Query + { + internal static void Initialize(global::HotChocolate.Types.IObjectTypeDescriptor descriptor) + { + var extension = descriptor.Extend(); + var configuration = extension.Configuration; + var thisType = typeof(global::TestNamespace.Query); + var bindingResolver = extension.Context.ParameterBindingResolver; + var resolvers = new __Resolvers(); + + HotChocolate.Internal.ConfigurationHelper.ApplyConfiguration( + extension.Context, + descriptor, + null, + new global::HotChocolate.Types.QueryTypeAttribute()); + configuration.ConfigurationsAreApplied = true; + + var naming = descriptor.Extend().Context.Naming; + + descriptor + .Field(naming.GetMemberName("Public", global::HotChocolate.Types.MemberKind.ObjectField)) + .ExtendWith(static (field, context) => + { + var configuration = field.Configuration; + var typeInspector = field.Context.TypeInspector; + var bindingResolver = field.Context.ParameterBindingResolver; + var naming = field.Context.Naming; + + configuration.Type = global::HotChocolate.Types.Descriptors.TypeReference.Create( + typeInspector.GetTypeRef(typeof(int), HotChocolate.Types.TypeContext.Output), + new global::HotChocolate.Language.NonNullTypeNode(new global::HotChocolate.Language.NamedTypeNode("int"))); + configuration.ResultType = typeof(int); + + configuration.SetSourceGeneratorFlags(); + + configuration.Resolvers = context.Resolvers.GetPublic(); + }, + (Resolvers: resolvers, ThisType: thisType)); + + descriptor + .Field(naming.GetMemberName("Internal", global::HotChocolate.Types.MemberKind.ObjectField)) + .ExtendWith(static (field, context) => + { + var configuration = field.Configuration; + var typeInspector = field.Context.TypeInspector; + var bindingResolver = field.Context.ParameterBindingResolver; + var naming = field.Context.Naming; + + configuration.Type = global::HotChocolate.Types.Descriptors.TypeReference.Create( + typeInspector.GetTypeRef(typeof(int), HotChocolate.Types.TypeContext.Output), + new global::HotChocolate.Language.NonNullTypeNode(new global::HotChocolate.Language.NamedTypeNode("int"))); + configuration.ResultType = typeof(int); + + configuration.SetSourceGeneratorFlags(); + + configuration.Resolvers = context.Resolvers.GetInternal(); + }, + (Resolvers: resolvers, ThisType: thisType)); + + Configure(descriptor); + } + + static partial void Configure(global::HotChocolate.Types.IObjectTypeDescriptor descriptor); + + private sealed class __Resolvers + { + public HotChocolate.Resolvers.FieldResolverDelegates GetPublic() + { + return new global::HotChocolate.Resolvers.FieldResolverDelegates(pureResolver: GetPublic); + } + + private global::System.Object? GetPublic(global::HotChocolate.Resolvers.IResolverContext context) + { + var result = global::TestNamespace.Query.GetPublic(); + return result; + } + + public HotChocolate.Resolvers.FieldResolverDelegates GetInternal() + { + return new global::HotChocolate.Resolvers.FieldResolverDelegates(pureResolver: GetInternal); + } + + private global::System.Object? GetInternal(global::HotChocolate.Resolvers.IResolverContext context) + { + var result = global::TestNamespace.Query.GetInternal(); + return result; + } + } + } +} + + +``` diff --git a/website/src/docs/hotchocolate/v16/migrating/migrate-from-15-to-16.md b/website/src/docs/hotchocolate/v16/migrating/migrate-from-15-to-16.md index 974e89151ad..032d0b194de 100644 --- a/website/src/docs/hotchocolate/v16/migrating/migrate-from-15-to-16.md +++ b/website/src/docs/hotchocolate/v16/migrating/migrate-from-15-to-16.md @@ -280,6 +280,27 @@ Some GraphQL validation errors included an extension named `fieldCoordinate` tha } ``` +## `FileValueNode` renamed to `UploadValueNode` + +The upload literal node has been renamed from `FileValueNode` to `UploadValueNode`. +If you are referencing this type directly in custom scalar logic or tests, update your code accordingly: + +```diff +-if (valueLiteral is FileValueNode fileValue) ++if (valueLiteral is UploadValueNode uploadValue) + { + var file = uploadValue.File; + var key = uploadValue.Key; + } +``` + +If you are constructing upload value nodes manually, note that the constructor now also requires the multipart key: + +```diff +-var valueNode = new FileValueNode(file); ++var valueNode = new UploadValueNode("0", file); +``` + ## Errors from `TypeConverter`s are now accessible in the `ErrorFilter` Previously, exceptions thrown by a `TypeConverter` were not forwarded to the `ErrorFilter`. Such exceptions are now properly propagated and can therefore be intercepted.