react-native-hyperswitch-dev-sdk 0.4.1

package/ios/hyperswitchSDK/Shared/HyperNetworking.swift

@@ -0,0 +1,151 @@
+//
+//  HyperswitchNetworking.swift
+//  hyperswitch
+//
+//  Created by Kuntimaddi Manideep on 24/01/25.
+//
+
+import Foundation
+
+// MARK: HTTP Methods
+enum HTTPMethod: String, Encodable {
+    case get = "GET"
+    case head = "HEAD"
+    case post = "POST"
+    case put = "PUT"
+    case delete = "DELETE"
+    case connect = "CONNECT"
+    case options = "OPTIONS"
+    case trace = "TRACE"
+    case patch = "PATCH"
+}
+
+// MARK: HTTPClient
+/// The protocol used to define the specifications necessary for a `HTTPClient`.
+protocol HTTPClient {
+    /// The host, conforming to RFC 1808.
+    var host: String { get }
+
+    /// The path, conforming to RFC 1808
+    var path: String { get }
+
+    /// API Endpoint
+    var endpoint: String { get }
+
+    /// The HTTP method used in the request.
+    var method: HTTPMethod { get }
+
+    /// The HTTP JSON request parameters.
+    var jsonParameters: [String: Any]? { get }
+
+    /// The HTTP Data request parameters.
+    var bodyData: Data? { get }
+
+    /// A dictionary containing all the HTTP header fields
+    var headers: [String: String]? { get }
+}
+
+/// HTTPClient Errors
+enum HTTPClientError: Error {
+    case badURL
+}
+
+extension HTTPClient {
+    /// The URL of the receiver.
+    fileprivate var url: String {
+        return host + path + endpoint
+    }
+
+    func request<T: Codable>(type: T.Type, completionHandler: @escaping (Result<T, Error>, Int) -> Void) {
+        guard let url = URL(string: url) else {
+            completionHandler(.failure(HTTPClientError.badURL), 400)
+            return
+        }
+
+        var request = URLRequest(url: url)
+        request.httpMethod = method.rawValue
+        request.allHTTPHeaderFields = headers
+        request.cachePolicy = .reloadIgnoringLocalAndRemoteCacheData
+
+        if let parameters = jsonParameters {
+            do {
+                request.httpBody = try JSONSerialization.data(withJSONObject: parameters, options: [])
+            } catch {
+                completionHandler(.failure(error), 400)
+                return
+            }
+        } else if let bodyData = bodyData {
+            request.httpBody = bodyData
+        }
+
+        let configuration = URLSessionConfiguration.default
+        configuration.timeoutIntervalForRequest = 10.0  // 10 seconds
+        configuration.timeoutIntervalForResource = 10.0  // 10 seconds
+        let session = URLSession(configuration: configuration)
+        let dataTask = session.dataTask(
+            with: request,
+            completionHandler: { (data, response, error) -> Void in
+                var responseCode = 400
+                if let httpResponse = response as? HTTPURLResponse {
+                    responseCode = httpResponse.statusCode
+                }
+                if let error = error {
+                    completionHandler(.failure(error), responseCode)
+                    return
+                }
+
+                if let data = data {
+                    do {
+                        if T.self == Data.self {
+                            completionHandler(.success(data as! T), responseCode)
+                        } else {
+                            completionHandler(.success(try JSONDecoder().decode(type, from: data)), responseCode)
+                        }
+                    } catch {
+                        completionHandler(.failure(error), responseCode)
+                        return
+                    }
+                }
+            }
+        )
+
+        dataTask.resume()
+    }
+}
+
+class HTTPRequestService: HTTPClient {
+
+    let host: String
+    let path: String
+    let endpoint: String
+    let method: HTTPMethod
+
+    var jsonParameters: [String: Any]?
+    var bodyData: Data?
+    var headers: [String: String]?
+
+    init(
+        host: String,
+        path: String,
+        endpoint: String,
+        method: HTTPMethod,
+        jsonParameters: [String: Any]? = nil,
+        bodyData: Data? = nil,
+        headers: [String: String]? = nil
+    ) {
+        self.host = host
+        self.path = path
+        self.endpoint = endpoint
+        self.method = method
+        self.jsonParameters = jsonParameters
+        self.bodyData = bodyData
+        self.headers = headers
+    }
+
+    func getDictionary() -> [String: Any] {
+        return [
+            "host": host, "path": path, "endpoint": endpoint, "method": method.rawValue, "jsonParameters": jsonParameters ?? "nil",
+            "headers": headers ?? "nil",
+        ]
+    }
+}

