Implemented the "client" property that conforms to the APIClient protocol for the AmiiboService service in the package target.

Sources/Public/Services/AmiiboService.swift

@@ -17,215 +17,48 @@ public struct AmiiboService {
     
     // MARK: Properties
     
-    private let client: Client
+    private let client: any APIClient
     
     // MARK: Initialisers
 
-    public init() throws {
+    public init(_ client: any APIClient) {
-        self.client = try .live
+        self.client = client
     }
 
     // MARK: Functions
     
     public func getAmiibos(
-        by filter: AmiiboFilter = .init()
+        _ filter: AmiiboFilter = .init()
     ) async throws -> [Amiibo] {
-        let response = try await client.getAmiibos(
+        try await client.getAmiibos(by: filter)
-            .init(query: .init(
-                amiiboSeries: filter.series,
-                character: filter.gameCharacter,
-                gameseries: filter.gameSeries,
-                id: filter.identifier,
-                name: filter.name,
-                showgames: filter.showGames,
-                showusage: filter.showUsage,
-                _type: filter.type
-            ))
-        )
-        
-        switch response {
-        case let .ok(okResponse):
-            switch okResponse.body {
-            case let .json(output):
-                switch output.amiibo {
-                case let .Amiibo(object):
-                    return [.init(object)]
-
-                case let .AmiiboList(list):
-                    return list
-                        .map { .init($0) }
-                        .sorted { $0.identifier < $1.identifier }
-                }
-            }
-            
-        case .badRequest:
-            throw AmiiboServiceError.badRequest
-
-        case let .undocumented(statusCode, _):
-            throw AmiiboServiceError.undocumented(statusCode)
-        }
     }
     
     public func getAmiiboSeries(
-        by filter: AmiiboSeriesFilter = .init()
+        _ filter: AmiiboSeriesFilter = .init()
     ) async throws -> [AmiiboSeries] {
-        let response = try await client.getAmiiboSeries(
+        try await client.getAmiiboSeries(by: filter)
-            .init(query: .init(
-                key: filter.key,
-                name: filter.name
-            ))
-        )
-        
-        switch response {
-        case let .ok(okResponse):
-            switch okResponse.body {
-            case let .json(output):
-                return map(output, to: AmiiboSeries.self)
-            }
-            
-        case .badRequest:
-            throw AmiiboServiceError.badRequest
-            
-        case .internalServerError:
-            throw AmiiboServiceError.notAvailable
-            
-        case .notFound:
-            throw AmiiboServiceError.notFound
-            
-        case let .undocumented(statusCode, _):
-            throw AmiiboServiceError.undocumented(statusCode)
-        }
     }
     
     public func getAmiiboTypes(
-        by filter: AmiiboTypeFilter = .init()
+        _ filter: AmiiboTypeFilter = .init()
     ) async throws -> [AmiiboType] {
-        let response = try await client.getAmiiboTypes(
+        try await client.getAmiiboTypes(by: filter)
-            .init(query: .init(
-                key: filter.key,
-                name: filter.name
-            ))
-        )
-        
-        switch response {
-        case let .ok(okResponse):
-            switch okResponse.body {
-            case let .json(output):
-                return map(output, to: AmiiboType.self)
-            }
-            
-        case .badRequest:
-            throw AmiiboServiceError.badRequest
-            
-        case .internalServerError:
-            throw AmiiboServiceError.notAvailable
-            
-        case .notFound:
-            throw AmiiboServiceError.notFound
-
-        case let .undocumented(statusCode, _):
-            throw AmiiboServiceError.undocumented(statusCode)
-        }
     }
     
     public func getGameCharacters(
-        by filter: GameCharacterFilter = .init()
+        _ filter: GameCharacterFilter = .init()
     ) async throws -> [GameCharacter] {
-        let response = try await client.getGameCharacters(
+        try await client.getGameCharacters(by: filter)
-            .init(query: .init(
-                key: filter.key,
-                name: filter.name
-            ))
-        )
-        
-        switch response {
-        case let .ok(okResponse):
-            switch okResponse.body {
-            case let .json(output):
-                return map(output, to: GameCharacter.self)
-            }
-            
-        case .badRequest:
-            throw AmiiboServiceError.badRequest
-            
-        case .internalServerError:
-            throw AmiiboServiceError.notAvailable
-            
-        case .notFound:
-            throw AmiiboServiceError.notFound
-            
-        case let .undocumented(statusCode, _):
-            throw AmiiboServiceError.undocumented(statusCode)
-        }
     }
     
     public func getGameSeries(
-        by filter: GameSeriesFilter = .init()
+        _ filter: GameSeriesFilter = .init()
     ) async throws -> [GameSeries] {
-        let response = try await client.getGameSeries(
+        try await client.getGameSeries(by: filter)
-            .init(query: .init(
-                key: filter.key,
-                name: filter.name
-            ))
-        )
-        
-        switch response {
-        case let .ok(okResponse):
-            switch okResponse.body {
-            case let .json(output):
-                return map(output, to: GameSeries.self)
-            }
-            
-        case .badRequest:
-            throw AmiiboServiceError.badRequest
-            
-        case .internalServerError:
-            throw AmiiboServiceError.notAvailable
-            
-        case .notFound:
-            throw AmiiboServiceError.notFound
-            
-        case let .undocumented(statusCode, _):
-            throw AmiiboServiceError.undocumented(statusCode)
-        }
     }
     
     public func getLastUpdated() async throws -> Date {
-        let response = try await client.getLastUpdated()
+        try await client.getLastUpdated()
-
-        switch response {
-        case let .ok(okResponse):
-            switch okResponse.body {
-            case let .json(output):
-                return output.lastUpdated
-            }
-
-        case let .undocumented(statusCode, _):
-            throw AmiiboServiceError.undocumented(statusCode)
-        }
-    }
-    
-}
-
-// MARK: - Helpers
-
-private extension AmiiboService {
-    
-    // MARK: Functions
-    
-    func map<Model: KeyNameModel>(
-        _ output: Components.Schemas.TupleWrapper,
-        to: Model.Type
-    ) -> [Model] {
-        switch output.amiibo {
-        case let .Tuple(payload):
-            return [.init(payload)]
-            
-        case let .TupleList(list):
-            return list
-                .map { .init($0) }
-                .sorted { $0.key < $1.key }
-        }
     }
     
 }