Authenticator.swift

import RxSwift
import Heimdallr


class Authenticator {
    static let tokenURL = NSURL(string: "http://localhost:3000/oauth/token")
    let oauthProvider: Heimdallr
    
    init() {
        let credentials = OAuthClientCredentials(id: "", secret: "")
        self.oauthProvider = Heimdallr(tokenURL: Authenticator.tokenURL, credentials: credentials)
    }
    
    func signRequest(request: NSURLRequest) -> Observable<NSURLRequest> {
        return Observable.create {
            observer in
            
            self.oauthProvider.authenticateRequest(request) {
                result in
                switch result {
                case .Success(let signedRequest):
                    observer.onNext(signedRequest)
                case .Failure(let error):
                    observer.onError(error)
                }
                observer.onCompleted()
            }
            
            return NopDisposable.instance
        }
    }
}

Endpoint.swift

import Moya

public enum Endpoint {
    case Me
}

extension Endpoint: TargetType {
    public var baseURL: NSURL { return NSURL(string: "http://localhost:3000/api/v1")! }
    
    public var path: String {
        switch self {
        case .Me:
            return "/user/me"
        }
    }
    
    public var method: RxMoya.Method {
        return .GET
    }
    
    public var parameters: [String: AnyObject]? {
        return nil
    }
    
    public var sampleData: NSData {
        return NSData()
    }
}

extension Endpoint {
    var requiresAuthentication: Bool {
        switch self {
        case .Me:
            return true
        }
    }
}

extension Endpoint {
    var requiresAuthentication: Bool {
        switch self {
        case .Me:
            return true
        }
    }
}

Provider.swift

import RxSwift
import RxMoya

enum APIProviderError: ErrorType {
    case NoToken
}

class Provider: RxMoyaProvider<Endpoint> {
    typealias Target = Endpoint
    
    let authenticator: Authenticator
    
    let disposeBag: DisposeBag
    
    init() {
        let authProvider = Authenticator()
        let bag = DisposeBag()
        
        let signRequest = {
            (endpoint: RxMoya.Endpoint<Target>, done: (NSURLRequest -> Void)) in
            
            authProvider
                .signRequest(endpoint.urlRequest).subscribeNext {
                    done($0)
                }
                .addDisposableTo(bag)
        }
        
        self.disposeBag = bag
        self.authenticator = authProvider
        super.init(requestClosure: signRequest)
    }
    
    override func request(token: Target) -> Observable<Response> {
        if token.requiresAuthentication {
            if !self.authenticator.oauthProvider.hasAccessToken {
                return Observable<Response>.error(APIProviderError.NoToken)
            }
        }
        
        return super.request(token)
    }
}