Added setting UsePolymorphicSerialization

src/Refitter.Core/CSharpClientGeneratorFactory.cs

@@ -1,3 +1,5 @@
+using System.Reflection;
+using NJsonSchema.CodeGeneration;
 using NJsonSchema.CodeGeneration.CSharp;
 
 using NSwag;
@@ -17,30 +19,41 @@
             }
         }
 
+        var csharpClientGeneratorSettings = new CSharpClientGeneratorSettings
+        {
+            GenerateClientClasses = false,
+            GenerateDtoTypes = true,
+            GenerateClientInterfaces = false,
+            GenerateExceptionClasses = false,
+            CodeGeneratorSettings = { PropertyNameGenerator = new CustomCSharpPropertyNameGenerator(), },
+            CSharpGeneratorSettings =
+            {
+                Namespace = settings.ContractsNamespace ?? settings.Namespace,
+                JsonLibrary = CSharpJsonLibrary.SystemTextJson,
+                TypeAccessModifier = settings.TypeAccessibility.ToString().ToLowerInvariant(),
+                ClassStyle =
+                    settings.ImmutableRecords ||
+                    settings.CodeGeneratorSettings?.GenerateNativeRecords is true
+                    ? CSharpClassStyle.Record
+                    : CSharpClassStyle.Poco,
+                GenerateNativeRecords =
+                    settings.ImmutableRecords ||
+                    settings.CodeGeneratorSettings?.GenerateNativeRecords is true,
+            }
+        };
+
+        csharpClientGeneratorSettings.CSharpGeneratorSettings.TemplateFactory = new CustomTemplateFactory(
+            csharpClientGeneratorSettings.CSharpGeneratorSettings,
+            [
+                typeof(CSharpGenerator).Assembly,
+                typeof(CSharpGeneratorBaseSettings).Assembly,
+                typeof(CustomTemplateFactory).Assembly,
+            ]);
+
         var generator = new CustomCSharpClientGenerator(
             document,
-            new CSharpClientGeneratorSettings
-            {
-                GenerateClientClasses = false,
-                GenerateDtoTypes = true,
-                GenerateClientInterfaces = false,
-                GenerateExceptionClasses = false,
-                CodeGeneratorSettings = { PropertyNameGenerator = new CustomCSharpPropertyNameGenerator(), },
-                CSharpGeneratorSettings =
-                {
-                    Namespace = settings.ContractsNamespace ?? settings.Namespace,
-                    JsonLibrary = CSharpJsonLibrary.SystemTextJson,
-                    TypeAccessModifier = settings.TypeAccessibility.ToString().ToLowerInvariant(),
-                    ClassStyle =
-                        settings.ImmutableRecords ||
-                        settings.CodeGeneratorSettings?.GenerateNativeRecords is true
-                        ? CSharpClassStyle.Record
-                        : CSharpClassStyle.Poco,
-                    GenerateNativeRecords =
-                        settings.ImmutableRecords ||
-                        settings.CodeGeneratorSettings?.GenerateNativeRecords is true,
-                }
-            });
+            csharpClientGeneratorSettings,
+            settings.UsePolymorphicSerialization);
 
         MapCSharpGeneratorSettings(
             settings.CodeGeneratorSettings,
@@ -82,4 +95,42 @@
             settingsProperty.SetValue(destination, value);
         }
     }
-}
+
+    /// <summary>
+    /// custom template factory
+    /// solely for the purpose of supporting UsePolymorphicSerialization
+    /// This class and its templates should be removed when NSwag supports this feature.
+    /// </summary>
+    private class CustomTemplateFactory : NSwag.CodeGeneration.DefaultTemplateFactory
+    {
+        /// <summary>Initializes a new instance of the <see cref="DefaultTemplateFactory" /> class.</summary>
+        /// <param name="settings">The settings.</param>
+        /// <param name="assemblies">The assemblies.</param>
+        public CustomTemplateFactory(CodeGeneratorSettingsBase settings, Assembly[] assemblies)
+            : base(settings, assemblies)
+        {
+        }
+
+        /// <summary>Tries to load an embedded Liquid template.</summary>
+        /// <param name="language">The language.</param>
+        /// <param name="template">The template name.</param>
+        /// <returns>The template.</returns>
+        protected override string GetEmbeddedLiquidTemplate(string language, string template)
+        {
+            template = template.TrimEnd('!');
+            var assembly = Assembly.GetExecutingAssembly(); // this code is running in Refitter.Core and Refitter.SourceGenerator
+            var resourceName = $"{assembly.GetName().Name}.Templates.{template}.liquid";
+
+            var resource = assembly.GetManifestResourceStream(resourceName);
+            if (resource != null)
+            {
+                using (var reader = new StreamReader(resource))
+                {
+                    return reader.ReadToEnd();
+                }
+            }
+
+            return base.GetEmbeddedLiquidTemplate(language, template);
+        }
+    }
+}

