Extend the customization to both client and server

Author: czechboy0

Sources/OpenAPIRuntime/Conversion/Configuration.swift

@@ -152,6 +152,12 @@ public struct Configuration: Sendable {
     /// Custom XML coder for encoding and decoding xml bodies.
     public var xmlCoder: (any CustomCoder)?
 
+    /// An error mapping closure to allow customizing the error thrown by the client.
+    public var clientErrorMapper: (@Sendable (ClientError) -> any Error)?
+
+    /// An error mapping closure to allow customizing the error thrown by the server.
+    public var serverErrorMapper: (@Sendable (ServerError) -> any Error)?
+
     /// Creates a new configuration with the specified values.
     ///
     /// - Parameters:
@@ -160,15 +166,20 @@ public struct Configuration: Sendable {
     ///   - jsonEncodingOptions: The options for the underlying JSON encoder.
     ///   - multipartBoundaryGenerator: The generator to use when creating mutlipart bodies.
     ///   - xmlCoder: Custom XML coder for encoding and decoding xml bodies. Only required when using XML body payloads.
+    ///   - errorMapper: An error mapping closure to allow customizing the final error thrown.
     public init(
         dateTranscoder: any DateTranscoder = .iso8601,
         jsonEncodingOptions: JSONEncodingOptions = [.sortedKeys, .prettyPrinted],
         multipartBoundaryGenerator: any MultipartBoundaryGenerator = .random,
-        xmlCoder: (any CustomCoder)? = nil
+        xmlCoder: (any CustomCoder)? = nil,
+        clientErrorMapper: (@Sendable (ClientError) -> any Error)? = nil,
+        serverErrorMapper: (@Sendable (ServerError) -> any Error)? = nil
     ) {
         self.dateTranscoder = dateTranscoder
         self.jsonEncodingOptions = jsonEncodingOptions
         self.multipartBoundaryGenerator = multipartBoundaryGenerator
         self.xmlCoder = xmlCoder
+        self.clientErrorMapper = clientErrorMapper
+        self.serverErrorMapper = serverErrorMapper
     }
 }

Sources/OpenAPIRuntime/Deprecated/Deprecated.swift

@@ -58,6 +58,31 @@ extension Configuration {
             xmlCoder: xmlCoder
         )
     }
+
+    /// Creates a new configuration with the specified values.
+    ///
+    /// - Parameters:
+    ///   - dateTranscoder: The transcoder to use when converting between date
+    ///   and string values.
+    ///   - jsonEncodingOptions: The options for the underlying JSON encoder.
+    ///   - multipartBoundaryGenerator: The generator to use when creating mutlipart bodies.
+    ///   - xmlCoder: Custom XML coder for encoding and decoding xml bodies. Only required when using XML body payloads.
+    @available(*, deprecated, renamed: "init(dateTranscoder:jsonEncodingOptions:multipartBoundaryGenerator:xmlCoder:clientErrorMapper:serverErrorMapper:)")
+    @_disfavoredOverload public init(
+        dateTranscoder: any DateTranscoder = .iso8601,
+        jsonEncodingOptions: JSONEncodingOptions = [.sortedKeys, .prettyPrinted],
+        multipartBoundaryGenerator: any MultipartBoundaryGenerator = .random,
+        xmlCoder: (any CustomCoder)? = nil
+    ) {
+        self.init(
+            dateTranscoder: dateTranscoder,
+            jsonEncodingOptions: [.sortedKeys, .prettyPrinted],
+            multipartBoundaryGenerator: multipartBoundaryGenerator,
+            xmlCoder: xmlCoder,
+            clientErrorMapper: nil,
+            serverErrorMapper: nil
+        )
+    }
 }
 
 extension AsyncSequence where Element == ArraySlice<UInt8>, Self: Sendable {

Sources/OpenAPIRuntime/Interface/UniversalClient.swift

@@ -61,15 +61,14 @@ import struct Foundation.URL
         serverURL: URL = .defaultOpenAPIServerURL,
         configuration: Configuration = .init(),
         transport: any ClientTransport,
-        middlewares: [any ClientMiddleware] = [],
-        errorMapper: (@Sendable (ClientError) -> any Error)? = nil
+        middlewares: [any ClientMiddleware] = []
     ) {
         self.init(
             serverURL: serverURL,
             converter: Converter(configuration: configuration),
             transport: transport,
             middlewares: middlewares,
-            errorMapper: errorMapper
+            errorMapper: configuration.clientErrorMapper
         )
     }
 

