vibes-react-native 5.0.0 → 5.0.1-rc2

package/vendor/VibesPush/Sources/EventCollection.swift

@@ -0,0 +1,36 @@
+/// A simple object to encapsulate the notion of an array of Events.
+final class EventCollection {
+  /// The events in the collection
+  var events: [Event] = []
+
+  /// Initialize this object.
+  ///
+  /// - parameters:
+  ///   - events: the initial events to contain
+  init(events: [Event] = []) {
+    self.events = events
+  }
+}
+
+// Ideally, instead of `EventCollection` we would use conditional conformance
+// to do:
+//
+//   extension Array: LocalObjectType where Element: LocalObjectType {
+//     ...
+//   }
+//
+// but this sort of functionality isn't available yet in Swift.
+// See: https://github.com/apple/swift-evolution/blob/master/proposals/0143-conditional-conformances.md
+
+extension EventCollection: LocalObjectType {
+  var attributes: [String: Any] {
+    return ["object": events.map { $0.attributes }]
+  }
+
+  convenience init?(attributes: [String: Any]) {
+    self.init()
+
+    guard let eventAttributes = attributes["object"] as? [[String: Any]] else { return nil }
+    self.events = eventAttributes.compactMap { Event(attributes: $0) }
+  }
+}

package/vendor/VibesPush/Sources/EventTracker.swift

@@ -0,0 +1,39 @@
+/// A protocol for Types that wish to track events.
+protocol EventTracker: class {
+  /// Tracks events.
+  ///
+  /// - parameters:
+  ///   - events: the Events to track, e.g. [.launch]
+  ///   - completion: a handler for receiving the result of tracking the events
+  ///     (it returns an Array of the events that have been tracked)
+  func track(events incomingEvents: [Event], completion: VibesCompletion<[Event]>?)
+}
+
+extension EventTracker {
+  /// A convenience method for tracking a single event.
+  ///
+  /// - parameters:
+  ///   - event: the Event to track, e.g. .launch
+  ///   - completion: a handler for receiving the result of tracking the events
+  ///     (it returns an Array of the events that have been tracked)
+  func track(event incomingEvent: Event, completion: VibesCompletion<[Event]>?) {
+    track(events: [incomingEvent], completion: completion)
+  }
+
+  /// A convenience method for tracking events without caring about completion.
+  ///
+  /// - parameters:
+  ///   - events: the Events to track, e.g. [.launch]
+  func track(events incomingEvents: [Event]) {
+    track(events: incomingEvents, completion: nil)
+  }
+
+  /// A convenience method for tracking a single event without caring about
+  /// completion.
+  ///
+  /// - parameters:
+  ///   - event: the Event to track, e.g. .launch
+  func track(event incomingEvent: Event) {
+    track(events: [incomingEvent], completion: nil)
+  }
+}

package/vendor/VibesPush/Sources/FoundationExtensions.swift

@@ -0,0 +1,16 @@
+//
+//  FoundationExtensions.swift
+//  VibesPush
+//
+//  Created by Moin' Victor on 10/08/2021.
+//  Copyright © 2021 Vibes. All rights reserved.
+//
+
+import Foundation
+
+extension String {
+    func toJSON() -> Any? {
+        guard let data = self.data(using: .utf8, allowLossyConversion: false) else { return nil }
+        return try? JSONSerialization.jsonObject(with: data, options: .mutableContainers)
+    }
+}

package/vendor/VibesPush/Sources/GitTag.swift

@@ -0,0 +1,27 @@
+//
+//  GitTag.swift
+//  VibesPush
+//
+//  Created by Moin' Victor on 15/09/2020.
+//  Copyright © 2020 Vibes. All rights reserved.
+//
+
+import Foundation
+
+/// A small data object to hold a Git Tag
+public struct GitTag {
+    let name: String
+}
+
+extension GitTag: JSONEncodable, JSONDecodable {
+    init?(json: VibesJSONDictionary) {
+        guard let name = json["name"] as? String else { return nil }
+        self.name = name
+    }
+
+    func encodeJSON() -> VibesJSONDictionary {
+        return [
+            "name": name as AnyObject,
+        ]
+    }
+}

package/vendor/VibesPush/Sources/HTTP/HTTPBehavior.swift

