Fixes scenario where recursive depth = 0 not generating properties on root object

Author: soenneker

src/AutoFakerBinder.cs

@@ -179,9 +179,30 @@ private static bool ShouldSkip(AutoMember autoMember, AutoFakerContext context)
         if (config.TreeDepth != null && stackCount >= config.TreeDepth)
             return true;
 
-        // Handle special case: If RecursiveDepth is 0, all recursive elements should be skipped.
+        // Handle special case: If RecursiveDepth is 0, skip recursive types (same as parent) and nested children.
+        // When RecursiveDepth is 0:
+        // - stackCount = 0: We're generating first-level properties - skip if member type is same as parent (recursive)
+        // - stackCount > 0: We're generating nested children (skip them)
         if (config.RecursiveDepth == 0)
-            return true;
+        {
+            if (stackCount > 0)
+                return true; // Skip nested children
+            
+            // Skip recursive types (member type same as parent type) at first level
+            if (autoMember.CachedType.CacheKey is { } memberCacheKey &&
+                autoMember.ParentType.CacheKey is { } parentCacheKey &&
+                memberCacheKey == parentCacheKey)
+            {
+                // Check if this is a complex type (not a collection/dictionary, which are handled separately)
+                if (!autoMember.IsCollection && !autoMember.IsDictionary)
+                {
+                    // Check if it has members to populate (making it a complex type)
+                    List<AutoMember>? membersToPopulate = context.Binder.GetMembersToPopulate(autoMember.CachedType, context.CacheService, config);
+                    if (membersToPopulate != null && membersToPopulate.Count > 0)
+                        return true; // Skip recursive complex types
+                }
+            }
+        }
 
         // Check if the stack count is below the recursive depth threshold.
         if (stackCount < config.RecursiveDepth)

src/Extensions/AutoGenerateContextExtension.cs

@@ -44,6 +44,12 @@ public static class AutoGenerateContextExtension
     /// <returns>The generated collection of instances.</returns>
     public static List<TType> GenerateMany<TType>(this AutoFakerContext context, int? count = null)
     {
+        // When RecursiveDepth is 0 and we're generating nested items (stackCount > 0), return empty list
+        if (context.Config.RecursiveDepth == 0 && context.TypesStack.Count > 0)
+        {
+            return [];
+        }
+
         count ??= context.Config.RepeatCount;
 
         return GenerateMany<TType>(context, count.Value, false);

src/Generators/Types/DictionaryGenerator.cs

@@ -69,7 +69,7 @@ object IAutoFakerGenerator.Generate(AutoFakerContext context)
         }
         else
         {
-            // Custom IDictionary<,> fallback (can’t avoid interface calls)
+            // Custom IDictionary<,> fallback (can�t avoid interface calls)
             // If it *happens* to be a Dictionary under the hood, ensure capacity
             if (items is Dictionary<TKey, TValue> d2)
                 d2.EnsureCapacity(target);
@@ -87,7 +87,7 @@ object IAutoFakerGenerator.Generate(AutoFakerContext context)
                     continue;
 
                 // Using ContainsKey+indexer would be two lookups; Add throws on dup, so try/catch is ok but slower.
-                // Interface doesn’t expose TryAdd; if dups are possible, you can guard:
+                // Interface doesn�t expose TryAdd; if dups are possible, you can guard:
                 if (items is Dictionary<TKey, TValue> d3)
                 {
                     _ = d3.TryAdd(key, val);

test/Soenneker.Utils.AutoBogus.Tests/AutoFakerTests.cs

@@ -508,6 +508,39 @@ public void Generate_with_recursive_depth_0_should_generate()
         testClass.Child.Should().BeNull();
     }
 
+    [Fact]
+    public void Generate_with_recursive_depth_0_should_set_first_level_properties_but_not_children()
+    {
+        var faker = new AutoFaker
+        {
+            Config =
+            {
+                RecursiveDepth = 0
+            }
+        };
+
+        var testClass = faker.Generate<TestClassWithRecursiveConstructor>();
+        
+        testClass.Name.Should().NotBeNull();
+        testClass.Age.Should().NotBe(0);
+        
+        testClass.Child.Should().BeNull();
+        
+        var order = faker.Generate<Order>();
+        
+        order.Id.Should().NotBe(0);
+        order.Code.Should().NotBeNull();
+        order.Status.Should().BeDefined();
+        order.DateCreated.Should().NotBe(default);
+        
+        order.Items.Should().NotBeNull();
+        order.Items.Should().BeEmpty();
+        order.Discounts.Should().NotBeNull();
+        order.Discounts.Should().BeEmpty();
+        order.Comments.Should().NotBeNull();
+        order.Comments.Should().BeEmpty();
+    }
+
     [Fact]
     public void Generate_with_recursive_depth_1_should_generate()
     {