Configure non-nullable types as required

[coder925]

In my project we do not distinguish between required and nullable: false. If a type is non-nullable, it is also required. This is regardless if it is a value type or reference type.

It would be great if one could optionally configure Swashbuckle to set all non-nullable properties to required. E.g. like: setupAction.MarkNonNullableTypesAsRequired(); This way, I could remove all my [Required] annotations on the non-nullable C# properties.

This is a subsequent request following #1686. As originally posted by @felschr in #1686 (comment) , treating non-nullable as required is the default for nullable contexts in .NET validation.

[flibustier7seas]

Temporary solution:

serviceCollection.AddSwaggerGen(builder =>
{
    builder.SupportNonNullableReferenceTypes();
    builder.SchemaFilter<RequiredNotNullableSchemaFilter>();

    ...
});

class RequiredNotNullableSchemaFilter : ISchemaFilter {
    public void Apply(OpenApiSchema schema, SchemaFilterContext context) {
        if (schema.Properties == null) {
            return;
        }

        var notNullableProperties = schema
            .Properties
            .Where(x => !x.Value.Nullable  && !schema.Required.Contains(x.Key))
            .ToList();

        foreach (var property in notNullableProperties)
        {
            schema.Required.Add(property.Key);
        }
    }
}

UPD: This solution is not completely correct, see example:

public class User
{
    public Guid Id { get; set; }
    public Guid? OrganizationId { get; set; }
    public string FirstName { get; set; } = default!;
    public string? MiddleName { get; set; }
    public string LastName { get; set; } = default!;

    public UserEmail Email { get; set; } = default!;
    public UserPhone? Phone { get; set; }
}

public class UserEmail
{
    public string Address { get; set; } = default!;
}

public class UserPhone
{
    public string Number { get; set; } = default!;
}

{
      "User": {
        "required": [
          "email",
          "firstName",
          "id",
          "lastName",
          "phone" // Incorrect
        ],
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "format": "uuid"
          },
          "organizationId": {
            "type": "string",
            "format": "uuid",
            "nullable": true
          },
          "firstName": {
            "type": "string"
          },
          "middleName": {
            "type": "string",
            "nullable": true
          },
          "lastName": {
            "type": "string"
          },
          "email": {
            "$ref": "#/components/schemas/UserEmail"
          },
          "phone": {
            "$ref": "#/components/schemas/UserPhone"
          }
        },
        "additionalProperties": false
      }

[JosNun]

@flibustier7seas you mention that your solution isn't completely correct, and I see you mention the phone field being marked as required, even though it's not. Do you know what in particular causes this case, or if there's any workarounds?

[flibustier7seas]

@JosNun I'm using the following workaround:

class RequiredNotNullableSchemaFilter : ISchemaFilter
{
    public void Apply(OpenApiSchema schema, SchemaFilterContext context)
    {
        if (schema.Properties == null)
        {
            return;
        }

        FixNullableProperties(schema, context);

        var notNullableProperties = schema
            .Properties
            .Where(x => !x.Value.Nullable && !schema.Required.Contains(x.Key))
            .ToList();

        foreach (var property in notNullableProperties)
        {
            schema.Required.Add(property.Key);
        }
    }

    /// <summary>
    /// Option "SupportNonNullableReferenceTypes" not working with complex types ({ "type": "object" }), 
    /// so they always have "Nullable = false",
    /// see method "SchemaGenerator.GenerateSchemaForMember"
    /// </summary>
    private static void FixNullableProperties(OpenApiSchema schema, SchemaFilterContext context)
    {
        foreach (var property in schema.Properties)
        {
            if (property.Value.Reference != null)
            {
                var field = context.Type
                    .GetMembers(BindingFlags.Public | BindingFlags.Instance)
                    .FirstOrDefault(x =>
                        string.Equals(x.Name, property.Key, StringComparison.InvariantCultureIgnoreCase));

                if (field != null)
                {
                    var fieldType = field switch
                    {
                        FieldInfo fieldInfo => fieldInfo.FieldType,
                        PropertyInfo propertyInfo => propertyInfo.PropertyType,
                        _ => throw new NotSupportedException(),
                    };

                    property.Value.Nullable = fieldType.IsValueType
                        ? Nullable.GetUnderlyingType(fieldType) != null
                        : !field.IsNonNullableReferenceType();
                }
            }
        }
    }    
}