@@ -0,0 +1,19 @@
+import Foundation
+/// A protocol to allow a network client to add behavior around requesting an
+/// HTTP resource.
+///
+/// This protocol may house more methods in the future, to allow for further
+/// customization of request-handling in a network client (e.g. for before/after
+/// callbacks to support an observer pattern).
+protocol HTTPBehavior {
+  /// Allows for the modification of a request object prior to it being sent.
+  ///
+  /// - parameters:
+  ///   - request: the request you would like to modify
+  func modifyRequest(request: inout URLRequest)
+}
+
+// We extend HTTPBehavior with a default no-op for its protocol methods.
+extension HTTPBehavior {
+  func modifyRequest(request: inout URLRequest) {}
+}

package/vendor/VibesPush/Sources/HTTP/HTTPMethod.swift

@@ -0,0 +1,20 @@
+/// A simple enum to provide type safety around HTTP methods.
+enum HTTPMethod: String {
+  /// A HEAD method for an HTTP Request.
+  case HEAD
+
+  /// A GET method for an HTTP Request.
+  case GET
+
+  /// A POST method for an HTTP Request.
+  case POST
+
+  /// A PUT method for an HTTP Request.
+  case PUT
+
+  /// A DELETE method for an HTTP Request.
+  case DELETE
+
+  /// A PATCH method for an HTTP Request.
+  case PATCH
+}

package/vendor/VibesPush/Sources/HTTP/HTTPResource.swift

@@ -0,0 +1,69 @@
+import Foundation
+
+/// A generic value object representing an HTTP resource that can be requested
+/// and parsed.
+///
+/// T represents the Type that will be returned for this resource, e.g.
+/// `Credential` or `String`.
+struct HTTPResource<T> {
+    // The base URL to be used for this resource
+    var baseURL: URL?
+    /// The path of the resource relative to the base url, e.g. "/devices"
+    let path: String
+
+    /// The HTTP method to use to fetch this resource, e.g. .POST
+    let method: HTTPMethod
+
+    /// The body to send when requesting this resource.
+    let requestBody: Data?
+
+    /// A set of headers to send when requesting this resource.
+    let headers: [String: String]
+
+    /// A closure to use to transform the returned Data for the resource into
+    /// the generic type, T.
+    let parse: (Data) -> T?
+
+    /// Initialize this object.
+    ///
+    /// - parameters:
+    ///   - baseURL: The Base URL, if this is specified, the default base URL will not be used.
+    ///   - path: The path of the resource relative to the base url, e.g.
+    ///     "/devices"
+    ///   - method: The HTTP method to use to fetch this resource, e.g. .POST
+    ///   - requestBody: The body to send when requesting this resource.
+    ///   - headers: A set of headers to send when requesting this resource.
+    ///   - parse: A closure to use to transform the returned Data for the
+    ///     resource into the generic type, T.
+    // swiftlint:disable:next line_length
+    init(baseURL: URL? = nil, path: String, method: HTTPMethod = .GET, requestBody: Data? = nil, headers: [String: String] = [:], parse: @escaping (Data) -> T?) {
+        self.baseURL = baseURL
+        self.path = path
+        self.method = method
+        self.requestBody = requestBody
+        self.headers = headers
+        self.parse = parse
+    }
+
+    /// Creates a new URLRequest for this resource. This can be passed to
+    /// URLSession to make a network request.
+    ///
+    /// - parameters:
+    ///   - baseURL: The base URL to use for a request for this resource, e.g.
+    ///     "http://example.com". The path will be appended to this.
+    func toRequest(baseURL: URL) -> URLRequest {
+        // use the base URL provided in the resource or use the default base URL
+        let url = (self.baseURL ?? baseURL).appendingPathComponent(path)
+        var request = URLRequest(url: url)
+
+        for (key, value) in headers {
+            request.setValue(value, forHTTPHeaderField: key)
+        }
+        request.httpMethod = method.rawValue
+        if method != .GET {
+            request.httpBody = requestBody
+        }
+
+        return request
+    }
+}

package/vendor/VibesPush/Sources/HTTP/HTTPResourceClient.swift

