vibes-react-native 5.0.0 → 5.0.1-rc2

package/vendor/VibesPush/Sources/VibesAPI.swift

@@ -0,0 +1,81 @@
+import Foundation
+
+/// A closure used as a completion handler for API requests.
+typealias APICompletion<A> = (ResourceResult<A>) -> Void
+
+/// A protocol that indicates the required interface for being considered an
+/// `VibesAPI`
+protocol VibesAPIType {
+  func request<A>(resource: HTTPResource<A>, completion: APICompletion<A>?)
+  func request<A>(authToken: String?, resource: HTTPResource<A>, completion: APICompletion<A>?)
+}
+
+/// An API client for requesting Resources from the Vibes API. It wraps an
+/// `HTTPResourceClientType` to layer in Vibes-specific API functionality, e.g.
+/// handling of authentcation tokens.
+class VibesAPI: VibesAPIType {
+  /// The HTTP client to use for making network requests.
+  private let client: HTTPResourceClientType
+
+  /// Initialize this object.
+  ///
+  /// - parameters:
+  ///   - client: the HTTP client to use for making network requests.
+  init(client: HTTPResourceClientType) {
+    self.client = client
+  }
+
+  /// Initialize this object.
+  ///
+  /// - parameters:
+  ///   - url: the URL object used for creating client.
+  convenience init(url: URL) {
+    let sessionConfig = URLSessionConfiguration.default
+    sessionConfig.timeoutIntervalForRequest = 5.0
+    sessionConfig.timeoutIntervalForResource = 5.0
+    let session = URLSession(configuration: sessionConfig)
+
+    let client = HTTPResourceClient(baseURL: url, session: session) {
+      Vibes.configuredLogger
+    }
+    self.init(client: client)
+  }
+
+  /// Requests a resource from the Vibes API.
+  ///
+  /// Use this function when making a request that does not necessitate
+  /// authentication (e.g. registering a device).
+  ///
+  /// - parameters:
+  ///   - resource: the resource to request from the API
+  ///   - completion: a closure to receive the result of the API request
+  func request<A>(resource: HTTPResource<A>, completion: APICompletion<A>?) {
+    request(resource: resource, behavior: nil, completion: completion)
+  }
+
+  /// Requests a resource from the Vibes API, using an authentication token.
+  ///
+  /// Use this function when making a request that does necessitate
+  /// authentication (most do).
+  ///
+  /// - parameters:
+  ///   - authToken: the authentication token to send along with this request
+  ///   - resource: the resource to request from the API
+  ///   - completion: a closure to receive the result of the API request
+  func request<A>(authToken: String?, resource: HTTPResource<A>, completion: APICompletion<A>?) {
+    let authTokenBehavior = AuthTokenBehavior(token: authToken)
+    request(resource: resource, behavior: authTokenBehavior, completion: completion)
+  }
+
+  /// A helper method for requesting a resource via the API.
+  ///
+  /// - parameters:
+  ///   - resource: the resource to request from the API
+  ///   - behavior: an `HTTPBehavior` to use when making this request
+  ///   - completion: a closure to receive the result of the API request
+  private func request<A>(resource: HTTPResource<A>, behavior: HTTPBehavior?, completion: APICompletion<A>?) {
+    client.request(resource: resource, behavior: behavior) { httpResult in
+      completion?(httpResult)
+    }
+  }
+}

package/vendor/VibesPush/Sources/VibesAPIDelegate.swift

@@ -0,0 +1,41 @@
+//
+//  VibesAPIDelegate.swift
+//  VibesPush-iOS
+//
+//  Created by Jean-Michel Barbieri on 3/8/18.
+//  Copyright © 2018 Vibes. All rights reserved.
+//
+import Foundation
+
+@objc public protocol VibesAPIDelegate {
+    /// Callback to inform SDK users of the result of the device registration
+    /// - parameters:
+    ///     - deviceId: the vibes device id that uniquely identifies the registered device
+    ///     - error: Registration device error
+    @objc optional func didRegisterDevice(deviceId: String?, error: Error?)
+
+    /// Callback to inform SDK users of the result of the device unregistration
+    /// - parameters:
+    ///     - error: Unregistration device error
+    @objc optional func didUnregisterDevice(error: Error?)
+
+    /// Callback to inform SDK users of the result of the device push registration
+    /// - parameters:
+    ///     - error: Push registration error
+    @objc optional func didRegisterPush(error: Error?)
+
+    /// Callback to inform SDK users of the result of the device push unregistration
+    /// - parameters:
+    ///     - error: Push unregistration error
+    @objc optional func didUnregisterPush(error: Error?)
+
+    /// Callback to inform SDK users of the result of the device update
+    /// - parameters:
+    ///     - error: Device update error
+    @objc optional func didUpdateDevice(error: Error?)
+
+    /// Callback to inform SDK users of the result of associating a person with this device
+    /// - parameters:
+    ///     - error: Associate person error
+    @objc optional func didAssociatePerson(error: Error?)
+}

