vibes-react-native 5.0.1-rc1 → 5.0.1-rc2

package/ios/Vibes.swift

@@ -1,9 +1,8 @@
 import Foundation
 import UserNotifications
-import VibesPush
 
 @objc(Vibes)
-class Vibes: NSObject, RCTBridgeModule, VibesPush.VibesAPIDelegate {
+class VibesModule: NSObject, RCTBridgeModule, VibesAPIDelegate {
     static func moduleName() -> String! {
         return "Vibes"
     }
@@ -12,7 +11,7 @@ class Vibes: NSObject, RCTBridgeModule, VibesPush.VibesAPIDelegate {
 
     let userDefaults = UserDefaults.standard
 
-    var vibes: VibesPush.Vibes
+    var vibes: Vibes
     var registerDeviceResolver: RCTPromiseResolveBlock?
     var registerDeviceRejecter: RCTPromiseRejectBlock?
     var unregisterDeviceResolver: RCTPromiseResolveBlock?

package/ios/VibesClient.swift

@@ -6,13 +6,12 @@
 //  Copyright © 2022 Facebook. All rights reserved.
 //
 
-import VibesPush
 
 @objcMembers
 class VibesClient: NSObject {
     static let standard = VibesClient()
 
-    public let vibes: VibesPush.Vibes
+    public let vibes: Vibes
     public var logger: VibesLogger? = VibesPluginLogger.shared
 
     override private init() {
@@ -29,7 +28,7 @@ class VibesClient: NSObject {
                                         logger: logger,
                                         storageType: .USERDEFAULTS)
 
-        VibesPush.Vibes.configure(appId: appId, configuration: config)
-        vibes = VibesPush.Vibes.shared
+        Vibes.configure(appId: appId, configuration: config)
+        vibes = Vibes.shared
     }
 }

package/ios/VibesPluginLogger.swift

@@ -7,7 +7,6 @@
 //
 
 import UIKit
-import VibesPush
 
 @objcMembers
 class VibesPluginLogger: NSObject {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibes-react-native",
-  "version": "5.0.1-rc1",
+  "version": "5.0.1-rc2",
   "description": "The React Native plugin for the Vibes Mobile SDKs",
   "author": "Vibes",
   "main": "lib/commonjs/index",
@@ -20,7 +20,8 @@
     "!ios/build",
     "!**/__tests__",
     "!**/__fixtures__",
-    "!**/__mocks__"
+    "!**/__mocks__",
+    "vendor"
   ],
   "scripts": {
     "test": "jest",

package/vendor/VibesPush/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2018 Vibes Media, LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/vendor/VibesPush/Sources/APIDefinition.swift

@@ -0,0 +1,502 @@
+import Foundation
+/// A data structure to hold the `HTTPResource` defintions for the Vibes API.
+///
+/// A caseless enum is used in order to provide a namespace without allowing the
+/// possibility of accidentally instantiating an instance of this Type.
+enum APIDefinition {
+    /// A resource for registering a device with Vibes.
+    ///
+    /// - parameters:
+    ///   - appId: a unique ID, provided by Vibes, that identifies the account
+    ///   - device: a `DeviceType` object with relevant device information to
+    ///     record with Vibes
+    /// - Returns: The HttpResource
+    static func registerDevice(appId: String, device: DeviceType) -> HTTPResource<VibesCredential> {
+        return jsonResource(
+            path: "/\(appId)/devices",
+            method: .POST,
+            requestParameters: device.encodeJSON(),
+            parse: VibesCredential.init
+        )
+    }
+
+    /// A resource for obtaining person information at Vibes. This is used to
+    /// retrieve person information.
+    ///
+    /// - parameters:
+    ///   - appId: a unique ID, provided by Vibes, that identifies the account
+    ///   - deviceId: the vibes device id that uniquely identifies the device to
+    ///     unregister
+    /// - Returns: The HttpResource
+    static func getPerson(appId: String, deviceId: String) -> HTTPResource<Person> {
+        return jsonResource(
+            path: "/\(appId)/devices/\(deviceId)/person",
+            method: .GET,
+            requestParameters: VibesJSONArray(),
+            parse: Person.init
+        )
+    }
+
+    /// A resource for updating a device with Vibes. This is used to save
+    /// the device location.
+    ///
+    /// - parameters:
+    ///   - appId: a unique ID, provided by Vibes, that identifies the account
+    ///   - deviceId: the vibes device id that uniquely identifies the device to
+    ///     unregister
+    ///   - device: a `DeviceType` object with relevant device information to
+    ///     record with Vibes
+    /// - Returns: The HttpResource
+    static func updateDeviceInfoPut(appId: String, deviceId: String, device: DeviceType) -> HTTPResource<VibesCredential> {
+        return jsonResource(
+            path: "/\(appId)/devices/\(deviceId)",
+            method: .PUT,
+            requestParameters: device.encodeJSON(),
+            parse: VibesCredential.init
+        )
+    }
+
+    /// A resource for updating a device with Vibes. This is used to save
+    /// the device location.
+    ///
+    /// - parameters:
+    ///   - appId: a unique ID, provided by Vibes, that identifies the account
+    ///   - deviceId: the vibes device id that uniquely identifies the device to
+    ///     unregister
+    ///   - device: a `DeviceType` object with relevant device information to
+    ///     record with Vibes
+    /// - Returns: The HttpResource
+    static func updateDeviceInfoPatch(appId: String, deviceId: String, device: DeviceType) -> HTTPResource<Void> {
+        return jsonResource(
+            path: "/\(appId)/devices/\(deviceId)",
+            method: .PATCH,
+            requestParameters: device.encodeJSON(),
+            parse: noResult
+        )
+    }
+
+    /// A resource for associating a device with an external person
+    ///
+    /// - parameters:
+    ///   - appId: a unique ID, provided by Vibes, that identifies the account
+    ///   - deviceId: the vibes device id that uniquely identifies the device to associate
+    ///   - externalPersonId: a string representation of the person identifier used by third parties,
+    ///     stored by Vibes as `external_person_id`
+    /// - Returns: The HttpResource
+    static func associatePerson(appId: String, deviceId: String, externalPersonId: String) -> HTTPResource<Void> {
+        let personData = ["external_person_id": externalPersonId as AnyObject]
+        return jsonResource(
+            path: "/\(appId)/devices/\(deviceId)/assign",
+            method: .POST,
+            requestParameters: personData as VibesJSONDictionary,
+            parse: noResult
+        )
+    }
+
+    /// A resource for unregistering a device with Vibes.
+    ///
+    /// - parameters:
+    ///   - appId: a unique ID, provided by Vibes, that identifies the account
+    ///   - deviceId: the vibes device id that uniquely identifies the device to
+    ///     unregister
+    /// - Returns: The HttpResource
+    static func unregisterDevice(appId: String, deviceId: String) -> HTTPResource<Void> {
+        return HTTPResource(
+            path: "/\(appId)/devices/\(deviceId)",
+            method: .DELETE,
+            parse: noResult
+        )
+    }
+
+    /// A resource for registering this device for push notifications from Vibes.
+    ///
+    /// - parameters:
+    ///   - appId: a unique ID, provided by Vibes, that identifies the account
+    ///   - deviceId: the vibes device id that uniquely identifies the device to
+    ///     unregister
+    ///   - pushToken: a unique token, provided by Apple, that identifies the
+    ///     device
+    /// - Returns: The HttpResource
+    static func registerPush(appId: String, deviceId: String, pushToken: String) -> HTTPResource<Void> {
+        let deviceToken = DeviceToken(token: pushToken)
+        return jsonResource(
+            path: "/\(appId)/devices/\(deviceId)/push_registration",
+            method: .POST,
+            requestParameters: deviceToken.encodeJSON(),
+            parse: noResult
+        )
+    }
+
+    /// A resource for unregistering this device for push notifications from Vibes.
+    ///
+    /// - parameters:
+    ///   - appId: a unique ID, provided by Vibes, that identifies the account
+    ///   - deviceId: the vibes device id that uniquely identifies the device to
+    ///     unregister
+    /// - Returns: The HttpResource
+    static func unregisterPush(appId: String, deviceId: String) -> HTTPResource<Void> {
+        return HTTPResource(
+            path: "/\(appId)/devices/\(deviceId)/push_registration",
+            method: .DELETE,
+            parse: noResult
+        )
+    }
+
+    /// A resource for tracking events with Vibes.
+    ///
+    /// - parameters:
+    ///   - appId: a unique ID, provided by Vibes, that identifies the account
+    ///   - deviceId: the vibes device id that uniquely identifies this device
+    ///   - events: the events to track
+    /// - Returns: The HttpResource
+    static func trackEvents(appId: String, deviceId: String, events: [Event]) -> HTTPResource<Void> {
+        let params: VibesJSONDictionary = [
+            "events": events.map { $0.encodeJSON() } as AnyObject,
+        ]
+
+        return jsonResource(
+            path: "/\(appId)/devices/\(deviceId)/events",
+            method: .POST,
+            requestParameters: params,
+            headers: ["X-Event-Type": events.first?.type ?? "event"],
+            parse: noResult
+        )
+    }
+
+    /// Tracks an action linked to ecommerce activity on a product
+    ///
+    /// - Parameters:
+    ///   - action: the type of  `ProductAction`
+    ///   - product: the product being tracked.
+    ///   - data: Tracking data for making tracking call.
+    ///   - activityUid: Optional activityUid in case user wants to override the one stored in local storage.
+    /// - Returns: HTTPResource
+    static func trackProductAction(action: ProductAction, product: Product, data: VibesTrackingData, activityUid: String?) -> HTTPResource<Void> {
+        var theActivityUID = activityUid
+        if let activityUid = activityUid,
+           !activityUid.isEmpty {
+            theActivityUID = activityUid
+        } else {
+            theActivityUID = data["activity_uid"] as? String
+        }
+
+        var resource = jsonResource(
+            path: "",
+            method: .GET,
+            requestParameters: [:],
+            parse: noResult
+        )
+        resource.baseURL = APIDefinition.createTrackingURL(theActivityUID: theActivityUID,
+                                                           data: data,
+                                                           action: action,
+                                                           product: product)
+        return resource
+    }
+  
+  /// Tracks an action linked to ecommerce activity on a Purchase
+  ///
+  /// - Parameters:
+  ///   - action: the type of  `PurchaseAction`
+  ///   - data: Tracking data for making tracking call.
+  ///   - activityUid: Optional activityUid in case user wants to override the one stored in local storage.
+  /// - Returns: HTTPResource
+  static func trackPurchaseAction(action: PurchaseAction, purchase: Purchase, data: VibesTrackingData, activityUid: String?) -> HTTPResource<Void> {
+      var theActivityUID = activityUid
+      if let activityUid = activityUid,
+         !activityUid.isEmpty {
+          theActivityUID = activityUid
+      } else {
+          theActivityUID = data["activity_uid"] as? String
+      }
+
+      var resource = jsonResource(
+          path: "",
+          method: .GET,
+          requestParameters: [:],
+          parse: noResult
+      )
+      resource.baseURL = APIDefinition.createTrackingURL(theActivityUID: theActivityUID,
+                                                         data: data,
+                                                         action: action,
+                                                         purchase: purchase)
+      return resource
+  }
+
+  static func createTrackingURL(theActivityUID: String?, data: VibesTrackingData, action: PurchaseAction, purchase: Purchase) -> URL {
+    let payload: VibesJSONDictionary = [
+        "activityId": theActivityUID as AnyObject,
+        "personId": data["person_key"] as AnyObject,
+        "action": action.rawValue as AnyObject,
+        "companyId": data["company_key"] as AnyObject,
+        "data": purchase.attributes as AnyObject,
+    ]
+
+    let qStr = "[\(payload.jsonStringRepresentation!)]".addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)
+    return URL(string: Vibes.shared.configuration.trackingApiUrl + "?d=\(qStr!)")!
+  }
+
+    static func createTrackingURL(theActivityUID: String?, data: VibesTrackingData, action: ProductAction, product: Product) -> URL {
+      let payload: VibesJSONDictionary = [
+          "activityId": theActivityUID as AnyObject,
+          "personId": data["person_key"] as AnyObject,
+          "action": action.rawValue as AnyObject,
+          "companyId": data["company_key"] as AnyObject,
+          "data": product.attributes as AnyObject,
+      ]
+
+      let qStr = "[\(payload.jsonStringRepresentation!)]".addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)
+      return URL(string: Vibes.shared.configuration.trackingApiUrl + "?d=\(qStr!)")!
+    }
+
+    /// A resource for retrieving Git Tags
+    ///
+    /// - Returns: The HttpResource
+    static func getGitTags() -> HTTPResource<[GitTag]> {
+        var resource: HTTPResource<[GitTag]> = jsonResources(
+            path: "/tags",
+            method: .GET,
+            requestParameters: VibesJSONDictionary(),
+            headers: ["Accept": "application/vnd.github.v3+json"],
+            parse: fromJSONArray
+        )
+        resource.baseURL = URL(string: "https://api.github.com/repos/vibes/push-sdk-ios")
+        return resource
+    }
+
+    /// A resource for retrieving a single  inbox message
+    ///
+    /// - Parameters:
+    ///     - appId: a unique ID, provided by Vibes, that identifies the account
+    ///     - personKey: The Alphanumeric person key
+    ///     - messageUID: The Alphanumeric message UID
+    /// - Returns: The HttpResource
+    static func getInboxMessage(appId: String, personKey: String, messageUID: String) -> HTTPResource<InboxMessage> {
+        return jsonResource(
+            path: "/\(appId)/persons/\(personKey)/messages/\(messageUID)",
+            method: .GET,
+            requestParameters: VibesJSONDictionary(),
+            parse: InboxMessage.init
+        )
+    }
+
+    /// A resource for retrieving inbox messages
+    ///
+    /// - Parameters:
+    ///     - appId: a unique ID, provided by Vibes, that identifies the account
+    ///     - personKey: The Alphanumeric person key
+    /// - Returns: The HttpResource
+    static func getInboxMessages(appId: String, personKey: String) -> HTTPResource<[InboxMessage]> {
+        return jsonResources(
+            path: "/\(appId)/persons/\(personKey)/messages",
+            method: .GET,
+            requestParameters: VibesJSONDictionary(),
+            parse: fromJSONArray
+        )
+    }
+
+    /// A resource for updating inbox messages
+    ///
+    /// - Parameters:
+    ///   - appId: a unique ID, provided by Vibes, that identifies the account
+    ///   - personKey: The Alphanumeric person key
+    ///   - messageUID: The Alphanumeric messge UID
+    /// - Returns: The HttpResource
+    static func updateMessage(appId: String, personKey: String, messageUID: String, payload: VibesJSONDictionary) -> HTTPResource<InboxMessage> {
+        return jsonResource(
+            path: "/\(appId)/persons/\(personKey)/messages/\(messageUID)",
+            method: .PUT,
+            requestParameters: payload,
+            parse: InboxMessage.init
+        )
+    }
+
+    static func fetchVibesAppInfo(appId: String) -> HTTPResource<VibesAppInfo> {
+        return jsonResource(
+            path: "/\(appId)",
+            method: .GET,
+            requestParameters: VibesJSONDictionary(),
+            parse: VibesAppInfo.init
+        )
+    }
+
+    /// A resource to triggers silent push migration callback
+    ///
+    /// - Parameters:
+    ///   - appId: a unique ID, provided by Vibes, that identifies the account
+    ///   - migrationItemId: The migration item Id
+    ///   - vibesDeviceId: Vibes Device Id
+    ///
+    /// - Returns: The HttpResource
+    static func migrationCallback(appId: String, migrationItemId: String, vibesDeviceId: String) -> HTTPResource<Void> {
+        let payload: VibesJSONDictionary = [
+            "migration_item_id": migrationItemId as AnyObject,
+            "vibes_device_id": vibesDeviceId as AnyObject,
+        ]
+        return jsonResource(
+            path: "/\(appId)/migrations/callbacks",
+            method: .PUT,
+            requestParameters: payload,
+            parse: noResult
+        )
+    }
+
+    /// A generic utility function for creating an `HTTPResource` that expects to
+    /// send and receive JSON.
+    ///
+    /// - parameters:
+    ///   - path: the path for this resource, e.g. "/devices"
+    ///   - method: the HTTP method for this resource, e.g. .DELETE
+    ///   - requestParameters: the JSON object to send with this request
+    ///   - headers: an optional list of headers for the resource. `Content-Type`
+    ///     and `Accept` headers will automatically be added in.
+    ///   - parse: a closure that dictates how to map the received JSON (not Data)
+    ///     into an instance of `A`.
+    private static func jsonResource<A>(path: String,
+                                        method: HTTPMethod,
+                                        requestParameters: VibesJSONDictionary = [:],
+                                        headers: [String: String] = [:],
+                                        parse: @escaping (VibesJSONDictionary) -> A?) -> HTTPResource<A> {
+        let parser = JSONParser()
+        let jsonBody = parser.encode(requestParameters)
+
+        return commonJsonResource(path: path, method: method, jsonBody: jsonBody, headers: headers, parse: parse)
+    }
+
+    /// A generic utility function for creating an `HTTPResource` that expects to
+    /// send and receive JSON.
+    ///
+    /// - parameters:
+    ///   - path: the path for this resource, e.g. "/devices"
+    ///   - method: the HTTP method for this resource, e.g. .DELETE
+    ///   - requestParameters: the JSON object to send with this request
+    ///   - headers: an optional list of headers for the resource. `Content-Type`
+    ///     and `Accept` headers will automatically be added in.
+    ///   - parse: a closure that dictates how to map the received JSON (not Data)
+    ///     into an instance of `[A]`.
+    private static func jsonResources<A>(path: String,
+                                         method: HTTPMethod,
+                                         requestParameters: VibesJSONDictionary = [:],
+                                         headers: [String: String] = [:],
+                                         parse: @escaping (VibesJSONArray) -> [A]) -> HTTPResource<[A]> {
+        let parser = JSONParser()
+        let jsonBody = parser.encode(requestParameters)
+
+        return commonJsonResources(path: path, method: method, jsonBody: jsonBody, headers: headers, parse: parse)
+    }
+
+    /// A generic utility function for creating an `HTTPResource` that expects to
+    /// send and receive JSON.
+    ///
+    /// - parameters:
+    ///   - path: the path for this resource, e.g. "/devices"
+    ///   - method: the HTTP method for this resource, e.g. .DELETE
+    ///   - requestParameters: the JSON array to send with this request
+    ///   - headers: an optional list of headers for the resource. `Content-Type`
+    ///     and `Accept` headers will automatically be added in.
+    ///   - parse: a closure that dictates how to map the received JSON (not Data)
+    ///     into an instance of `A`.
+    private static func jsonResource<A>(path: String,
+                                        method: HTTPMethod,
+                                        requestParameters: VibesJSONArray = [],
+                                        headers: [String: String] = [:],
+                                        parse: @escaping (VibesJSONDictionary) -> A?) -> HTTPResource<A> {
+        let parser = JSONParser()
+        let jsonBody = parser.encode(requestParameters)
+        return commonJsonResource(path: path, method: method, jsonBody: jsonBody, headers: headers, parse: parse)
+    }
+
+    /// A generic helper for creating an `HTTPResource` that expects to send and
+    /// receive JSON.
+    ///
+    /// - parameters:
+    ///   - path: the path for this resource, e.g. "/devices"
+    ///   - method: the HTTP method for this resource, e.g. .DELETE
+    ///   - jsonBody: JSON, encoded as Data
+    ///   - headers: an optional list of headers for the resource. `Content-Type`
+    ///     and `Accept` headers will automatically be added in.
+    ///   - parse: a closure that dictates how to map the received JSON (not Data)
+    ///     into an instance of `A`.
+    private static func commonJsonResource<A>(path: String,
+                                              method: HTTPMethod,
+                                              jsonBody: Data?,
+                                              headers: [String: String] = [:],
+                                              parse: @escaping (VibesJSONDictionary) -> A?) -> HTTPResource<A> {
+        let parser = JSONParser()
+
+        // Creates a function that parses `Data` into a `JSONDictionary`, and then
+        // passes that dictionary on to the custom `parse` function to create an
+        // instance of our `A` type
+        let parseWrapper: (Data) -> A? = { data in
+            guard let dict = parser.decode(data: data) else { return nil }
+            return parse(dict)
+        }
+
+        let headers = headers.merged(with: ["Content-Type": "application/json", "Accept": "application/json"])
+
+        return HTTPResource(path: path, method: method, requestBody: jsonBody, headers: headers, parse: parseWrapper)
+    }
+
+    /// A generic helper for creating an `HTTPResource` that expects to send and
+    /// receive JSON.
+    ///
+    /// - parameters:
+    ///   - path: the path for this resource, e.g. "/devices"
+    ///   - method: the HTTP method for this resource, e.g. .DELETE
+    ///   - jsonBody: JSON, encoded as Data
+    ///   - headers: an optional list of headers for the resource. `Content-Type`
+    ///     and `Accept` headers will automatically be added in.
+    ///   - parse: a closure that dictates how to map the received JSON (not Data)
+    ///     into an instance of `[A]`.
+    private static func commonJsonResources<A>(path: String,
+                                               method: HTTPMethod,
+                                               jsonBody: Data?,
+                                               headers: [String: String] = [:],
+                                               parse: @escaping (VibesJSONArray) -> [A]) -> HTTPResource<[A]> {
+        let parser = JSONParser()
+
+        // Creates a function that parses `Data` into a `JSONArray`, and then
+        // passes that dictionary on to the custom `parse` function to create an
+        // instance of our `[A]` type
+        let parseWrapper: (Data) -> [A]? = { data in
+            guard let array = parser.decodeJSONArray(data: data) else { return nil }
+            return parse(array)
+        }
+
+        let headers = headers.merged(with: ["Content-Type": "application/json", "Accept": "application/json"])
+
+        return HTTPResource(path: path, method: method, requestBody: jsonBody, headers: headers, parse: parseWrapper)
+    }
+
+    /// A helper function for when there is no expected response data.
+    private static func noResult(data: Data) {
+    }
+
+    /// A helper function for when there is no expected response JSON.
+    private static func noResult(json: VibesJSONDictionary) {
+    }
+
+    /// A convenience initializer for decoding a JSONArray into their Array Types.
+    ///
+    /// - parameters:
+    ///   - jsonArray: the JSON Array to encode into data
+    private static func fromJSONArray<T: JSONDecodable>(jsonArray: VibesJSONArray) -> [T] {
+        var result: [T] = [T]()
+        for json in jsonArray {
+            if let object = T(json: json) {
+                result.append(object)
+            }
+        }
+        return result
+    }
+}
+
+extension Dictionary {
+    var jsonStringRepresentation: String? {
+        guard let theJSONData = try? JSONSerialization.data(withJSONObject: self,
+                                                            options: [.prettyPrinted]) else {
+            return nil
+        }
+
+        return String(data: theJSONData, encoding: .utf8)
+    }
+}

package/vendor/VibesPush/Sources/Actions.swift

@@ -0,0 +1,24 @@
+//
+//  ProductActions.swift
+//  VibesPush
+//
+//  Created by Moin' Victor on 11/08/2022.
+//  Copyright © 2022 Vibes. All rights reserved.
+//
+
+import Foundation
+
+public enum ProductAction: String {
+    case click
+    case detail
+    case add
+    case remove
+    case checkout
+    case checkoutOption = "checkout_option"
+    case promoClick = "promo_click"
+}
+
+public enum PurchaseAction: String {
+    case purchase
+    case refund
+}