Fix: Remove parent class nesting from implicit DTOs in hash namespaces (#219)

* Initial plan

* Add test for issue: implicit DTOs should not be nested in parent class when using hash namespace

Co-authored-by: arika0093 <4524647+arika0093@users.noreply.github.com>

* Fix: Implicit DTOs should not be nested in parent class when using hash namespace

Co-authored-by: arika0093 <4524647+arika0093@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: arika0093 <4524647+arika0093@users.noreply.github.com>

Author: Copilot

src/Linqraft.Core/SelectExprInfoExplicitDto.cs

@@ -135,14 +135,23 @@ private List<GenerateDtoClassInfo> GenerateDtoClasses(
         var actualNamespace = GetActualDtoNamespace();
 
         // When NestedDtoUseHashNamespace option is enabled, child DTOs are placed in
-        // a hash-named sub-namespace (e.g., LinqraftGenerated_{Hash}.ClassName)
+        // a hash-named sub-namespace (e.g., LinqraftGenerated_{Hash}) WITHOUT parent class nesting
         // However, DTOs with explicit names from nested SelectExpr should NOT use hash namespace
+        // and should maintain their parent class structure
+        List<string> finalParentClasses = currentParentClasses;
+        List<string> finalParentAccessibilities = currentParentAccessibilities;
+        
         if (!isExplicitDto && Configuration?.NestedDtoUseHashNamespace == true)
         {
             var hash = structure.GetUniqueId();
             actualNamespace = string.IsNullOrEmpty(actualNamespace)
                 ? $"LinqraftGenerated_{hash}"
                 : $"{actualNamespace}.LinqraftGenerated_{hash}";
+            
+            // Implicit DTOs in hash namespace should NOT be nested inside parent classes
+            // They are managed by the hash, so they don't need to exist within a class
+            finalParentClasses = [];
+            finalParentAccessibilities = [];
         }
 
         var dtoClassInfo = new GenerateDtoClassInfo
@@ -152,8 +161,8 @@ private List<GenerateDtoClassInfo> GenerateDtoClasses(
             ClassName = className,
             Structure = structure,
             NestedClasses = [.. result],
-            ParentClasses = currentParentClasses,
-            ParentAccessibilities = currentParentAccessibilities,
+            ParentClasses = finalParentClasses,
+            ParentAccessibilities = finalParentAccessibilities,
             ExistingProperties = existingProperties,
             IsExplicitRootDto = isExplicitDto, // Mark explicit DTOs (main or from nested SelectExpr) to avoid adding the attribute
         };
@@ -258,7 +267,8 @@ protected override string GetClassName(DtoStructure structure)
 
     /// <summary>
     /// Gets the full name for a nested DTO class using the structure.
-    /// When NestedDtoUseHashNamespace is enabled, includes the LinqraftGenerated_{hash} namespace.
+    /// When NestedDtoUseHashNamespace is enabled, includes the LinqraftGenerated_{hash} namespace
+    /// WITHOUT parent class nesting (implicit DTOs are managed by hash, not class hierarchy).
     /// </summary>
     protected override string GetNestedDtoFullNameFromStructure(DtoStructure nestedStructure)
     {
@@ -269,22 +279,20 @@ protected override string GetNestedDtoFullNameFromStructure(DtoStructure nestedS
         var actualNamespace = GetActualDtoNamespace();
 
         // When NestedDtoUseHashNamespace option is enabled, include LinqraftGenerated_{hash} in namespace
+        // Implicit DTOs should NOT be nested inside parent classes - they are placed directly
+        // in the LinqraftGenerated_{hash} namespace
         if (Configuration?.NestedDtoUseHashNamespace == true)
         {
             var hash = nestedStructure.GetUniqueId();
             var generatedNamespace = string.IsNullOrEmpty(actualNamespace)
                 ? $"LinqraftGenerated_{hash}"
                 : $"{actualNamespace}.LinqraftGenerated_{hash}";
 
-            // Handle parent classes
-            if (ParentClasses.Count > 0)
-            {
-                return $"global::{generatedNamespace}.{string.Join(".", ParentClasses)}.{className}";
-            }
+            // Implicit DTOs in hash namespace should NOT include parent classes
             return $"global::{generatedNamespace}.{className}";
         }
 
-        // Default behavior: use GetNestedDtoFullName
+        // Default behavior: use GetNestedDtoFullName (includes parent classes)
         return GetNestedDtoFullName(className);
     }
 

tests/Linqraft.Tests/Issue_ClassInClassGeneratedTest.cs

@@ -0,0 +1,66 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Linqraft.Tests;
+
+/// <summary>
+/// Test case for issue: Minor issues when generating multi-layer DTO classes for classes nested within other classes
+/// When NestedDtoUseHashNamespace is enabled (default), implicit DTOs should be placed in LinqraftGenerated_{hash} namespace
+/// WITHOUT being nested inside the parent class
+/// </summary>
+public partial class ClassInClassGeneratedExpr
+{
+    private readonly List<NestedEntity> TestData = [];
+
+    [Fact]
+    public void NestedSelectExpr_WithExplicitDtoTypes_ShouldWork()
+    {
+        var query = TestData.AsQueryable();
+
+        var result = query
+            .SelectExpr<NestedEntity, NestedEntityDto>(x => new
+            {
+                x.Id,
+                x.Name,
+                Items = x.Items.Select(i => new { i.Id }),
+            })
+            .ToList();
+
+        result.Count.ShouldBe(0);
+
+        // Verify that NestedEntityDto is NOT in the LinqraftGenerated_ namespace
+        var nestedEntityDtoType = typeof(NestedEntityDto);
+        nestedEntityDtoType.Namespace!.ShouldNotContain("LinqraftGenerated");
+        nestedEntityDtoType.Namespace.ShouldBe("Linqraft.Tests");
+
+        // Verify that the auto-generated ItemsDto IS in the LinqraftGenerated_ namespace
+        // and NOT nested inside ClassInClassGeneratedExpr
+        var itemsProperty = nestedEntityDtoType.GetProperty("Items");
+        itemsProperty.ShouldNotBeNull();
+        var itemsElementType = itemsProperty!
+            .PropertyType.GetGenericArguments()
+            .FirstOrDefault();
+        itemsElementType.ShouldNotBeNull();
+        itemsElementType!.Namespace!.ShouldContain("LinqraftGenerated");
+        
+        // The key assertion: ItemsDto should NOT be nested inside ClassInClassGeneratedExpr
+        // It should be directly in the LinqraftGenerated_{hash} namespace
+        var itemsDtoFullName = itemsElementType.FullName!;
+        itemsDtoFullName.ShouldNotContain("ClassInClassGeneratedExpr");
+    }
+
+    internal class NestedEntity
+    {
+        public int Id { get; set; }
+        public string Name { get; set; } = null!;
+        public List<NestedItem> Items { get; set; } = [];
+    }
+
+    internal class NestedItem
+    {
+        public int Id { get; set; }
+        public string Title { get; set; } = null!;
+    }
+
+    internal partial class NestedEntityDto;
+}