package/vendor/VibesPush/Sources/VibesAppInfo.swift

@@ -0,0 +1,77 @@
+//
+//  InboxStatus.swift
+//  VibesPush
+//
+//  Created by DHwty on 10/11/2020.
+//  Copyright © 2020 Vibes. All rights reserved.
+//
+
+import Foundation
+
+/// Vibes App Info
+@objcMembers
+public class VibesAppInfo: NSObject, JSONDecodable, LocalObjectType, JSONEncodable {
+
+    /// Local Atrributes
+    public var attributes: [String: Any] {
+        return [
+            "app_id": appId ?? "",
+            "inbox_enabled": inboxEnabled = false,
+        ]
+    }
+
+    public func encodeJSON() -> VibesJSONDictionary {
+        return [
+            "app_id": appId as AnyObject,
+            "inbox_enabled": inboxEnabled as AnyObject,
+        ] as VibesJSONDictionary
+    }
+
+    public var jsonString: String? {
+        let jsonData = try? JSONSerialization.data(withJSONObject: encodeJSON(), options: .prettyPrinted)
+        return String(data: jsonData!, encoding: .utf8)
+    }
+
+    /// An uniqie identifier assosiated with the app
+    public internal(set) var appId: String!
+    /// The app inbox status
+    public internal(set) var inboxEnabled: Bool = false
+
+    override init() {
+    }
+
+    /// Initialize new VibesAppInfo using properties
+    ///
+    /// - Parameters:
+    ///   - appId: The app id
+    ///   - inboxEnabled: The app inbox status
+    init(appId: String, inboxEnabled: Bool) {
+        self.appId = appId
+        self.inboxEnabled = inboxEnabled
+    }
+
+    /// Initialize new VibesAppInfo from JSONObject
+    ///
+    /// - Parameter json: The JSON object
+    required convenience init?(json: VibesJSONDictionary) {
+        self.init()
+        guard let appId = json["app_id"] as? String,
+            let inboxEnabled = json["inbox_enabled"] as? Bool else { return nil }
+
+        self.appId = appId
+        self.inboxEnabled = inboxEnabled
+    }
+
+    /// Initialize this object using Attributes
+    ///
+    /// - Parameter attributes: - The dictionary with attributes
+    public required convenience init?(attributes: [String: Any]) {
+        self.init()
+
+        guard let appId = attributes["app_id"] as? String, !appId.isEmpty,
+            let inboxEnabled = attributes["inbox_enabled"] as? Bool else { return nil }
+
+        self.appId = appId
+        self.inboxEnabled = inboxEnabled
+    }
+}

package/vendor/VibesPush/Sources/VibesConfiguration.swift

