fix: fall back from huge generated json contexts

HavenDV · HavenDV · commit fc7e74dbb309 · 2026-04-02T08:58:43.000+04:00
diff --git a/src/libs/AutoSDK.CLI/Commands/GenerateCommand.cs b/src/libs/AutoSDK.CLI/Commands/GenerateCommand.cs
@@ -327,15 +327,16 @@ private async Task HandleAsync(ParseResult parseResult)
             throw new NotSupportedException($"Unsupported language '{language}'. Currently only 'csharp' is supported.");
         }
 
-        var coreResult = CorePipeline.Prepare(
-            ((yaml, settings), GlobalSettings: settings),
-            static (document, currentSettings) => document.GetSchemas((CSharpSettings)currentSettings),
-            CSharpPipeline.ApplyModelNaming,
-            static text => text.ToClassName(),
-            static text => text.ToPropertyName());
-        var plugin = CSharpLanguagePlugin.Instance;
-        var data = plugin.Enrich(coreResult);
-        var files = plugin
+        var data = CSharpPipeline.PrepareAndEnrich(
+            ((yaml, settings), GlobalSettings: settings));
+
+        if (settings.GenerateJsonSerializerContextTypes &&
+            string.IsNullOrWhiteSpace(data.Converters.Settings.JsonSerializerContext))
+        {
+            Console.WriteLine("Warning: Disabled generated System.Text.Json source-generation context because some union-heavy types exceeded compiler metadata limits.");
+        }
+
+        var files = CSharpLanguagePlugin.Instance
             .GenerateFiles(data)
             .Where(x => !x.IsEmpty)
             .ToArray();
diff --git a/src/libs/AutoSDK.CSharp/Pipeline/CSharpPipeline.cs b/src/libs/AutoSDK.CSharp/Pipeline/CSharpPipeline.cs
@@ -15,6 +15,21 @@ public static Models.Data PrepareAndEnrich(
         CancellationToken cancellationToken = default)
     {
         var totalTime = System.Diagnostics.Stopwatch.StartNew();
+        var data = PrepareAndEnrichCore(tuple, allowJsonSerializerContextFallback: true, cancellationToken);
+        return data with
+        {
+            Times = data.Times with
+            {
+                Total = totalTime.Elapsed,
+            },
+        };
+    }
+
+    private static Models.Data PrepareAndEnrichCore(
+        ((string Text, Settings Settings) Context, Settings GlobalSettings) tuple,
+        bool allowJsonSerializerContextFallback,
+        CancellationToken cancellationToken)
+    {
         var coreResult = CorePipeline.Prepare(
             tuple,
             static (document, settings) => document.GetSchemas((CSharpSettings)settings),
@@ -24,13 +39,37 @@ public static Models.Data PrepareAndEnrich(
             cancellationToken);
 
         var data = Enrich(coreResult, cancellationToken);
-        return data with
+
+        if (allowJsonSerializerContextFallback &&
+            ShouldDisableGeneratedJsonSerializerContext(tuple.Context.Settings, data))
         {
-            Times = data.Times with
+            var fallbackSettings = tuple.Context.Settings with
             {
-                Total = totalTime.Elapsed,
-            },
-        };
+                JsonSerializerContext = string.Empty,
+                GenerateJsonSerializerContextTypes = false,
+            };
+            var fallbackGlobalSettings = tuple.GlobalSettings with
+            {
+                JsonSerializerContext = string.Empty,
+                GenerateJsonSerializerContextTypes = false,
+            };
+
+            return PrepareAndEnrichCore(
+                ((tuple.Context.Text, fallbackSettings), fallbackGlobalSettings),
+                allowJsonSerializerContextFallback: false,
+                cancellationToken);
+        }
+
+        return data;
+    }
+
+    private static bool ShouldDisableGeneratedJsonSerializerContext(
+        Settings settings,
+        Models.Data data)
+    {
+        return settings.GenerateJsonSerializerContextTypes &&
+               settings.UsesSystemTextJson() &&
+               Sources.HasOversizedGeneratedJsonSerializerContextTypeNames(data.Types);
     }
 
     public static void ApplyModelNaming(IReadOnlyList<SchemaContext> schemas)
diff --git a/src/libs/AutoSDK.CSharp/Sources/Sources.JsonSerializerContext.cs b/src/libs/AutoSDK.CSharp/Sources/Sources.JsonSerializerContext.cs
@@ -1,5 +1,8 @@
 using AutoSDK.Extensions;
 using AutoSDK.Models;
+using System.Globalization;
+using System.Security.Cryptography;
+using System.Text;
 namespace AutoSDK.Generation;
 
 public static partial class Sources
@@ -123,16 +126,10 @@ private static Dictionary<string, string> BuildExplicitTypeInfoPropertyNames(
                 }
 
                 var baseName = $"{GetImplicitTypeInfoPropertyName(type)}_{SanitizeTypeInfoPropertyName(type)}";