@@ -0,0 +1,190 @@
+import Foundation
+/// A closure used as a completion handler for HTTP requests.
+typealias HTTPCompletion<T> = (ResourceResult<T>) -> Void
+
+/// A protocol that indicates the required interface for being considered an
+/// `HTTPResourceClient`
+protocol HTTPResourceClientType {
+    func request<A>(resource: HTTPResource<A>,
+                    behavior: HTTPBehavior?,
+                    completion: HTTPCompletion<A>?)
+    func request<A>(resource: HTTPResource<A>,
+                    completion: HTTPCompletion<A>?)
+}
+
+/// A closure used as a completion handler for URLSessionDataTasks.
+typealias DataTaskResult = (Data?, URLResponse?, Error?) -> Void
+
+/// A protocol that indicates the required interface for being considered a
+/// `URLSession` for use with an `HTTPResourceClient`.
+protocol URLSessionType {
+    func dataTask(with request: URLRequest,
+                  completionHandler: @escaping DataTaskResult) -> URLSessionDataTaskType
+}
+
+extension URLSession: URLSessionType {
+    func dataTask(with request: URLRequest,
+                  completionHandler: @escaping DataTaskResult) -> URLSessionDataTaskType {
+        let task = dataTask(with: request,
+                            completionHandler: completionHandler) as URLSessionDataTask
+        return task as URLSessionDataTaskType
+    }
+}
+
+/// A protocol that indicates the required interface for being considered a
+/// `URLSessionDataTask` for use with an `HTTPResourceClient`.
+protocol URLSessionDataTaskType {
+    func resume()
+}
+
+extension URLSessionDataTask: URLSessionDataTaskType {}
+
+extension HTTPResourceClientType {
+    /// Make an HTTP request for an `HTTPResource`.
+    ///
+    /// - parameters:
+    ///   - resource: The resource to request
+    ///   - completion: A handler for when the request fails or succeeds.
+    func request<A>(resource: HTTPResource<A>,
+                    completion: HTTPCompletion<A>?) {
+        request(resource: resource, behavior: nil, completion: completion)
+    }
+}
+
+/// A network client that knows how to take `HTTPResource` objects, request them
+/// via URLSession, and parse them.
+class HTTPResourceClient: HTTPResourceClientType {
+    /// The base URL to use for this network client, e.g. "http://example.com"
+    private let baseURL: URL
+
+    /// A session to use, usually URLSession.shared.
+    private let session: URLSessionType
+
+    /// Optional provider for request/response logging. Evaluated per request so
+    /// it is safe before `Vibes.configure` has finished.
+    private let loggerProvider: () -> VibesLogger?
+
+    /// Initialize this object.
+    ///
+    /// - parameters:
+    ///   - baseURL: the base URL to use for this network client, e.g.
+    ///   "http://example.com"
+    ///   - session: the `URLSessionType` to use for making HTTP requests
+    ///   - loggerProvider: returns the logger to use for this request, if any
+    init(baseURL: URL,
+         session: URLSessionType = URLSession.shared,
+         loggerProvider: @escaping () -> VibesLogger? = { nil }) {
+        self.baseURL = baseURL
+        self.session = session
+        self.loggerProvider = loggerProvider
+    }
+
+    /// Make an HTTP request for an `HTTPResource`.
+    ///
+    /// - parameters:
+    ///   - resource: The resource to request
+    ///   - behavior: An optional HTTPBehavior to apply to the request
+    ///   - completion: A handler for when the request fails or succeeds.
+    func request<A>(resource: HTTPResource<A>,
+                    behavior: HTTPBehavior?,
+                    completion: HTTPCompletion<A>?) {
+        var request = resource.toRequest(baseURL: baseURL)
+        behavior?.modifyRequest(request: &request)
+
+        loggerProvider()?.log(request: request)
+
+        let task = session.dataTask(with: request) { data, response, error in
+            if let error = error {
+                self.loggerProvider()?.log(error: error)
+                self.handleError(error, completion: completion)
+                return
+            }
+
+            if let response = response {
+                self.loggerProvider()?.log(response: response, data: data)
+            }
+
+            guard let response = response as? HTTPURLResponse else {
+                completion?(.failure(.other(error)))
+                return
+            }
+
+            guard 200 ... 299 ~= response.statusCode else {
+                self.handleResponseWithStatusCode(of: response.statusCode,
+                                                  data: data,
+                                                  completion: completion)
+                return
+            }
+
+            guard let data = data else {
+                completion?(.failure(.noData))
+                return
+            }
+
+            if let value = resource.parse(data) {
+                completion?(.success(value))
+            } else {
+                completion?(.failure(.couldNotParse(data: data)))
+            }
+        }
+
+        task.resume()
+    }
+
+    /// Handle an error in even being able to make a request.
+    ///
+    /// - parameters:
+    ///   - error: The error
+    ///   - completion: A handler for when the request fails or succeeds.
+    fileprivate func handleError<A>(_ error: Error?, completion: HTTPCompletion<A>?) {
+        if let nserror = error as NSError? {
+            switch nserror.code {
+            case NSURLErrorTimedOut, NSURLErrorNotConnectedToInternet: completion?(.failure(.unreachable))
+            default: completion?(.failure(.other(error)))
+            }
+        }
+    }
+
+    /// Handle an HTTP response status (which may indicate an error or a success).
+    ///
+    /// - parameters:
+    ///   - statusCode: The HTTP response code, e.g. 200 or 502
+    ///   - data: The data returned with the response
+    ///   - completion: A handler for when the request fails or succeeds.
+    fileprivate func handleResponseWithStatusCode<A>(of statusCode: Int,
+                                                     data: Data?,
+                                                     completion: HTTPCompletion<A>?) {
+        let responseText = String(data: data ?? Data(), encoding: .utf8)
+
+        switch statusCode {
+        case 401: completion?(.failure(.unauthorized))
+        default:
+            let error = ResourceError.invalidResponse(statusCode: statusCode, responseText: responseText ?? "")
+            completion?(.failure(error))
+        }
+    }
+}
+
+internal extension URLRequest {
+
+    func toString() -> String {
+        return """
+          \(httpMethod!) \((url?.absoluteString)!),
+          \nBody: \(String(describing: httpBody != nil ? String(data: httpBody!,
+                                                                  encoding: String.Encoding.utf8)! : "")) \nHeaders: \(allHTTPHeaderFields!)
+        """
+    }
+}
+
+internal extension Int {
+
+    /// Returns `true` if this Int is a status code value to be retried
+    func isStatusCodeForRetryableServerError() -> Bool {
+        switch self {
+        case 408, 429, 500, 502, 503, 504:
+            return true
+        default:
+            return false
+        }
+    }
+}

