refactor: extract CSharpClientGeneratorFactory schema mutations into IOpenApiDocumentMutator pipeline

src/Refitter.Core/CustomIntegerTypeMutator.cs

@@ -0,0 +1,25 @@
+using NJsonSchema;
+using NSwag;
+
+namespace Refitter.Core;
+
+internal sealed class CustomIntegerTypeMutator(IntegerType customIntegerType)
+    : IOpenApiDocumentMutator
+{
+    public void Mutate(OpenApiDocument document)
+    {
+        if (customIntegerType == IntegerType.Int32)
+            return;
+
+        SchemaWalker.TraverseDocumentSchemas(document, FixSchemaIntegerFormat);
+    }
+
+    private static void FixSchemaIntegerFormat(JsonSchema schema)
+    {
+        if (schema.Type == JsonObjectType.Integer &&
+            string.IsNullOrEmpty(schema.Format))
+        {
+            schema.Format = "int64";
+        }
+    }
+}

src/Refitter.Core/CustomTemplateFactory.cs

@@ -0,0 +1,34 @@
+using NJsonSchema;
+using NJsonSchema.CodeGeneration;
+using NJsonSchema.CodeGeneration.CSharp;
+using NSwag;
+using NSwag.CodeGeneration.CSharp;
+
+namespace Refitter.Core;
+
+/// <summary>
+/// Custom template factory solely for the purpose of tweaking the JsonPolymorphic attribute
+/// with UnknownDerivedTypeHandling = FallBackToBaseType and IgnoreUnrecognizedTypeDiscriminators = true.
+/// This class should be removed if NSwag eventually supports setting UnknownDerivedTypeHandling
+/// and IgnoreUnrecognizedTypeDiscriminators.
+/// </summary>
+internal class CustomTemplateFactory : NSwag.CodeGeneration.DefaultTemplateFactory
+{
+    public CustomTemplateFactory(CodeGeneratorSettingsBase settings)
+        : base(settings, [typeof(CSharpGenerator).Assembly, typeof(CSharpGeneratorBaseSettings).Assembly, typeof(NJsonSchema.CodeGeneration.CSharp.CSharpGeneratorSettings).Assembly])
+    {
+    }
+
+    protected override string GetEmbeddedLiquidTemplate(string language, string template)
+    {
+        var templateText = base.GetEmbeddedLiquidTemplate(language, template);
+        return template switch
+        {
+            "Class" => templateText
+                .Replace(
+                    "[System.Text.Json.Serialization.JsonPolymorphic(TypeDiscriminatorPropertyName = \"{{ Discriminator }}\")]",
+                    "[System.Text.Json.Serialization.JsonPolymorphic(TypeDiscriminatorPropertyName = \"{{ Discriminator }}\", UnknownDerivedTypeHandling = System.Text.Json.Serialization.JsonUnknownDerivedTypeHandling.FallBackToBaseType, IgnoreUnrecognizedTypeDiscriminators = true)]"),
+            _ => templateText,
+        };
+    }
+}

src/Refitter.Core/DisableAdditionalPropertiesMutator.cs

@@ -0,0 +1,21 @@
+using NSwag;
+
+namespace Refitter.Core;
+
+internal sealed class DisableAdditionalPropertiesMutator(bool generateDefaultAdditionalProperties)
+    : IOpenApiDocumentMutator
+{
+    public void Mutate(OpenApiDocument document)
+    {
+        if (generateDefaultAdditionalProperties)
+            return;
+
+        if (document.Components?.Schemas == null)
+            return;
+
+        foreach (var kvp in document.Components.Schemas)
+        {
+            kvp.Value.ActualSchema.AllowAdditionalProperties = false;
+        }
+    }
+}

src/Refitter.Core/FixMissingIntegerTypesMutator.cs

@@ -0,0 +1,28 @@
+using NJsonSchema;
+using NSwag;
+
+namespace Refitter.Core;
+
+internal sealed class FixMissingIntegerTypesMutator : IOpenApiDocumentMutator
+{
+    public void Mutate(OpenApiDocument document)
+    {
+        SchemaWalker.TraverseDocumentSchemas(document, FixSchemaTypeFromFormat);
+    }
+
+    private static void FixSchemaTypeFromFormat(JsonSchema schema)
+    {
+        if ((schema.Type == JsonObjectType.None || schema.Type == JsonObjectType.Null) &&
+            !string.IsNullOrEmpty(schema.Format))
+        {
+            if (schema.Format == "int32" || schema.Format == "int64")
+            {
+                schema.Type = JsonObjectType.Integer;
+            }
+            else if (schema.Format == "float" || schema.Format == "double")
+            {
+                schema.Type = JsonObjectType.Number;
+            }
+        }
+    }
+}