-                var name = baseName;
-                var suffix = 2;
-
-                while (usedNames.Contains(name))
-                {
-                    name = $"{baseName}_{suffix++}";
-                }
-
-                usedNames.Add(name);
-                explicitNames[type] = name;
+                explicitNames[type] = ReserveExplicitTypeInfoPropertyName(
+                    usedNames,
+                    baseName,
+                    type);
             }
         }
 
@@ -160,16 +157,10 @@ private static Dictionary<string, string> BuildExplicitTypeInfoPropertyNames(
 
             var implicitName = GetImplicitTypeInfoPropertyName(type);
             var baseName = $"{implicitName}2";
-            var name = baseName;
-            var suffix = 3;
-
-            while (usedNames.Contains(name))
-            {
-                name = $"{implicitName}{suffix++}";
-            }
-
-            usedNames.Add(name);
-            explicitNames[type] = name;
+            explicitNames[type] = ReserveExplicitTypeInfoPropertyName(
+                usedNames,
+                baseName,
+                type);
         }
 
         // Phase 3: Handle collisions between explicit types and STJ's implicit nullable naming.
@@ -196,19 +187,119 @@ private static Dictionary<string, string> BuildExplicitTypeInfoPropertyNames(
             }
 
             var baseName = $"{implicitName}2";
-            var name = baseName;
-            var suffix = 3;
+            explicitNames[type] = ReserveExplicitTypeInfoPropertyName(
+                usedNames,
+                baseName,
+                type);
+        }
+
+        return explicitNames;
+    }
+
+    private const int MaxExplicitTypeInfoPropertyNameLength = 120;
+    private const int MaxGeneratedTypeInfoNameLength = 120;
+
+    public static bool HasOversizedGeneratedJsonSerializerContextTypeNames(
+        EquatableArray<TypeData> types)
+    {
+        var distinctTypeNames = types
+            .Select(static x => x.CSharpTypeWithoutNullability)
+            .Where(static x => !string.IsNullOrWhiteSpace(x))
+            .Distinct(StringComparer.Ordinal)
+            .ToArray();
+
+        if (distinctTypeNames.Any(static x => GetImplicitTypeInfoPropertyName(x).Length > MaxGeneratedTypeInfoNameLength))
+        {
+            return true;
+        }
+
+        if (types.Any(static x =>
+                x.IsValueType &&
+                x.CSharpTypeWithNullability != x.CSharpTypeWithoutNullability &&
+                $"Nullable{GetImplicitTypeInfoPropertyName(x.CSharpTypeWithoutNullability)}".Length > MaxGeneratedTypeInfoNameLength))
+        {
+            return true;
+        }
+
+        var concreteListTypes = GetConcreteListTypes(
+            types
+                .Select(static x => x.CSharpTypeWithNullability)
+                .Where(static x => !string.IsNullOrWhiteSpace(x))
+                .Distinct(StringComparer.Ordinal)
+                .ToArray());
+
+        return concreteListTypes.Any(static x => GetImplicitTypeInfoPropertyName(x).Length > MaxGeneratedTypeInfoNameLength);
+    }
 
-            while (usedNames.Contains(name))
+    private static string ReserveExplicitTypeInfoPropertyName(
+        HashSet<string> usedNames,
+        string baseName,
+        string type)
+    {
+        for (var suffix = 0; ; suffix++)
+        {
+            var candidateSeed = suffix == 0
+                ? baseName
+                : $"{baseName}_{suffix + 2}";
+            var candidate = NormalizeExplicitTypeInfoPropertyName(candidateSeed, type);
+
+            if (usedNames.Add(candidate))
             {
-                name = $"{implicitName}{suffix++}";
+                return candidate;
             }
+        }
+    }
 
-            usedNames.Add(name);
-            explicitNames[type] = name;
+    private static string NormalizeExplicitTypeInfoPropertyName(string candidate, string type)
+    {
+        if (candidate.Length <= MaxExplicitTypeInfoPropertyNameLength)
+        {
+            return candidate;
         }
 
-        return explicitNames;
+        var prefix = SanitizeTypeInfoPropertyName(GetSimpleTypeName(type));
+        var hash = ComputeStableTypeInfoPropertyNameHash(candidate);
+        var maxPrefixLength = MaxExplicitTypeInfoPropertyNameLength - hash.Length - 1;
+
+        if (maxPrefixLength <= 0)
+        {
+            return hash;
+        }
+
+        if (prefix.Length > maxPrefixLength)
+        {
+            prefix = prefix.Substring(0, maxPrefixLength);
+        }
+
+        if (prefix.Length == 0)
+        {
+            prefix = "Type";
+            if (prefix.Length > maxPrefixLength)
+            {
+                prefix = prefix.Substring(0, maxPrefixLength);
+            }
+        }
+
+        return $"{prefix}_{hash}";
+    }
+
+    private static string ComputeStableTypeInfoPropertyNameHash(string value)
+    {
+        var bytes = Encoding.UTF8.GetBytes(value);
+#if NET10_0_OR_GREATER
+        var hash = SHA256.HashData(bytes);
+#else
+        using var sha256 = SHA256.Create();
+        var hash = sha256.ComputeHash(bytes);
+#endif
+        var builder = new StringBuilder(capacity: 16);
+
+        for (var index = 0; index < 8; index++)
+        {
+            builder.Append(hash[index].ToString("x2", CultureInfo.InvariantCulture));
+        }
+
+        return builder.ToString();
     }
 
     private static string GetImplicitTypeInfoPropertyName(string type)
