[Swashbuckle] Non-null reference types and types with IDisallowDefaultValue are flagged as required.

Author: PawelGerr

Directory.Build.props

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <Copyright>(c) $([System.DateTime]::Now.Year), Pawel Gerr. All rights reserved.</Copyright>
-    <VersionPrefix>8.8.0</VersionPrefix>
+    <VersionPrefix>8.8.1</VersionPrefix>
     <Authors>Pawel Gerr</Authors>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <PackageProjectUrl>https://github.com/PawelGerr/Thinktecture.Runtime.Extensions</PackageProjectUrl>

README.md

@@ -72,7 +72,7 @@ Unlike regular C# enums which are limited to numeric values and lack extensibili
 * Include additional fields, properties and behavior
 * Use polymorphism to define custom behavior for each value
 * Prevent creation of invalid values
-* Integrate seamlessly with JSON serializers, MessagePack, Entity Framework Core and ASP.NET Core
+* Integrate seamlessly with JSON serializers, MessagePack, Entity Framework Core, ASP.NET Core and Swashbuckle (OpenAPI)
 
 Install: `Install-Package Thinktecture.Runtime.Extensions`
 
@@ -345,6 +345,7 @@ Key Features:
     * JSON serialization (System.Text.Json and Newtonsoft.Json)
     * Entity Framework Core support
     * ASP.NET Core Model Binding
+    * Swashbuckle (OpenAPI)
     * MessagePack serialization
 * Rich feature set:
     * Type conversion and comparison operators

docs

@@ -1,3 +1,4 @@
+using System.Reflection;
 using Microsoft.OpenApi.Models;
 using Swashbuckle.AspNetCore.SwaggerGen;
 using Thinktecture.Internal;