package/ios/hyperswitchSDK/Shared/HyperParams.swift

@@ -0,0 +1,44 @@
+//
+//  HyperParams.swift
+//  hyperswitch
+//
+//  Created by Shivam Nan on 15/01/25.
+//
+
+import Foundation
+import WebKit
+
+class HyperParams {
+    static let appId: String? = Bundle.main.bundleIdentifier
+    static let sdkVersion: String = SDKVersion.current
+    static let country: String? = NSLocale.current.regionCode
+    static let userAgent: String? = WKWebView().value(forKey: "userAgent") as? String
+    static let deviceModel: String = UIDevice.current.model
+    static let osVersion: String = UIDevice.current.systemVersion
+
+    static func getSafeAreaInsets() -> UIEdgeInsets {
+        let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene
+        return windowScene?.windows.first?.safeAreaInsets ?? UIEdgeInsets.zero
+    }
+
+    static func getHyperParams() -> [String: Any?] {
+
+        let safeAreaInset = getSafeAreaInsets()
+
+        let params: [String: Any?] = [
+            "appId": appId,
+            "sdkVersion": sdkVersion,
+            "country": country,
+            "user-agent": userAgent,
+            "device_model": deviceModel,
+            "os_version": osVersion,
+            "os_type": "ios",
+            "launchTime": Int(Date().timeIntervalSince1970 * 1000),
+            "topInset": safeAreaInset.top,
+            "bottomInset": safeAreaInset.bottom,
+            "leftInset": safeAreaInset.left,
+            "rightInset": safeAreaInset.right,
+        ]
+        return params
+    }
+}

package/ios/hyperswitchSDK/Shared/HyperUIViewController.swift

@@ -0,0 +1,27 @@
+//
+//  HyperUIViewController.swift
+//  hyperswitch
+//
+//  Created by Harshit Srivastava on 07/10/24.
+//
+
+import Foundation
+import UIKit
+
+internal class HyperUIViewController: UIViewController {
+    internal var paymentSheet: PaymentSheet?
+
+    internal override var shouldAutorotate: Bool {
+        return false
+    }
+    internal override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
+        return UIInterfaceOrientationMask.portrait
+    }
+    internal override var preferredInterfaceOrientationForPresentation: UIInterfaceOrientation {
+        return UIInterfaceOrientation.portrait
+    }
+    internal override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {}
+    internal override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {}
+    internal override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {}
+    internal override func touchesCancelled(_ touches: Set<UITouch>, with event: UIEvent?) {}
+}

package/ios/hyperswitchSDK/Shared/Hyperswitch.swift

@@ -0,0 +1,20 @@
+//
+//  Hyperswitch.swift
+//  HyperswitchCore
+//
+//  Created by Harshit Srivastava on 17/05/26.
+//
+
+public final class Hyperswitch {
+
+    internal let hyperswitchConfiguration: HyperswitchConfiguration
+
+    public init(configuration: HyperswitchConfiguration) {  // MARK: async on superposition impl
+        self.hyperswitchConfiguration = configuration
+        // Task {} Superposition
+    }
+
+    public func initPaymentSession(configuration: PaymentSessionConfiguration) -> PaymentSession {
+        PaymentSession(paymentSessionConfiguration: configuration, hyperswitchConfiguration: hyperswitchConfiguration)
+    }
+}

package/ios/hyperswitchSDK/Shared/HyperswitchConfigurationSchema.swift