Result:

{
  "User": {
    "required": ["email", "firstName", "id", "lastName"],
    "type": "object",
    "properties": {
      "id": {
        "type": "string",
        "format": "uuid"
      },
      "organizationId": {
        "type": "string",
        "format": "uuid",
        "nullable": true
      },
      "firstName": {
        "type": "string"
      },
      "middleName": {
        "type": "string",
        "nullable": true
      },
      "lastName": {
        "type": "string"
      },
      "email": {
        "$ref": "#/components/schemas/UserEmail"
      },
      "phone": {
        "$ref": "#/components/schemas/UserPhone"
      }
    },
    "additionalProperties": false
  }
}

[ahmednfwela]

small modification on @flibustier7seas 's answer

var notNullableProperties = schema
      .Properties
      .Where(x => !x.Value.Nullable && x.Value.Default == default && !schema.Required.Contains(x.Key))
      .ToList();

[brather1ng]

If you use the SwaggerGenOptions.UseAllOfToExtendReferenceSchemas() extension method, the FixNullableProperties workaround of @flibustier7seas is not necessary. With that, references are wrapped in an allOf and SupportNonNullableReferenceTypes also applies to them.

[niemyjski]

I would love to see this work out of the box

[sebasptsch]

+1 For this feature

[mladenkn]

Thx @flibustier7seas, that works for me!
But I had to remove if (property.Value.Reference != null).

[Rookian]

If you use the SwaggerGenOptions.UseAllOfToExtendReferenceSchemas() extension method, the FixNullableProperties workaround of @flibustier7seas is not necessary. With that, references are wrapped in an allOf and SupportNonNullableReferenceTypes also applies to them.

This won't work for string type or e.g. DateTimeOffset.

[josundt]

With C# 11.0/.NET 7.0, the required keyword is being introduced for properties.
Properties with this keyword needs to be initialized through the object initializer when the class/struct/record is initialized from code.

But required properties also affects the behavior of System.Text.Json 7.x deserialization and thereby aspnetcore model validation.

The default behavior for System.Text.Json deserialization / aspnetcore model validation in .NET 7.0 is as follows.

Nullable/not required properties:

• Property CAN be null, and property CAN be omitted from JSON payload.

Nullable/required properties:

• Property CAN be null, but property CAN NOT be omitted from JSON payload.

Not nullable/not required properties:

• Property CAN NOT be null, but property CAN be omitted from JSON payload (since it implies null).

Not nullable/required properties:

• Property CAN NOT be null, and property CAN NOT be omitted from JSON payload.

Since nullablility and required/not are different things where one does not necessarily imply the other, I think SwasBuckle should use the C# property nullability for swagger property nullable, and C# property required/not for the swagger property required.

If the C# property is annotated with RequiredAttribute, I think this should override the above, and set both swagger nullable/required to true.

References:

• What’s new in System.Text.Json in .NET 7 - Required Members
• .NET Required Properties

[JohnGalt1717]

With C# 11.0/.NET 7.0, the required keyword is being introduced for properties. Properties with this keyword needs to be initialized through the object initializer when the class/struct/record is initialized from code.

But required properties also affects the behavior of System.Text.Json 7.x deserialization and thereby aspnetcore model validation.

The default behavior for System.Text.Json deserialization / aspnetcore model validation in .NET 7.0 is as follows.

Nullable/not required properties:

• Property CAN be null, and property CAN be omitted from JSON payload.

Nullable/required properties:

• Property CAN be null, but property CAN NOT be omitted from JSON payload.

Not nullable/not required properties:

• Property CAN NOT be null, but property CAN NOT be omitted from JSON payload (since it implies null).

Not nullable/required properties:

• Property CAN NOT be null, and property CAN NOT be omitted from JSON payload.

Since nullablility and required/not are different things where one does not necessarily imply the other, I think SwasBuckle should use the C# property nullability for swagger property nullable, and C# property required/not for the swagger property required.

If the C# property is annotated with RequiredAttribute, I think this should override the above, and set both swagger nullable/required to true.

References:

• What’s new in System.Text.Json in .NET 7 - Required Members
• .NET Required Properties

... And if C# 11's required modifier is specified it should also set required regardless of if it's a string or not.