@@ -0,0 +1,108 @@
+import Foundation
+
+@objcMembers
+public class VibesConfiguration: NSObject {
+    /// The internal console logger
+    internal static var consoleLogger: ConsoleLogger?
+
+    // MARK: Public Instance Properties
+
+    /// A unique advertising identifier for this device
+    public var advertisingId: String?
+
+    /// The default URL to hit when talking to the Vibes API
+    public let apiUrl: String
+
+    /// The default tracking URL to hit when talking to the Vibes API
+    public var trackingApiUrl: String
+
+    /// The logger to use.
+    public var logger: CombinedLogger?
+
+    /// Storage to store credential
+    public let storageType: VibesStorageEnum
+
+    /// Array for Objc interoperability , type of tracking
+    public var trackedEventTypes: NSArray
+
+    public var vibesAPIURL: URL {
+        if let url = URL(string: apiUrl) {
+            return url
+        } else {
+            return URL(string: VibesConfiguration.defaultApiUrl)!
+        }
+    }
+    
+    public var vibesTrackingAPIURL: URL {
+        if let url = URL(string: trackingApiUrl) {
+            return url
+        } else {
+            return URL(string: VibesConfiguration.defaultTrackingApiUrl)!
+        }
+    }
+
+    // MARK: Private Static Properties
+
+    /// The default URL to hit when talking to the Vibes API
+    private static let defaultApiUrl = "https://public-api.vibescm.com/mobile_apps"
+
+    /// TThe default URL to use to talk to EU Vibes environment, if not overridden by client settings.
+    private static let europeApiUrl = "https://public-api.vibescmeurope.com/mobile_apps"
+    
+    /// The default URL to use to send tracking info to Vibes, if not overridden by client settings.
+    private static let defaultTrackingApiUrl = "https://tagtracking.vibescm.com/track"
+
+    /// The default URL to use to send tracking info to EU Vibes environment
+    private static let europeTrackingApiUrl = "https://tagtracking.eu.vibes.com/track"
+
+    /// Enable Developer Logging which will print logs to the console.
+    ///
+    /// - Parameter level: The minimum Log level, Default is `.verbose`
+    public func enableDevLogging(level: LogLevel = .verbose) {
+        VibesConfiguration.consoleLogger = ConsoleLogger(level: level)
+    }
+
+    /// Disable Developer Logging
+    public func disableDevLogging() {
+        VibesConfiguration.consoleLogger = nil
+    }
+
+    ///
+    /// Configure paramenters for Vibes instance.
+    ///
+    /// - parameters:
+    ///   - advertisingId: AdSupport.advertisingId. If the application doesn't
+    ///     support it nil will be sent as value to the backend.
+    ///   - apiUrl: An optional URL to hit for accessing for the Vibes API; if not
+    ///     present, the staging URL will be used.
+    ///   - trackingApiUrl: An optional URL to hit for accessing for the Vibes Tracking API ; if not
+    ///     present, the staging URL will be used.
+    ///   - logger: The logger to use, in addition to`ConsoleLogger`. if enabled.
+    ///     You can enable console logging with `Vibes.shared.configuration.enableDevLogging()`
+    ///     and disable with `Vibes.shared.configuration.disableDevLogging()` at any point.
+    ///   - storageType: define the type of storage for storing data locally; if not
+    ///     present, data will be securely stored in the Keychain.
+    ///   - trackedEventTypes: NSArray for Objc interoperability , type of tracking
+    ///     events sent to Vibes; if not present, all events type (`.launch`,
+    ///    `.clickthru` e.t.c) will be monitored.
+    ///
+    public init(advertisingId: String? = nil,
+                apiUrl: String? = nil,
+                trackingApiUrl: String? = nil,
+                logger: VibesLogger? = nil,
+                storageType: VibesStorageEnum = .KEYCHAIN,
+                trackedEventTypes: NSArray = TrackedEventType.all as NSArray) {
+        self.advertisingId = advertisingId
+        self.apiUrl = apiUrl ?? VibesConfiguration.defaultApiUrl
+        if let apiUrl = apiUrl,
+           let trackingApiUrl = trackingApiUrl,
+           apiUrl.contains("vibescmeurope.com") && !trackingApiUrl.contains("eu.vibes.com") {
+            self.trackingApiUrl = VibesConfiguration.europeTrackingApiUrl
+        } else {
+            self.trackingApiUrl = trackingApiUrl ?? VibesConfiguration.defaultTrackingApiUrl
+        }
+        self.logger = CombinedLogger(customLogger: logger)
+        self.storageType = storageType
+        self.trackedEventTypes = trackedEventTypes
+    }
+}

package/vendor/VibesPush/Sources/VibesLogger.swift

@@ -0,0 +1,65 @@
+import Foundation
+
+/// A protocol for logging the Vibes SDK's HTTP-related logs
+@objc public protocol VibesLogger {
+    /// Logs a message to the logger if the `logObject.level` matches or is above the configured log `level`
+    ///
+    /// - Parameters:
+    ///   - logObject: The Log object with  log `level` and specified log `message`.
+    @objc func log(_ logObject: LogObject)
+
+    /// Logs an HTTP request.
+    ///
+    /// - parameters:
+    ///   - request: the HTTP request to log
+    @objc func log(request: URLRequest)
+
+    /// Logs an HTTP response with its accompanying data.
+    ///
+    /// - parameters:
+    ///   - response: the HTTP response to log
+    ///   - data: the data received, if any
+    @objc func log(response: URLResponse, data: Data?)
+
+    /// Logs an error.
+    ///
+    /// - parameters:
+    ///   - error: the error that occurred
+    @objc func log(error: Error)
+}
+
+/// Log Object with log `level` and `message`
+@objc public class LogObject: NSObject {
+    /// The Log leve
+    @objc public let level: LogLevel
+    /// The log message
+    @objc public let message: String
+
+    public init(_ level: LogLevel, message: String) {
+        self.level = level
+        self.message = message
+    }
+}
+
+/// A simple enum for specifying desired log level
+@objc public enum LogLevel: Int {
+    /// All requests and their info (endpoint, header, body, etc.), and errors
+    case verbose = 0
+
+    /// Request method and endpoint, and errors
+    case info
+
+    /// Only errors
+    case error
+
+    public var logPrefix: String {
+        switch self {
+        case .verbose:
+            return "VERBOSE"
+        case .info:
+            return "INFO"
+        default:
+            return "ERROR"
+        }
+    }
+}

