Use the proper generator

MelbourneDeveloper · MelbourneDeveloper · commit 643da516b06a · 2025-10-18T10:21:41.000+11:00
diff --git a/.vscode/launch.json b/.vscode/launch.json
@@ -33,7 +33,7 @@
                 "-u",
                 "${workspaceFolder}/Samples/NucliaDbClient/api.yaml",
                 "-o",
-                "${workspaceFolder}/Samples/RestClient.OpenApiGenerator.Sample.NucliaDB/Generated",
+                "${workspaceFolder}/Samples/NucliaDbClient/Generated",
                 "-n",
                 "NucliaDB.Generated",
                 "-c",
diff --git a/RestClient.Net.OpenApiGenerator.Tests/RestClient.Net.OpenApiGenerator.Tests.csproj b/RestClient.Net.OpenApiGenerator.Tests/RestClient.Net.OpenApiGenerator.Tests.csproj
@@ -9,7 +9,6 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
-    <PackageReference Include="Microsoft.OpenApi.Readers" Version="1.6.28" />
     <PackageReference Include="MSTest" Version="3.6.4" />
   </ItemGroup>
 
diff --git a/RestClient.Net.OpenApiGenerator/ExtensionMethodGenerator.cs b/RestClient.Net.OpenApiGenerator/ExtensionMethodGenerator.cs
@@ -1,4 +1,4 @@
-using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi;
 
 namespace RestClient.Net.OpenApiGenerator;
 
