Refactor subscription configuration and dependency setup

Sources/Common/Extensions/URLExtension.swift

@@ -382,7 +382,7 @@ extension URL {
 
         var percentEncodedQueryItems = components.percentEncodedQueryItems ?? [URLQueryItem]()
         percentEncodedQueryItems.removeAll { parametersToRemove.contains($0.name) }
-        components.percentEncodedQueryItems = percentEncodedQueryItems
+        components.percentEncodedQueryItems = !percentEncodedQueryItems.isEmpty ? percentEncodedQueryItems : nil
 
         return components.url ?? self
     }

Sources/Subscription/Flows/AppStore/AppStoreAccountManagementFlow.swift

@@ -28,25 +28,36 @@ public final class AppStoreAccountManagementFlow {
             case authenticatingWithTransactionFailed
         }
 
+    private var tokenStorage: SubscriptionTokenStorage
+    private var accountStorage: SubscriptionAccountStorage
+    private var accountManager: AccountManaging
+    private var authService: AuthServiceProtocol
+
+    init(tokenStorage: SubscriptionTokenStorage, accountStorage: SubscriptionAccountStorage, accountManager: AccountManaging, authService: AuthServiceProtocol) {
+        self.tokenStorage = tokenStorage
+        self.accountStorage = accountStorage
+        self.accountManager = accountManager
+        self.authService = authService
+    }
+
     @discardableResult