package/vendor/VibesPush/Sources/VibesResult.swift

@@ -0,0 +1,78 @@
+/// A custom error enum that indicates why a Vibes operation has failed.
+public enum VibesError: Error {
+  /// An error indicating that the request could not be performed because
+  /// the device credentials are not available. This may indicate that the call
+  /// to `registerDevice` never completed successfully.
+  case noCredentials
+
+  /// An error indicating that the request could not be performed because
+  /// the device's push token is not available. This may indicate that the call
+  /// to `setPushToken` was never made.
+  case noPushToken
+
+  /// An error indicating that the request could not be performed because
+  /// authorization has failed.
+  case authFailed(String)
+
+  /// An error indicating that we have attempted to track an array containing
+  /// no events.
+  case noEvents
+
+  /// An error indicating that we have attempted to track an array containing
+  /// events with multiple types.
+  case tooManyEventTypes
+
+  /// A catch-all error, for issues that don't fall into other cases.
+  case other(String)
+
+  /// A friendly human-readable description of the error that occurred.
+  public var description: String {
+    switch self {
+    case .noCredentials:
+      return "There are no available credentials"
+    case .noPushToken:
+      return "There is no push token available"
+    case .noEvents:
+      return "There are no events to track"
+    case .tooManyEventTypes:
+      return "Too many types of events - can only handle one type at a time"
+    case .authFailed(let details):
+      return "Authentication failed: \(details)"
+    case .other(let details):
+      return "Error: \(details)"
+    }
+  }
+}
+
+/// A generic result object to created a tagged union of success or failure for
+/// completion a Vibes operation.
+public enum VibesResult<T> {
+  /// Used to indicate that a Vibes operation was successful
+  case success(T)
+
+  /// Used to indicate that the Vibes operation failed; the reason why is
+  /// attached as aa `VibesError`
+  case failure(VibesError)
+
+  /// Create a VibesResult from a ResourceResult. This keeps our public API
+  /// separate from our internal ones.
+  ///
+  /// - parameters:
+  ///   - result: a ResourceResult to convert into a VibesResult
+  init(_ result: ResourceResult<T>) {
+    switch result {
+    case .success(let value):
+      self = VibesResult<T>.success(value)
+    case .failure(let error):
+      switch error {
+      case .invalidResponse(let statusCode, let responseText) where statusCode == 401:
+        self = VibesResult<T>.failure(.authFailed(responseText))
+      case .invalidResponse(let statusCode, let responseText):
+        let description = "[HTTP \(statusCode)]: \(responseText)"
+        self = VibesResult<T>.failure(.other(description))
+      default:
+        self = VibesResult<T>.failure(.other("\(error)"))
+      }
+    }
+  }
+}

package/vibes-react-native.podspec

@@ -11,10 +11,14 @@ Pod::Spec.new do |s|
   s.authors      = package["author"]
 
   s.platforms    = { :ios => "15.6" }
+  s.swift_version = "5.0"
   s.source       = { :git => "https://github.com/vibes/vibes-react-native.git", :tag => "#{s.version}" }
 
-  s.source_files = "ios/**/*.{h,m,mm,swift}"
+  # Compile the iOS SDK into this pod so `pod install` does not need
+  # VibesPush on CocoaPods trunk. App targets can still `import VibesPush`.
+  s.module_name  = "VibesPush"
+  s.source_files = "ios/**/*.{h,m,mm,swift}", "vendor/VibesPush/Sources/**/*.swift"
+  s.frameworks   = "Foundation", "UIKit"
 
   s.dependency "React-Core"
-      s.dependency "VibesPush", "5.0.0"
 end