Swift concurrency support

Author: Daiki Matsudate

Package.swift

@@ -4,7 +4,7 @@ import PackageDescription
 
 let package = Package(
   name: "OAuth2Client",
-  platforms: [.iOS(.v14), .macOS(.v11)],
+  platforms: [.iOS("15.0"), .macOS("12.0")],
   products: [
     .library(
       name: "OAuth2Client",

README.md

@@ -10,13 +10,7 @@ Lightweight OAuth 2.0 Client with PKCE (Proof key for Code Exchange: see [RFC 76
 ### Sign in
 
 ```swift
-OAuth2Client().signIn(request: request) 
-  .receive(on: yourQueue)
-  .sink(receiveCompletion: { (completion) in
-    
-  }, receiveValue: { (credential) in
-    credential.save()
-  })
+  let credential = await OAuth2Client().signIn(request: request) 
 ```
 
 ### Load Access Token
@@ -28,41 +22,33 @@ Credential.load()
 ### Refresh
 
 ```swift
-OAuth2Client().refresh(request: request) 
-.receive(on: yourQueue)
-.sink(receiveCompletion: { (completion) in
-
-}, receiveValue: { (credential) in
-credential.save()
-})
+let credential = await OAuth2Client().refresh(request: request) 
 ```
 
 ### Sign Out
-Removing cache on WebKit, and showing new auth screen.
+Removing cache on WebKit, and show new screen to authenticate.
 
 ```swift
-OAuth2Client().signOut(request: request) 
-  .receive(on: yourQueue)
-  .sink(receiveCompletion: { (completion) in
-
-  }, receiveValue: { (credential) in
-    credential.save()
-  })
+let credential = await OAuth2Client().signOut(request: request) 
 ```
 
 ## Features
 
 - [x] Supporting OAuth 2.0 with PKCE
 - [x] Publish / refresh access token
-- [x] Combine interface
+- [x] Swift Concurrency interface
+
+Note: If you want to use Combine interface, use 0.x version
 
 ## General notes for OAuth 2.0
 - Make sure setting callback url scheme on your setting
 
 ## Supported platforms
 
-- macOS v11.0 and later
-- iOS / iPadOS v14.0 and later
+- macOS v12.0 or later
+- iOS / iPadOS v15.0 or later
+
+Note: After Swift Concurrency is backported, iOS 13.0 / macOS 10.15 can be used
 
 ## Installation
 
@@ -72,6 +58,6 @@ Only support via Swift package manager installation.
 
 ```swift
 dependencies: [
-  .package(url: "https://github.com/d-date/OAuth2Client.git", from: "0.1.0")
+  .package(url: "https://github.com/d-date/OAuth2Client.git", .branch("concurrency"))
 ]
 ```

Sources/OAuth2Client/OAuth2Client.swift

@@ -1,155 +1,85 @@
 import AuthenticationServices
-import Combine
 import Foundation
 import WebKit
 import os.log
 
-public class OAuth2Client: NSObject {
-
-  private var cancellables: [AnyCancellable] = []
+public actor OAuth2Client: NSObject {
 
   var logger: Logger
 
   public init(logger: Logger = .init()) {
     self.logger = logger
   }
 
-  public func signIn(with request: Request) -> Future<Credential, OAuth2Error> {
-    return Future { [weak self, logger] completion in
-      guard let self = self else { return }
-      guard let components = URLComponents(string: request.redirectUri),
-        let callbackScheme = components.scheme
-      else {
-        completion(.failure(OAuth2Error.invalidRedirectUri))
-        return
-      }
-      let pkce = PKCE()
-      self.requestAuth(url: request.buildAuthorizeURL(pkce: pkce), callbackScheme: callbackScheme)
-        .flatMap { return self.requestToken(for: request.buildTokenURL(code: $0, pkce: pkce)) }
-        .sink { (result) in
-          switch result {
-          case .failure(let error):
-            logger.error("\(error.localizedDescription)")
-            completion(.failure(error))
-          default: break
-          }
-        } receiveValue: { [logger] credential in
-          logger.debug("\(credential.accessToken)")
-          completion(.success(credential))
-        }
-        .store(in: &self.cancellables)
-
+  public func signIn(with request: Request) async throws -> Credential {
+    guard let components = URLComponents(string: request.redirectUri),
+          let callbackScheme = components.scheme
+    else {
+      throw OAuth2Error.invalidRedirectUri
     }
+    let pkce = PKCE()
+    let code = try await requestAuth(url: request.buildAuthorizeURL(pkce: pkce), callbackScheme: callbackScheme)
+    let url = request.buildTokenURL(code: code, pkce: pkce)
+    return try await requestToken(for: url)
   }
 
-  public func signOut(with request: Request) -> Future<Credential, OAuth2Error> {
-    Future { finalCompletion in
-      let dataTypes = Set([
-        WKWebsiteDataTypeCookies, WKWebsiteDataTypeSessionStorage, WKWebsiteDataTypeLocalStorage,
-        WKWebsiteDataTypeWebSQLDatabases, WKWebsiteDataTypeIndexedDBDatabases,
-      ])
-      Future<Void, Never> { completion in
-        WKWebsiteDataStore.default().removeData(ofTypes: dataTypes, modifiedSince: Date.distantPast)
-        {
-          completion(.success(()))
-        }
-      }.flatMap {
-        self.signIn(with: request)
-      }
-      .sink { (completion) in
-        switch completion {
-        case let .failure(error):
-          finalCompletion(.failure(error))
-        default:
-          break
-        }
-      } receiveValue: { (value) in
-        finalCompletion(.success(value))
-      }
-      .store(in: &self.cancellables)
-    }
+  public func signOut(with request: Request) async throws -> Credential {
+    let dataTypes = Set([
+      WKWebsiteDataTypeCookies, WKWebsiteDataTypeSessionStorage, WKWebsiteDataTypeLocalStorage,
+      WKWebsiteDataTypeWebSQLDatabases, WKWebsiteDataTypeIndexedDBDatabases,
+    ])
+    await WKWebsiteDataStore.default().removeData(ofTypes: dataTypes, modifiedSince: Date.distantPast)
+    return try await signIn(with: request)
   }
 
-  public func refresh(with request: Request, refreshToken: String) -> Future<
-    Credential, OAuth2Error
-  > {
-    Future { [weak self] completion in
-      guard let self = self else { return }
-      self.requestToken(for: request.buildRefreshTokenURL(refreshToken: refreshToken))
-        .sink { (result) in
-          switch result {
-          case .failure(let error):
-            completion(.failure(error))
-          default: break
-          }
-        } receiveValue: { credential in
-          credential.save()
-          completion(.success(credential))
-        }
-        .store(in: &self.cancellables)
-    }
+  public func refresh(with request: Request, refreshToken: String) async throws -> Credential {
+    try await requestToken(for: request.buildRefreshTokenURL(refreshToken: refreshToken))
   }
 }
 
 extension OAuth2Client: ASWebAuthenticationPresentationContextProviding {
-  public func presentationAnchor(for session: ASWebAuthenticationSession) -> ASPresentationAnchor {
+  nonisolated public func presentationAnchor(for session: ASWebAuthenticationSession) -> ASPresentationAnchor {
     .init()
   }
 }
 
 extension OAuth2Client {
-  fileprivate func requestAuth(url: URL, callbackScheme: String) -> Future<String, OAuth2Error> {
-    Future { [weak self] finalCompletion in
-      guard let self = self else { return }
-      Future<URL, OAuth2Error> { completion in
-        let session = ASWebAuthenticationSession(url: url, callbackURLScheme: callbackScheme) {
-          (url, error) in
-          if let error = error {
-            completion(.failure(OAuth2Error.authError(error as NSError)))
-          } else if let url = url {
-            completion(.success(url))
-          }
+  fileprivate func requestAuth(url: URL, callbackScheme: String) async throws -> String {
+    let url: URL = try await withCheckedThrowingContinuation { continuation in
+      let session = ASWebAuthenticationSession(url: url, callbackURLScheme: callbackScheme) { url, error in
+        if let error = error {
+          continuation.resume(throwing: OAuth2Error.authError(error as NSError))
+        } else if let url = url {
+          continuation.resume(returning: url)
         }
-        session.presentationContextProvider = self
-        session.prefersEphemeralWebBrowserSession = true
-        session.start()
-      }.tryMap { url in
-        guard let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
-          let code = components.queryItems?.first(where: { $0.name == "code" })?.value
-        else {
-          throw OAuth2Error.codeNotFound
-        }
-        return code
-      }.sink { (completion) in
-        switch completion {
-        case .failure(let error):
-          finalCompletion(.failure(OAuth2Error.authError(error as NSError)))
-        default:
-          break
-        }
-      } receiveValue: { code in
-        finalCompletion(.success(code))
       }
-      .store(in: &self.cancellables)
+      session.presentationContextProvider = self
+      session.prefersEphemeralWebBrowserSession = true
+      session.start()
+    }
+
+    guard let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
+          let code = components.queryItems?.first(where: { $0.name == "code" })?.value
+    else {
+      throw OAuth2Error.codeNotFound
     }
+    return code
   }
 
-  fileprivate func requestToken(for url: URL) -> AnyPublisher<Credential, OAuth2Error> {
+  fileprivate func requestToken(for url: URL) async throws -> Credential {
     var request = URLRequest(url: url)
     request.httpMethod = "POST"
     request.addValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
     request.addValue("application/json", forHTTPHeaderField: "Accept")
 
-    return URLSession.shared.dataTaskPublisher(for: request)
-      .tryMap { data, response in
-        guard let httpResponse = response as? HTTPURLResponse, 200..<300 ~= httpResponse.statusCode
-        else {
-          throw OAuth2Error.urlError(URLError(.badServerResponse))
-        }
-        return data
-      }
-      .decode(type: Credential.self, decoder: JSONDecoder.convertFromSnakeCase)
-      .mapError { OAuth2Error.decodingError($0 as NSError) }
-      .eraseToAnyPublisher()
+    let (data, response) = try await URLSession.shared.data(for: request)
+    guard let httpResponse = response as? HTTPURLResponse, 200..<300 ~= httpResponse.statusCode else {
+      throw OAuth2Error.urlError(URLError(.badServerResponse))
+    }
+    do {
+      return try JSONDecoder.convertFromSnakeCase.decode(Credential.self, from: data)
+    } catch {
+      throw OAuth2Error.decodingError(error as NSError)
+    }
   }
 }