Allow for internal DataLoader modules and groups. (#8028)

michaelstaib · web-flow · commit 037b69a2109e · 2025-02-17T12:01:59.000+01:00
diff --git a/.vscode/settings.json b/.vscode/settings.json
@@ -13,5 +13,5 @@
     "*.targets": "xml",
     "*.tasks": "xml"
   },
-  "dotnet.defaultSolution": "src/All.sln"
+  "dotnet.defaultSolution": "src/All.slnx"
 }
diff --git a/global.json b/global.json
@@ -1,6 +1,6 @@
 {
   "sdk": {
-    "version": "9.0.100",
+    "version": "9.0.200",
     "rollForward": "latestMinor"
   }
 }
diff --git a/src/GreenDonut/src/GreenDonut.Abstractions/Attributes/DataLoaderModuleAttribute.cs b/src/GreenDonut/src/GreenDonut.Abstractions/Attributes/DataLoaderModuleAttribute.cs
@@ -23,4 +23,9 @@ public DataLoaderModuleAttribute(string name)
     /// </summary>
     /// <value></value>
     public string Name { get; }
+
+    /// <summary>
+    /// Specifies if the generated module shall be internal.
+    /// </summary>
+    public bool IsInternal { get; set; }
 }
diff --git a/src/HotChocolate/Core/src/Types.Analyzers/FileBuilders/DataLoaderFileBuilder.cs b/src/HotChocolate/Core/src/Types.Analyzers/FileBuilders/DataLoaderFileBuilder.cs
@@ -567,11 +567,16 @@ kind is DataLoaderKind.Cache
     public void WriteDataLoaderGroupClass(
         string groupClassName,
         IReadOnlyList<GroupedDataLoaderInfo> dataLoaders,
-        bool withInterface)
+        bool withInterface,
+        bool isInterfacePublic,
+        bool isClassPublic)
     {
         if (withInterface)
         {
-            _writer.WriteIndentedLine("public interface I{0}", groupClassName);
+            _writer.WriteIndentedLine(
+                "{0} interface I{1}",
+                isInterfacePublic ? "public" : "internal",
+                groupClassName);
             _writer.WriteIndentedLine("{");
             _writer.IncreaseIndent();
 
@@ -587,11 +592,17 @@ public void WriteDataLoaderGroupClass(
 
         if (withInterface)
         {
-            _writer.WriteIndentedLine("public sealed partial class {0} : I{0}", groupClassName);
+            _writer.WriteIndentedLine(
+                "{0} sealed partial class {1} : I{1}",
+                isClassPublic ? "public" : "internal",
+                groupClassName);
         }
         else
         {
-            _writer.WriteIndentedLine("public sealed partial class {0}", groupClassName);
+            _writer.WriteIndentedLine(
+                "{0} sealed partial class {1}",
+                isClassPublic ? "public" : "internal",
+                groupClassName);
         }
 
         _writer.WriteIndentedLine("{");
diff --git a/src/HotChocolate/Core/src/Types.Analyzers/FileBuilders/DataLoaderModuleFileBuilder.cs b/src/HotChocolate/Core/src/Types.Analyzers/FileBuilders/DataLoaderModuleFileBuilder.cs
@@ -44,10 +44,11 @@ public void WriteEndNamespace()
         _writer.WriteIndentedLine("}");
     }
 
-    public void WriteBeginClass()
+    public void WriteBeginClass(bool isInternal)
     {
         _writer.WriteIndentedLine(
-            "public static partial class {0}DataLoaderServiceExtensions",
+            "{0} static partial class {1}DataLoaderServiceExtensions",
+            isInternal ? "internal" : "public",
             _moduleName);
         _writer.WriteIndentedLine("{");
         _writer.IncreaseIndent();
diff --git a/src/HotChocolate/Core/src/Types.Analyzers/Generators/DataLoaderGenerator.cs b/src/HotChocolate/Core/src/Types.Analyzers/Generators/DataLoaderGenerator.cs
@@ -106,10 +106,15 @@ private static void WriteDataLoader(
                         t.InterfaceName,
                         t.IsInterfacePublic ?? isPublic));
 
-                buffer ??= new();
+                buffer ??= [];
                 buffer.Clear();
                 buffer.AddRange(dataLoaderGroups);
-                generator.WriteDataLoaderGroupClass(dataLoaderGroup.Key, buffer, defaults.GenerateInterfaces);
+                generator.WriteDataLoaderGroupClass(
+                    dataLoaderGroup.Key,
+                    buffer,
+                    defaults.GenerateInterfaces,
+                    defaults.IsInterfacePublic ?? true,
+                    defaults.IsPublic ?? true);
             }
 
             generator.WriteEndNamespace();
diff --git a/src/HotChocolate/Core/src/Types.Analyzers/Generators/DataLoaderModuleGenerator.cs b/src/HotChocolate/Core/src/Types.Analyzers/Generators/DataLoaderModuleGenerator.cs
@@ -26,7 +26,7 @@ public void Generate(
 
         generator.WriteHeader();
         generator.WriteBeginNamespace();
-        generator.WriteBeginClass();
+        generator.WriteBeginClass(module.IsInternal);
         generator.WriteBeginRegistrationMethod();
 
         foreach (var syntaxInfo in syntaxInfos)
@@ -81,7 +81,9 @@ public void Generate(
         {
             if (syntaxInfo is DataLoaderModuleInfo module)
             {
-                return new DataLoaderModuleInfo(GeneratorUtils.SanitizeIdentifier(module.ModuleName));
+                return new DataLoaderModuleInfo(
+                    GeneratorUtils.SanitizeIdentifier(module.ModuleName),
+                    module.IsInternal);
             }
         }
 
diff --git a/src/HotChocolate/Core/src/Types.Analyzers/Helpers/DataLoaderAttributeHelper.cs b/src/HotChocolate/Core/src/Types.Analyzers/Helpers/DataLoaderAttributeHelper.cs
@@ -92,26 +92,6 @@ static bool IsDataLoaderGroupAttribute(INamedTypeSymbol? attributeClass)
         return null;
     }
 
-    private static bool IsTypeName(INamedTypeSymbol? type, string containingNamespace, string typeName)
-    {
-        if (type is null)
-        {
-            return false;
-        }
-
-        while (type != null)
-        {
-            if (type.MetadataName == typeName && type.ContainingNamespace?.ToDisplayString() == containingNamespace)
-            {
-                return true;
-            }
-
-            type = type.BaseType;
-        }
-
-        return false;
-    }
-
     public static bool? IsScoped(
         this SeparatedSyntaxList<AttributeArgumentSyntax> arguments,
         GeneratorSyntaxContext context)
@@ -307,6 +287,27 @@ public static string[] GetLookups(this AttributeData attribute)
         return null;
     }
 
+    public static bool IsModuleInternal(
+        this SeparatedSyntaxList<AttributeArgumentSyntax> arguments,
+        GeneratorSyntaxContext context)
+    {
+        var argumentSyntax = arguments.FirstOrDefault(
+            t => t.NameEquals?.Name.ToFullString().Trim() == "IsInternal");
+
+        if (argumentSyntax is not null)
+        {
+            var valueExpression = argumentSyntax.Expression;
+            var value = context.SemanticModel.GetConstantValue(valueExpression).Value;
+
+            if (value is bool b)
+            {
+                return b;
+            }
+        }
+
+        return false;
+    }
+
     public static bool RegisterService(
         this SeparatedSyntaxList<AttributeArgumentSyntax> arguments,
         GeneratorSyntaxContext context)
@@ -319,9 +320,9 @@ public static bool RegisterService(
             var valueExpression = argumentSyntax.Expression;
             var value = context.SemanticModel.GetConstantValue(valueExpression).Value;
 
-            if (value is not null)
+            if (value is bool b)
             {
-                return (bool)value;
+                return b;
             }
         }
 
diff --git a/src/HotChocolate/Core/src/Types.Analyzers/Inspectors/DataLoaderModuleInspector.cs b/src/HotChocolate/Core/src/Types.Analyzers/Inspectors/DataLoaderModuleInspector.cs
@@ -3,9 +3,9 @@
 using HotChocolate.Types.Analyzers.Models;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using HotChocolate.Types.Analyzers.Helpers;
 using static System.StringComparison;
 using static HotChocolate.Types.Analyzers.WellKnownAttributes;
-using static HotChocolate.Types.Analyzers.WellKnownTypes;
 
 namespace HotChocolate.Types.Analyzers.Inspectors;
 
@@ -31,11 +31,14 @@ public bool TryHandle(
                 var fullName = attributeContainingTypeSymbol.ToDisplayString();
 
                 if (fullName.Equals(DataLoaderModuleAttribute, Ordinal) &&
-                    attributeSyntax.ArgumentList is { Arguments.Count: > 0, })
+                    attributeSyntax.ArgumentList is { Arguments.Count: > 0 })
                 {
+
                     var nameExpr = attributeSyntax.ArgumentList.Arguments[0].Expression;
                     var name = context.SemanticModel.GetConstantValue(nameExpr).ToString();
-                    syntaxInfo = new DataLoaderModuleInfo(name);
+                    syntaxInfo = new DataLoaderModuleInfo(
+                        name,
+                        attributeSyntax.ArgumentList.Arguments.IsModuleInternal(context));
                     return true;
                 }
             }
