Support Optional covariance and pattern matching

Directory.Build.props

@@ -30,15 +30,15 @@
 		<ExtensionsConfigurationYamlVersion>0.2.0</ExtensionsConfigurationYamlVersion>
 		<OpenApiSpecificationsv3_0Version>0.2.0</OpenApiSpecificationsv3_0Version>
 		<OpenApiAbstractionsVersion>0.3.0</OpenApiAbstractionsVersion>
-		<OpenApiJsonExtensionsVersion>0.17.1</OpenApiJsonExtensionsVersion>
+		<OpenApiJsonExtensionsVersion>0.18.0</OpenApiJsonExtensionsVersion>
 		<OpenApiLoadersVersion>0.2.0</OpenApiLoadersVersion>
-		<OpenApiCSharpVersion>0.24.0</OpenApiCSharpVersion>
+		<OpenApiCSharpVersion>0.25.0</OpenApiCSharpVersion>
 		<OpenApiTypeScriptClientVersion>0.12.1</OpenApiTypeScriptClientVersion>
 		<OpenApiTypeScriptRxjsClientVersion>0.9.0</OpenApiTypeScriptRxjsClientVersion>
 		<OpenApiTypeScriptMswVersion>0.9.0</OpenApiTypeScriptMswVersion>
 		<OpenApiTypeScriptFetchVersion>0.9.0</OpenApiTypeScriptFetchVersion>
 		<!-- Should be incremented anytime one of the internal libraries changes -->
-		<SharedAnalyzerLibrariesVersion>0.9.0</SharedAnalyzerLibrariesVersion>
+		<SharedAnalyzerLibrariesVersion>0.10.0</SharedAnalyzerLibrariesVersion>
 	</PropertyGroup>
 
 	<Import Project="Directory.Build.local.props" Condition="exists('$(MSBuildThisFileDirectory)Directory.Build.local.props')" />

generators/csharp/OpenApiCodegen.CSharp.Base/Client/Templates/client.handlebars