@@ -0,0 +1,54 @@
+//
+//  HyperswitchConfigurationSchema.swift
+//  HyperswitchCore
+//
+//  Created by Harshit Srivastava on 17/05/26.
+//
+
+private protocol HyperswitchConfigurationSchema {
+    var publishableKey: String { get }
+    var profileId: String? { get }
+    var customEndpoints: CustomEndpointConfiguration? { get }
+    var environment: HyperswitchEnvironment? { get }
+}
+
+public struct HyperswitchConfiguration: HyperswitchConfigurationSchema, Codable {
+    let publishableKey: String
+    let profileId: String?
+    let customEndpoints: CustomEndpointConfiguration?
+    let environment: HyperswitchEnvironment?
+
+    public init(
+        publishableKey: String,
+        profileId: String? = nil,
+        customEndpoints: CustomEndpointConfiguration? = nil,
+        environment: HyperswitchEnvironment? = nil
+    ) {
+        self.publishableKey = publishableKey
+        self.profileId = profileId
+        self.customEndpoints = customEndpoints
+        self.environment = environment
+    }
+}
+
+public struct HyperswitchPlatformConfiguration: HyperswitchConfigurationSchema, Codable {
+    let platformPublishableKey: String
+    let publishableKey: String
+    let profileId: String?
+    let customEndpoints: CustomEndpointConfiguration?
+    let environment: HyperswitchEnvironment?
+
+    public init(
+        platformPublishableKey: String,
+        publishableKey: String,
+        profileId: String? = nil,
+        customEndpoints: CustomEndpointConfiguration? = nil,
+        environment: HyperswitchEnvironment? = nil
+    ) {
+        self.platformPublishableKey = platformPublishableKey
+        self.publishableKey = publishableKey
+        self.profileId = profileId
+        self.customEndpoints = customEndpoints
+        self.environment = environment
+    }
+}

package/ios/hyperswitchSDK/Shared/HyperswitchEnvironment.swift

@@ -0,0 +1,11 @@
+//
+//  HyperswitchEnvironment.swift
+//  hyperswitch
+//
+//  Created by Harshit Srivastava on 18/05/26.
+//
+
+public enum HyperswitchEnvironment: String, Codable {
+    case production
+    case sandbox
+}

package/ios/hyperswitchSDK/Shared/NativeLogger/Debouncer.swift

@@ -0,0 +1,37 @@
+//
+//  Debouncer.swift
+//  hyperswitch
+//
+//  Created by Kuntimaddi Manideep on 24/01/25.
+//
+
+import Foundation
+
+final class Debouncer {
+    private let delay: TimeInterval
+    private var workItem: DispatchWorkItem?
+    private let queue: DispatchQueue
+    private let lock = NSLock()
+
+    init(delayInMillis: TimeInterval, queue: DispatchQueue = .main) {
+        self.delay = delayInMillis / 1000.0
+        self.queue = queue
+    }
+
+    func debounce(action: @escaping @Sendable () -> Void) {
+        lock.lock()
+        defer { lock.unlock() }
+        workItem?.cancel()
+        let task = DispatchWorkItem { action() }
+        workItem = task
+        queue.asyncAfter(deadline: .now() + delay, execute: task)
+    }
+
+    func cancel() {
+        lock.lock()
+        defer { lock.unlock() }
+
+        workItem?.cancel()
+        workItem = nil
+    }
+}

package/ios/hyperswitchSDK/Shared/NativeLogger/LogBuilder.swift