diff --git a/src/HotChocolate/Core/src/Types.Analyzers/Inspectors/ModuleInspector.cs b/src/HotChocolate/Core/src/Types.Analyzers/Inspectors/ModuleInspector.cs
@@ -5,7 +5,6 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using static System.StringComparison;
 using static HotChocolate.Types.Analyzers.WellKnownAttributes;
-using static HotChocolate.Types.Analyzers.WellKnownTypes;
 
 namespace HotChocolate.Types.Analyzers.Inspectors;
 
diff --git a/src/HotChocolate/Core/src/Types.Analyzers/Models/DataLoaderModuleInfo.cs b/src/HotChocolate/Core/src/Types.Analyzers/Models/DataLoaderModuleInfo.cs
@@ -1,9 +1,11 @@
 namespace HotChocolate.Types.Analyzers.Models;
 
-public sealed class DataLoaderModuleInfo(string moduleName) : SyntaxInfo
+public sealed class DataLoaderModuleInfo(string moduleName, bool isInternal) : SyntaxInfo
 {
     public string ModuleName { get; } = moduleName;
 
+    public bool IsInternal { get; } = isInternal;
+
     public override string OrderByKey => ModuleName;
 
     public override bool Equals(object? obj)
@@ -13,8 +15,9 @@ public override bool Equals(SyntaxInfo obj)
         => obj is DataLoaderModuleInfo other && Equals(other);
 
     private bool Equals(DataLoaderModuleInfo other)
-        => string.Equals(ModuleName, other.ModuleName, StringComparison.Ordinal);
+        => string.Equals(ModuleName, other.ModuleName, StringComparison.Ordinal)
+            && IsInternal == other.IsInternal;
 
     public override int GetHashCode()
-        => HashCode.Combine(ModuleName);
+        => HashCode.Combine(ModuleName, IsInternal);
 }