package/vendor/VibesPush/Sources/HTTP/JSONParser.swift

@@ -0,0 +1,91 @@
+import Foundation
+
+/// A Type for a JSON dictionary (object)
+public typealias VibesJSONDictionary = [String: AnyObject]
+/// A Type for Vibes Tracking JSON dictionary (object)
+public typealias VibesTrackingData = [String: Any]
+/// A Type for a JSON array
+typealias VibesJSONArray = [VibesJSONDictionary]
+
+/// A protocol that can be adopted to say that a Type can be encoded into JSON.
+protocol JSONEncodable {
+  /// Encodes this Type into a JSONDictionary.
+  func encodeJSON() -> VibesJSONDictionary
+}
+
+/// A protocol that can be adopted to say that a Type can be decoded from JSON.
+protocol JSONDecodable {
+  /// A convenience initializer for decoding a JSONDictionary into this Type.
+  ///
+  /// - parameters:
+  ///   - json: the JSONDictionary to encode into data
+  init?(json: VibesJSONDictionary)
+}
+
+/// Allows the ability to decode/encode `Data` to/from a `JSONDictionary`.
+struct JSONParser {
+  /// Decodes data into a JSONDictionary.
+  ///
+  /// - parameters:
+  ///   - data: the data to decode
+  func decode(data: Data) -> VibesJSONDictionary? {
+    // Treat an existing but blank data as an empty JSON object
+    guard !data.isEmpty else { return [:] }
+
+    // swiftlint:disable:next force_cast
+    return try? JSONSerialization.jsonObject(with: data) as? VibesJSONDictionary
+  }
+
+  /// Decodes data into a JSONArray.
+  ///
+  /// - parameters:
+  ///   - data: the data to decode
+  func decodeJSONArray(data: Data) -> VibesJSONArray? {
+    // Treat an existing but blank data as an empty JSON object
+    guard !data.isEmpty else { return [] }
+
+    guard let arrayJson = ((try? JSONSerialization.jsonObject(with: data) as? VibesJSONArray) as VibesJSONArray??)
+      else {
+        return nil
+      }
+
+    return arrayJson
+  }
+
+  /// Encodes a JSONEncodable to data.
+  ///
+  /// - parameters:
+  ///   - object: a JSONEncodable object to encode into data
+  func encode(_ object: JSONEncodable) -> Data? {
+    let dict = object.encodeJSON()
+    return encode(dict)
+  }
+
+  /// Encodes an array of JSONEncodable objects to data.
+  ///
+  /// - parameters:
+  ///   - objects: an array of JSONEncodable object to encode into data
+  func encode(_ objects: [JSONEncodable]) -> Data? {
+    let array = objects.map { $0.encodeJSON() }
+    return encode(array)
+  }
+
+  /// Encodes a JSONDictionary to data.
+  ///
+  /// - parameters:
+  ///   - dict: the JSONDictionary to encode into data
+  func encode(_ dict: VibesJSONDictionary) -> Data? {
+    guard !dict.isEmpty else { return nil }
+    guard JSONSerialization.isValidJSONObject(dict) else { return nil }
+    return try? JSONSerialization.data(withJSONObject: dict, options: .prettyPrinted)
+  }
+
+  /// Encodes a JSONArray to data.
+  ///
+  /// - parameters:
+  ///   - array: the JSONArray to encode into data
+  func encode(_ array: VibesJSONArray) -> Data? {
+    guard JSONSerialization.isValidJSONObject(array) else { return nil }
+    return try? JSONSerialization.data(withJSONObject: array, options: .prettyPrinted)
+  }
+}

