Merge pull request #10 from adborbas/adborbas/support_rapidapi

adborbas · web-flow · commit 01c850237400 · 2024-06-25T16:04:34.000+02:00
Adding support for API exposed on RapidAPI
diff --git a/README.md b/README.md
@@ -1,6 +1,6 @@
 # AlphaSwiftage
 
-Lightweight Swift library to access the [Alpha Vantage API](https://www.alphavantage.co/documentation/).
+Lightweight Swift library to access the [Alpha Vantage API](https://www.alphavantage.co/documentation/). The library does also support the [Alpha Vantage API exposed on RapidAPI](https://rapidapi.com/alphavantage/api/alpha-vantage).
 
 ## Installation
 
@@ -14,20 +14,27 @@ dependencies: [
 
 ## Usage
 
+Using the native Alpha Vantage API:
+
 ```swift
 import AlphaSwiftage
 
 let service = AlphaVantageService(apiKey: "{YOUR_API_KEY}")
 let symbols = try await service.symbolSearch(keywords: "VWCE")
 ```
 
+Alpha Vantage API exposed on RapidAPI:
+
+```swift
+import AlphaSwiftage
+
+let service = AlphaVantageService(serviceType: .rapidAPI(apiKey: "{YOUR_API_KEY}"))
+let symbols = try await service.symbolSearch(keywords: "VWCE")
+```
+
 ## Supported routes
 
 - [Symbol Search](https://www.alphavantage.co/documentation/#symbolsearch)
 - [Quote](https://www.alphavantage.co/documentation/#latestprice)
 - [Exchange Rates](https://www.alphavantage.co/documentation/#currency-exchange)
 - [Time Series - Daily Adjusted](https://www.alphavantage.co/documentation/#dailyadj)
-
-## API Key
-
-You can get a free API Key [here](https://www.alphavantage.co/support/#api-key).
diff --git a/Sources/AlphaSwiftage/Private/APIHost/APIHost.swift b/Sources/AlphaSwiftage/Private/APIHost/APIHost.swift
@@ -0,0 +1,8 @@
+import Alamofire
+import Foundation
+
+protocol APIHost {
+    var baseURL: URL { get }
+    var headers: HTTPHeaders { get }
+    var baseParameters: Parameters { get }
+}
diff --git a/Sources/AlphaSwiftage/Private/APIHost/APIHostFactory.swift b/Sources/AlphaSwiftage/Private/APIHost/APIHostFactory.swift
@@ -0,0 +1,16 @@
+import Foundation
+
+class APIHostFactory {
+    private init () {}
+    
+    static let shared = APIHostFactory()
+    
+    func host(for serviceType: AlphaVantageServiceType) -> APIHost {
+        switch serviceType {
+        case .native(let apiKey):
+            return NativeAPIHost(apiKey: apiKey)
+        case .rapidAPI(let apiKey):
+            return RapidAPIHost(apiKey: apiKey)
+        }
+    }
+}
diff --git a/Sources/AlphaSwiftage/Private/APIHost/NativeAPIHost.swift b/Sources/AlphaSwiftage/Private/APIHost/NativeAPIHost.swift
@@ -0,0 +1,16 @@
+import Alamofire
+import Foundation
+
+class NativeAPIHost: APIHost {
+    private let apiKey: String
+    
+    let baseURL = URL(string: "https://www.alphavantage.co/query")!
+    let  headers = HTTPHeaders()
+    lazy var baseParameters: Parameters = {
+        return ["apikey": apiKey]
+    }()
+    
+    init(apiKey: String) {
+        self.apiKey = apiKey
+    }
+}
diff --git a/Sources/AlphaSwiftage/Private/APIHost/RapidAPIHost.swift b/Sources/AlphaSwiftage/Private/APIHost/RapidAPIHost.swift
@@ -0,0 +1,19 @@
+import Alamofire
+import Foundation
+
+class RapidAPIHost: APIHost {
+    private let apiKey: String
+    
+    let baseURL = URL(string: "https://alpha-vantage.p.rapidapi.com/query")!
+    lazy var headers: HTTPHeaders = {
+        return HTTPHeaders([
+            "x-rapidapi-host": "alpha-vantage.p.rapidapi.com",
+            "x-rapidapi-key": apiKey
+        ])
+    }()
+    let baseParameters: Parameters = [:]
+    
+    init(apiKey: String) {
+        self.apiKey = apiKey
+    }
+}
diff --git a/Sources/AlphaSwiftage/Private/Alamofire+AlphaSwiftage/AlphaVantageResponseSerializer.swift b/Sources/AlphaSwiftage/Private/Alamofire+AlphaSwiftage/AlphaVantageResponseSerializer.swift
@@ -1,10 +1,3 @@
-//
-//  AlphaVantageResponseSerializer.swift
-//
-//
-//  Created by Adam Borbas on 22/03/2024.
-//
-
 import Foundation
 import Alamofire
 
diff --git a/Sources/AlphaSwiftage/Private/Alamofire+AlphaSwiftage/DataRequest+SerializingAlphaVantageResponse.swift b/Sources/AlphaSwiftage/Private/Alamofire+AlphaSwiftage/DataRequest+SerializingAlphaVantageResponse.swift
diff --git a/Sources/AlphaSwiftage/Private/Alamofire+AlphaSwiftage/KeyedDecodingContainer+DecodeUS.swift b/Sources/AlphaSwiftage/Private/Alamofire+AlphaSwiftage/KeyedDecodingContainer+DecodeUS.swift
diff --git a/Sources/AlphaSwiftage/Private/AlphaVantageAPI.swift b/Sources/AlphaSwiftage/Private/AlphaVantageAPI.swift
diff --git a/Sources/AlphaSwiftage/Private/AlphaVantageAPI/AlphaVantageAPI.swift b/Sources/AlphaSwiftage/Private/AlphaVantageAPI/AlphaVantageAPI.swift
@@ -0,0 +1,18 @@
+import Foundation
+
+enum AlphaVantageAPI {
+    enum Function: String {
+        case globalQuote = "GLOBAL_QUOTE"
+        case currencyExchangeRate = "CURRENCY_EXCHANGE_RATE"
+        case symbolSearch = "SYMBOL_SEARCH"
+        case dailyAdjustedTimeSeries = "TIME_SERIES_DAILY_ADJUSTED"
+    }
+
+    enum Parameter: String {
+        case symbol
+        case apiKey = "apikey"
+        case fromCurrency = "from_currency"
+        case toCurrency = "to_currency"
+        case keywords
+    }
+}
diff --git a/Sources/AlphaSwiftage/Private/AlphaVantageAPI/AlphaVantageRequest.swift b/Sources/AlphaSwiftage/Private/AlphaVantageAPI/AlphaVantageRequest.swift
@@ -0,0 +1,8 @@
+import Foundation
+import Alamofire
+
+struct AlphaVantageRequest {
+    let url: URL
+    let parameters: Parameters
+    let headers: HTTPHeaders
+}
diff --git a/Sources/AlphaSwiftage/Private/AlphaVantageAPI/AlphaVantageRequestBuilder.swift b/Sources/AlphaSwiftage/Private/AlphaVantageAPI/AlphaVantageRequestBuilder.swift
@@ -0,0 +1,72 @@
+import Alamofire
+import Foundation
+
+class AlphaVantageRequestBuilder {
+    private let host: APIHost
+    
+    init(host: APIHost) {
+        self.host = host
+    }
+    
+    func requestForGlobalQuote(symbol: String) -> AlphaVantageRequest {
+        var parameters = Parameters()
+        parameters.appendFunction(.globalQuote)
+        parameters.appendParameter(.symbol, value: symbol)
+        return request(for: parameters)
+    }
+    
+    func requestForCurrencyExchangeRate(from: String, to: String) -> AlphaVantageRequest {
+        var parameters = Parameters()
+        parameters.appendFunction(.currencyExchangeRate)
+        parameters.appendParameter(.fromCurrency, value: from)
+        parameters.appendParameter(.toCurrency, value: to)
+        return request(for: parameters)
+    }
+    
+    func requestForSymbolSearch(keywords: String) -> AlphaVantageRequest {
+        var parameters = Parameters()
+        parameters.appendFunction(.symbolSearch)
+        parameters.appendParameter(.keywords, value: keywords)
+        return request(for: parameters)
+    }
+    
+    func requestForDailyAdjustedTimeSeries(symbol: String) -> AlphaVantageRequest {
+        var parameters = Parameters()
+        parameters.appendFunction(.dailyAdjustedTimeSeries)
+        parameters.appendParameter(.symbol, value: symbol)
+        return request(for: parameters)
+    }
+    
+    private func request(for parameters: Parameters) -> AlphaVantageRequest {
+        var finalParameters = parameters
+        finalParameters.appendParameters(host.baseParameters)
+        
+        return AlphaVantageRequest(url: host.baseURL,
+                                   parameters: finalParameters,
+                                   headers: host.headers)
+    }
+    
+    fileprivate enum Parameter: String {
+        case symbol
+        case function
+        case fromCurrency = "from_currency"
+        case toCurrency = "to_currency"
+        case keywords
+    }
+}
+
+fileprivate extension Parameters {
+    mutating func appendParameter(_ parameter: AlphaVantageAPI.Parameter, value: String) {
+        self[parameter.rawValue] = value
+    }
+    
+    mutating func appendFunction(_ function: AlphaVantageAPI.Function) {
+        self["function"] = function.rawValue
+    }
+    
+    mutating func appendParameters(_ parameters: Parameters) {
+        parameters.forEach { (key: String, value: Any) in
+            self[key] = value
+        }
+    }
+}
diff --git a/Sources/AlphaSwiftage/Public/AlphaVantageService.swift b/Sources/AlphaSwiftage/Public/AlphaVantageService.swift
@@ -2,41 +2,51 @@ import Foundation
 import Alamofire
 
 public class AlphaVantageService {
-    private let apiKey: String
+    private let requestBuilder: AlphaVantageRequestBuilder
     private let session: Session
     
     public convenience init(apiKey: String) {
-        self.init(apiKey: apiKey, session: Session())
+        self.init(serviceType: .native(apiKey: apiKey))
     }
     
-    required init(apiKey: String, session: Session) {
-        self.apiKey = apiKey
+    public convenience init(serviceType: AlphaVantageServiceType) {
+        let host = APIHostFactory.shared.host(for: serviceType)
+        let requestBuilder = AlphaVantageRequestBuilder(host: host)
+        self.init(requestBuilder: requestBuilder, session: Session())
+    }
+    
+    required init(requestBuilder: AlphaVantageRequestBuilder, session: Session) {
+        self.requestBuilder = requestBuilder
         self.session = session
     }
     
     public func quote(for symbol: String) async -> Result<Quote, AlphaVantageError>  {
-        let request = AlphaVantageAPI.globalQuote(symbol: symbol, apiKey: apiKey)
-        
+        let request = requestBuilder.requestForGlobalQuote(symbol: symbol)
         return await session.request(request)
             .serializingAlphaVantageWrappedResponse(QuoteResponse.self) { $0.quote }
     }
     
     public func currencyExchangeRate(from base: String, to target: String) async -> Result<CurrencyExchangeRate, AlphaVantageError>  {
-        let request = AlphaVantageAPI.currencyExchangeRate(from: base, to: target, apiKey: apiKey)
-        
+        let request = requestBuilder.requestForCurrencyExchangeRate(from: base, to: target)
         return await session.request(request)
             .serializingAlphaVantageWrappedResponse(CurrencyExchangeRateResponse.self) { $0.exchangeRate }
     }
     
     public func symbolSearch(keywords: String) async -> Result<[Symbol], AlphaVantageError> {
-        let request = AlphaVantageAPI.symbolSearch(keywords: keywords, apiKey: apiKey)
+        let request = requestBuilder.requestForSymbolSearch(keywords: keywords)
         return await session.request(request)
             .serializingAlphaVantageWrappedResponse(SearchSymbolResponse.self) { $0.matches }
     }
     
     public func dailyAdjustedTimeSeries(for symbol: String) async -> Result<[String: EquityDailyData], AlphaVantageError> {
-        let request = AlphaVantageAPI.dailyAdjustedTimeSeries(symbol: symbol, apiKey: apiKey)
+        let request = requestBuilder.requestForDailyAdjustedTimeSeries(symbol: symbol)
         return await session.request(request)
             .serializingAlphaVantageWrappedResponse(TimeSeriesResponse.self) { $0.dailyTimeSeries }
     }
 }
+
+extension Session {
+    func request(_ request: AlphaVantageRequest) -> DataRequest {
+        self.request(request.url, parameters: request.parameters, headers: request.headers)
+    }
+}
diff --git a/Sources/AlphaSwiftage/Public/AlphaVantageServiceType.swift b/Sources/AlphaSwiftage/Public/AlphaVantageServiceType.swift
@@ -0,0 +1,6 @@
+import Foundation
+
+public enum AlphaVantageServiceType {
+    case native(apiKey: String)
+    case rapidAPI(apiKey: String)
+}
diff --git a/Tests/APIHostFactoryTestCase.swift b/Tests/APIHostFactoryTestCase.swift
@@ -0,0 +1,13 @@
+import XCTest
+
+@testable import AlphaSwiftage
+
+class APIHostFactoryTestCase: XCTestCase {
+    func testExpectedHostIsCreated() {
+        let native = APIHostFactory.shared.host(for: .native(apiKey: ""))
+        XCTAssert(native is NativeAPIHost)
+        
+        let rapid = APIHostFactory.shared.host(for: .rapidAPI(apiKey: ""))
+        XCTAssert(rapid is RapidAPIHost)
+    }
+}
diff --git a/Tests/APIHostsTestCase.swift b/Tests/APIHostsTestCase.swift
@@ -0,0 +1,28 @@
+import XCTest
+import Alamofire
+
+@testable import AlphaSwiftage
+
+class APIHostsTestCase: XCTestCase {
+    
+    func testNativeAPIHost() {
+        let apiKey = "daApiKey"
+        let host = NativeAPIHost(apiKey: apiKey)
+        
+        XCTAssertEqual(host.baseURL.absoluteString, "https://www.alphavantage.co/query")
+        XCTAssertEqual(host.headers.dictionary, HTTPHeaders().dictionary)
+        XCTAssertEqual(host.baseParameters as! [String: String], ["apikey": apiKey])
+    }
+    
+    func testRapidAPIHost() {
+        let apiKey = "theApiKey"
+        let host = RapidAPIHost(apiKey: apiKey)
+        
+        XCTAssertEqual(host.baseURL.absoluteString, "https://alpha-vantage.p.rapidapi.com/query")
+        XCTAssertEqual(host.headers.dictionary, HTTPHeaders([
+            "x-rapidapi-host": "alpha-vantage.p.rapidapi.com",
+            "x-rapidapi-key": apiKey
+        ]).dictionary)
+        XCTAssertEqual(host.baseParameters as! [String: String], [:])
+    }
+}
diff --git a/Tests/AlphaVantageRequestBuilderTestCase.swift b/Tests/AlphaVantageRequestBuilderTestCase.swift
diff --git a/Tests/AlphaVantageServiceTests.swift b/Tests/AlphaVantageServiceTests.swift