Sources/OpenAPIRuntime/Interface/UniversalServer.swift

@@ -40,12 +40,22 @@ import struct Foundation.URLComponents
     /// The middlewares to be invoked before the handler receives the request.
     public var middlewares: [any ServerMiddleware]
 
+    /// An error mapping closure to allow customizing the error thrown by the server handler.
+    public var errorMapper: (@Sendable (ServerError) -> any Error)?
+
     /// Internal initializer that takes an initialized converter.
-    internal init(serverURL: URL, converter: Converter, handler: APIHandler, middlewares: [any ServerMiddleware]) {
+    internal init(
+        serverURL: URL,
+        converter: Converter,
+        handler: APIHandler,
+        middlewares: [any ServerMiddleware],
+        errorMapper: (@Sendable (ServerError) -> any Error)?
+    ) {
         self.serverURL = serverURL
         self.converter = converter
         self.handler = handler
         self.middlewares = middlewares
+        self.errorMapper = errorMapper
     }
 
     /// Creates a new server with the specified parameters.
@@ -59,7 +69,8 @@ import struct Foundation.URLComponents
             serverURL: serverURL,
             converter: Converter(configuration: configuration),
             handler: handler,
-            middlewares: middlewares
+            middlewares: middlewares,
+            errorMapper: configuration.serverErrorMapper
         )
     }
 
@@ -169,7 +180,15 @@ import struct Foundation.URLComponents
                 }
             }
         }
-        return try await next(request, requestBody, metadata)
+        do {
+            return try await next(request, requestBody, metadata)
+        } catch {
+            if let errorMapper, let serverError = error as? ServerError {
+                throw errorMapper(serverError)
+            } else {
+                throw error
+            }
+        }
     }
 
     /// Returns the path with the server URL's path prefix prepended.

Tests/OpenAPIRuntimeTests/Interface/Test_UniversalClient.swift

@@ -122,11 +122,13 @@ final class Test_UniversalClient: Test_Runtime {
     func testErrorPropagation_customErrorMapper() async throws {
         do {
             let client = UniversalClient(
-                transport: MockClientTransport.failing,
-                errorMapper: { clientError in
-                    // Don't care about the extra context, just wants the underlyingError
-                    clientError.underlyingError
-                }
+                configuration: .init(
+                    clientErrorMapper: { clientError in
+                        // Don't care about the extra context, just wants the underlyingError
+                        clientError.underlyingError
+                    }
+                ),
+                transport: MockClientTransport.failing
             )
             try await client.send(
                 input: "input",

Tests/OpenAPIRuntimeTests/Interface/Test_UniversalServer.swift

@@ -129,6 +129,34 @@ final class Test_UniversalServer: Test_Runtime {
         }
     }
 
+    func testErrorPropagation_errorMapper() async throws {
+        do {
+            let server = UniversalServer(
+                handler: MockHandler(shouldFail: true),
+                configuration: .init(
+                    serverErrorMapper: { serverError in
+                        // Don't care about the extra context, just wants the underlyingError
+                        serverError.underlyingError
+                    }
+                )
+            )
+            _ = try await server.handle(
+                request: .init(soar_path: "/", method: .post),
+                requestBody: MockHandler.requestBody,
+                metadata: .init(),
+                forOperation: "op",
+                using: { MockHandler.greet($0) },
+                deserializer: { request, body, metadata in
+                    let body = try XCTUnwrap(body)
+                    return try await String(collecting: body, upTo: 10)
+                },
+                serializer: { output, _ in fatalError() }
+            )
+        } catch {
+            XCTAssertTrue(error is TestError, "Threw an unexpected error: \(type(of: error))")
+        }
+    }
+
     func testErrorPropagation_serializer() async throws {
         do {
             let server = UniversalServer(handler: MockHandler())