diff --git a/src/tests/AutoSDK.IntegrationTests.Cli/CliTests.cs b/src/tests/AutoSDK.IntegrationTests.Cli/CliTests.cs
@@ -872,6 +872,116 @@ await GenerateFromContentAsync(
             targetFramework: "net10.0");
     }
 
+    [TestMethod]
+    public async Task Generate_WithHugeUnionTypeInfoPropertyName_Builds()
+    {
+        var policyNames = new[]
+        {
+            "NewModerateModerateRequestPolicieToxicity",
+            "NewModerateModerateRequestPoliciePersonalInformation",
+            "NewModerateModerateRequestPolicieToxicitySevere",
+            "NewModerateModerateRequestPolicieHate",
+            "NewModerateModerateRequestPolicieIllicit",
+            "NewModerateModerateRequestPolicieIllicitDrugs",
+            "NewModerateModerateRequestPolicieIllicitAlcohol",
+            "NewModerateModerateRequestPolicieIllicitFirearms",
+            "NewModerateModerateRequestPolicieIllicitTobacco",
+            "NewModerateModerateRequestPolicieIllicitGambling",
+            "NewModerateModerateRequestPolicieCannabis",
+            "NewModerateModerateRequestPolicieAdult",
+            "NewModerateModerateRequestPolicieCrypto",
+            "NewModerateModerateRequestPolicieSexual",
+            "NewModerateModerateRequestPolicieFlirtation",
+            "NewModerateModerateRequestPolicieProfanity",
+            "NewModerateModerateRequestPolicieViolence",
+            "NewModerateModerateRequestPolicieSelfHarm",
+            "NewModerateModerateRequestPolicieSpam",
+            "NewModerateModerateRequestPolicieSelfPromotion",
+            "NewModerateModerateRequestPoliciePolitical",
+            "NewModerateModerateRequestPolicieReligion",
+            "NewModerateModerateRequestPolicieCodeAbuse",
+            "NewModerateModerateRequestPoliciePiiMasking",
+            "NewModerateModerateRequestPolicieUrlMasking",
+            "NewModerateModerateRequestPolicieGuideline",
+        };
+        var anyOfRefs = string.Join(
+            Environment.NewLine,
+            policyNames.Select(name => $"                - $ref: '#/components/schemas/{name}'"));
+        var policySchemas = string.Join(
+            Environment.NewLine + Environment.NewLine,
+            policyNames.Select(name => $$"""
+    {{name}}:
+      type: object
+      properties:
+        enabled:
+          type: boolean
+"""));
+        var spec = $$"""
+openapi: 3.0.3
+info:
+  title: HugeUnion
+  version: 1.0.0
+paths:
+  /moderate:
+    post:
+      operationId: moderate
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ModerateRequest'
+      responses:
+        '200':
+          description: OK
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  ok:
+                    type: boolean
+components:
+  schemas:
+    ModerateRequest:
+      type: object
+      required:
+        - content
+      properties:
+        content:
+          type: string
+        policies:
+          type: array
+          items:
+            anyOf:
+{{anyOfRefs}}
+
+{{policySchemas}}
+""";
+
+        await GenerateFromContentAsync(
+            fileName: "huge-union-typeinfo.yaml",
+            specContent: spec,
+            targetFramework: "net10.0",
+            namespaceValue: "HugeUnion",
+            assertGeneratedOutput: async outputDirectory =>
+            {
+                var contextFile = Path.Combine(outputDirectory, "HugeUnion.JsonSerializerContext.g.cs");
+                var contextTypesFile = Path.Combine(outputDirectory, "HugeUnion.JsonSerializerContextTypes.g.cs");
+
+                File.Exists(contextFile).Should().BeFalse();
+                File.Exists(contextTypesFile).Should().BeFalse();
+
+                var generatedContents = await Task.WhenAll(
+                    Directory.EnumerateFiles(outputDirectory, "*.g.cs", SearchOption.AllDirectories)
+                        .Select(path => File.ReadAllTextAsync(path)));
+                var content = string.Join("\n\n", generatedContents);
+
+                content.Should().Contain("JsonSerializerOptions");
+                content.Should().NotContain("JsonSerializerContext { get; set; } =");
+            });
+    }
+
     [TestMethod]
     public async Task Generate_WithRequiredNullableAnyOfRequestProperty_Builds()
     {
diff --git a/src/tests/AutoSDK.UnitTests/JsonTests.JsonSerializerContextTypes.cs b/src/tests/AutoSDK.UnitTests/JsonTests.JsonSerializerContextTypes.cs