@@ -12,6 +13,19 @@ namespace Thinktecture.Swashbuckle.Internal.ComplexValueObjects;
 /// </summary>
 public class ComplexValueObjectSchemaFilter : IInternalComplexValueObjectSchemaFilter
 {
+   private readonly IRequiredMemberEvaluator _requiredMemberEvaluator;
+
+   /// <summary>
+   /// This is an internal API that supports the Thinktecture.Runtime.Extensions infrastructure and not subject to
+   /// the same compatibility standards as public APIs. It may be changed or removed without notice in
+   /// any release. You should only use it directly in your code with extreme caution and knowing that
+   /// doing so can result in application failures when updating to a new Thinktecture.Runtime.Extensions release.
+   /// </summary>
+   public ComplexValueObjectSchemaFilter(IRequiredMemberEvaluator requiredMemberEvaluator)
+   {
+      _requiredMemberEvaluator = requiredMemberEvaluator;
+   }
+
    /// <inheritdoc />
    public void Apply(OpenApiSchema schema, SchemaFilterContext context)
    {
@@ -24,6 +38,12 @@ public void Apply(OpenApiSchema schema, SchemaFilterContext context)
    /// <inheritdoc />
    public void Apply(OpenApiSchema schema, SchemaFilterContext context, Metadata.ComplexValueObject metadata)
    {
+      foreach (var memberInfo in metadata.AssignableMembers)
+      {
+         if (_requiredMemberEvaluator.IsRequired(schema, context, memberInfo))
+            schema.Required.Add(memberInfo.Name);
+      }
+
       // Otherwise the type gets: "additionalProperties": false
       schema.AdditionalPropertiesAllowed = true;
       schema.AdditionalProperties = null;

src/Thinktecture.Runtime.Extensions.Swashbuckle/Swashbuckle/Internal/ComplexValueObjects/KeyedValueObjectSchemaFilter.cs renamed to src/Thinktecture.Runtime.Extensions.Swashbuckle/Swashbuckle/Internal/ComplexValueObjects/ComplexValueObjectSchemaFilter.cs

@@ -0,0 +1,37 @@
+using System.Reflection;
+using Microsoft.OpenApi.Models;
+using Swashbuckle.AspNetCore.SwaggerGen;
+
+namespace Thinktecture.Swashbuckle.Internal.ComplexValueObjects;
+
+/// <summary>
+/// This is an internal API that supports the Thinktecture.Runtime.Extensions infrastructure and not subject to
+/// the same compatibility standards as public APIs. It may be changed or removed without notice in
+/// any release. You should only use it directly in your code with extreme caution and knowing that
+/// doing so can result in application failures when updating to a new Thinktecture.Runtime.Extensions release.
+/// </summary>
+public class DefaultRequiredMemberEvaluator : IRequiredMemberEvaluator
+{
+   private readonly NullabilityInfoContext _nullabilityInfoContext = new();
+
+   /// <inheritdoc />
+   public bool IsRequired(OpenApiSchema schema, SchemaFilterContext context, MemberInfo member)
+   {
+      var (type, nullabilityInfo) = member switch
+      {
+         PropertyInfo propertyInfo => (propertyInfo.PropertyType, _nullabilityInfoContext.Create(propertyInfo)),
+         FieldInfo fieldInfo => (fieldInfo.FieldType, _nullabilityInfoContext.Create(fieldInfo)),
+         _ => throw new ArgumentException($"Assignable member of a complex value object must be a field or a property but found '{member.GetType().FullName}'.", nameof(member))
+      };
+
+      if (typeof(IDisallowDefaultValue).IsAssignableFrom(type))
+         return true;
+
+      // Use "ReadState" instead of "WriteState" because the members are read-only
+      if (type.IsClass && nullabilityInfo.ReadState == NullabilityState.NotNull)
+         return true;
+
+      // Is struct, nullable struct or nullable reference type
+      return false;
+   }
+}

src/Thinktecture.Runtime.Extensions.Swashbuckle/Swashbuckle/Internal/ComplexValueObjects/DefaultRequiredMemberEvaluator.cs

@@ -0,0 +1,22 @@
+using System.Reflection;
+using Microsoft.OpenApi.Models;
+using Swashbuckle.AspNetCore.SwaggerGen;
+
+namespace Thinktecture.Swashbuckle.Internal.ComplexValueObjects;
+
+/// <summary>
+/// This is an internal API that supports the Thinktecture.Runtime.Extensions infrastructure and not subject to
+/// the same compatibility standards as public APIs. It may be changed or removed without notice in
+/// any release. You should only use it directly in your code with extreme caution and knowing that
+/// doing so can result in application failures when updating to a new Thinktecture.Runtime.Extensions release.
+/// </summary>
+public interface IRequiredMemberEvaluator
+{
+   /// <summary>
+   /// This is an internal API that supports the Thinktecture.Runtime.Extensions infrastructure and not subject to
+   /// the same compatibility standards as public APIs. It may be changed or removed without notice in
+   /// any release. You should only use it directly in your code with extreme caution and knowing that
+   /// doing so can result in application failures when updating to a new Thinktecture.Runtime.Extensions release.
+   /// </summary>
+   bool IsRequired(OpenApiSchema schema, SchemaFilterContext context, MemberInfo member);
+}

src/Thinktecture.Runtime.Extensions.Swashbuckle/Swashbuckle/Internal/ComplexValueObjects/IInternalKeyedValueObjectSchemaFilter.cs renamed to src/Thinktecture.Runtime.Extensions.Swashbuckle/Swashbuckle/Internal/ComplexValueObjects/IInternalComplexValueObjectSchemaFilter.cs

@@ -23,23 +23,23 @@ public void Apply(
 
       metadata?.Switch(
          (Filter: this, parameter, context),
-         keyedSmartEnum: static (state, smartEnumMetadata) => state.Filter.Apply(state.parameter, state.context, smartEnumMetadata),
-         keyedValueObject: static (state, keyedValueObjectMetadata) => state.Filter.Apply(state.parameter, state.context, keyedValueObjectMetadata),
-         complexValueObject: static (state, complexValueObjectMetadata) => state.Filter.Apply(state.parameter, state.context, complexValueObjectMetadata),
-         adHocUnion: static (state, adHocUnionMetadata) => state.Filter.Apply(state.parameter, state.context, adHocUnionMetadata));
+         keyedSmartEnum: static (state, smartEnumMetadata) => Apply(state.parameter, state.context, smartEnumMetadata),
+         keyedValueObject: static (state, keyedValueObjectMetadata) => Apply(state.parameter, state.context, keyedValueObjectMetadata),
+         complexValueObject: static (state, complexValueObjectMetadata) => Apply(state.parameter, state.context, complexValueObjectMetadata),
+         adHocUnion: static (state, adHocUnionMetadata) => Apply(state.parameter, state.context, adHocUnionMetadata));
    }
 
-   private void Apply(OpenApiParameter parameter, ParameterFilterContext context, Metadata.Keyed.SmartEnum metadata)
+   private static void Apply(OpenApiParameter parameter, ParameterFilterContext context, Metadata.Keyed.SmartEnum metadata)
    {
       parameter.Schema = context.SchemaGenerator.GenerateSchema(metadata.Type, context.SchemaRepository);
    }
 
-   private void Apply(OpenApiParameter parameter, ParameterFilterContext context, Metadata.Keyed.ValueObject metadata)
+   private static void Apply(OpenApiParameter parameter, ParameterFilterContext context, Metadata.Keyed.ValueObject metadata)
    {
       parameter.Schema = context.SchemaGenerator.GenerateSchema(metadata.Type, context.SchemaRepository);
    }
 
-   private void Apply(OpenApiParameter parameter, ParameterFilterContext context, Metadata.ComplexValueObject metadata)
+   private static void Apply(OpenApiParameter parameter, ParameterFilterContext context, Metadata.ComplexValueObject metadata)
    {
       // IParsable
       if (typeof(IObjectFactory<string>).IsAssignableFrom(metadata.Type))
@@ -48,7 +48,7 @@ private void Apply(OpenApiParameter parameter, ParameterFilterContext context, M
       }
    }
 
-   private void Apply(OpenApiParameter parameter, ParameterFilterContext context, Metadata.AdHocUnion metadata)
+   private static void Apply(OpenApiParameter parameter, ParameterFilterContext context, Metadata.AdHocUnion metadata)
    {
       // IParsable
       if (typeof(IObjectFactory<string>).IsAssignableFrom(metadata.Type))

src/Thinktecture.Runtime.Extensions.Swashbuckle/Swashbuckle/Internal/ComplexValueObjects/IRequiredMemberEvaluator.cs

@@ -25,14 +25,15 @@ public static IServiceCollection AddThinktectureOpenApiFilters(
       Action<ThinktectureSchemaFilterOptions>? configureOptions = null)
    {
       services.TryAddSingleton<IOpenApiValueFactoryProvider, JsonSerializerOpenApiValueFactoryProvider>();
+      services.TryAddSingleton<IKeyedValueObjectSchemaFilter, KeyedValueObjectSchemaFilter>();
+      services.TryAddSingleton<IComplexValueObjectSchemaFilter, ComplexValueObjectSchemaFilter>();
+      services.TryAddSingleton<IRequiredMemberEvaluator, DefaultRequiredMemberEvaluator>();
+      services.TryAddSingleton<IAdHocUnionSchemaFilter, AdHocUnionSchemaFilter>();
+      services.TryAddSingleton<ISmartEnumSchemaFilter, DefaultSmartEnumSchemaFilter>();
+      services.TryAddSingleton<ISmartEnumSchemaExtension, NoSmartEnumSchemaExtension>();
 
       services
          .AddSingleton<JsonSerializerOptionsResolver>()
-         .AddSingleton<ISmartEnumSchemaFilter, DefaultSmartEnumSchemaFilter>()
-         .AddSingleton<IKeyedValueObjectSchemaFilter, KeyedValueObjectSchemaFilter>()
-         .AddSingleton<IComplexValueObjectSchemaFilter, ComplexValueObjectSchemaFilter>()
-         .AddSingleton<IAdHocUnionSchemaFilter, AdHocUnionSchemaFilter>()
-         .AddSingleton<ISmartEnumSchemaExtension, NoSmartEnumSchemaExtension>()
          .Configure<ThinktectureSchemaFilterOptions>(options => configureOptions?.Invoke(options))
          .AddOptions<SwaggerGenOptions>()
          .Configure((SwaggerGenOptions options,

src/Thinktecture.Runtime.Extensions.Swashbuckle/Swashbuckle/Internal/ThinktectureParameterFilter.cs

@@ -69,6 +69,26 @@ public class Nullable : ControllerBase
             }
          }
 
+         [Route("/")]
+         public class BodyWithRequiredProperties : ControllerBase
+         {
+            [HttpPost("/test")]
+            public ValueObjectWithRequiredProperties Get([FromBody] ValueObjectWithRequiredProperties value)
+            {
+               return value;
+            }
+
+            [Route("/")]
+            public class Nullable : ControllerBase
+            {
+               [HttpPost("/test")]
+               public ValueObjectWithRequiredProperties? Get([FromBody] ValueObjectWithRequiredProperties? value = null)
+               {
+                  return value;
+               }
+            }
+         }
+
          [Route("/")]
          public class Form : ControllerBase
          {