src/Refitter.Core/IOpenApiDocumentMutator.cs

@@ -0,0 +1,8 @@
+using NSwag;
+
+namespace Refitter.Core;
+
+internal interface IOpenApiDocumentMutator
+{
+    void Mutate(OpenApiDocument document);
+}

src/Refitter.Core/JsonSchemaReferenceComparer.cs

@@ -0,0 +1,15 @@
+using System.Runtime.CompilerServices;
+using NJsonSchema;
+
+namespace Refitter.Core;
+
+internal sealed class JsonSchemaReferenceComparer : IEqualityComparer<JsonSchema>
+{
+    public static JsonSchemaReferenceComparer Instance { get; } = new();
+
+    public bool Equals(JsonSchema? x, JsonSchema? y) =>
+        ReferenceEquals(x, y);
+
+    public int GetHashCode(JsonSchema obj) =>
+        RuntimeHelpers.GetHashCode(obj);
+}

src/Refitter.Core/OneOfDiscriminatorToAllOfMutator.cs

@@ -0,0 +1,48 @@
+using NJsonSchema;
+using NSwag;
+
+namespace Refitter.Core;
+
+internal sealed class OneOfDiscriminatorToAllOfMutator : IOpenApiDocumentMutator
+{
+    public void Mutate(OpenApiDocument document)
+    {
+        if (document.Components?.Schemas == null)
+            return;
+
+        foreach (var kvp in document.Components.Schemas)
+        {
+            var schema = kvp.Value?.ActualSchema;
+            if (schema == null)
+                continue;
+
+            if (schema.DiscriminatorObject == null)
+                continue;
+
+            var unionSchemas = schema.OneOf.Concat(schema.AnyOf).ToArray();
+            if (unionSchemas.Length == 0)
+                continue;
+
+            if (schema.Type == JsonObjectType.None || schema.Type == JsonObjectType.Null)
+                schema.Type = JsonObjectType.Object;
+
+            foreach (var subSchemaRef in unionSchemas)
+            {
+                var subSchema = subSchemaRef?.ActualSchema;
+                if (subSchema == null)
+                    continue;
+
+                bool alreadyInherits = subSchema.AllOf.Any(
+                    a => a.HasReference && a.ActualSchema == schema);
+                if (!alreadyInherits)
+                {
+                    var reference = new JsonSchema { Reference = schema };
+                    subSchema.AllOf.Add(reference);
+                }
+            }
+
+            schema.OneOf.Clear();
+            schema.AnyOf.Clear();
+        }
+    }
+}

src/Refitter.Core/SafeSchemaTypeNameGenerator.cs

@@ -0,0 +1,39 @@
+using NJsonSchema;
+using NJsonSchema.CodeGeneration;
+
+namespace Refitter.Core;
+
+internal sealed class SafeSchemaTypeNameGenerator(
+    HashSet<string> preferredExactTypeNameHints) : ITypeNameGenerator
+{
+    private const string AnonymousTypeName = "Anonymous";
+    private readonly DefaultTypeNameGenerator inner = new();
+
+    public string Generate(
+        JsonSchema schema,
+        string? typeNameHint,
+        IEnumerable<string> reservedTypeNames)
+    {
+        var normalizedHint = IdentifierUtils.NormalizeSchemaTypeNameHint(typeNameHint)
+                          ?? IdentifierUtils.NormalizeSchemaTypeNameHint(schema.Title)
+                          ?? AnonymousTypeName;
+
+        var typeNames = reservedTypeNames as string[] ?? reservedTypeNames.ToArray();
+        if (!string.IsNullOrEmpty(typeNameHint) &&
+            !string.Equals(typeNameHint, normalizedHint, StringComparison.Ordinal) &&
+            preferredExactTypeNameHints.Contains(normalizedHint))
+        {
+            var reservedHints = typeNames
+                .Concat(preferredExactTypeNameHints);
+
+            var reservedHintSet = new HashSet<string>(reservedHints, StringComparer.Ordinal);
+
+            normalizedHint = IdentifierUtils.Counted(reservedHintSet, normalizedHint);
+        }
+
+        var generatedTypeName = inner.Generate(schema, normalizedHint, typeNames);
+        return string.IsNullOrWhiteSpace(generatedTypeName)
+            ? inner.Generate(schema, AnonymousTypeName, typeNames)
+            : generatedTypeName;
+    }
+}