package/vendor/VibesPush/Sources/HTTP/Operations/AssociatePersonOperation.swift

@@ -0,0 +1,56 @@
+//
+//  AssociatePersonOperation.swift
+//  VibesPush-iOS
+//
+//  Created by Peter Compernolle on 5/30/2018.
+//  Copyright © 2018 Vibes. All rights reserved.
+//
+
+internal class AssociatePersonOperation: BaseOperation<Void> {
+    fileprivate let resource: () -> HTTPResource<Void>
+    fileprivate weak var delegate: VibesAPIDelegate?
+    fileprivate var callback: VibesCompletion<Void>?
+
+    /// Completion handler responsible for notifying sdk users
+    fileprivate lazy var completionHandler: VibesCompletion<Void> = {[weak self] (result) in
+        switch result {
+        case .success:
+            self?.callback?(.success(()))
+            self?.delegate?.didAssociatePerson?(error: nil)
+        case .failure(let error):
+            self?.callback?(.failure(error))
+            self?.delegate?.didAssociatePerson?(error: error)
+        }
+    }
+
+    /// Initialize this object
+    ///
+    /// - parameters:
+    ///   - credentialManager: an object to store credentials, keeping track of the current Credential..
+    ///   - api: an object that allows talking to the Vibes API
+    ///   - advertisingId: AdSupport.advertisingId
+    ///   - appId: the application ID provided by Vibes to identify this application
+    ///   - delegate: VibesAPIDelegate.
+    ///   - externalPersonId: a String representation of the third party person identifier
+    public init(credentials: CredentialManager,
+                api: VibesAPIType,
+                advertisingId: String,
+                appId: String,
+                delegate: VibesAPIDelegate?,
+                callback: VibesCompletion<Void>? = nil,
+                externalPersonId: String) {
+        self.delegate = delegate
+        self.callback = callback
+        resource = {
+            let deviceId = credentials.currentCredential?.deviceId ?? VibesQueueConstant.NONE
+            return APIDefinition.associatePerson(appId: appId, deviceId: deviceId, externalPersonId: externalPersonId)
+        }
+        super.init(credentials: credentials, api: api, advertisingId: advertisingId, appId: appId)
+    }
+
+    /// Execute the operation
+    override func start() {
+        super.start()
+        super.execute(retry: 0, resource: resource, completion: completionHandler)
+    }
+}