Options and Swagger

[speterson-zoll]

When I use Option<string> on a DTO, Swagger interprets the properties as arrays:

{
  "property1": [
    "string"
  ],
  "property2": [
    "string"
  ]
}

instead of

{
  "property1":  "string",
  "property2": "string"
}

If I use the second JSON, my API works just fine.

What I'm unclear about is where I need to deal with this. Is there something I need to do in my LanguageExt code or is this strictly a Swagger issue?

[StefanBertels]

IMO:

Default JSON serialization of Option and other types is a bit different to what you might expect. This is true for dictionary types, too.
I built my own custom serializer (for System.Text.Json) to make LanguageExt types more "compatible", i.e. serialize Option<string> in the same way as string?.

But this has some drawbacks and if you have a strict view on those things it is even better to serialize Option like an array because it is equivalent to an array that can have size 0 and size 1. So it depends who is consuming your API and how compatible you want/have to be.

[StefanBertels]

Consume needs to consume a token, not just check. Use Read() before checking.

The attribute should work this way to get the non-array format. I use this in combination with [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)].

If this does not work, let me know. I hope I can back to this on Monday.

[speterson-zoll]

Thanks again. I'm not that familiar with JS?ON readers, so I don't think I have the Consume method quite right.

Also, the addition of the [JsonIgnore] attribute did not alter the 422 error I received above.

[StefanBertels]

Sorry, there was a bug in this converter (for array style) regarding (my) Consume method. Here are some tests and an updated converted. (I don't know what is wrong in your setup, you should write a unit test or compare with my test methods.)

Tests:

public class SomeTypeWithOptions
{
    public Option<int> MaybeIntPropArray { get; set; }
    
    [OptionAsNullableJsonConverter]
    public Option<int> MaybeIntPropNullable { get; set; }

    [OptionAsNullableJsonConverter]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]
    public Option<int> MaybeIntPropNullableIgnore { get; set; }

}

[Fact]
void OptionTest1()
{
    var json = @"{ ""MaybeIntPropArray"": [4], ""MaybeIntPropNullable"": 5, ""MaybeIntPropNullableIgnore"": 6 }";

    var options = new JsonSerializerOptions(JsonSerializerDefaults.Web);
    options.Converters.Add(new OptionJsonConverterFactory());

    var result = JsonSerializer.Deserialize<SomeTypeWithOptions>(json, options);

    Assert.Equal(4, result!.MaybeIntPropArray);
    Assert.Equal(5, result!.MaybeIntPropNullable);
    Assert.Equal(6, result!.MaybeIntPropNullableIgnore);
}

[Fact]
void OptionTest2()
{
    var json = @"{}";

    var options = new JsonSerializerOptions(JsonSerializerDefaults.Web);
    options.Converters.Add(new OptionJsonConverterFactory());

    var result = JsonSerializer.Deserialize<SomeTypeWithOptions>(json, options);

    Assert.Equal(None, result!.MaybeIntPropArray);
    Assert.Equal(None, result!.MaybeIntPropNullable);
    Assert.Equal(None, result!.MaybeIntPropNullableIgnore);
}


[Fact]
void OptionTest3()
{
    var data = new SomeTypeWithOptions
    {
        MaybeIntPropArray =1,
        MaybeIntPropNullable = 2,
        MaybeIntPropNullableIgnore = 3
    };
    
    var options = new JsonSerializerOptions(JsonSerializerDefaults.General);
    options.Converters.Add(new OptionJsonConverterFactory());

    var json = JsonSerializer.Serialize(data, options);

    Assert.Equal(@"{""MaybeIntPropArray"":[1],""MaybeIntPropNullable"":2,""MaybeIntPropNullableIgnore"":3}", json);
}

[Fact]
void OptionTest4()
{
    var data = new SomeTypeWithOptions(); // all none
    var options = new JsonSerializerOptions(JsonSerializerDefaults.General);
    options.Converters.Add(new OptionJsonConverterFactory());

    var json = JsonSerializer.Serialize(data, options);

    Assert.Equal(@"{""MaybeIntPropArray"":[],""MaybeIntPropNullable"":null}", json);
}

Code:

/// <summary>
/// serialize Option&lt;T&gt; like T? 
/// </summary>
/// <remarks>Add [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)] to the property to disable writing 'null' for None into json</remarks>
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
public class OptionAsNullableJsonConverterAttribute : JsonConverterAttribute
{
    public override JsonConverter? CreateConverter(Type typeToConvert) => 
        Activator.CreateInstance(typeof(OptionJsonConverterFactory.OptionAsNullableJsonConverter<>).MakeGenericType(typeToConvert.IsGenericType(typeof(Option<>)) ? typeToConvert.GetGenericArguments().Head() : typeToConvert)) as JsonConverter;
}

internal class OptionJsonConverterFactory : JsonConverterFactory
{
    public override JsonConverter? CreateConverter(Type typeToConvert, JsonSerializerOptions options)
    {
        // var innerType = typeToConvert.GetSingleGenericTypeArgument();
        var innerType = typeToConvert.GetGenericArguments().Match(
            () => throw new Exception("no generic type argument"),
            x => x,
            (x, xs) => throw new Exception("more than one generic type argument")
        );
        return Activator.CreateInstance(typeof(OptionJsonConverter<>).MakeGenericType(innerType), options) as JsonConverter;
    }

    public override bool CanConvert(Type typeToConvert) => typeToConvert.IsGenericType(typeof(Option<>));

    private class OptionJsonConverter<T> : JsonConverter<Option<T>>
    {
        private readonly JsonConverter<T> _innerConverter;

        public OptionJsonConverter(JsonSerializerOptions options) => _innerConverter = (JsonConverter<T>) options.GetConverter(typeof(T));

        public override Option<T> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            if (reader.TokenType == JsonTokenType.Null)
            {
                return None;
            }
            else
            {
                if (reader.TokenType != JsonTokenType.StartArray)
                {
                    throw new JsonException($"expected {JsonTokenType.StartArray} but found {reader.TokenType}");
                }
                if (!reader.Read())
                {
                    throw new JsonException($"could not read element in array or {JsonTokenType.EndArray}");
                }
                if (reader.TokenType != JsonTokenType.EndArray)
                {
                    // non-empty-array
                    var value = _innerConverter.Read(ref reader, typeof(T), options);
                    if (!reader.Read())
                    {
                        throw new JsonException("could not read next token");
                    }
                    if (reader.TokenType != JsonTokenType.EndArray)
                    {
                        throw new JsonException($"expected token {JsonTokenType.EndArray} but found {reader.TokenType}");
                    }
                    return Option<T>.Some(value!);
                }
                else
                {
                    return Option<T>.None;
                }
            }
        }

        public override void Write(Utf8JsonWriter writer, Option<T> value, JsonSerializerOptions options)
        {
            writer.WriteStartArray();
            value.IfSome(some => _innerConverter.Write(writer, some, options));
            writer.WriteEndArray();
        }
    }

    internal class OptionAsNullableJsonConverter<T> : JsonConverter<Option<T>>
    {
        public override Option<T> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) =>
                reader.TokenType == JsonTokenType.Null ? None : Some((options.GetConverter(typeof(T?)) as JsonConverter<T> ?? throw new JsonException($"Could not get converter for {typeof(T)}")).Read(ref reader, typeof(T), options)!);

        public override void Write(Utf8JsonWriter writer, Option<T> value, JsonSerializerOptions options)
        {
            if (value.Case is T some)
            {
                ((JsonConverter<T>) options.GetConverter(typeof(T))).Write(writer, some, options);
            }
            else
            {
                writer.WriteNullValue();
            }
        }
    }
}

Helper extension method

internal static bool IsGenericType(this Type t, Type genericTypeDefinition) => t.IsGenericType && t.GetGenericTypeDefinition() == genericTypeDefinition;

[speterson-zoll]

Thank you! Your updated code works well in terms of the unit tests passing. However, something may be amiss in my Startup.cs in ASP.NET which is setup like so:

            services.AddControllers().AddJsonOptions(x =>
            {
                x.JsonSerializerOptions.Converters.Add(new OptionJsonConverterFactory());
            });

I still get the same 422 error I received before whenever a property has the [OptionAsNullableJsonConverter] attribute on it. Any thoughts about how this needs to be configured in Startup? Debugging has not given me a definite path to follow.

[StefanBertels]

I tried this class in one of my Web apis (ASP.NET core) and it workes fine for me -- both as a parameter ([FromBody]) and as return type.

    public class EchoData
    {
        [OptionAsNullableJsonConverter]
        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]
        public Option<string> MaybeString { get; set; }
    }

I suggest you check your serialization (what is sent to the server) and which JsonSerializerOptions you are using (your settings code above looks ok to me).