Add workflows network layer for multipage paywalls

Sources/Networking/Backend.swift

@@ -24,6 +24,7 @@ class Backend {
     let customerCenterConfig: CustomerCenterConfigAPI
     let redeemWebPurchaseAPI: RedeemWebPurchaseAPI
     let virtualCurrenciesAPI: VirtualCurrenciesAPI
+    let workflowsAPI: WorkflowsAPI
 
     private let config: BackendConfiguration
 
@@ -65,6 +66,7 @@ class Backend {
         let customerCenterConfig = CustomerCenterConfigAPI(backendConfig: backendConfig)
         let redeemWebPurchaseAPI = RedeemWebPurchaseAPI(backendConfig: backendConfig)
         let virtualCurrenciesAPI = VirtualCurrenciesAPI(backendConfig: backendConfig)
+        let workflowsAPI = WorkflowsAPI(backendConfig: backendConfig)
 
         self.init(backendConfig: backendConfig,
                   customerAPI: customer,
@@ -75,7 +77,8 @@ class Backend {
                   internalAPI: internalAPI,
                   customerCenterConfig: customerCenterConfig,
                   redeemWebPurchaseAPI: redeemWebPurchaseAPI,
-                  virtualCurrenciesAPI: virtualCurrenciesAPI)
+                  virtualCurrenciesAPI: virtualCurrenciesAPI,
+                  workflowsAPI: workflowsAPI)
     }
 
     required init(backendConfig: BackendConfiguration,
@@ -87,7 +90,8 @@ class Backend {
                   internalAPI: InternalAPI,
                   customerCenterConfig: CustomerCenterConfigAPI,
                   redeemWebPurchaseAPI: RedeemWebPurchaseAPI,
-                  virtualCurrenciesAPI: VirtualCurrenciesAPI) {
+                  virtualCurrenciesAPI: VirtualCurrenciesAPI,
+                  workflowsAPI: WorkflowsAPI) {
         self.config = backendConfig
 
         self.customer = customerAPI
@@ -99,6 +103,7 @@ class Backend {
         self.customerCenterConfig = customerCenterConfig
         self.redeemWebPurchaseAPI = redeemWebPurchaseAPI
         self.virtualCurrenciesAPI = virtualCurrenciesAPI
+        self.workflowsAPI = workflowsAPI
     }
 
     func clearHTTPClientCaches() {

Sources/Networking/Caching/WorkflowsCallback.swift

@@ -0,0 +1,28 @@
+//
+//  Copyright RevenueCat Inc. All Rights Reserved.
+//
+//  Licensed under the MIT License (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/MIT
+//
+//  WorkflowsCallback.swift
+//
+//  Created by RevenueCat.
+
+import Foundation
+
+struct WorkflowsListCallback: CacheKeyProviding {
+
+    let cacheKey: String
+    let completion: (Result<WorkflowsListResponse, BackendError>) -> Void
+
+}
+
+struct WorkflowDetailCallback: CacheKeyProviding {
+
+    let cacheKey: String
+    let completion: (Result<WorkflowFetchResult, BackendError>) -> Void
+
+}

Sources/Networking/HTTPClient/HTTPClient.swift

@@ -219,6 +219,31 @@ extension HTTPClient {
 // - Class is not `final` (it's mocked). This implicitly makes subclasses `Sendable` even if they're not thread-safe.
 extension HTTPClient: @unchecked Sendable {}
 
+// MARK: - CDN
+
+internal extension HTTPClient {
+
+    /// Fetches raw data from an arbitrary URL using the client's configured `URLSession`.
+    ///
+    /// Use this for CDN or other non-RC-API requests where the SDK's path-based request building
+    /// is not applicable, but we still want the same session configuration (timeouts, connection limits).
+    func fetchRawData(from url: URL, completion: @escaping (Result<Data, Error>) -> Void) {
+        self.session.dataTask(with: url) { data, response, error in
+            if let error = error {
+                completion(.failure(error))
+            } else if let httpResponse = response as? HTTPURLResponse,
+                      !(200..<300).contains(httpResponse.statusCode) {
+                completion(.failure(URLError(.badServerResponse)))
+            } else if let data = data {
+                completion(.success(data))
+            } else {
+                completion(.failure(URLError(.unknown)))
+            }
+        }.resume()
+    }
+
+}
+
 // MARK: - Private
 
 internal extension HTTPClient {

Sources/Networking/HTTPClient/HTTPRequestPath.swift

@@ -11,6 +11,8 @@
 //
 //  Created by Nacho Soto on 8/8/23.
 
+// swiftlint:disable file_length
+
 import Foundation
 
 protocol HTTPRequestPath {
@@ -101,6 +103,8 @@ extension HTTPRequest {
         case getProductEntitlementMapping
         case getCustomerCenterConfig(appUserID: String)
         case getVirtualCurrencies(appUserID: String)
+        case getWorkflows(appUserID: String)
+        case getWorkflow(appUserID: String, workflowId: String)
         case postRedeemWebPurchase
         case postCreateTicket
         case isPurchaseAllowedByRestoreBehavior(appUserID: String)
@@ -187,6 +191,8 @@ extension HTTPRequest.Path: HTTPRequestPath {
                 .getProductEntitlementMapping,
                 .getCustomerCenterConfig,
                 .getVirtualCurrencies,
+                .getWorkflows,
+                .getWorkflow,
                 .appHealthReport,
                 .postCreateTicket,
                 .isPurchaseAllowedByRestoreBehavior:
@@ -213,6 +219,8 @@ extension HTTPRequest.Path: HTTPRequestPath {
                 .getProductEntitlementMapping,
                 .getCustomerCenterConfig,
                 .getVirtualCurrencies,
+                .getWorkflows,
+                .getWorkflow,
                 .appHealthReport,
                 .postCreateTicket,
                 .isPurchaseAllowedByRestoreBehavior:
@@ -232,6 +240,7 @@ extension HTTPRequest.Path: HTTPRequestPath {
                 .getOfferings,
                 .getProductEntitlementMapping,
                 .getVirtualCurrencies,
+                .getWorkflows,
                 .appHealthReport,
                 .appHealthReportAvailability,
                 .isPurchaseAllowedByRestoreBehavior:
@@ -243,6 +252,7 @@ extension HTTPRequest.Path: HTTPRequestPath {
                 .postOfferForSigning,
                 .postRedeemWebPurchase,
                 .getCustomerCenterConfig,
+                .getWorkflow,
                 .postCreateTicket:
             return false
         }
@@ -267,6 +277,8 @@ extension HTTPRequest.Path: HTTPRequestPath {
                 .postRedeemWebPurchase,
                 .getProductEntitlementMapping,
                 .getCustomerCenterConfig,
+                .getWorkflows,
+                .getWorkflow,
                 .appHealthReport,
                 .postCreateTicket:
             return false
@@ -327,6 +339,12 @@ extension HTTPRequest.Path: HTTPRequestPath {
         case let .getVirtualCurrencies(appUserID):
             return "subscribers/\(Self.escape(appUserID))/virtual_currencies"
 
+        case let .getWorkflows(appUserID):
+            return "subscribers/\(Self.escape(appUserID))/workflows"
+
+        case let .getWorkflow(appUserID, workflowId):
+            return "subscribers/\(Self.escape(appUserID))/workflows/\(Self.escape(workflowId))"
+
         case .postCreateTicket:
             return "customercenter/support/create-ticket"
         case let .isPurchaseAllowedByRestoreBehavior(appUserID):
@@ -381,6 +399,12 @@ extension HTTPRequest.Path: HTTPRequestPath {
         case .getVirtualCurrencies:
             return "get_virtual_currencies"
 
+        case .getWorkflows:
+            return "get_workflows"
+
+        case .getWorkflow:
+            return "get_workflow"
+
         case .appHealthReportAvailability:
             return "get_app_health_report_availability"
 

Sources/Networking/Operations/GetWorkflowOperation.swift

@@ -0,0 +1,132 @@
+//
+//  Copyright RevenueCat Inc. All Rights Reserved.
+//
+//  Licensed under the MIT License (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/MIT
+//
+//  GetWorkflowOperation.swift
+//
+//  Created by RevenueCat.
+
+import Foundation
+
+final class GetWorkflowOperation: CacheableNetworkOperation {
+
+    private let workflowDetailCallbackCache: CallbackCache<WorkflowDetailCallback>
+    private let configuration: AppUserConfiguration
+    private let workflowId: String
+    private let detailProcessor: WorkflowDetailProcessor
+
+    static func createFactory(
+        configuration: UserSpecificConfiguration,
+        workflowId: String,
+        detailProcessor: WorkflowDetailProcessor,
+        workflowDetailCallbackCache: CallbackCache<WorkflowDetailCallback>
+    ) -> CacheableNetworkOperationFactory<GetWorkflowOperation> {
+        return .init({ cacheKey in
+                .init(
+                    configuration: configuration,
+                    workflowId: workflowId,
+                    detailProcessor: detailProcessor,
+                    workflowDetailCallbackCache: workflowDetailCallbackCache,
+                    cacheKey: cacheKey
+                )
+            },
+            individualizedCacheKeyPart: configuration.appUserID + "\n" + workflowId)
+    }
+
+    private init(configuration: UserSpecificConfiguration,
+                 workflowId: String,
+                 detailProcessor: WorkflowDetailProcessor,
+                 workflowDetailCallbackCache: CallbackCache<WorkflowDetailCallback>,
+                 cacheKey: String) {
+        self.configuration = configuration
+        self.workflowId = workflowId
+        self.detailProcessor = detailProcessor
+        self.workflowDetailCallbackCache = workflowDetailCallbackCache
+
+        super.init(configuration: configuration, cacheKey: cacheKey)
+    }
+
+    override func begin(completion: @escaping () -> Void) {
+        self.getWorkflow(completion: completion)
+    }
+
+}
+
+// Restating inherited @unchecked Sendable from Foundation's Operation
+extension GetWorkflowOperation: @unchecked Sendable {}
+
+private extension GetWorkflowOperation {
+
+    func getWorkflow(completion: @escaping () -> Void) {
+        let appUserID = self.configuration.appUserID
+
+        guard appUserID.isNotEmpty else {
+            self.workflowDetailCallbackCache.performOnAllItemsAndRemoveFromCache(withCacheable: self) { callback in
+                callback.completion(.failure(.missingAppUserID()))
+            }
+            completion()
+            return
+        }
+
+        let request = HTTPRequest(
+            method: .get,
+            path: .getWorkflow(appUserID: appUserID, workflowId: self.workflowId)
+        )
+
+        httpClient.perform(request) { (response: VerifiedHTTPResponse<Data>.Result) in
+            self.handleResponse(response, completion: completion)
+        }
+    }
+
+    func handleResponse(_ response: VerifiedHTTPResponse<Data>.Result, completion: @escaping () -> Void) {
+        switch response {
+        case .failure(let networkError):
+            defer { completion() }
+            self.distribute(.failure(BackendError.networkError(networkError)))
+
+        case .success(let verifiedResponse):
+            self.detailProcessor.process(verifiedResponse.body) { processingResult in
+                defer { completion() }
+                self.distribute(self.backendResult(from: processingResult, envelopeData: verifiedResponse.body))
+            }
+        }
+    }
+
+    func backendResult(
+        from processingResult: Result<WorkflowDetailProcessingResult, Error>,
+        envelopeData: Data
+    ) -> Result<WorkflowFetchResult, BackendError> {
+        switch processingResult {
+        case .success(let processed):
+            do {
+                let workflow = try PublishedWorkflow.create(with: processed.workflowData)
+                return .success(WorkflowFetchResult(workflow: workflow, enrolledVariants: processed.enrolledVariants))
+            } catch {
+                return .failure(BackendError.networkError(NetworkError.decoding(error, envelopeData)))
+            }
+        case .failure(let processingError as WorkflowDetailProcessingError):
+            switch processingError {
+            case .cdnFetchFailed(let underlyingError):
+                return .failure(.networkError(NetworkError.networkError(underlyingError)))
+            case .invalidEnvelopeJson, .unknownAction, .missingInlineData, .missingCdnUrl:
+                return .failure(.networkError(NetworkError.decoding(processingError, envelopeData)))
+            }
+        case .failure(let error):
+            return .failure(.networkError(NetworkError.decoding(error, envelopeData)))
+        }
+    }
+
+    func distribute(_ result: Result<WorkflowFetchResult, BackendError>) {
+        self.workflowDetailCallbackCache.performOnAllItemsAndRemoveFromCache(
+            withCacheable: self
+        ) { callbackObject in
+            callbackObject.completion(result)
+        }
+    }
+
+}