Add parameter option to Request (#494)

* Make `Request.payload` modifiable

* Add `parameter` to `credentials` in `CredentialsManager`

* rename `parameter` -> `parameters`

* use spaces instead of tabs for formatting

* add Comments for parameters

* use spaces on comment

* rename `payload` to `parameters`

* add tests to read and modify payload on renew

* update override Test

* add test to verify that copied object contains the same information

* Fix several typos and improve API readability

* Add test to check if parameters are passed through the HTTP-layer

* Update Auth0/CredentialsManager.swift

* Update Auth0Tests/CredentialsManagerSpec.swift

* Update Auth0/Request.swift

Co-authored-by: Rita Zerrizuela <[email protected]>

Author: kmeinh

Auth0/CredentialsManager.swift

@@ -164,70 +164,74 @@ public struct CredentialsManager {
     /// - Parameters:
     ///   - scope: scopes to request for the new tokens. By default is nil which will ask for the same ones requested during original Auth.
     ///   - minTTL: minimum time in seconds the access token must remain valid to avoid being renewed.
+    ///   - parameters: additional parameters to add to a possible token refresh. The parameters will be set via Request.payload.
     ///   - callback: callback with the user's credentials or the cause of the error.
     /// - Important: This method only works for a refresh token obtained after auth with OAuth 2.0 API Authorization.
     /// - Note: [Auth0 Refresh Tokens Docs](https://auth0.com/docs/tokens/concepts/refresh-tokens)
     #if WEB_AUTH_PLATFORM
-    public func credentials(withScope scope: String? = nil, minTTL: Int = 0, callback: @escaping (CredentialsManagerError?, Credentials?) -> Void) {
+    public func credentials(withScope scope: String? = nil, minTTL: Int = 0, parameters: [String: Any] = [:], callback: @escaping (CredentialsManagerError?, Credentials?) -> Void) {
         guard self.hasValid(minTTL: minTTL) else { return callback(.noCredentials, nil) }
         if #available(iOS 9.0, macOS 10.15, *), let bioAuth = self.bioAuth {
             guard bioAuth.available else { return callback(.touchFailed(LAError(LAError.touchIDNotAvailable)), nil) }
             bioAuth.validateBiometric {
                 guard $0 == nil else {
                     return callback(.touchFailed($0!), nil)
                 }
-                self.retrieveCredentials(withScope: scope, minTTL: minTTL, callback: callback)
+                self.retrieveCredentials(withScope: scope, minTTL: minTTL, parameters: parameters, callback: callback)
             }
         } else {
-            self.retrieveCredentials(withScope: scope, minTTL: minTTL, callback: callback)
+            self.retrieveCredentials(withScope: scope, minTTL: minTTL, parameters: parameters, callback: callback)
         }
     }
     #else
-    public func credentials(withScope scope: String? = nil, minTTL: Int = 0, callback: @escaping (CredentialsManagerError?, Credentials?) -> Void) {
+    public func credentials(withScope scope: String? = nil, minTTL: Int = 0, parameters: [String: Any] = [:], callback: @escaping (CredentialsManagerError?, Credentials?) -> Void) {
         guard self.hasValid(minTTL: minTTL) else { return callback(.noCredentials, nil) }
-        self.retrieveCredentials(withScope: scope, minTTL: minTTL, callback: callback)
+        self.retrieveCredentials(withScope: scope, minTTL: minTTL, parameters: parameters, callback: callback)
     }
     #endif
 
     private func retrieveCredentials() -> Credentials? {
         guard let data = self.storage.data(forKey: self.storeKey),
-            let credentials = NSKeyedUnarchiver.unarchiveObject(with: data) as? Credentials else { return nil }
+              let credentials = NSKeyedUnarchiver.unarchiveObject(with: data) as? Credentials else { return nil }
 
         return credentials
     }
 
-    private func retrieveCredentials(withScope scope: String?, minTTL: Int, callback: @escaping (CredentialsManagerError?, Credentials?) -> Void) {
+    private func retrieveCredentials(withScope scope: String?, minTTL: Int, parameters: [String: Any] = [:], callback: @escaping (CredentialsManagerError?, Credentials?) -> Void) {
         guard let credentials = retrieveCredentials(),
-            let expiresIn = credentials.expiresIn else { return callback(.noCredentials, nil) }
+              let expiresIn = credentials.expiresIn else { return callback(.noCredentials, nil) }
         guard self.hasExpired(credentials) ||
-            self.willExpire(credentials, within: minTTL) ||
-            self.hasScopeChanged(credentials, from: scope) else { return callback(nil, credentials) }
+                self.willExpire(credentials, within: minTTL) ||
+                self.hasScopeChanged(credentials, from: scope) else { return callback(nil, credentials) }
         guard let refreshToken = credentials.refreshToken else { return callback(.noRefreshToken, nil) }
 
-        self.authentication.renew(withRefreshToken: refreshToken, scope: scope).start {
-            switch $0 {
-            case .success(let credentials):
-                let newCredentials = Credentials(accessToken: credentials.accessToken,
-                                                 tokenType: credentials.tokenType,
-                                                 idToken: credentials.idToken,
-                                                 refreshToken: credentials.refreshToken ?? refreshToken,
-                                                 expiresIn: credentials.expiresIn,
-                                                 scope: credentials.scope)
-                if self.willExpire(newCredentials, within: minTTL) {
-                    let accessTokenLifetime = Int(expiresIn.timeIntervalSinceNow)
-                    // TODO: On the next major add a new case to CredentialsManagerError
-                    let error = NSError(domain: "The lifetime of the renewed Access Token (\(accessTokenLifetime)s) is less than minTTL requested (\(minTTL)s). Increase the 'Token Expiration' setting of your Auth0 API in the dashboard or request a lower minTTL",
-                        code: -99999,
-                        userInfo: nil)
+        self.authentication
+            .renew(withRefreshToken: refreshToken, scope: scope)
+            .parameters(parameters)
+            .start {
+                switch $0 {
+                case .success(let credentials):
+                    let newCredentials = Credentials(accessToken: credentials.accessToken,
+                                                     tokenType: credentials.tokenType,
+                                                     idToken: credentials.idToken,
+                                                     refreshToken: credentials.refreshToken ?? refreshToken,
+                                                     expiresIn: credentials.expiresIn,
+                                                     scope: credentials.scope)
+                    if self.willExpire(newCredentials, within: minTTL) {
+                        let accessTokenLifetime = Int(expiresIn.timeIntervalSinceNow)
+                        // TODO: On the next major add a new case to CredentialsManagerError
+                        let error = NSError(domain: "The lifetime of the renewed Access Token (\(accessTokenLifetime)s) is less than minTTL requested (\(minTTL)s). Increase the 'Token Expiration' setting of your Auth0 API in the dashboard or request a lower minTTL",
+                                            code: -99999,
+                                            userInfo: nil)
+                        callback(.failedRefresh(error), nil)
+                    } else {
+                        _ = self.store(credentials: newCredentials)
+                        callback(nil, newCredentials)
+                    }
+                case .failure(let error):
                     callback(.failedRefresh(error), nil)
-                } else {
-                    _ = self.store(credentials: newCredentials)
-                    callback(nil, newCredentials)
                 }
-            case .failure(let error):
-                callback(.failedRefresh(error), nil)
             }
-        }
     }
 
     func willExpire(_ credentials: Credentials, within ttl: Int) -> Bool {

Auth0/Request.swift

@@ -95,6 +95,17 @@ public struct Request<T, E: Auth0Error>: Requestable {
         task.resume()
     }
 
+    /**
+     Modify the parameters by creating a copy of self and adding the provided parameters to `payload`.
+
+     - parameter payload: Additional parameters for the request. The provided map will be added to `payload`.
+     */
+    public func parameters(_ payload: [String: Any]) -> Self {
+        var parameter = self.payload
+        payload.forEach { parameter[$0] = $1 }
+
+        return Request(session: self.session, url: self.url, method: self.method, handle: self.handle, payload: parameter, headers: self.headers, logger: self.logger, telemetry: self.telemetry)
+    }
 }
 
 /**

Auth0Tests/AuthenticationSpec.swift

@@ -318,7 +318,46 @@ class AuthenticationSpec: QuickSpec {
             }
 
         }
-        
+
+        // MARK:- Modify and Create Requests
+
+        describe("Requests create and update") {
+
+            let refreshToken = UUID().uuidString.replacingOccurrences(of: "-", with: "")
+
+            it("should contain payload") {
+                let request = auth.renew(withRefreshToken: refreshToken)
+
+                expect(request.payload["refresh_token"] as? String) == refreshToken
+                expect(request.payload["grant_type"] as? String) == "refresh_token"
+                expect(request.payload["client_id"] as? String) == ClientId
+            }
+
+            it("add and override parameters") {
+                let request = auth.renew(withRefreshToken: refreshToken)
+                    .parameters([
+                        "client_id": "new Client ID",
+                        "phone": Phone
+                    ])
+
+                expect(request.payload["refresh_token"] as? String) == refreshToken
+                expect(request.payload["grant_type"] as? String) == "refresh_token"
+                expect(request.payload["client_id"] as? String) == "new Client ID"
+                expect(request.payload["phone"] as? String) == Phone
+            }
+
+            it("copy contains same informations") {
+                let baseRequest = auth.renew(withRefreshToken: refreshToken)
+                let modifiedRequest = baseRequest.parameters([:])
+
+                expect(baseRequest.session) == modifiedRequest.session
+                expect(baseRequest.url) == modifiedRequest.url
+                expect(baseRequest.method) == modifiedRequest.method
+                expect(baseRequest.payload as? [String: String]) == modifiedRequest.payload as? [String: String]
+                expect(baseRequest.headers) == modifiedRequest.headers
+            }
+        }
+
         // MARK:- Token Exchange
 
         describe("native social token exchange") {

Auth0Tests/CredentialsManagerSpec.swift

@@ -530,6 +530,23 @@ class CredentialsManagerSpec: QuickSpec {
                     }
                 }
 
+                it("request should include custom parameters on renew") {
+                    let someId = UUID().uuidString
+                    stub(condition: isToken(Domain) && hasAtLeast(["refresh_token": RefreshToken, "some_id": someId])) {
+                        _ in return authResponse(accessToken: NewAccessToken, idToken: NewIdToken, refreshToken: NewRefreshToken, expiresIn: 86400)
+                    }
+                    credentials = Credentials(accessToken: AccessToken, tokenType: TokenType, idToken: IdToken, refreshToken: RefreshToken, expiresIn: Date(timeIntervalSinceNow: -3600))
+                    _ = credentialsManager.store(credentials: credentials)
+                    waitUntil(timeout: Timeout) { done in
+                        credentialsManager.credentials(parameters: ["some_id": someId]) { error = $0; newCredentials = $1
+                            expect(error).to(beNil())
+                            expect(newCredentials?.accessToken) == NewAccessToken
+                            expect(newCredentials?.refreshToken) == NewRefreshToken
+                            expect(newCredentials?.idToken) == NewIdToken
+                            done()
+                        }
+                    }
+                }
             }
 
             context("forced renew") {