Represent "default" responses instead of crashing on them

Response keys were unconditionally Int32.Parsed, so any valid Swagger 2
spec containing a "default" response aborted generation with a
FormatException. Responses are now keyed by a ResponseKey DU
(Code of int | Default), and the client generator explicitly ignores
Default when selecting the success response: it describes the status
codes not otherwise listed, which in practice means errors.

No generated output changes: Gitea declares no default responses.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: Smaug123

WoofWare.Myriad.Plugins.Test/TestSwagger/TestSwaggerParse.fs

@@ -76,9 +76,9 @@ module TestSwaggerParse =
                     |> Some
                 Responses =
                     [
-                        204, Definition.Unspecified
-                        303, Definition.Unspecified
-                        404, Definition.Unspecified
+                        ResponseKey.Code 204, Definition.Unspecified
+                        ResponseKey.Code 303, Definition.Unspecified
+                        ResponseKey.Code 404, Definition.Unspecified
                     ]
                     |> Map.ofList
             }
@@ -118,12 +118,50 @@ module TestSwaggerParse =
         endpoint.Responses
         |> shouldEqual (
             [
-                200,
+                ResponseKey.Code 200,
                 Definition.Array
                     {
                         Items = Definition.String
                     }
-                403, Definition.Handle "#/responses/forbidden"
+                ResponseKey.Code 403, Definition.Handle "#/responses/forbidden"
+            ]
+            |> Map.ofList
+        )
+
+    [<Test>]
+    let ``Can parse a default response`` () : unit =
+        let s =
+            """{
+  "tags": [
+    "pet"
+  ],
+  "summary": "Returns all pets from the system that the user has access to",
+  "operationId": "findPets",
+  "responses": {
+    "200": {
+      "description": "pet response",
+      "schema": {
+        "type": "string"
+      }
+    },
+    "default": {
+      "description": "unexpected error",
+      "schema": {
+        "$ref": "#/definitions/Error"
+      }
+    }
+  }
+}
+"""
+            |> JsonNode.Parse
+
+        let endpoint = s.AsObject () |> SwaggerEndpoint.Parse
+
+        endpoint.Responses
+        |> shouldEqual (
+            [
+                ResponseKey.Code 200, Definition.String
+                ResponseKey.Default, Definition.Handle "#/definitions/Error"
             ]
             |> Map.ofList
         )

WoofWare.Myriad.Plugins/SwaggerClientGenerator.fs

@@ -655,10 +655,13 @@ module internal SwaggerV2Generator =
                     let returnType =
                         endpoint.Responses
                         |> Seq.choose (fun (KeyValue (response, defn)) ->
-                            if 200 <= response && response < 300 then
-                                Some defn
-                            else
-                                None
+                            match response with
+                            | SwaggerV2.ResponseKey.Code code when 200 <= code && code < 300 -> Some defn
+                            | SwaggerV2.ResponseKey.Code _
+                            // The "default" response describes what comes back for status
+                            // codes not otherwise listed, which in practice means errors;
+                            // it doesn't contribute to the success return type.
+                            | SwaggerV2.ResponseKey.Default -> None
                         )
                         |> Seq.toList
 

WoofWare.Myriad.Plugins/SwaggerV2.fs

@@ -330,6 +330,22 @@ type Response =
             Schema = schema
         }
 
+/// Key into an endpoint's "responses" map: either a specific HTTP status code,
+/// or the catch-all "default", which describes all responses whose status codes
+/// are not otherwise listed.
+type ResponseKey =
+    /// A specific HTTP status code, e.g. 200.
+    | Code of int
+    /// The catch-all "default" response.
+    | Default
+
+    /// Parse a key of the "responses" object, e.g. "200" or "default".
+    static member Parse (s : string) : ResponseKey =
+        if s = "default" then
+            ResponseKey.Default
+        else
+            ResponseKey.Code (Int32.Parse s)
+
 /// An "endpoint" is basically a single HTTP verb, applied to some path.
 type SwaggerEndpoint =
     {
@@ -350,9 +366,9 @@ type SwaggerEndpoint =
         /// (Each parameter knows how it needs to be supplied: e.g. if it's a query parameter or
         /// if it's interpolated into the path.)
         Parameters : SwaggerParameter list option
-        /// Map of HTTP response code to the type that we expect to receive in the body if we
-        /// get that response code back.
-        Responses : Map<int, Definition>
+        /// Map of HTTP response code (or the catch-all "default") to the type that we
+        /// expect to receive in the body if we get that response code back.
+        Responses : Map<ResponseKey, Definition>
     }
 
     /// Render a JsonObject into this strongly-typed specification.
@@ -375,7 +391,7 @@ type SwaggerEndpoint =
                     | Some _ -> Definition.Parse value
                     | None -> (Response.Parse value).Schema
 
-                Int32.Parse key, defn
+                ResponseKey.Parse key, defn
             )
             |> Map.ofSeq