diff --git a/src/HotChocolate/Core/test/Types.Analyzers.Tests/DataLoaderTests.cs b/src/HotChocolate/Core/test/Types.Analyzers.Tests/DataLoaderTests.cs
@@ -579,4 +579,90 @@ public static Task<IDictionary<int, string>> GetEntityByIdAsync(
             }
             """).MatchMarkdownAsync();
     }
+
+    [Fact]
+    public async Task Generate_DataLoader_Module_As_Internal()
+    {
+        await TestHelper.GetGeneratedSourceSnapshot(
+            """
+            using System.Collections.Generic;
+            using System.Threading;
+            using System.Threading.Tasks;
+            using HotChocolate;
+            using GreenDonut;
+
+            [assembly: GreenDonut.DataLoaderModule("Abc", IsInternal = true)]
+
+            namespace TestNamespace;
+
+            internal static class TestClass
+            {
+                [DataLoader]
+                public static Task<IDictionary<int, string>> GetEntityByIdAsync(
+                    IReadOnlyList<int> entityIds,
+                    GreenDonut.Data.IPredicateBuilder predicate,
+                    CancellationToken cancellationToken)
+                    => default!;
+            }
+            """).MatchMarkdownAsync();
+    }
+
+    [Fact]
+    public async Task Generate_DataLoader_Module_As_Internal_Implementation_As_Internal()
+    {
+        await TestHelper.GetGeneratedSourceSnapshot(
+            """
+            using System.Collections.Generic;
+            using System.Threading;
+            using System.Threading.Tasks;
+            using HotChocolate;
+            using GreenDonut;
+
+            [assembly: GreenDonut.DataLoaderModule("Abc", IsInternal = true)]
+            [assembly: GreenDonut.DataLoaderDefaults(
+                AccessModifier = GreenDonut.DataLoaderAccessModifier.PublicInterface)]
+
+            namespace TestNamespace;
+
+            internal static class TestClass
+            {
+                [DataLoader]
+                public static Task<IDictionary<int, string>> GetEntityByIdAsync(
+                    IReadOnlyList<int> entityIds,
+                    GreenDonut.Data.IPredicateBuilder predicate,
+                    CancellationToken cancellationToken)
+                    => default!;
+            }
+            """).MatchMarkdownAsync();
+    }
+
+    [Fact]
+    public async Task Generate_DataLoader_Module_As_Internal_Implementation_As_Internal_With_Group()
+    {
+        await TestHelper.GetGeneratedSourceSnapshot(
+            """
+            using System.Collections.Generic;
+            using System.Threading;
+            using System.Threading.Tasks;
+            using HotChocolate;
+            using GreenDonut;
+
+            [assembly: GreenDonut.DataLoaderModule("Abc", IsInternal = true)]
+            [assembly: GreenDonut.DataLoaderDefaults(
+                AccessModifier = GreenDonut.DataLoaderAccessModifier.PublicInterface)]
+
+            namespace TestNamespace;
+
+            [DataLoaderGroup("Test123")]
+            internal static class TestClass
+            {
+                [DataLoader]
+                public static Task<IDictionary<int, string>> GetEntityByIdAsync(
+                    IReadOnlyList<int> entityIds,
+                    GreenDonut.Data.IPredicateBuilder predicate,
+                    CancellationToken cancellationToken)
+                    => default!;
+            }
+            """).MatchMarkdownAsync();
+    }
 }
diff --git a/src/HotChocolate/Core/test/Types.Analyzers.Tests/__snapshots__/DataLoaderTests.Generate_DataLoader_Module_As_Internal.md b/src/HotChocolate/Core/test/Types.Analyzers.Tests/__snapshots__/DataLoaderTests.Generate_DataLoader_Module_As_Internal.md
diff --git a/src/HotChocolate/Core/test/Types.Analyzers.Tests/__snapshots__/DataLoaderTests.Generate_DataLoader_Module_As_Internal_Implementation_As_Internal.md b/src/HotChocolate/Core/test/Types.Analyzers.Tests/__snapshots__/DataLoaderTests.Generate_DataLoader_Module_As_Internal_Implementation_As_Internal.md
diff --git a/src/HotChocolate/Core/test/Types.Analyzers.Tests/__snapshots__/DataLoaderTests.Generate_DataLoader_Module_As_Internal_Implementation_As_Internal_With_Group.md b/src/HotChocolate/Core/test/Types.Analyzers.Tests/__snapshots__/DataLoaderTests.Generate_DataLoader_Module_As_Internal_Implementation_As_Internal_With_Group.md

Original file line number	Diff line number	Diff line change
`@@ -13,5 +13,5 @@`
`13`	`13`	`"*.targets": "xml",`
`14`	`14`	`"*.tasks": "xml"`
`15`	`15`	`},`
`16`		`- "dotnet.defaultSolution": "src/All.sln"`
	`16`	`+ "dotnet.defaultSolution": "src/All.slnx"`
`17`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"sdk": {`
`3`		`- "version": "9.0.100",`
	`3`	`+ "version": "9.0.200",`
`4`	`4`	`"rollForward": "latestMinor"`
`5`	`5`	`}`
`6`	`6`	`}`
Original file line number	Diff line number	Diff line change
`@@ -44,10 +44,11 @@ public void WriteEndNamespace()`
`44`	`44`	`_writer.WriteIndentedLine("}");`
`45`	`45`	`}`
`46`	`46`
`47`		`- public void WriteBeginClass()`
	`47`	`+ public void WriteBeginClass(bool isInternal)`
`48`	`48`	`{`
`49`	`49`	`_writer.WriteIndentedLine(`
`50`		`- "public static partial class {0}DataLoaderServiceExtensions",`
	`50`	`+ "{0} static partial class {1}DataLoaderServiceExtensions",`
	`51`	`+ isInternal ? "internal" : "public",`
`51`	`52`	`_moduleName);`
`52`	`53`	`_writer.WriteIndentedLine("{");`
`53`	`54`	`_writer.IncreaseIndent();`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ public void Generate(`
`26`	`26`
`27`	`27`	`generator.WriteHeader();`
`28`	`28`	`generator.WriteBeginNamespace();`
`29`		`- generator.WriteBeginClass();`
	`29`	`+ generator.WriteBeginClass(module.IsInternal);`
`30`	`30`	`generator.WriteBeginRegistrationMethod();`
`31`	`31`
`32`	`32`	`foreach (var syntaxInfo in syntaxInfos)`
`@@ -81,7 +81,9 @@ public void Generate(`
`81`	`81`	`{`
`82`	`82`	`if (syntaxInfo is DataLoaderModuleInfo module)`
`83`	`83`	`{`
`84`		`- return new DataLoaderModuleInfo(GeneratorUtils.SanitizeIdentifier(module.ModuleName));`
	`84`	`+ return new DataLoaderModuleInfo(`
	`85`	`+ GeneratorUtils.SanitizeIdentifier(module.ModuleName),`
	`86`	`+ module.IsInternal);`
`85`	`87`	`}`
`86`	`88`	`}`
`87`	`89`