@@ -26,10 +26,15 @@ string basePath
 
         foreach (var path in document.Paths)
         {
+            if (path.Value?.Operations == null)
+            {
+                continue;
+            }
+
             foreach (var operation in path.Value.Operations)
             {
                 var responseType = GetResponseType(operation.Value);
-                var isDelete = operation.Key == OperationType.Delete;
+                var isDelete = operation.Key == HttpMethod.Delete;
                 var resultResponseType = isDelete ? "Unit" : responseType;
                 _ = responseTypes.Add(resultResponseType);
 
@@ -123,7 +128,7 @@ private static async Task<string> DeserializeError(
 
     private static (string Method, List<string> PrivateFunctions) GenerateMethod(
         string path,
-        OperationType operationType,
+        HttpMethod operationType,
         OpenApiOperation operation,
         string basePath
     )
@@ -148,7 +153,7 @@ string basePath
 
 #pragma warning disable CA1502 // Avoid excessive complexity - code generator method is inherently complex
     private static (string Method, List<string> PrivateFunctions) GenerateHttpMethod(
-        OperationType operationType,
+        HttpMethod operationType,
         string methodName,
         string path,
         List<(string Name, string Type, bool IsPath)> parameters,
@@ -159,8 +164,10 @@ string summary
 #pragma warning restore CA1502
     {
         var hasBody =
-            operationType is OperationType.Post or OperationType.Put or OperationType.Patch;
-        var isDelete = operationType == OperationType.Delete;
+            operationType == HttpMethod.Post
+            || operationType == HttpMethod.Put
+            || operationType == HttpMethod.Patch;
+        var isDelete = operationType == HttpMethod.Delete;
         var hasPathParams = parameters.Any(p => p.IsPath);
         var queryParams = parameters.Where(p => !p.IsPath).ToList();
         var hasQueryParams = queryParams.Count > 0;
@@ -175,7 +182,12 @@ string summary
             ? "?" + string.Join("&", queryParams.Select(q => $"{q.Name}={{{q.Name}}}"))
             : string.Empty;
 
-        var verb = operationType.ToString();
+        var verb = operationType == HttpMethod.Get ? "Get"
+            : operationType == HttpMethod.Post ? "Post"
+            : operationType == HttpMethod.Put ? "Put"
+            : operationType == HttpMethod.Delete ? "Delete"
+            : operationType == HttpMethod.Patch ? "Patch"
+            : operationType.Method;
         var createMethod = $"Create{verb}";
         var delegateType = $"{verb}Async";
 
@@ -369,7 +381,7 @@ string summary
 
     private static string GetMethodName(
         OpenApiOperation operation,
-        OperationType operationType,
+        HttpMethod operationType,
         string path
     )
     {
@@ -382,15 +394,15 @@ string path
             path.Split('/').LastOrDefault(p => !string.IsNullOrEmpty(p) && !p.StartsWith('{'))
             ?? "Resource";
 
-        return operationType switch
-        {
-            OperationType.Get => $"Get{CodeGenerationHelpers.ToPascalCase(pathPart)}",
-            OperationType.Post => $"Create{CodeGenerationHelpers.ToPascalCase(pathPart)}",
-            OperationType.Put => $"Update{CodeGenerationHelpers.ToPascalCase(pathPart)}",
-            OperationType.Delete => $"Delete{CodeGenerationHelpers.ToPascalCase(pathPart)}",
-            OperationType.Patch => $"Patch{CodeGenerationHelpers.ToPascalCase(pathPart)}",
-            _ => $"{operationType}{CodeGenerationHelpers.ToPascalCase(pathPart)}",
-        };
+        var methodName =
+            operationType == HttpMethod.Get ? "Get"
+            : operationType == HttpMethod.Post ? "Create"
+            : operationType == HttpMethod.Put ? "Update"
+            : operationType == HttpMethod.Delete ? "Delete"
+            : operationType == HttpMethod.Patch ? "Patch"
+            : operationType.Method;
+
+        return $"{methodName}{CodeGenerationHelpers.ToPascalCase(pathPart)}";
     }
 
     private static List<(string Name, string Type, bool IsPath)> GetParameters(
@@ -399,8 +411,18 @@ OpenApiOperation operation
     {
         var parameters = new List<(string Name, string Type, bool IsPath)>();
 
+        if (operation.Parameters == null)
+        {
+            return parameters;
+        }
+
         foreach (var param in operation.Parameters)
         {
+            if (param.Name == null)
+            {
+                continue;
+            }
+
             var isPath = param.In == ParameterLocation.Path;
             var type = ModelGenerator.MapOpenApiType(param.Schema);
             parameters.Add((param.Name, type, isPath));
@@ -409,11 +431,18 @@ OpenApiOperation operation
         return parameters;
     }
 
-    private static string? GetRequestBodyType(OpenApiOperation operation) =>
-        operation.RequestBody == null ? null
-        : operation.RequestBody.Content.FirstOrDefault().Value?.Schema?.Reference != null
-            ? operation.RequestBody.Content.FirstOrDefault().Value.Schema.Reference.Id
-        : "object";
+    private static string? GetRequestBodyType(OpenApiOperation operation)
+    {
+        if (operation.RequestBody?.Content == null)
+        {
+            return null;
+        }
+
+        var firstContent = operation.RequestBody.Content.FirstOrDefault();
+        return firstContent.Value?.Schema is OpenApiSchemaReference schemaRef
+            ? schemaRef.Reference.Id ?? "object"
+            : "object";
+    }
 
     private static string GenerateTypeAliasesFile(HashSet<string> responseTypes, string @namespace)
     {
@@ -488,20 +517,22 @@ _ when responseType.StartsWith("List<", StringComparison.Ordinal) =>
 
     private static string GetResponseType(OpenApiOperation operation)
     {
-        var successResponse = operation.Responses.FirstOrDefault(r =>
+        var successResponse = operation.Responses?.FirstOrDefault(r =>
             r.Key.StartsWith('2') || r.Key == "default"
         );
 
-        if (successResponse.Value == null)
+        if (successResponse?.Value?.Content == null)
         {
             return "object";
         }
 
-        var content = successResponse.Value.Content.FirstOrDefault();
-        return content.Value?.Schema?.Reference != null ? content.Value.Schema.Reference.Id
-            : content.Value?.Schema?.Type == "array"
-            && content.Value.Schema.Items?.Reference != null
-                ? $"List<{content.Value.Schema.Items.Reference.Id}>"
+        var content = successResponse.Value.Value.Content.FirstOrDefault();
+        return content.Value?.Schema is OpenApiSchemaReference schemaRef
+                ? schemaRef.Reference.Id ?? "object"
+            : content.Value?.Schema is OpenApiSchema schema
+            && schema.Type == JsonSchemaType.Array
+            && schema.Items is OpenApiSchemaReference itemsRef
+                ? $"List<{itemsRef.Reference.Id ?? "object"}>"
             : ModelGenerator.MapOpenApiType(content.Value?.Schema);
     }
 }
diff --git a/RestClient.Net.OpenApiGenerator/ModelGenerator.cs b/RestClient.Net.OpenApiGenerator/ModelGenerator.cs
@@ -1,4 +1,4 @@
-using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi;
 
 namespace RestClient.Net.OpenApiGenerator;
 
@@ -13,12 +13,16 @@ public static string GenerateModels(OpenApiDocument document, string @namespace)
     {
         var models = new List<string>();
 
-        foreach (
-            var schema in document.Components?.Schemas ?? new Dictionary<string, OpenApiSchema>()
-        )
+        if (document.Components?.Schemas != null)
         {
-            var model = GenerateModel(schema.Key, schema.Value);
-            models.Add(model);
+            foreach (var schema in document.Components.Schemas)
+            {
+                if (schema.Value is OpenApiSchema schemaObj)
+                {
+                    var model = GenerateModel(schema.Key, schemaObj);
+                    models.Add(model);
+                }
+            }
         }
 
         var modelsCode = string.Join("\n\n", models);
@@ -36,12 +40,12 @@ namespace {{@namespace}};
     /// <returns>The generated model code.</returns>
     private static string GenerateModel(string name, OpenApiSchema schema)
     {
-        var properties = schema
-            .Properties.Select(p =>
+        var properties = (schema.Properties ?? new Dictionary<string, IOpenApiSchema>())
+            .Select(p =>
             {
                 var propName = CodeGenerationHelpers.ToPascalCase(p.Key);
                 var propType = MapOpenApiType(p.Value);
-                var propDesc = p.Value.Description ?? propName;
+                var propDesc = (p.Value as OpenApiSchema)?.Description ?? propName;
                 return $"    /// <summary>{propDesc}</summary>\n    public {propType} {propName} {{ get; set; }}";
             })
             .ToList();
@@ -60,36 +64,47 @@ public class {{name}}
     /// <summary>Maps an OpenAPI schema to a C# type.</summary>
     /// <param name="schema">The OpenAPI schema.</param>
     /// <returns>The C# type name.</returns>
-    public static string MapOpenApiType(OpenApiSchema? schema)
+    public static string MapOpenApiType(IOpenApiSchema? schema)
     {
         if (schema == null)
         {
             return "object";
         }
 
         // Check for schema reference first
-        if (schema.Reference != null)
+        if (schema is OpenApiSchemaReference schemaRef)
+        {
+            return schemaRef.Reference.Id ?? "object";
+        }
+
+        if (schema is not OpenApiSchema schemaObj)
         {
-            return schema.Reference.Id;
+            return "object";
         }
 
         // Handle arrays
-        if (schema.Type == "array")
+        if (schemaObj.Type == JsonSchemaType.Array)
         {
-            return schema.Items?.Reference != null ? $"List<{schema.Items.Reference.Id}>"
-                : schema.Items?.Type == "string" ? "List<string>"
-                : schema.Items?.Type == "integer" ? "List<int>"
-                : schema.Items?.Type == "number" ? "List<double>"
+            return schemaObj.Items is OpenApiSchemaReference itemsRef
+                    ? $"List<{itemsRef.Reference.Id ?? "object"}>"
+                : schemaObj.Items is OpenApiSchema items
+                    ? items.Type switch
+                    {
+                        JsonSchemaType.String => "List<string>",
+                        JsonSchemaType.Integer => "List<int>",
+                        JsonSchemaType.Number => "List<double>",
+                        _ => "List<object>",
+                    }
                 : "List<object>";
         }
 
         // Handle primitive types
-        return schema.Type switch
+        return schemaObj.Type switch
         {
-            "integer" => schema.Format == "int64" ? "long" : "int",
-            "number" => schema.Format == "double" ? "double" : "float",
-            "string" => "string",
-            "boolean" => "bool",
+            JsonSchemaType.Integer => schemaObj.Format == "int64" ? "long" : "int",
+            JsonSchemaType.Number => schemaObj.Format == "double" ? "double" : "float",
+            JsonSchemaType.String => "string",
+            JsonSchemaType.Boolean => "bool",
             _ => "object",
         };
     }
diff --git a/RestClient.Net.OpenApiGenerator/OpenApiCodeGenerator.cs b/RestClient.Net.OpenApiGenerator/OpenApiCodeGenerator.cs
@@ -1,5 +1,5 @@
-using Microsoft.OpenApi.Readers;
-using Microsoft.OpenApi.Validations;
+using Microsoft.OpenApi;
+using Microsoft.OpenApi.Reader;
 using ErrorUrl = Outcome.Result<(string, string), string>.Error<(string, string), string>;
 using GeneratorError = Outcome.Result<
     RestClient.Net.OpenApiGenerator.GeneratorResult,
@@ -15,7 +15,10 @@
 
 namespace RestClient.Net.OpenApiGenerator;
 
-/// <summary>Generates C# extension methods from OpenAPI specifications.</summary>
+/// <summary>Generates C# extension methods from OpenAPI specifications.
+/// This uses the Microsoft.OpenApi library to parse OpenAPI documents and generate code https://github.com/microsoft/OpenAPI.NET.
+/// See the tests here https://github.com/microsoft/OpenAPI.NET/tree/main/test/Microsoft.OpenApi.Tests to see how the API works.
+/// </summary>
 public static class OpenApiCodeGenerator
 {
     /// <summary>Generates code from an OpenAPI document.</summary>
@@ -37,25 +40,24 @@ public static Outcome.Result<GeneratorResult, string> Generate(
     {
         try
         {
-            var document = new OpenApiStringReader(
-                new OpenApiReaderSettings
-                {
-                    ReferenceResolution = ReferenceResolutionSetting.ResolveLocalReferences,
-                    RuleSet = ValidationRuleSet.GetDefaultRuleSet(),
-                }
-            ).Read(openApiContent, out var diagnostic);
+            var settings = new OpenApiReaderSettings();
+            settings.AddYamlReader();
 
-            if (diagnostic.Errors.Count > 0)
+            var readResult = OpenApiDocument.Parse(openApiContent, settings: settings);
+
+            if (readResult.Diagnostic?.Errors.Count > 0)
             {
-                var errors = string.Join(", ", diagnostic.Errors.Select(e => e.Message));
+                var errors = string.Join(", ", readResult.Diagnostic.Errors.Select(e => e.Message));
                 return new GeneratorError($"Error parsing OpenAPI: {errors}");
             }
 
-            if (document == null)
+            if (readResult.Document == null)
             {
                 return new GeneratorError("Error parsing OpenAPI: Document is null");
             }
 
+            var document = readResult.Document;
+
             var urlResult = UrlParser.GetBaseUrlAndPath(document, baseUrlOverride);
 
             return urlResult switch
@@ -80,7 +82,7 @@ public static Outcome.Result<GeneratorResult, string> Generate(
     }
 
     private static GeneratorOk GenerateCodeFiles(
-        Microsoft.OpenApi.Models.OpenApiDocument document,
+        OpenApiDocument document,
         string @namespace,
         string className,
         string outputPath,
diff --git a/RestClient.Net.OpenApiGenerator/README.md b/RestClient.Net.OpenApiGenerator/README.md
@@ -340,8 +340,8 @@ Test coverage includes:
 
 ## Dependencies
 
-- Microsoft.OpenApi.Readers (1.6.22) - OpenAPI parsing
 - Microsoft.CodeAnalysis.CSharp (4.11.0) - Code generation
+- https://github.com/microsoft/OpenAPI.NET
 
 ## License
 
diff --git a/RestClient.Net.OpenApiGenerator/RestClient.Net.OpenApiGenerator.csproj b/RestClient.Net.OpenApiGenerator/RestClient.Net.OpenApiGenerator.csproj
@@ -5,7 +5,8 @@
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.11.0" />
-    <PackageReference Include="Microsoft.OpenApi.Readers" Version="1.6.28" />
+    <PackageReference Include="Microsoft.OpenApi" Version="2.3.5" />
+    <PackageReference Include="Microsoft.OpenApi.YamlReader" Version="2.3.5" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\RestClient.Net\RestClient.Net.csproj" />
diff --git a/RestClient.Net.OpenApiGenerator/UrlParser.cs b/RestClient.Net.OpenApiGenerator/UrlParser.cs
@@ -1,4 +1,4 @@
-using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi;
 using Outcome;
 
 namespace RestClient.Net.OpenApiGenerator;
@@ -15,7 +15,7 @@ internal static class UrlParser
         string? baseUrlOverride
     )
     {
-        var server = document.Servers.FirstOrDefault();
+        var server = document.Servers?.FirstOrDefault();
 
         if (server == null || string.IsNullOrWhiteSpace(server.Url))
         {
diff --git a/Samples/NucliaDbClient/Generated/GlobalUsings.g.cs b/Samples/NucliaDbClient/Generated/GlobalUsings.g.cs
diff --git a/Samples/NucliaDbClient/Generated/NucliaDBApiExtensions.g.cs b/Samples/NucliaDbClient/Generated/NucliaDBApiExtensions.g.cs
diff --git a/Samples/NucliaDbClient/Generated/NucliaDBApiModels.g.cs b/Samples/NucliaDbClient/Generated/NucliaDBApiModels.g.cs
diff --git a/Samples/NucliaDbClient/NucliaDbClient.csproj b/Samples/NucliaDbClient/NucliaDbClient.csproj

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-using Microsoft.OpenApi.Models;`
	`1`	`+using Microsoft.OpenApi;`
`2`	`2`	`using Outcome;`
`3`	`3`
`4`	`4`	`namespace RestClient.Net.OpenApiGenerator;`
`@@ -15,7 +15,7 @@ internal static class UrlParser`
`15`	`15`	`string? baseUrlOverride`
`16`	`16`	`)`
`17`	`17`	`{`
`18`		`- var server = document.Servers.FirstOrDefault();`
	`18`	`+ var server = document.Servers?.FirstOrDefault();`
`19`	`19`
`20`	`20`	`if (server == null \|\| string.IsNullOrWhiteSpace(server.Url))`
`21`	`21`	`{`