The base of octokit.swift, TanukiKit, TrashCanKit and VloggerKit.
# Cartfile
github "nerdishbynature/RequestKit"
# Podfile
pod "NBNRequestKit"
To make a request using RequestKit you will need three parts: a Router, a Configuration and usually an object that know both and connects them. See OctoKit.
Router are defined by the Router protocol. It is recommended to define them as Enumerations having a case for every route.
This is what a basic router looks like:
enum MyRouter: Router {
case getMyself(Configuration)
var configuration: Configuration {
switch self {
case .getMyself(let config): return config
}
}
var method: HTTPMethod {
switch self {
case .getMyself:
return .GET
}
}
var encoding: HTTPEncoding {
switch self {
case .getMyself:
return .url
}
}
var path: String {
switch self {
case .getMyself:
return "myself"
}
}
var params: [String: Any] {
switch self {
case .getMyself(_):
return ["key1": "value1", "key2": "value2"]
}
}
}As RequestKit was designed to handle OAuth requests we needed something to store user credentials. This is where Configurations come into play. Configurations are defined in the Configuration protocol.
public struct TokenConfiguration: Configuration {
public let accessToken: String?
public let apiEndpoint = "https://my.webservice.example/api/2.0/"
public let accessTokenFieldName = "access_token"
public let errorDomain = "com.my.customErrorDomain"
public init(_ accessToken: String? = nil) {
self.accessToken = accessToken
}
}In the above Configuration the accessToken will be passed as a URL parameter named access_token with each request. Alternatively you can have the accessToken passed in an HTTP Authorization header by setting the authorizationHeader property to the desired token type. As an example the following Configuration passes it as a Bearer token.
public struct TokenConfiguration: Configuration {
public let accessToken: String?
public let apiEndpoint = "https://my.webservice.example/api/2.0/"
public let authorizationHeader: String? = "Bearer"
public let errorDomain = "com.my.customErrorDomain"
public init(_ accessToken: String? = nil) {
self.accessToken = accessToken
}
}We will need something that connects the router and the configuration to make provide a convenient interface. The common way of doing this is to use a struct or a class that does it for you.
struct User : Codable {
}
struct MyWebservice {
var configuration: Configuration
init(configuration: Configuration) {
self.configuration = configuration
}
func getMyself(session: RequestKitURLSession = URLSession.shared, completion: @escaping (_ response: Response<User>) -> Void) -> URLSessionDataTaskProtocol? {
let router = MyRouter.getMyself(self.configuration)
return router.load(session, expectedResultType: User.self) { user, error in
if let error = error {
completion(Response.failure(error))
} else if let user = user {
completion(Response.success(user))
}
}
}
}All your user has to do is call your MyWebservice:
let config = TokenConfiguration("123456")
MyWebservice(configuration:config).getMyself { response in
switch response {
case .success(let user):
print(user)
case .failure(let error):
print(error)
}
}
}