src/Refitter.Core/SchemaWalker.cs

@@ -0,0 +1,161 @@
+using NJsonSchema;
+using NSwag;
+
+namespace Refitter.Core;
+
+internal static class SchemaWalker
+{
+    public static void TraverseDocumentSchemas(
+        OpenApiDocument document,
+        Action<JsonSchema> visitor)
+    {
+        var visited = new HashSet<JsonSchema>(JsonSchemaReferenceComparer.Instance);
+        var schemasToProcess = new Stack<JsonSchema>();
+
+        foreach (var schema in EnumerateDocumentSchemaRoots(document))
+        {
+            TryPush(schema, schemasToProcess);
+        }
+
+        while (schemasToProcess.Count > 0)
+        {
+            var actualSchema = schemasToProcess.Pop().ActualSchema;
+            if (!visited.Add(actualSchema))
+            {
+                continue;
+            }
+
+            visitor(actualSchema);
+
+            foreach (var childSchema in EnumerateTraversableSchemas(actualSchema))
+            {
+                TryPush(childSchema, schemasToProcess);
+            }
+        }
+    }
+
+    public static IEnumerable<JsonSchema?> EnumerateDocumentSchemaRoots(
+        OpenApiDocument document)
+    {
+        if (document.Components?.Schemas != null)
+        {
+            foreach (var schema in document.Components.Schemas.Values)
+            {
+                yield return schema;
+            }
+        }
+
+        if (document.Paths == null)
+        {
+            yield break;
+        }
+
+        foreach (var pathItem in document.Paths.Values)
+        {
+            if (pathItem == null)
+            {
+                continue;
+            }
+
+            foreach (var parameter in pathItem.Parameters)
+            {
+                yield return parameter;
+            }
+
+            foreach (var operation in pathItem.Values)
+            {
+                if (operation == null)
+                {
+                    continue;
+                }
+
+                foreach (var parameter in operation.ActualParameters)
+                {
+                    yield return parameter;
+                }
+
+                if (operation.RequestBody?.Content != null)
+                {
+                    foreach (var content in operation.RequestBody.Content.Values)
+                    {
+                        yield return content.Schema;
+                    }
+                }
+
+                foreach (var response in operation.ActualResponses.Values)
+                {
+                    if (response.Headers != null)
+                    {
+                        foreach (var header in response.Headers.Values)
+                        {
+                            yield return header;
+                        }
+                    }
+
+                    if (response.Content == null)
+                    {
+                        continue;
+                    }
+
+                    foreach (var content in response.Content.Values)
+                    {
+                        yield return content.Schema;
+                    }
+                }
+            }
+        }
+    }
+
+    public static IEnumerable<JsonSchema?> EnumerateTraversableSchemas(JsonSchema schema)
+    {
+        yield return schema.AdditionalItemsSchema;
+        yield return schema.AdditionalPropertiesSchema;
+        yield return schema.DictionaryKey;
+        yield return schema.Item;
+
+        if (schema.Items.Count != 0)
+        {
+            foreach (var item in schema.Items)
+            {
+                yield return item;
+            }
+        }
+
+        yield return schema.Not;
+
+        foreach (var property in schema.Properties.Values)
+        {
+            yield return property;
+        }
+
+        foreach (var subSchema in schema.AllOf)
+        {
+            yield return subSchema;
+        }
+
+        foreach (var subSchema in schema.OneOf)
+        {
+            yield return subSchema;
+        }
+
+        foreach (var subSchema in schema.AnyOf)
+        {
+            yield return subSchema;
+        }
+
+        foreach (var definition in schema.Definitions.Values)
+        {
+            yield return definition;
+        }
+    }
+
+    private static void TryPush(JsonSchema? schema, Stack<JsonSchema> stack)
+    {
+        if (schema == null)
+        {
+            return;
+        }
+
+        stack.Push(schema);
+    }
+}