-    public static func refreshAuthTokenIfNeeded(subscriptionAppGroup: String) async -> Result<String, AppStoreAccountManagementFlow.Error> {
+    public func refreshAuthTokenIfNeeded() async -> Result<String, AppStoreAccountManagementFlow.Error> {
         os_log(.info, log: .subscription, "[AppStoreAccountManagementFlow] refreshAuthTokenIfNeeded")
-        let accountManager = AccountManager(subscriptionAppGroup: subscriptionAppGroup)
 
-        var authToken = accountManager.authToken ?? ""
+        var authToken = tokenStorage.authToken ?? ""
 
         // Check if auth token if still valid
-        if case let .failure(validateTokenError) = await AuthService.validateToken(accessToken: authToken) {
+        if case let .failure(validateTokenError) = await authService.validateToken(accessToken: authToken) {
             os_log(.error, log: .subscription, "[AppStoreAccountManagementFlow] validateToken error: %{public}s", String(reflecting: validateTokenError))
 
             // In case of invalid token attempt store based authentication to obtain a new one
             guard let lastTransactionJWSRepresentation = await PurchaseManager.mostRecentTransaction() else { return .failure(.noPastTransaction) }
 
-            switch await AuthService.storeLogin(signature: lastTransactionJWSRepresentation) {
+            switch await authService.storeLogin(signature: lastTransactionJWSRepresentation) {
             case .success(let response):
-                if response.externalID == accountManager.externalID {
+                if response.externalID == accountStorage.externalID {
                     authToken = response.authToken
-                    accountManager.storeAuthToken(token: authToken)
+                    tokenStorage.authToken = authToken
                 }
             case .failure(let storeLoginError):
                 os_log(.error, log: .subscription, "[AppStoreAccountManagementFlow] storeLogin error: %{public}s", String(reflecting: storeLoginError))

Sources/Subscription/Flows/AppStore/AppStorePurchaseFlow.swift

@@ -33,7 +33,21 @@ public final class AppStorePurchaseFlow {
         case missingEntitlements
     }
 
-    public static func subscriptionOptions() async -> Result<SubscriptionOptions, AppStorePurchaseFlow.Error> {
+    private var tokenStorage: SubscriptionTokenStorage
+    private var accountManager: AccountManaging
+    private var authService: AuthServiceProtocol
+    private var subscriptionService: SubscriptionServiceProtocol
+
+    private lazy var appStoreRestoreFlow = AppStoreRestoreFlow(tokenStorage: tokenStorage, accountManager: accountManager, authService: authService, subscriptionService: subscriptionService)
+
+    init(tokenStorage: SubscriptionTokenStorage, accountManager: AccountManaging, authService: AuthServiceProtocol, subscriptionService: SubscriptionServiceProtocol) {
+        self.tokenStorage = tokenStorage
+        self.accountManager = accountManager
+        self.authService = authService
+        self.subscriptionService = subscriptionService
+    }
+
+    public func subscriptionOptions() async -> Result<SubscriptionOptions, AppStorePurchaseFlow.Error> {
         os_log(.info, log: .subscription, "[AppStorePurchaseFlow] subscriptionOptions")
 
         let products = PurchaseManager.shared.availableProducts
@@ -59,17 +73,16 @@ public final class AppStorePurchaseFlow {
     public typealias TransactionJWS = String
 
     // swiftlint:disable cyclomatic_complexity
-    public static func purchaseSubscription(with subscriptionIdentifier: String, emailAccessToken: String?, subscriptionAppGroup: String) async -> Result<TransactionJWS, AppStorePurchaseFlow.Error> {
+    public func purchaseSubscription(with subscriptionIdentifier: String, emailAccessToken: String?) async -> Result<TransactionJWS, AppStorePurchaseFlow.Error> {
         os_log(.info, log: .subscription, "[AppStorePurchaseFlow] purchaseSubscription")
 
-        let accountManager = AccountManager(subscriptionAppGroup: subscriptionAppGroup)
         let externalID: String
 
         // Clear the Subscription cache
         SubscriptionService.signOut()
 
         // Check for past transactions most recent
-        switch await AppStoreRestoreFlow.restoreAccountFromPastPurchase(subscriptionAppGroup: subscriptionAppGroup) {
+        switch await appStoreRestoreFlow.restoreAccountFromPastPurchase() {
         case .success:
             os_log(.info, log: .subscription, "[AppStorePurchaseFlow] purchaseSubscription -> restoreAccountFromPastPurchase: activeSubscriptionAlreadyPresent")
             return .failure(.activeSubscriptionAlreadyPresent)
@@ -78,17 +91,19 @@ public final class AppStorePurchaseFlow {
             switch error {
             case .subscriptionExpired(let expiredAccountDetails):
                 externalID = expiredAccountDetails.externalID
-                accountManager.storeAuthToken(token: expiredAccountDetails.authToken)
+                tokenStorage.authToken = expiredAccountDetails.authToken
+                tokenStorage.accessToken = expiredAccountDetails.accessToken
                 accountManager.storeAccount(token: expiredAccountDetails.accessToken, email: expiredAccountDetails.email, externalID: expiredAccountDetails.externalID)
             default:
                 // No history, create new account
-                switch await AuthService.createAccount(emailAccessToken: emailAccessToken) {
+                switch await authService.createAccount(emailAccessToken: emailAccessToken) {
                 case .success(let response):
                     externalID = response.externalID
 
                     if case let .success(accessToken) = await accountManager.exchangeAuthTokenToAccessToken(response.authToken),
                        case let .success(accountDetails) = await accountManager.fetchAccountDetails(with: accessToken) {
-                        accountManager.storeAuthToken(token: response.authToken)
+                        tokenStorage.authToken = response.authToken
+                        tokenStorage.accessToken = accessToken
                         accountManager.storeAccount(token: accessToken, email: accountDetails.email, externalID: accountDetails.externalID)
                     }
                 case .failure(let error):
@@ -104,7 +119,10 @@ public final class AppStorePurchaseFlow {
             return .success(transactionJWS)
         case .failure(let error):
             os_log(.error, log: .subscription, "[AppStorePurchaseFlow] purchaseSubscription error: %{public}s", String(reflecting: error))
-            AccountManager(subscriptionAppGroup: subscriptionAppGroup).signOut(skipNotification: true)
+//
+//            subscriptionManager.signOut(skipNotification: true)
+            tokenStorage.clear()
+//            Do the silent clean up
             switch error {
             case .purchaseCancelledByUser:
                 return .failure(.cancelledByUser)
@@ -116,17 +134,17 @@ public final class AppStorePurchaseFlow {
 
     // swiftlint:enable cyclomatic_complexity
     @discardableResult
-    public static func completeSubscriptionPurchase(with transactionJWS: TransactionJWS, subscriptionAppGroup: String) async -> Result<PurchaseUpdate, AppStorePurchaseFlow.Error> {
+    public func completeSubscriptionPurchase(with transactionJWS: TransactionJWS) async -> Result<PurchaseUpdate, AppStorePurchaseFlow.Error> {
 
         // Clear subscription Cache
         SubscriptionService.signOut()
 
         os_log(.info, log: .subscription, "[AppStorePurchaseFlow] completeSubscriptionPurchase")
 
-        guard let accessToken = AccountManager(subscriptionAppGroup: subscriptionAppGroup).accessToken else { return .failure(.missingEntitlements) }
+        guard let accessToken = tokenStorage.accessToken else { return .failure(.missingEntitlements) }
 
         let result = await callWithRetries(retry: 5, wait: 2.0) {
-            switch await SubscriptionService.confirmPurchase(accessToken: accessToken, signature: transactionJWS) {
+            switch await subscriptionService.confirmPurchase(accessToken: accessToken, signature: transactionJWS) {
             case .success:
                 return true
             case .failure:
@@ -137,7 +155,7 @@ public final class AppStorePurchaseFlow {
         return result ? .success(PurchaseUpdate(type: "completed")) : .failure(.missingEntitlements)
     }
 
-    private static func callWithRetries(retry retryCount: Int, wait waitTime: Double, conditionToCheck: () async -> Bool) async -> Bool {
+    private func callWithRetries(retry retryCount: Int, wait waitTime: Double, conditionToCheck: () async -> Bool) async -> Bool {
         var count = 0
         var successful = false