src/Refitter.Core/CustomCSharpClientGenerator.cs

@@ -1,16 +1,139 @@
+using NJsonSchema;
+using NJsonSchema.CodeGeneration;
+using NJsonSchema.CodeGeneration.CSharp;
+using NJsonSchema.CodeGeneration.CSharp.Models;
 using NSwag;
 using NSwag.CodeGeneration.CSharp;
 using NSwag.CodeGeneration.CSharp.Models;
 
 namespace Refitter.Core;
 
-internal class CustomCSharpClientGenerator : CSharpClientGenerator
+internal class CustomCSharpClientGenerator(OpenApiDocument document, CSharpClientGeneratorSettings settings, bool usePolymorphicSerialization)
+#pragma warning disable CS9107 // Parameter is captured into the state of the enclosing type and its value is also passed to the base constructor. The value might be captured by the base class as well.
+    : CSharpClientGenerator(document, settings)
+#pragma warning restore CS9107 // Parameter is captured into the state of the enclosing type and its value is also passed to the base constructor. The value might be captured by the base class as well.
 {
-    internal CustomCSharpClientGenerator(OpenApiDocument document, CSharpClientGeneratorSettings settings)
-        : base(document, settings)
+    internal CSharpOperationModel CreateOperationModel(OpenApiOperation operation) =>
+        CreateOperationModel(operation, Settings);
+
+    /// <summary>
+    /// override to generate DTO types with our custom CSharpGenerator
+    /// This code should be removed when NSwag supports STJ polymorphic serialization
+    /// </summary>
+    protected override IEnumerable<CodeArtifact> GenerateDtoTypes()
     {
+        var generator = new CCustomSharpGenerator(document, Settings.CSharpGeneratorSettings, (CSharpTypeResolver)Resolver, usePolymorphicSerialization);
+        return generator.GenerateTypes();
     }
 
-    internal CSharpOperationModel CreateOperationModel(OpenApiOperation operation) =>
-        CreateOperationModel(operation, Settings);
+    private class CCustomSharpGenerator(OpenApiDocument document, CSharpGeneratorSettings settings, CSharpTypeResolver resolver, bool usePolymorphicSerialization)
+#pragma warning disable CS9107 // Parameter is captured into the state of the enclosing type and its value is also passed to the base constructor. The value might be captured by the base class as well.
+        : CSharpGenerator(document, settings, resolver)
+#pragma warning restore CS9107 // Parameter is captured into the state of the enclosing type and its value is also passed to the base constructor. The value might be captured by the base class as well.
+    {
+        /// <summary>
+        /// override to generate Class with our custom ClassTemplateModel
+        /// code is taken from NJsonSchema.CodeGeneration.CSharp.CSharpGenerator.GenerateType
+        /// </summary>
+        protected override CodeArtifact GenerateType(JsonSchema schema, string typeNameHint)
+        {
+            var typeName = resolver.GetOrGenerateTypeName(schema, typeNameHint);
+
+            if (schema.IsEnumeration)
+            {
+                return base.GenerateType(schema, typeName);
+            }
+            else
+            {
+                return GenerateClass(schema, typeName);
+            }
+        }
+
+        /// <summary>
+        /// override to generate JsonInheritanceAttribute, JsonInheritanceConverter with our custom template models
+        /// code is taken from NJsonSchema.CodeGeneration.CSharp.CSharpGenerator.GenerateTypes
+        /// </summary>
+        public override IEnumerable<CodeArtifact> GenerateTypes()
+        {
+            var baseArtifacts = base.GenerateTypes();
+            var artifacts = new List<CodeArtifact>();
+
+            if (baseArtifacts.Any(r => r.Code.Contains("JsonInheritanceConverter")))
+            {
+                if (Settings.ExcludedTypeNames?.Contains("JsonInheritanceAttribute") != true)
+                {
+                    var template = Settings.TemplateFactory.CreateTemplate("CSharp", "JsonInheritanceAttribute", new CustomJsonInheritanceConverterTemplateModel(Settings, usePolymorphicSerialization));
+                    artifacts.Add(new CodeArtifact("JsonInheritanceAttribute", CodeArtifactType.Class, CodeArtifactLanguage.CSharp, CodeArtifactCategory.Utility, template));
+                }
+
+                if (Settings.ExcludedTypeNames?.Contains("JsonInheritanceConverter") != true)
+                {
+                    var template = Settings.TemplateFactory.CreateTemplate("CSharp", "JsonInheritanceConverter", new CustomJsonInheritanceConverterTemplateModel(Settings, usePolymorphicSerialization));
+                    artifacts.Add(new CodeArtifact("JsonInheritanceConverter", CodeArtifactType.Class, CodeArtifactLanguage.CSharp, CodeArtifactCategory.Utility, template));
+                }
+            }
+
+            return baseArtifacts.Concat(artifacts);
+        }
+
+        /// <summary>
+        /// Code is taken from NJsonSchema.CodeGeneration.CSharp.CSharpGenerator.GenerateClass
+        /// to instantiate our custom ClassTemplateModel
+        /// </summary>
+        private CodeArtifact GenerateClass(JsonSchema schema, string typeName)
+        {
+            var model = new CustomClassTemplateModel(typeName, Settings, resolver, schema, RootObject, usePolymorphicSerialization);
+
+            RenamePropertyWithSameNameAsClass(typeName, model.Properties);
+
+            var template = Settings.TemplateFactory.CreateTemplate("CSharp", "Class", model);
+            return new CodeArtifact(typeName, model.BaseClassName, CodeArtifactType.Class, CodeArtifactLanguage.CSharp, CodeArtifactCategory.Contract, template);
+        }
+
+        /// <summary>
+        /// Code is taken from NJsonSchema.CodeGeneration.CSharp.CSharpGenerator.RenamePropertyWithSameNameAsClass
+        /// </summary>
+        private static void RenamePropertyWithSameNameAsClass(string typeName, IEnumerable<PropertyModel> properties)
+        {
+            var propertyModels = properties as PropertyModel[] ?? properties.ToArray();
+            PropertyModel? propertyWithSameNameAsClass = null;
+            foreach (var p in propertyModels)
+            {
+                if (p.PropertyName == typeName)
+                {
+                    propertyWithSameNameAsClass = p;
+                    break;
+                }
+            }
+
+            if (propertyWithSameNameAsClass != null)
+            {
+                var number = 1;
+                var candidate = typeName + number;
+                while (propertyModels.Any(p => p.PropertyName == candidate))
+                {
+                    number++;
+                }
+
+                propertyWithSameNameAsClass.PropertyName = propertyWithSameNameAsClass.PropertyName + number;
+            }
+        }
+
+        /// <summary>
+        /// finally, our custom ClassTemplateModel and CustomJsonInheritanceConverterTemplateModel
+        /// to have access to UsePolymorphicSerialization
+        /// This code should be removed when NSwag supports STJ polymorphic serialization
+        /// </summary>
+        private class CustomClassTemplateModel(string typeName, CSharpGeneratorSettings settings, CSharpTypeResolver resolver, JsonSchema schema, object rootObject, bool usePolymorphicSerialization)
+            : ClassTemplateModel(typeName, settings, resolver, schema, rootObject)
+        {
+            public bool UsePolymorphicSerialization => usePolymorphicSerialization;
+        }
+
+        private class CustomJsonInheritanceConverterTemplateModel(CSharpGeneratorSettings settings, bool usePolymorphicSerialization)
+            : JsonInheritanceConverterTemplateModel(settings)
+        {
+            public bool UsePolymorphicSerialization => usePolymorphicSerialization;
+        }
+    }
 }

src/Refitter.Core/Refitter.Core.csproj

@@ -23,4 +23,8 @@
     </AssemblyAttribute>
   </ItemGroup>
 
+  <ItemGroup>
+    <EmbeddedResource Include="Templates/*.liquid" />
+  </ItemGroup>
+
 </Project>

src/Refitter.Core/Settings/RefitGeneratorSettings.cs

@@ -1,4 +1,4 @@
-using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics.CodeAnalysis;
 using System.Text.Json.Serialization;
 
 namespace Refitter.Core;
@@ -216,4 +216,10 @@ public class RefitGeneratorSettings
     /// Dependency Injection is written to a file called DependencyInjection.cs
     /// </summary>
     public bool GenerateMultipleFiles { get; set; }
-}
+
+    /// <summary>
+    /// Set to <c>true</c> to use System.Text.Json polymorphic serialization. Default is <c>false</c>
+    /// Gets a value indicating whether to use System.Text.Json polymorphic serialization
+    /// </summary>
+    public bool UsePolymorphicSerialization { get; set; }
+}