react-native-hubspot-wrapper 0.1.0

package/HUBSPOT_IOS_SDK_VERSION.json

@@ -0,0 +1,5 @@
+{
+  "sourceRepository": "https://github.com/HubSpot/mobile-chat-sdk-ios.git",
+  "tag": "1.0.7",
+  "commit": "be33ea03c2f14d9ae47079128edf1f3c7c11d6a8"
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Marcin Olek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/MIGRATION.md

@@ -0,0 +1,19 @@
+# Migration from react-native-hubspot-chat
+
+## Import change
+
+```ts
+// before
+import HubspotChat from 'react-native-hubspot-chat';
+
+// after
+import HubspotWrapper from 'react-native-hubspot-wrapper';
+```
+
+## API mapping
+
+- `HubspotChat.init()` -> `HubspotWrapper.initialize()`
+- `HubspotChat.open(chatflow)` -> `HubspotWrapper.openChat(chatflow)`
+- `HubspotChat.identify(token, email)` -> `HubspotWrapper.setIdentity({ identityToken: token, email })`
+- `HubspotChat.setProperties(properties)` -> `HubspotWrapper.setProperties(properties)`
+- `HubspotChat.endSession()` -> `HubspotWrapper.clearUserData()`

package/README.md

@@ -0,0 +1,119 @@
+# react-native-hubspot-wrapper
+
+TurboModule-only React Native wrapper for the HubSpot Mobile Chat SDK.
+
+> Unofficial. Not affiliated with, endorsed by, or sponsored by HubSpot, Inc.
+> "HubSpot" is a trademark of HubSpot, Inc.
+
+## Status
+
+Early release (`0.x`). The public API may evolve before `1.0`.
+
+Currently supported:
+
+- `initialize()`
+- `openChat(chatflow)`
+- `setIdentity({ identityToken, email? })`
+- `setProperties(properties)`
+- `clearUserData()`
+
+Not yet implemented (planned):
+
+- Push notifications (FCM token registration on Android, APNs token on iOS,
+  deep-linking from a notification into the relevant chat)
+- Chat lifecycle events (open / close / message-received callbacks exposed to JS)
+- Custom theming hooks beyond what the HubSpot dashboard chatflow already provides
+
+PRs welcome.
+
+## Requirements
+
+- React Native 0.81+
+- New Architecture enabled
+- iOS 15+
+- Android minSdk 26
+
+## Installation
+
+```sh
+yarn add react-native-hubspot-wrapper
+```
+
+Then install iOS dependencies:
+
+```sh
+cd ios && pod install
+```
+
+## Configuration
+
+- iOS: include `Hubspot-Info.plist` in your app target.
+- Android: include `android/app/src/main/assets/hubspot-info.json`.
+
+## Usage
+
+```ts
+import HubspotWrapper from 'react-native-hubspot-wrapper';
+
+await HubspotWrapper.initialize();
+await HubspotWrapper.setIdentity({ identityToken: 'token', email: 'user@example.com' });
+await HubspotWrapper.setProperties([{ name: 'plan', value: 'pro' }]);
+await HubspotWrapper.openChat('support');
+```
+
+## API
+
+- `initialize(): Promise<void>`
+- `openChat(chatflow: string): Promise<void>`
+- `setIdentity({ identityToken, email? }): Promise<void>`
+- `setProperties(properties): Promise<void>`
+- `clearUserData(): Promise<void>`
+
+## iOS SDK source strategy
+
+This package vendors HubSpot iOS SDK source files under `ios/HubspotMobileSDK`.
+The files are intentionally committed to git for reproducible CocoaPods builds,
+since React Native does not yet integrate Swift Package Manager natively.
+
+Current vendored source metadata is tracked in `HUBSPOT_IOS_SDK_VERSION.json`.
+The upstream `LICENSE.txt` is preserved alongside the vendored sources at
+`ios/HubspotMobileSDK/LICENSE.txt`, in compliance with the MIT license HubSpot
+ships their iOS SDK under.
+
+When React Native adds first-class SwiftPM support, the vendored sources can be
+removed and replaced with a `Package.swift` dependency without any consumer-facing
+API changes.
+
+## Updating vendored HubSpot iOS SDK
+
+Use the helper script:
+
+```sh
+yarn update:hubspot:ios
+```
+
+Note: the update script also reapplies a small CocoaPods compatibility patch set
+to HubSpot iOS sources (resource bundle + asset/localization access), so the
+wrapper remains buildable outside of pure Swift Package Manager integration.
+
+Optional: update to an explicit tag:
+
+```sh
+yarn update:hubspot:ios 1.0.7
+```
+
+After updating:
+
+1. run `cd ios && pod install` in the consuming app
+2. run iOS/Android compile checks
+3. commit updated `ios/HubspotMobileSDK` and `HUBSPOT_IOS_SDK_VERSION.json`
+
+## License
+
+This wrapper is released under the [MIT license](./LICENSE).
+
+The vendored HubSpot iOS SDK source under `ios/HubspotMobileSDK/` is also
+MIT-licensed by HubSpot, Inc. — see `ios/HubspotMobileSDK/LICENSE.txt`.
+
+The HubSpot Android SDK is not redistributed by this package; it is fetched
+from Maven Central by the consuming app under HubSpot's terms.

package/ReactNativeHubspotWrapper.podspec

@@ -0,0 +1,27 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "ReactNativeHubspotWrapper"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.description  = package["description"]
+  s.homepage     = "https://github.com/marcinolek/react-native-hubspot-wrapper"
+  s.license      = package["license"]
+  s.authors      = "Marcin Olek"
+  s.platforms    = { :ios => "15.0" }
+  s.source       = { :path => "." }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+  s.private_header_files = "ios/**/*.h"
+  s.resource_bundles = {
+    "HubspotMobileSDKResources" => ["ios/HubspotMobileSDK/Resources/**/*"]
+  }
+
+  if respond_to?(:install_modules_dependencies, true)
+    install_modules_dependencies(s)
+  else
+    s.dependency "React-Core"
+  end
+end

package/android/build.gradle

@@ -0,0 +1,49 @@
+buildscript {
+  ext.kotlin_version = "1.9.22"
+  repositories {
+    google()
+    mavenCentral()
+  }
+  dependencies {
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply plugin: "com.facebook.react"
+
+android {
+  compileSdk 34
+  namespace "com.marcinolek.reactnativehubspotwrapper"
+
+  defaultConfig {
+    minSdk 26
+    targetSdk 34
+  }
+
+  sourceSets {
+    main.java.srcDirs += "src/main/kotlin"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+  kotlinOptions {
+    jvmTarget = "17"
+  }
+}
+
+react {
+  jsRootDir = file("../")
+  libraryName = "HubspotWrapperSpec"
+  codegenJavaPackageName = "com.marcinolek.reactnativehubspotwrapper"
+}
+
+dependencies {
+  implementation "com.facebook.react:react-native:+"
+  implementation "com.hubspot.mobilechatsdk:mobile-chat-sdk-android:1.0.8"
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.1"
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.1"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest package="com.marcinolek.reactnativehubspotwrapper" />

package/android/src/main/java/com/reactnativehubspotwrapper/HubspotWrapperModule.kt

@@ -0,0 +1,83 @@
+package com.marcinolek.reactnativehubspotwrapper
+
+import android.content.Intent
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.hubspot.mobilesdk.HubspotManager
+import com.hubspot.mobilesdk.HubspotWebActivity
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+class HubspotWrapperModule(reactContext: ReactApplicationContext) :
+  NativeHubspotWrapperSpec(reactContext) {
+
+  private val appContext = reactContext.applicationContext
+  private lateinit var hubspotManager: HubspotManager
+
+  override fun getName(): String = NAME
+
+  override fun initialize(promise: Promise) {
+    try {
+      hubspotManager = HubspotManager.getInstance(appContext)
+      hubspotManager.enableLogs()
+      hubspotManager.configure()
+      promise.resolve(null)
+    } catch (error: Exception) {
+      promise.reject("INIT_ERROR", "Failed to initialize HubSpot SDK", error)
+    }
+  }
+
+  override fun openChat(chatflow: String, promise: Promise) {
+    try {
+      val intent = Intent(appContext, HubspotWebActivity::class.java)
+      intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+      intent.putExtra("chatflow", chatflow)
+      appContext.startActivity(intent)
+      promise.resolve(null)
+    } catch (error: Exception) {
+      promise.reject("OPEN_CHAT_ERROR", "Failed to open HubSpot chat", error)
+    }
+  }
+
+  override fun setIdentity(identityToken: String, email: String?, promise: Promise) {
+    try {
+      hubspotManager.setUserIdentity(identityToken, email ?: "")
+      promise.resolve(null)
+    } catch (error: Exception) {
+      promise.reject("IDENTITY_ERROR", "Failed to set HubSpot identity", error)
+    }
+  }
+
+  override fun setProperties(properties: ReadableArray, promise: Promise) {
+    try {
+      val mapped = mutableMapOf<String, String>()
+      for (i in 0 until properties.size()) {
+        val item = properties.getMap(i) ?: continue
+        val name = item.getString("name") ?: continue
+        val value = item.getString("value") ?: ""
+        mapped[name] = value
+      }
+      hubspotManager.setChatProperties(mapped)
+      promise.resolve(null)
+    } catch (error: Exception) {
+      promise.reject("SET_PROPERTIES_ERROR", "Failed to set HubSpot chat properties", error)
+    }
+  }
+
+  override fun clearUserData(promise: Promise) {
+    CoroutineScope(Dispatchers.Main).launch {
+      try {
+        hubspotManager.logout()
+        promise.resolve(null)
+      } catch (error: Exception) {
+        promise.reject("CLEAR_USER_DATA_ERROR", "Failed to clear HubSpot user data", error)
+      }
+    }
+  }
+
+  companion object {
+    const val NAME = "NativeHubspotWrapper"
+  }
+}

package/android/src/main/java/com/reactnativehubspotwrapper/HubspotWrapperPackage.kt

@@ -0,0 +1,32 @@
+package com.marcinolek.reactnativehubspotwrapper
+
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class HubspotWrapperPackage : TurboReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == HubspotWrapperModule.NAME) {
+      HubspotWrapperModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      mapOf(
+        HubspotWrapperModule.NAME to ReactModuleInfo(
+          HubspotWrapperModule.NAME,
+          HubspotWrapperModule.NAME,
+          false,
+          false,
+          false,
+          true
+        )
+      )
+    }
+  }
+}

package/ios/HubspotMobileSDK/API/APIModels.swift

@@ -0,0 +1,50 @@
+// APIModels.swift
+// Hubspot Mobile SDK
+//
+// Copyright © 2024 Hubspot, Inc.
+
+import Foundation
+
+/// This is the body of the api request for sending chat properties,  to help with JSON encoding.
+struct ChatPropertyMetadataRequest: Encodable {
+    /// The visitor id token , provided by the app itself. This is the token obtained from app backend from hubspot api
+    let visitorToken: String?
+
+    /// The email provided with the visitor token itself.
+    let email: String?
+
+    /// dictionary of arbitary key and values to send to the api - see ``ChatPropertyKey``
+    /// - seeAlso: ``ChatPropertyKey``
+    let metadata: [String: String]
+}
+
+/// Model used for serialisation when creating a visitor token
+struct CreateVisitorTokenRequest: Codable {
+    let email: String
+    let firstName: String
+    let lastName: String
+}
+
+/// Model for serialising post body of adding a device token
+struct StoreDeviceTokenRequest: Encodable {
+    let devicePushToken: String
+    let platform = "ios"
+    // Do we need user id here?
+
+    init(devicePushToken: Data) {
+        self.devicePushToken = devicePushToken.toHexString()
+    }
+}
+
+/// Model used for deserialising the create visitor token response
+struct CreateVisitorTokenResponse: Codable {
+    let token: String
+}
+
+extension Data {
+    /// Used to encode push tokens
+    /// - Returns: The data in hex format, lowercase
+    func toHexString() -> String {
+        return map { String(format: "%02hhx", $0) }.joined()
+    }
+}

package/ios/HubspotMobileSDK/API/HubspotAPI.swift

@@ -0,0 +1,168 @@
+// HubspotAPI.swift
+// Hubspot Mobile SDK
+//
+// Copyright © 2024 Hubspot, Inc.
+
+import Foundation
+import OSLog
+
+/// Not public class yet, as its not known if we need to expose API directly to app.
+final class HubspotAPI: Sendable {
+    let logger: Logger
+
+    init(logger: Logger) {
+        self.logger = logger
+    }
+
+    /// Errors relating to API requests and reponses that the SDK may make.
+    enum APIError: Error {
+        /// Unable to form a request - likely due to poor configuration or formatting
+        case requestError
+
+        /// Response couldn't be handled as expected, perhaps due to decoding error or similar. Original error included.
+        case responseError(Error)
+    }
+
+    private let jsonEncoder: JSONEncoder = .init()
+    private let jsonDecoder: JSONDecoder = .init()
+
+    private let urlSession = URLSession(configuration: .default)
+
+    func sendDeviceToken(hublet: Hublet, token: Data, portalId: String) async throws {
+        // POST
+        let apiUrl = hublet.apiURL.appendingPathComponent("livechat-public/v1/mobile-sdk/device-token")
+
+        guard var components = URLComponents(url: apiUrl, resolvingAgainstBaseURL: false) else {
+            throw APIError.requestError
+        }
+
+        components.queryItems = [URLQueryItem(name: "portalId", value: portalId)]
+
+        guard let url = components.url else {
+            throw APIError.requestError
+        }
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+
+        let postBodyModel = StoreDeviceTokenRequest(devicePushToken: token)
+        let requestData = try jsonEncoder.encode(postBodyModel)
+
+        request.addValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.httpBody = requestData
+
+        let (data, _) = try await urlSession.data(for: request)
+
+        #if DEBUG
+            // Right now , we aren't using the reponse, but just logging it temporiarly to see if we get a response - I expect this to change once the api gets integrated in server, then we can either use the response or ignore it.
+            let bodyString = String(data: data, encoding: .utf8)
+            logger.trace("Response from sending token: \(bodyString ?? "<EMPTY>")")
+        #endif
+    }
+
+    func deleteDeviceToken(hublet: Hublet, token: Data, portalId: String) async throws {
+        // DELETE
+        let apiUrl = hublet.apiURL.appendingPathComponent("livechat-public/v1/mobile-sdk/device-token/\(token.toHexString())")
+
+        guard var components = URLComponents(url: apiUrl, resolvingAgainstBaseURL: false) else {
+            throw APIError.requestError
+        }
+
+        components.queryItems = [URLQueryItem(name: "portalId", value: portalId)]
+
+        guard let url = components.url else {
+            throw APIError.requestError
+        }
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "DELETE"
+
+        let (data, _) = try await urlSession.data(for: request)
+
+        #if DEBUG
+            // Right now , we aren't using the reponse, but just logging it temporiarly to see if we get a response - I expect this to change once the api gets integrated in server, then we can either use the response or ignore it.
+            let bodyString = String(data: data, encoding: .utf8)
+            logger.trace("Response from deleting token: \(bodyString ?? "<EMPTY>")")
+        #endif
+    }
+
+    /// Post chat properties for a specific thread id to the api.
+    /// - Parameters:
+    ///   - hublet: destination hublet
+    ///   - properties: The collection of properties to post.
+    ///   - visitorIdToken: The token set by the app to identify user. Optional.
+    ///   - threadId: The thread id read from the chat view / javascript bridge that identifies the current open thread
+    ///   - portalId: Account portal id
+    func sendChatProperties(hublet: Hublet, properties: [String: String], visitorIdToken: String?, email: String?, threadId: String, portalId: String) async throws {
+        let urlProperties = ["portalId": portalId, "threadId": threadId]
+
+        let apiUrl = hublet.apiURL.appendingPathComponent("livechat-public/v1/mobile-sdk/metadata")
+        guard var urlBuilder = URLComponents(url: apiUrl, resolvingAgainstBaseURL: false) else {
+            throw APIError.requestError
+        }
+
+        urlBuilder.queryItems = urlProperties.map { key, value in URLQueryItem(name: key, value: value) }
+
+        guard let url = urlBuilder.url else {
+            throw APIError.requestError
+        }
+
+        let requestModel = ChatPropertyMetadataRequest(visitorToken: visitorIdToken, email: email, metadata: properties)
+        let requestData = try jsonEncoder.encode(requestModel)
+
+        var request = URLRequest(url: url)
+        request.addValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.httpMethod = "POST"
+
+        request.httpBody = requestData
+        let (_, response) = try await urlSession.data(for: request)
+
+        if let httpResponse = response as? HTTPURLResponse {
+            // We aren't expecting any content as a response, just that it succeeded - hopefully the try await above is sufficient.
+            // Logging the code in debug builds just to confirm for now
+            #if DEBUG
+                if case 200 ..< 300 = httpResponse.statusCode {
+                    logger.trace("Sending metadata was a 2XX response: \(httpResponse.statusCode)")
+                }
+            #endif
+        }
+    }
+
+    /// Convenience for creating a visitor identity token using the given details, for situations where server infrastructure isn't available.
+    ///
+    ///  - WARNING: Embedding access token for your product in app is not recommended - This was originally for demo purposes, and may be removed. Strongly consider creating a token as part of app server infrastructure instead.
+    ///
+    /// - Parameters:
+    ///   - hublet: destination hublet
+    ///   - accessToken: The access token for your application, as returned by the Hubspot dashboard
+    ///   - email: the email of the user
+    ///   - firstName: users first name
+    ///   - lastName: users last name
+    /// - Returns: The generated JWT token
+    func createVisitorToken(hublet: Hublet, accessToken: String, email: String, firstName: String, lastName: String) async throws -> String {
+        // Later, if we have lots of requests we can refactor this to have common base path
+        let url = hublet.apiURL.appendingPathComponent("conversations/v3/visitor-identification/tokens/create")
+
+        let requestModel = CreateVisitorTokenRequest(email: email, firstName: firstName, lastName: lastName)
+        let requestData = try jsonEncoder.encode(requestModel)
+
+        var request = URLRequest(url: url)
+        request.addValue("Bearer \(accessToken)", forHTTPHeaderField: "Authorization")
+        request.addValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.httpMethod = "POST"
+
+        request.httpBody = requestData
+
+        let (data, response) = try await urlSession.data(for: request)
+
+        do {
+            let responseModel = try jsonDecoder.decode(CreateVisitorTokenResponse.self, from: data)
+            return responseModel.token
+        } catch {
+            let bodyString = String(data: data, encoding: .utf8)
+            /// Catching just to log, and then re-throw it wrapped
+            logger.error("Failed to decode visitor token model: \(error) - response was \(response), body contents: \(bodyString ?? "not set")")
+            throw APIError.responseError(error)
+        }
+    }
+}

package/ios/HubspotMobileSDK/DeviceTokenSyncState.swift

@@ -0,0 +1,13 @@
+// DeviceTokenSyncState.swift
+// Hubspot Mobile SDK
+//
+// Copyright © 2024 Hubspot, Inc.
+
+import Foundation
+
+/// Enum to help track if we have posted our device token, and when
+enum DeviceTokenSyncState: Equatable {
+    case notSent
+    case sending(Date)
+    case sent(Date)
+}