【Swift】APIのアクセストークンの処理でPhantomTypeを利用してみる

# はじめに

APIの通信周りの処理をframeworkとして別プロジェクトで管理したりする中で、APIリクエスト時のアクセストークンをアプリ側からタイプセーフに注入するとこができないかなと考えていました。
そんな中で、**PhantomType**を活用すればうまくいくかもしれないと思い立ったので実践してみました。
PhantomTypeやSwiftでの利用法については、「[Swift で Phantom Type (幽霊型)](https://qiita.com/taketo1024/items/71e3272211f08d7e0cde)」をご覧いただけると幸いです。

# PhantomTypeを利用したTokenを保持するオブジェクトの実装

この投稿では、[APIKit](https://github.com/ishkawa/APIKit)を利用していきます。
外部からtokenを注入する実装にすると、簡易的な利用例は下記のようになります。

```swift:利用例
enum UserRequest {
    struct GetByID: NetworkRequest {
        ...
        let id: String
        let requiresAuthorization = true
        ...
    }
    struct GetByIDs: NetworkRequest {
        ...
        let ids: [String]
        let requiresAuthorization = true
        ...
    }
}

// 初期化時の引数にInjectableTokenを返すクロージャーを渡す
let client = NetworkClient(injectToken: { InjectableToken(token: "Any Token") })

let request = UserRequest.GetByID(id: "1234ABCD")
client.send(request) { result in
    // do something
}
```

この例だけでは、NetworkClientの引数のinjectTokenで、tokenを引数にした`InjectableToken`を返しているだけの実装にしか見えないと思うので、内部でどのようにPhantomTypeが利用されているかを記述していこうと思います。

## NetworkRequest

まずは、`APIKit.Request`を採用している`NetworkRequest` protocolを定義します。
`NetworkRequest`では、APIにアクセスする際に認証情報が必要かどうかのpropertyが宣言されています。

```swift:NetworkRequest.swift
public protocol NetworkRequest: Request {
    var requiresAuthorization: Bool { get }
}
```

## InjectableToken

次に、トークンを注入するための`InjectableToken`を実装します。
ここでPhantomTypeを利用していきます。


```swift:InjectableToken.swift
public protocol Status {}
public enum Ready: Status {}
public enum NotReady: Status {}

public typealias InjectableToken = InjectableToken_<NotReady>

enum InjectError: Error {
    case emptyToken
}

public struct InjectableToken_<T: Status> {
    private let _token: String?
}

extension InjectableToken_ where T == NotReady {
    // structなので`public convenience init(token: String?)`と記載できない
    public init(token: String?) {
        self.init(_token: token)
    }

    func readify<U: NetworkRequest>(with request: U) throws -> InjectableToken_<Ready> {
        let token: String?
        if request.requiresAuthorization {
            guard let _token = _token, !_token.isEmpty else {
                throw InjectError.emptyToken
            }
            token = _token
        } else {
            token = nil
        }
        return .init(_token: token)
    }
}

extension InjectableToken_ where T == Ready {
    var token: String? {
        return _token
    }
}

```

まず始めに`Status` protocolを宣言し、それらを採用している`Ready`と`NotReady`のenumを定義します。これらがトークンの状態を示す型になります。
次にGenericType `T`を持つ`InjectableToken_`を定義します。TはStatusに準拠させます。InjectableToken_はprivateな`_token: String?`を持っています。
そして、typealiasで`InjectableToken_`を**InjectableToken = InjectableToken\_\<NotReady\>**とし、InjectableTokenを返すstatic functionを定義します。このよう実装することで、`InjectableToken(token: "Any Token")`のように初期化ができるようになります。
function内では、InjectableToken\_のMemberwise Initializerを利用して、\_tokenを初期化しています。
この時点で返されるのは、**InjectableToken\_\<NotReady\>**なので、外部から**\_token**にアクセスすることはできません。
次に**InjectableToken\_\<Ready\>**にするために `func readify(with:_) -> InjectableToken_<Ready>`を定義します。
上記を定義する際はTがNotReadyである場合にのみ利用したいので、InjectableToken\_のextensionに定義します。
readifyの中では、引数でNetworkRequestに準拠したオブジェクトが渡ってるので、`requiresAuthorization`がtrueの場合は_tokenが存在し空文字列でないことを確認し、**InjectableToken\_\<Ready\>**として初期化してから返します。`requiresAuthorization`がfalseの場合はトークンが不要なので、\_tokenをnilで初期化した**InjectableToken\_\<Ready\>**を返します。
そして、TがReadyの場合にのみアクセスできる`token: String?`をInjectableToken\_のextensionに定義することで、リクエストに対する認証情報をタイプセーフな状態で保持したオブジェクトを実現することができるようになります。

実際に利用する際は下記のようになります。

```swift:利用例
let request = UserRequest.GetByID(id: "1234ABCD")

let notReadyToken = InjectableToken(token: "Any Token")
print(notReadyToken.token) // TがNotReadyなのでエラーになる

do {
    let readyToken = try notReadyToken.readify(with: request)
    print(readyToken.token) // TがReadyなのでtokenにアクセスできる
} catch let error {
    // requiresAuthorizationに対してtokenの状態が正しくなかった場合にエラーとなる
}
```

このような実装にすることによって、下記のようなことが実現できます。

- tokenの状態確認がリクエスト生成時ではなくリクエストを送る直前に行うことができるので、リクエスト自体にtokenの状態に関するエラーハンドリングをする必要がなくなる
- InjectableToken\_\<Ready\>はprivateなinitializerしか持っていないので、外部からtokenを注入させるためにはInjectableToken\_\<NotReady\>からreadifyをしてInjectableToken\_\<Ready\>を取得するという経路をたどらなければいけないという実装にできるので、InjectableToken\_\<Ready\>に直接することはできずtokenの状態が保証される
- InjectableToken\_\<Ready\>でありtokenがnilでない場合はAPIアクセスに必要なトークンが存在していることを明確にでき、逆にInjectableToken\_\<Ready\>でありtokenがnilである場合はAPIアクセスにトークンがそもそも必要でないことも明確にできる

# Tokenを注入可能にするための実装

## RequestProxy

tokenを外部から注入できるようにするために、`RequestProxy`を実装していきます。
RequestProxyを定義することで、NetworkRequestに準拠した各Requestでtokenを持たせる必要がなくなるので、tokenに関する処理を1つにまとめることができます。

```swift:RequestProxy.swift
public struct RequestProxy<T: NetworkRequest>: Request {
    let request: T
    let token: String?

    public var headerFields: [String : String] {
        var headerFields = request.headerFields
        if let token = token {
            headerFields["Authorization"] = "bearer \(token)"
        }
        return headerFields
    }

    init(request: T, injectableToken: InjectableToken_<Ready>) {
        self.request = request
        self.token = injectableToken.token
    }
}

extension RequestProxy {
    public typealias Response = T.Response
    ...
    public var method: HTTPMethod {
        return request.method
    }
    ...
    public func response(from object: Any, urlResponse: HTTPURLResponse) throws -> Response {
        return try request.response(from: object, urlResponse: urlResponse)
    }
}
```

RequestProxyはNetworkRequestに準拠したTをGenericTypeとし、RequestProxy自体はAPIKit.Requestに準拠しています。
initializerの引数は`request: T`と`injectableToken: InjectableToken_<Ready>`で、requestはNetworkRequestをProxyし、injectableTokenは内部のtokenを利用しています。
RequestProxyのtokenをAPIKit.Requestの必須propertyである`headerFields: [String : String]`を定義し、`request.headerFields`に対して`["Authorization" : "bearer \(token)"]`を追加しています。
ここで利用しているtokenは`InjectableToken_<Ready>`から取得しているのものなので、nil・非nilに関わらず認証情報が必要かどうかとtokenが正しいかどうかをチェック済みのものになっています。
そして、RequestProxyのextensionでAPIKit.Requestで定義されているものを一通りRequestProxyのrequestからProxyしていきます。

## NetworkClient

APIにアクセスするためのクライアントの実装は下記のようになります。

```swift:NetworkClient.swift
public final class NetworkClient {
    public struct Error: Swift.Error {
        public let value: Swift.Error
    }

    private let injectToken: () -> InjectableToken
    private let session: Session

    public init(injectToken: @escaping () -> InjectableToken, configuration: URLSessionConfiguration = .default) {
        let adapter = URLSessionAdapter(configuration: .default)
        self.session = Session(adapter: adapter)
        self.injectToken = injectToken
    }

    public func send<T: NetworkRequest>(_ request: T, completion: @escaping (Result<T.Response, Error>) -> ()) {
        let injectableToken: InjectableToken_<Ready>
        do {
            injectableToken = try injectToken().readify(with: request)
        } catch let error {
            completion(.failure(Error(value: error)))
            return
        }
        let proxy = RequestProxy(request: request, injectableToken: injectableToken)
        session.send(proxy) { result in
            switch result {
            case .success(let value):
                completion(.success(value))
            case .failure(let error):
                completion(.failure(Error(value: error)))
            }
        }
    }
}
```

initializerの引数である`injectToken: @escaping () -> InjectableToken`は、InjectableTokenが`InjectableToken_<NotReady>`としてtypealiasされているものになります。
このクロージャーをリクエストを送信する直前に`let injectableToken = try injectToken().readify(with: request)`として、アプリ側からtokenを取得し、readifyでrequestをもとに認証情報が必要なリクエストなのかとtokenが正しいものなのかをチェックし、InjectableToken\_\<Ready\>なinjectableTokenを取得します。
そして、injectableTokenとrequestをもとにRequestProxyを初期化し、tokenを注入してリクエストを行います。

# 最後に

ふと思い立って実践してみたので不備がある箇所があるかもしれませんが、このようにしてアクセストークンをPhantomTypeを利用してタイプセーフに注入することができます。