@@ -0,0 +1,113 @@
+//
+//  LogBuilder.swift
+//  hyperswitch
+//
+//  Created by Kuntimaddi Manideep on 24/01/25.
+//
+
+import Foundation
+
+internal class LogBuilder {
+    private var timestamp: String = ""
+    private var logType: LogType = .INFO
+    private var component: String = "MOBILE"
+    private var category: LogCategory = .OTA_LIFE_CYCLE
+    private var version: String = SDKVersion.current
+    private var codePushVersion: String = ""  // MARK: replace with hyperOTAVersion
+    private var clientCoreVersion: String = ""
+    private var value: String = ""
+    private var internalMetadata: String = ""
+    private var sessionId: String = ""
+    private var merchantId: String = ""
+    private var paymentId: String = ""
+    private var authenticationId: String = ""
+    private var appId: String? = nil
+    private var platform: String = "IOS"
+    private var userAgent: String = ""
+    private var eventName: EventName = .hyperOTAInit
+    private var latency: String? = nil
+    private var firstEvent: Bool = false
+    private var paymentMethod: String? = nil
+    private var paymentExperience: String? = nil
+    private var source: String = ""
+
+    func setLogType(_ logType: String) -> LogBuilder {
+        switch logType.uppercased() {
+        case "ERROR":
+            self.logType = .ERROR
+            break
+        case "WARNING":
+            self.logType = .WARNING
+            break
+        case "DEBUG":
+            self.logType = .DEBUG
+            break
+        default:
+            self.logType = .INFO
+        }
+        return self
+    }
+
+    func setClientCoreVersion(_ clientCoreVersion: String) -> LogBuilder {
+        self.clientCoreVersion = clientCoreVersion
+        return self
+    }
+
+    func setValue(_ value: String) -> LogBuilder {
+        self.value = value
+        return self
+    }
+
+    func setEventName(_ eventName: EventName) -> LogBuilder {
+        self.eventName = eventName
+        return self
+    }
+
+    func setCategory(_ category: LogCategory) -> LogBuilder {
+        self.category = category
+        return self
+    }
+
+    func setPaymentId(_ paymentId: String) -> LogBuilder {
+        self.paymentId = paymentId
+        return self
+    }
+
+    func setAuthenticationId(_ authenticationId: String) -> LogBuilder {
+        self.authenticationId = authenticationId
+        return self
+    }
+
+    func setSessionId(_ sessionId: String) -> LogBuilder {
+        self.sessionId = sessionId
+        return self
+    }
+
+    func build() -> LogPayload {
+        self.timestamp = String(Int(Date().timeIntervalSince1970 * 1000))
+        return LogPayload(
+            timestamp: timestamp,
+            log_type: logType,
+            component: component,
+            category: category,
+            version: version,
+            code_push_version: codePushVersion,
+            client_core_version: clientCoreVersion,
+            value: value,
+            internal_metadata: internalMetadata,
+            session_id: sessionId,
+            merchant_id: merchantId,
+            payment_id: paymentId,
+            authentication_id: authenticationId,
+            app_id: appId,
+            platform: platform,
+            user_agent: userAgent,
+            event_name: eventName,
+            latency: latency,
+            first_event: firstEvent ? "true" : "false",
+            payment_method: paymentMethod,
+            payment_experience: paymentExperience,
+            source: source
+        )
+    }
+}

package/ios/hyperswitchSDK/Shared/NativeLogger/LogFileManager.swift

@@ -0,0 +1,76 @@
+//
+//  LogFileManager.swift
+//  hyperswitch
+//
+//  Created by Kuntimaddi Manideep on 24/01/25.
+//
+
+import Foundation
+
+class LogFileManager {
+    private let logFileName = "crash_logs.json"
+    private let fileManager = FileManager.default
+    private let queue = DispatchQueue(label: "logfile.queue", attributes: .concurrent)
+
+    private func getLogFileName() -> URL? {
+        guard let documentDirectory = fileManager.urls(for: .documentDirectory, in: .userDomainMask).first else {
+            return nil
+        }
+        return documentDirectory.appendingPathComponent(logFileName)
+    }
+
+    func addLogs(logs: [String]) {
+        queue.async(flags: .barrier) { [weak self] in
+            guard let self = self, let fileURL = self.getLogFileName() else { return }
+            do {
+                let existingLogs = self.getStoredLogs() ?? "[]"
+                var logsArray = self.parseLogs(existingLogs)
+                logsArray.append(contentsOf: logs)
+                let jsonData = try JSONSerialization.data(withJSONObject: logsArray, options: .prettyPrinted)
+                try jsonData.write(to: fileURL, options: .atomic)
+            } catch {
+            }
+        }
+    }
+
+    func getStoredLogs() -> String? {
+        guard let fileURL = getLogFileName(), fileManager.fileExists(atPath: fileURL.path) else {
+            return nil
+        }
+        do {
+            let data = try Data(contentsOf: fileURL)
+            if let jsonString = String(data: data, encoding: .utf8) {
+                return jsonString
+            } else {
+                return nil
+            }
+        } catch {
+            return nil
+        }
+    }
+
+    private func parseLogs(_ logs: String) -> [String] {
+        if let data = logs.data(using: .utf8),
+            let json = try? JSONSerialization.jsonObject(with: data, options: []) as? [String]
+        {
+            return json
+        }
+        return []
+    }
+
+    func getStoredLogsInArray() -> [String] {
+        return self.parseLogs(self.getStoredLogs() ?? "")
+    }
+
+    func clearFile() {
+        queue.async(flags: .barrier) { [weak self] in
+            guard let self = self, let fileURL = self.getLogFileName() else { return }
+            do {
+                if self.fileManager.fileExists(atPath: fileURL.path) {
+                    try self.fileManager.removeItem(at: fileURL)
+                }
+            } catch {
+            }
+        }
+    }
+}