@@ -19,14 +19,14 @@ namespace {{PackageName}}
         /// <param name="{{ParamName}}">{{Description}}</param>{{/each}}
         public static async global::System.Threading.Tasks.Task<{{Operation.Name}}ReturnType> {{Operation.Name}}(
             this global::System.Net.Http.HttpMessageInvoker client,
-            {{#each RequestBody.AllParams}}{{#unless Required}}global::DarkPatterns.OpenApiCodegen.Json.Extensions.Optional<{{/unless}}{{{DataType}}}{{#unless Required}}>?{{/unless}} {{ParamName}},
+            {{#each RequestBody.AllParams}}{{#unless Required}}global::DarkPatterns.OpenApiCodegen.Json.Extensions.IOptional<{{/unless}}{{{DataType}}}{{#unless Required}}>?{{/unless}} {{ParamName}},
             {{/each}}
             global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)
         ) => await (await client.SendAsync({{Operation.Name}}({{#each RequestBody.AllParams}}{{ParamName}}{{#unless @last}},{{/unless}}{{/each}}), cancellationToken).ConfigureAwait(false))
             .Parse{{Operation.Name}}().ConfigureAwait(false);
 
         public static global::System.Net.Http.HttpRequestMessage {{Operation.Name}}(
-            {{#each RequestBody.AllParams}}{{#unless Required}}global::DarkPatterns.OpenApiCodegen.Json.Extensions.Optional<{{/unless}}{{{DataType}}}{{#unless Required}}>?{{/unless}} {{ParamName}}{{#unless @last}},{{/unless}}
+            {{#each RequestBody.AllParams}}{{#unless Required}}global::DarkPatterns.OpenApiCodegen.Json.Extensions.IOptional<{{/unless}}{{{DataType}}}{{#unless Required}}>?{{/unless}} {{ParamName}}{{#unless @last}},{{/unless}}
             {{/each}})
         {
 {{#if RequestBody.HasQueryParam}}

generators/csharp/OpenApiCodegen.CSharp.Base/MvcServer/Templates/controller.handlebars

@@ -57,7 +57,7 @@ namespace {{PackageName}}
             }}{{#if HasMaxLength}}, global::System.ComponentModel.DataAnnotations.MaxLength({{MaxLength}}){{/if}}{{!
             }}{{#if HasMinimum}}{{#if HasMaximum}}, global::System.ComponentModel.DataAnnotations.Range({{Minimum}}, {{Maximum}}){{/if}}{{/if}}{{!
             }}] {{#unless Optional}}{{{DataType}}}{{else
-            }}global::DarkPatterns.OpenApiCodegen.Json.Extensions.Optional<{{{DataType}}}>{{/unless}} {{ParamName}}{{#unless @last}},
+            }}global::DarkPatterns.OpenApiCodegen.Json.Extensions.IOptional<{{{DataType}}}>{{/unless}} {{ParamName}}{{#unless @last}},
             {{/unless}}{{/unless}}{{/each}}
         ) => (await {{RequestBody.Name}}({{#each RequestBody.AllParams}}{{ParamName}}{{#unless @last}},{{/unless}}{{/each}})).ActionResult;
         {{!--
@@ -69,7 +69,7 @@ namespace {{PackageName}}
 
         protected abstract global::System.Threading.Tasks.Task<{{Operation.Name}}ActionResult> {{RequestBody.Name}}({{#each RequestBody.AllParams}}
             {{#unless Optional}}{{{DataType}}}{{else
-            }}global::DarkPatterns.OpenApiCodegen.Json.Extensions.Optional<{{{DataType}}}>{{/unless}} {{ParamName}}{{#unless @last}}, {{/unless}}{{/each}});
+            }}global::DarkPatterns.OpenApiCodegen.Json.Extensions.IOptional<{{{DataType}}}>{{/unless}} {{ParamName}}{{#unless @last}}, {{/unless}}{{/each}});
         {{/each}}
 
         public readonly struct {{Name}}ActionResult

generators/csharp/OpenApiCodegen.CSharp.Base/WebhookClient/Templates/webhooks.handlebars

@@ -20,15 +20,15 @@ namespace {{PackageName}}
         public static async global::System.Threading.Tasks.Task<{{Operation.Name}}ReturnType> {{Operation.Name}}(
             this global::System.Net.Http.HttpMessageInvoker client,
             global::System.Uri uri,
-            {{#each RequestBody.AllParams}}{{#unless Required}}global::DarkPatterns.OpenApiCodegen.Json.Extensions.Optional<{{/unless}}{{{DataType}}}{{#unless Required}}>?{{/unless}} {{ParamName}},
+            {{#each RequestBody.AllParams}}{{#unless Required}}global::DarkPatterns.OpenApiCodegen.Json.Extensions.IOptional<{{/unless}}{{{DataType}}}{{#unless Required}}>?{{/unless}} {{ParamName}},
             {{/each}}
             global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)
         ) => await (await client.SendAsync({{Operation.Name}}(uri{{#each RequestBody.AllParams}}, {{ParamName}}{{/each}}), cancellationToken).ConfigureAwait(false))
             .Parse{{Operation.Name}}().ConfigureAwait(false);
 
         public static global::System.Net.Http.HttpRequestMessage {{Operation.Name}}(
             global::System.Uri uri
-            {{#each RequestBody.AllParams}}, {{#unless Required}}global::DarkPatterns.OpenApiCodegen.Json.Extensions.Optional<{{/unless}}{{{DataType}}}{{#unless Required}}>?{{/unless}} {{ParamName}}
+            {{#each RequestBody.AllParams}}, {{#unless Required}}global::DarkPatterns.OpenApiCodegen.Json.Extensions.IOptional<{{/unless}}{{{DataType}}}{{#unless Required}}>?{{/unless}} {{ParamName}}
             {{/each}})
         {
 {{#if RequestBody.HasQueryParam}}

lib/OpenApi.CSharp/Templates/objectmodel.handlebars

@@ -19,7 +19,7 @@ namespace {{this.PackageName}}
             }}{{#if HasMinLength}}[global::System.ComponentModel.DataAnnotations.MinLength({{MinLength}})]{{/if}}{{!
             }}{{#if HasMaxLength}}[global::System.ComponentModel.DataAnnotations.MaxLength({{MaxLength}})]{{/if}}{{!
             }}{{#if HasMinimum}}{{#if HasMaximum}}[global::System.ComponentModel.DataAnnotations.Range({{Minimum}}, {{Maximum}})]{{/if}}{{/if}}{{!
-    data type: }} {{#if Optional}}global::DarkPatterns.OpenApiCodegen.Json.Extensions.Optional<{{/if}}{{{DataType}}}{{#if Optional}}>?{{/if}}{{!
+    data type: }} {{#if Optional}}global::DarkPatterns.OpenApiCodegen.Json.Extensions.IOptional<{{/if}}{{{DataType}}}{{#if Optional}}>?{{/if}}{{!
     name: }} {{Name}}{{#unless @last}}, {{/unless}}{{/each}}
     );
     {{/with}}

lib/OpenApiCodegen.Json.Extensions.Test/OptionalShould.cs

@@ -139,6 +139,36 @@ public void AllowUnwrappingOptional()
 		Assert.Equal("foo", actual);
 	}
 
+	[Fact]
+	public void AllowPatternMatchingOfOptional()
+	{
+		Optional<string> sample = Optional.Create("foo");
+		if (sample is { Value: var actual })
+			Assert.Equal("foo", actual);
+		else
+			Assert.Fail("Pattern match failed");
+	}
+
+	[Fact]
+	public void AllowPatternMatchingOfIOptional()
+	{
+		IOptional<string> sample = Optional.Create("foo");
+		if (sample is { Value: var actual })
+			Assert.Equal("foo", actual);
+		else
+			Assert.Fail("Pattern match failed");
+	}
+
+	[Fact]
+	public void AllowCovarianceOfIOptional()
+	{
+		IOptional<object> sample = Optional.Create("foo");
+		if (sample is { Value: var actual })
+			Assert.Equal("foo", actual);
+		else
+			Assert.Fail("Pattern match failed");
+	}
+
 	[Fact]
 	public void AllowCreationOfOptionalWithEnumerables()
 	{

lib/OpenApiCodegen.Json.Extensions/Optional.cs

@@ -1,7 +1,5 @@
 using System;
-using System.Collections.Generic;
 using System.Reflection;
-using System.Text;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
@@ -10,18 +8,28 @@ namespace DarkPatterns.OpenApiCodegen.Json.Extensions;
 public static class Optional
 {
 	public static Optional<T> Create<T>(T value) => new Optional<T>.Present(value);
-	public static T GetValueOrThrow<T>(Optional<T> input) =>
+	public static T GetValueOrThrow<T>(IOptional<T> input) =>
 		input.TryGet(out var result) ? result : throw new InvalidOperationException();
 }
 
 [JsonConverter(typeof(OptionalJsonConverterFactory))]
-public abstract record Optional<T>
+public interface IOptional<out T>
+{
+	T Value { get; }
+}
+
+[JsonConverter(typeof(OptionalJsonConverterFactory))]
+public abstract record Optional<T> : IOptional<T>
 {
 	private Optional() { }
 
 	public static readonly Optional<T>? None = null;
 
-	public sealed record Present(T Value) : Optional<T>;
+	public abstract T Value { get; init; }
+
+	public sealed record Present(T Value) : Optional<T>, IOptional<T>
+	{
+	}
 
 	public class Serializer : JsonConverter<Optional<T>>
 	{
@@ -52,7 +60,8 @@ public class OptionalJsonConverterFactory : JsonConverterFactory
 {
 	public override bool CanConvert(Type typeToConvert)
 	{
-		return typeToConvert.IsGenericType && typeToConvert.GetGenericTypeDefinition() == typeof(Optional<>);
+		return typeToConvert.IsGenericType
+			&& (typeToConvert.GetGenericTypeDefinition() == typeof(Optional<>) || typeToConvert.GetGenericTypeDefinition() == typeof(IOptional<>));
 	}
 
 	public override JsonConverter? CreateConverter(Type typeToConvert, JsonSerializerOptions options)

lib/OpenApiCodegen.Json.Extensions/OptionalExtensions.cs

@@ -1,12 +1,8 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace DarkPatterns.OpenApiCodegen.Json.Extensions;
+namespace DarkPatterns.OpenApiCodegen.Json.Extensions;
 
 public static class OptionalExtensions
 {
-	public static bool TryGet<T>(this Optional<T>? input, [System.Diagnostics.CodeAnalysis.MaybeNullWhen(false)] out T value)
+	public static bool TryGet<T>(this IOptional<T>? input, [System.Diagnostics.CodeAnalysis.MaybeNullWhen(false)] out T value)
 	{
 		if (input is Optional<T>.Present { Value: var presentValue })
 		{
@@ -17,8 +13,8 @@ public static bool TryGet<T>(this Optional<T>? input, [System.Diagnostics.CodeAn
 		return false;
 	}
 
-	public static T? GetValueOrDefault<T>(this Optional<T>? input) =>
+	public static T? GetValueOrDefault<T>(this IOptional<T>? input) =>
 		input.TryGet(out var result) ? result : default;
-	public static T GetValueOrDefault<T>(this Optional<T>? input, T defaultValue) =>
+	public static T GetValueOrDefault<T>(this IOptional<T>? input, T defaultValue) =>
 		input.TryGet(out var result) ? result : defaultValue;
 }

lib/TestApp.Test/OptionalYamlShould.cs

@@ -1,10 +1,6 @@
 using Microsoft.AspNetCore.Mvc;
 using DarkPatterns.OpenApiCodegen.Json.Extensions;
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Net.Http.Json;
-using System.Text;
 using System.Threading.Tasks;
 using Xunit;
 
@@ -25,8 +21,8 @@ public Task Handle_mixed_nullable_optional_with_all_provided() =>
 			{
 				Assert.True(controller.ModelState.IsValid);
 				Assert.Equal<int?>(2, request.NullableOnly);
-				Assert.Equal<Optional<int>?>(Optional.Create(3), request.OptionalOnly);
-				Assert.Equal<Optional<int?>?>(Optional.Create<int?>(5), request.OptionalOrNullable);
+				Assert.Equal<IOptional<int>?>(Optional.Create(3), request.OptionalOnly);
+				Assert.Equal<IOptional<int?>?>(Optional.Create<int?>(5), request.OptionalOrNullable);
 			},
 			AssertResponseMessage = VerifyResponse(200, new { nullableOnly = 2, optionalOnly = 3, optionalOrNullable = 5 }),
 		});