Support base64-encoded data

Motivation

OpenAPI supports base64-encoded data but to this point Swift OpenAPI Generator
has not (apple#11).

Modifications

A data type specified as `type: string, format: byte` will now result in
a generated type which is `Codable` and backed by a
`OpenAPIRuntime.Base64EncodedData` type which knows how to encode and
decode base64 data.

Result

Users will be able to specify request/response payloads as
base64-encoded data which will be encoded and decoded transparently

Test Plan

Unit tested locally.

Author: rnro

Sources/_OpenAPIGeneratorCore/Translator/TypeAssignment/TypeMatcher.swift

@@ -292,10 +292,10 @@ struct TypeMatcher {
                 return nil
             }
             switch core.format {
-            case .byte:
-                typeName = .swift("String")
             case .binary:
                 typeName = .foundation("Data")
+            case .byte:
+                typeName = .runtime("Base64EncodedData")
             case .dateTime:
                 typeName = .foundation("Date")
             default:

Tests/OpenAPIGeneratorCoreTests/Translator/TypeAssignment/Test_TypeMatcher.swift

@@ -24,7 +24,7 @@ final class Test_TypeMatcher: Test_Core {
 
     static let builtinTypes: [(JSONSchema, String)] = [
         (.string, "Swift.String"),
-        (.string(.init(format: .byte), .init()), "Swift.String"),
+        (.string(.init(format: .byte), .init()), "OpenAPIRuntime.Base64EncodedData"),
         (.string(.init(format: .binary), .init()), "Foundation.Data"),
         (.string(.init(format: .date), .init()), "Swift.String"),
         (.string(.init(format: .dateTime), .init()), "Foundation.Date"),

Tests/OpenAPIGeneratorReferenceTests/SnippetBasedReferenceTests.swift

@@ -948,6 +948,47 @@ final class SnippetBasedReferenceTests: XCTestCase {
         )
     }
 
+    func testComponentsSchemasBase64() throws {
+        try self.assertSchemasTranslation(
+            """
+            schemas:
+              MyData:
+                type: string
+                format: byte
+            """,
+            """
+            public enum Schemas {
+                public typealias MyData = OpenAPIRuntime.Base64EncodedData
+            }
+            """
+        )
+    }
+
+    func testComponentsSchemasBase64Object() throws {
+        try self.assertSchemasTranslation(
+            """
+            schemas:
+              MyObj:
+                type: object
+                properties:
+                  stuff:
+                    type: string
+                    format: byte
+            """,
+            """
+            public enum Schemas {
+                public struct MyObj: Codable, Hashable, Sendable {
+                    public var stuff: OpenAPIRuntime.Base64EncodedData?
+                    public init(stuff: OpenAPIRuntime.Base64EncodedData? = nil) {
+                      self.stuff = stuff
+                    }
+                    public enum CodingKeys: String, CodingKey { case stuff }
+                }
+            }
+            """
+        )
+    }
+
     func testComponentsResponsesResponseNoBody() throws {
         try self.assertResponsesTranslation(
             """
@@ -1433,6 +1474,40 @@ final class SnippetBasedReferenceTests: XCTestCase {
         )
     }
 
+
+    func testResponseWithExampleWithOnlyValueByte() throws {
+        try self.assertResponsesTranslation(
+            """
+            responses:
+              MyResponse:
+                description: Some response
+                content:
+                  application/json:
+                    schema:
+                      type: string
+                      format: byte
+                    examples:
+                      application/json:
+                        summary: "a hello response"
+            """,
+            """
+            public enum Responses {
+                public struct MyResponse: Sendable, Hashable {
+                    @frozen public enum Body: Sendable, Hashable {
+                        case json(OpenAPIRuntime.Base64EncodedData)
+                    }
+                    public var body: Components.Responses.MyResponse.Body
+                    public init(
+                        body: Components.Responses.MyResponse.Body
+                    ) {
+                        self.body = body
+                    }
+                }
+            }
+            """
+        )
+    }
+
 }
 
 extension SnippetBasedReferenceTests {