package/ios/hyperswitchSDK/Shared/NativeLogger/LogManager.swift

@@ -0,0 +1,113 @@
+//
+//  HyperLogManager.swift
+//  hyperswitch
+//
+//  Created by Kuntimaddi Manideep on 24/01/25.
+//
+
+import Foundation
+
+final class LogManager {
+    private static var logsBatch: [LogPayload] = []
+    private static var publishableKey: String = ""
+    private static var loggingEndPoint: String?
+    private static let fileManager = LogFileManager()
+    private static let queue = DispatchQueue(label: "hyperlog.queue")
+    private static let debouncer = Debouncer(delayInMillis: 2000.0)
+
+    private static func formatPayload(logs: [String]) -> String {
+        return "["
+            + logs.joined(separator: ",")
+            .replacingOccurrences(of: "\n", with: " ") + "]"
+    }
+
+    private static func getStringifiedLogs(_ logBatch: [LogPayload]) -> [String] {
+        return logBatch.compactMap { $0.toJson() }
+    }
+
+    static func initialize(publishableKey: String) {
+        queue.async {
+            self.publishableKey = publishableKey
+            self.loggingEndPoint = SDKEnvironment.loggingURL(for: publishableKey)
+        }
+        if !publishableKey.isEmpty {
+            sendLogsFromFile()
+        }
+    }
+
+    static func sendLogsFromFile() {
+        queue.async {
+            guard let endpoint = loggingEndPoint else { return }
+            let logs = fileManager.getStoredLogsInArray()
+            let payload = formatPayload(logs: logs)
+
+            let data = payload.data(using: .utf8)
+
+            let logRequest = HTTPRequestService(host: endpoint, path: "", endpoint: "", method: .post)
+            logRequest.headers = ["Content-Type": "application/json"]
+            logRequest.bodyData = data
+
+            logRequest.request(type: Data.self) { (result, statusCode) in
+                switch (result, statusCode) {
+                case (.success(_), 200..<300):
+                    fileManager.clearFile()
+                default:
+                    break
+                }
+            }
+        }
+    }
+
+    static func saveLogsToFile() {
+        queue.async {
+            let logs = getStringifiedLogs(logsBatch)
+            fileManager.addLogs(logs: logs)
+        }
+    }
+
+    static func saveLogsToFile(_ logsBatch: [LogPayload]) {
+        queue.async {
+            let logs = getStringifiedLogs(logsBatch)
+            fileManager.addLogs(logs: logs)
+        }
+    }
+
+    static func addLog(_ log: LogPayload) {
+        queue.async {
+            logsBatch.append(log)
+            debouncer.debounce {
+                sendLogsOverNetwork()
+            }
+        }
+    }
+
+    private static func sendLogsOverNetwork() {
+        queue.async {
+            guard !logsBatch.isEmpty, let endpoint = loggingEndPoint else { return }
+            var copiedLogs = logsBatch
+            logsBatch.removeAll()
+
+            for index in copiedLogs.indices {
+                copiedLogs[index].merchant_id = LogManager.publishableKey
+            }
+
+            let logsToSend = getStringifiedLogs(copiedLogs)
+            guard !logsToSend.isEmpty else { return }
+
+            let payload = formatPayload(logs: logsToSend)
+            let data = payload.data(using: .utf8)
+            let logRequest = HTTPRequestService(host: endpoint, path: "", endpoint: "", method: .post)
+
+            logRequest.headers = ["Content-Type": "application/json"]
+            logRequest.bodyData = data
+            logRequest.request(type: Data.self) { (result, statusCode) in
+                switch (result, statusCode) {
+                case (.success(_), 200..<300):
+                    break
+                default:
+                    saveLogsToFile(copiedLogs)
+                }
+            }
+        }
+    }
+}