react-native-spike-sdk 1.0.22 → 2.1.0

package/android/build.gradle

@@ -76,7 +76,7 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-android:0.71.3"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation 'com.spikeapi.sdk:spike-sdk:1.1.8'
+  implementation 'com.spikeapi.sdk:spike-sdk:2.1.0'
   implementation 'androidx.core:core-ktx:1.9.0'
   implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.5.1'
   implementation 'com.google.code.gson:gson:2.10.1'

package/android/src/main/java/com/spikesdk/SpikeMappers.kt

@@ -1,6 +1,7 @@
 package com.spikesdk
 
 import com.spikeapi.SpikeDataTypes
+import com.spikeapi.SpikeEnvironment
 import com.spikeapi.SpikeExceptions
 import com.spikeapi.healthconnect.HealthConnectAvailability
 import com.spikeapi.model.SpikeData
@@ -14,11 +15,10 @@ fun SpikeExceptions.mapException(): String {
         SpikeExceptions.SpikeConnectionIsClosedException -> "SpikeConnectionIsClosedException"
         SpikeExceptions.SpikeInvalidCredentialsException -> "SpikeInvalidCredentialsException"
         SpikeExceptions.SpikeInvalidDateRangeException -> "SpikeInvalidDateRangeException"
-        SpikeExceptions.SpikeInvalidPostbackUrlException -> "SpikeInvalidPostbackUrlException"
-        SpikeExceptions.SpikePackException -> "SpikePackException"
+        SpikeExceptions.SpikeInvalidCallbackUrlException -> "SpikeInvalidCallbackUrlException"
         SpikeExceptions.SpikePermissionsNotGrantedException -> "SpikePermissionsNotGrantedException"
         is SpikeExceptions.SpikeServerException -> "SpikeServerException"
-        SpikeExceptions.SpikeUnpackException -> "SpikeUnpackException"
+        else -> "SpikeException"
     }
 }
 
@@ -59,3 +59,9 @@ fun HealthConnectAvailability.toStringType(): String = when (this) {
     HealthConnectAvailability.INSTALLED -> "installed"
     HealthConnectAvailability.NOT_INSTALLED -> "notInstalled"
 }
+
+fun String.toSpikeEnvironment(): SpikeEnvironment = when (this) {
+    "PROD" -> SpikeEnvironment.PROD
+    "DEV" -> SpikeEnvironment.DEV
+    else -> SpikeEnvironment.PROD
+}

package/android/src/main/java/com/spikesdk/SpikeSdkModule.kt

@@ -8,13 +8,10 @@ import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
-import com.google.gson.FieldNamingPolicy
 import com.google.gson.GsonBuilder
-import com.google.gson.JsonDeserializer
 import com.spikeapi.SpikeConnection
 import com.spikeapi.SpikeExceptions
 import com.spikeapi.SpikeLogger
-import com.spikeapi.SpikeWebhookConnection
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
@@ -45,6 +42,8 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         appId: String,
         authToken: String,
         customerEndUserId: String,
+        callbackUrl: String,
+        env: String,
         useLogger: Boolean,
         promise: Promise
     ) {
@@ -60,6 +59,8 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
                     authToken = authToken,
                     customerEndUserId = customerEndUserId,
                     appId = appId,
+                    callbackUrl = callbackUrl,
+                    env = env.toSpikeEnvironment(),
                     logger = logger,
                 )
                 promise.resolve(uuid)
@@ -118,7 +119,7 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
     fun getCallbackUrl(uuid: String, promise: Promise) {
         try {
             val connection =
-                (connections[uuid] as? SpikeWebhookConnection) ?: return promise.reject(
+                connections[uuid] ?: return promise.reject(
                     SpikeExceptions.SpikeException(
                         "Connection not found"
                     ).mapException(), "Connection not found"
@@ -148,50 +149,6 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         }
     }
 
-    @ReactMethod
-    fun pack(uuid: String, promise: Promise) {
-        scope.launch {
-            try {
-                val connection = connections[uuid] ?: return@launch promise.reject(
-                    SpikeExceptions.SpikeException(
-                        "Connection not found"
-                    ).mapException(), "Connection not found"
-                )
-                val serializedConnection = connection.pack()
-                promise.resolve(serializedConnection)
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun unpackConnection(
-        uuid: String,
-        connection: String,
-        useLogger: Boolean,
-        promise: Promise
-    ) {
-        scope.launch {
-            try {
-                val logger = if (useLogger) {
-                    createLogger(uuid)
-                } else {
-                    null
-                }
-                connections[uuid] =
-                    SpikeConnection.unpackConnection(
-                        context = reactApplicationContext,
-                        connection = connection,
-                        logger = logger
-                    )
-                promise.resolve(uuid)
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
     @ReactMethod
     fun extractDataInRange(
         connectionUUID: String,
@@ -202,7 +159,12 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
     ) {
         scope.launch {
             try {
-                val result = connections[connectionUUID]?.extractData(
+                val connection = connections[connectionUUID] ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException(
+                        "Connection not found"
+                    ).mapException(), "Connection not found"
+                )
+                val result = connection.extractData(
                     dataType = dataType.toSpikeDataType(),
                     from = fromDateMillis.toLong().millisToOffsetDataTime(),
                     to = toDateMillis.toLong().millisToOffsetDataTime()
@@ -224,12 +186,16 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
     ) {
         scope.launch {
             try {
-                val result =
-                    (connections[connectionUUID] as? SpikeWebhookConnection)?.extractAndPostData(
-                        dataType = dataType.toSpikeDataType(),
-                        from = fromDateMillis.toLong().millisToOffsetDataTime(),
-                        to = toDateMillis.toLong().millisToOffsetDataTime()
-                    )
+                val connection = connections[connectionUUID] ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException(
+                        "Connection not found"
+                    ).mapException(), "Connection not found"
+                )
+                val result = connection.extractAndPostData(
+                    dataType = dataType.toSpikeDataType(),
+                    from = fromDateMillis.toLong().millisToOffsetDataTime(),
+                    to = toDateMillis.toLong().millisToOffsetDataTime()
+                )
                 promise.resolve(gson.toJson(result))
             } catch (e: SpikeExceptions) {
                 promise.reject(e.mapException(), e.message)
@@ -245,7 +211,12 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
     ) {
         scope.launch {
             try {
-                val result = connections[connectionUUID]?.extractData(
+                val connection = connections[connectionUUID] ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException(
+                        "Connection not found"
+                    ).mapException(), "Connection not found"
+                )
+                val result = connection.extractData(
                     dataType = dataType.toSpikeDataType()
                 )
                 promise.resolve(gson.toJson(result))
@@ -263,43 +234,15 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
     ) {
         scope.launch {
             try {
-                val result =
-                    (connections[connectionUUID] as? SpikeWebhookConnection)?.extractAndPostData(
-                        dataType = dataType.toSpikeDataType()
-                    )
-                promise.resolve(gson.toJson(result))
-            } catch (e: SpikeExceptions) {
-                promise.reject(e.mapException(), e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun createWebhookConnection(
-        uuid: String,
-        appId: String,
-        authToken: String,
-        customerEndUserId: String,
-        callbackUrl: String,
-        useLogger: Boolean,
-        promise: Promise
-    ) {
-        scope.launch {
-            try {
-                val logger = if (useLogger) {
-                    createLogger(uuid)
-                } else {
-                    null
-                }
-                connections[uuid] = SpikeWebhookConnection.createConnection(
-                    context = reactApplicationContext,
-                    authToken = authToken,
-                    customerEndUserId = customerEndUserId,
-                    appId = appId,
-                    logger = logger,
-                    callbackUrl = callbackUrl
+                val connection = connections[connectionUUID] ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException(
+                        "Connection not found"
+                    ).mapException(), "Connection not found"
                 )
-                promise.resolve(uuid)
+                val result = connection.extractAndPostData(
+                    dataType = dataType.toSpikeDataType()
+                )
+                promise.resolve(gson.toJson(result))
             } catch (e: SpikeExceptions) {
                 promise.reject(e.mapException(), e.message)
             }
@@ -325,9 +268,13 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
     fun checkPermissionsGranted(connectionUUID: String, promise: Promise) {
         scope.launch {
             try {
+                val connection = connections[connectionUUID] ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException(
+                        "Connection not found"
+                    ).mapException(), "Connection not found"
+                )
                 val permissionsGranted: Boolean =
-                    connections[connectionUUID]?.hasHealthPermissionsGranted()
-                        ?: return@launch promise.resolve(true)
+                    connection.hasHealthPermissionsGranted()
                 promise.resolve(permissionsGranted)
             } catch (e: SpikeExceptions) {
                 promise.reject(e.mapException(), e.message)
@@ -339,8 +286,12 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
     fun getHealthConnectAvailability(connectionUUID: String, promise: Promise) {
         scope.launch {
             try {
-                val availability = connections[connectionUUID]?.getHealthConnectAvailability()
-                    ?: return@launch promise.resolve(true)
+                val connection = connections[connectionUUID] ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException(
+                        "Connection not found"
+                    ).mapException(), "Connection not found"
+                )
+                val availability = connection.getHealthConnectAvailability()
                 promise.resolve(availability.toStringType())
             } catch (e: SpikeExceptions) {
                 promise.reject(e.mapException(), e.message)
@@ -352,7 +303,12 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
     fun revokeAllPermissions(connectionUUID: String, promise: Promise) {
         scope.launch {
             try {
-                connections[connectionUUID]?.revokeAllPermissions()
+                val connection = connections[connectionUUID] ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException(
+                        "Connection not found"
+                    ).mapException(), "Connection not found"
+                )
+                connection.revokeAllPermissions()
                 promise.resolve(true)
             } catch (e: SpikeExceptions) {
                 promise.reject(e.mapException(), e.message)
@@ -371,7 +327,7 @@ class SpikeSdkModule(reactContext: ReactApplicationContext) :
         val permissions = connection.getRequiredHealthPermissionsMetadata()
 
         val intent = connection.requestReadAuthorization().createIntent(
-            context = reactApplicationContext, permissions
+            reactApplicationContext, permissions
         )
 
         reactApplicationContext.currentActivity?.startActivityForResult(

package/ios/SpikeConnectionListener.swift

@@ -1,7 +1,7 @@
 import Foundation
 import SpikeSDK
 
-class SpikeConnectionListener: SpikeWebhookConnectionListener {
+class SpikeConnectionListener: SpikeBackgroundDeliveriesLogger {
     
     private let connectionUUID: String
     private var onLog: (String, String) -> Void

package/ios/SpikeDataTypeMapper.swift

@@ -141,7 +141,7 @@ class SpikeDataTypeMapper {
         }
     }
 
-    static func extractAndPostData(_ dataType: String, connection: SpikeWebhookConnection) async throws -> String? {
+    static func extractAndPostData(_ dataType: String, connection: SpikeConnection) async throws -> String? {
         switch dataType {
         case "activities_summary":
             let value = try await connection.extractAndPostData(SpikeDataTypes.activitiesSummary)
@@ -181,7 +181,7 @@ class SpikeDataTypeMapper {
         }
     }
 
-    static func extractAndPostDataInRange(_ dataType: String, connection: SpikeWebhookConnection, from: Date, to: Date) async throws -> String? {
+    static func extractAndPostDataInRange(_ dataType: String, connection: SpikeConnection, from: Date, to: Date) async throws -> String? {
         switch dataType {
         case "activities_summary":
             let value = try await connection.extractAndPostData(SpikeDataTypes.activitiesSummary, from: from, to: to)

package/ios/SpikeExceptionMapper.swift

@@ -23,6 +23,8 @@ class SpikeExceptionMapper {
             return "SpikeServerException"
         case is SpikeUnpackException:
             return "SpikeUnpackException"
+        case is SpikeCallbackURLNotProvidedException:
+            return "SpikeCallbackURLNotProvidedException"
         case is SpikeWrapperException:
             return "SpikeException"
         default:

package/ios/SpikeSdk.m

@@ -5,29 +5,12 @@
 
 // MARK: Spike SDK level
 
-RCT_EXTERN_METHOD(setEnvironment: (NSString)env
-                  withResolver: (RCTPromiseResolveBlock)resolve
-                  withRejecter: (RCTPromiseRejectBlock)reject)
-
 RCT_EXTERN_METHOD(createConnection: (NSString)uuid
-                  withAppId: (NSString)appId
-                  withAuthToken: (NSString)authToken
-                  withCustomerEndUserId: (NSString)customerEndUserId
-                  withUseLogger: (BOOL)useLogger
-                  withResolver: (RCTPromiseResolveBlock)resolve
-                  withRejecter: (RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(createWebhookConnection: (NSString)uuid
                   withAppId: (NSString)appId
                   withAuthToken: (NSString)authToken
                   withCustomerEndUserId: (NSString)customerEndUserId
                   withCallbackUrl: (NSString)callbackUrl
-                  withUseLogger: (BOOL)useLogger
-                  withResolver: (RCTPromiseResolveBlock)resolve
-                  withRejecter: (RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(unpackConnection: (NSString)uuid
-                  withConnection: (NSString)connection
+                  withEnv: (NSString)env
                   withUseLogger: (BOOL)useLogger
                   withResolver: (RCTPromiseResolveBlock)resolve
                   withRejecter: (RCTPromiseRejectBlock)reject)
@@ -39,8 +22,6 @@ RCT_EXTERN_METHOD(ensurePermissionsAreGranted: (NSArray<NSString>)permissions
                   withResolver: (RCTPromiseResolveBlock)resolve
                   withRejecter: (RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(initialize)
-
 // MARK: SpikeConnection level
 
 RCT_EXTERN_METHOD(getAppId: (NSString)connectionUUID
@@ -59,10 +40,6 @@ RCT_EXTERN_METHOD(close: (NSString)connectionUUID
                   withResolver: (RCTPromiseResolveBlock)resolve
                   withRejecter: (RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(pack: (NSString)connectionUUID
-                  withResolver: (RCTPromiseResolveBlock)resolve
-                  withRejecter: (RCTPromiseRejectBlock)reject)
-
 RCT_EXTERN_METHOD(extractData: (NSString)connectionUUID
                   withDataType: (NSString)dataType
                   withResolver: (RCTPromiseResolveBlock)resolve

package/ios/SpikeSdk.swift

@@ -16,44 +16,33 @@ class SpikeSdk: RCTEventEmitter {
     }
     
     // MARK: Spike SDK level
-
-    @objc(setEnvironment:
-            withResolver:
-            withRejecter:)
-    func setEnvironment(env: String,
-                        resolve: @escaping RCTPromiseResolveBlock,
-                        reject: @escaping RCTPromiseRejectBlock) {
-        switch (env) {
-            case "DEV":
-                Spike.setEnvironment(env: .DEV)
-            case "PROD":
-                Spike.setEnvironment(env: .PROD)
-            default:
-                break
-        }
-        resolve(Void())
-    }
-    
+        
     @objc(createConnection:
             withAppId:
             withAuthToken:
             withCustomerEndUserId:
+            withCallbackUrl:
+            withEnv:
             withUseLogger:
             withResolver:withRejecter:)
     func createConnection(uuid: String,
                           appId: String,
                           authToken: String,
                           customerEndUserId: String,
+                          callbackUrl: String?,
+                          env: String?,
                           useLogger: Bool,
                           resolve: @escaping RCTPromiseResolveBlock,
                           reject: @escaping RCTPromiseRejectBlock) {
         Task {
             do {
-                let logger = useLogger ? createLogger(connectionUUID: uuid) : nil
+                let logger = useLogger ? self.createLogger(connectionUUID: uuid) : nil
                 let spikeConnection = try await Spike.createConnection(
                     appId: appId,
                     authToken: authToken,
                     customerEndUserId: customerEndUserId,
+                    callbackUrl: callbackUrl != nil ? URL(string: callbackUrl!) : nil,
+                    env: env == "DEV" ? .DEV : .PROD,
                     logger: logger)
                 connections[uuid] = spikeConnection
                 resolve(Void())
@@ -63,66 +52,6 @@ class SpikeSdk: RCTEventEmitter {
         }
     }
     
-    @objc(createWebhookConnection:
-            withAppId:
-            withAuthToken:
-            withCustomerEndUserId:
-            withCallbackUrl:
-            withUseLogger:
-            withResolver:
-            withRejecter:)
-    func createWebhookConnection(uuid: String,
-                                 appId: String,
-                                 authToken: String,
-                                 customerEndUserId: String,
-                                 callbackUrl: String,
-                                 useLogger: Bool,
-                                 resolve: @escaping RCTPromiseResolveBlock,
-                                 reject: @escaping RCTPromiseRejectBlock) {
-        guard let url = URL(string: callbackUrl) else {
-            spikeReject(with: SpikeWrapperException(), reject: reject)
-            return
-        }
-        Task {
-            do {
-                let logger = useLogger ? createLogger(connectionUUID: uuid) : nil
-                let spikeConnection = try await Spike.createConnection(
-                    appId: appId,
-                    authToken: authToken,
-                    customerEndUserId: customerEndUserId,
-                    callbackUrl: url,
-                    logger: logger)
-                connections[uuid] = spikeConnection
-                resolve(uuid)
-            } catch let error {
-                spikeReject(with: error, reject: reject)
-            }
-        }
-    }
-    
-    @objc(unpackConnection:
-            withConnection:
-            withUseLogger:
-            withResolver:
-            withRejecter:)
-    func unpackConnection(uuid: String,
-                          connection: String,
-                          useLogger: Bool,
-                          resolve: @escaping RCTPromiseResolveBlock,
-                          reject: @escaping RCTPromiseRejectBlock) {
-        Task {
-            do {
-                let logger = useLogger ? createLogger(connectionUUID: uuid) : nil
-                let spikeConnection = try await Spike.unpackConnection(connection: connection,
-                                                                       logger: logger)
-                connections[uuid] = spikeConnection
-                resolve(uuid)
-            } catch let error {
-                spikeReject(with: error, reject: reject)
-            }
-        }
-    }
-    
     @objc(getBackgroundConnections:
             withRejecter:)
     func getBackgroundConnections(resolve: @escaping RCTPromiseResolveBlock,
@@ -160,11 +89,6 @@ class SpikeSdk: RCTEventEmitter {
         }
     }
     
-    @objc(initialize)
-    func initialize() {
-//        Spike.configure()
-    }
-    
     // MARK: SpikeConnection level
     
     @objc(getAppId:
@@ -243,25 +167,6 @@ class SpikeSdk: RCTEventEmitter {
         }
     }
     
-    @objc(pack:
-            withResolver:
-            withRejecter:)
-    func pack(connectionUUID: String,
-              resolve: @escaping RCTPromiseResolveBlock,
-              reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = connections[connectionUUID] else {
-            spikeReject(with: SpikeWrapperException(), reject: reject)
-            return
-        }
-        
-        do {
-            let value = try connection.pack()
-            resolve(value)
-        } catch let error {
-            spikeReject(with: error, reject: reject)
-        }
-    }
-    
     @objc(extractData:
             withDataType:
             withResolver:
@@ -334,7 +239,7 @@ class SpikeSdk: RCTEventEmitter {
     func getCallbackUrl(connectionUUID: String,
                         resolve: @escaping RCTPromiseResolveBlock,
                         reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = connections[connectionUUID] as? SpikeWebhookConnection else {
+        guard let connection = connections[connectionUUID] else {
             spikeReject(with: SpikeWrapperException(), reject: reject)
             return
         }
@@ -355,7 +260,7 @@ class SpikeSdk: RCTEventEmitter {
                             dataType: String,
                             resolve: @escaping RCTPromiseResolveBlock,
                             reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = connections[connectionUUID] as? SpikeWebhookConnection else {
+        guard let connection = connections[connectionUUID] else {
             spikeReject(with: SpikeWrapperException(), reject: reject)
             return
         }
@@ -387,7 +292,7 @@ class SpikeSdk: RCTEventEmitter {
                                    toDateMillis: Double,
                                    resolve: @escaping RCTPromiseResolveBlock,
                                    reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = connections[connectionUUID] as? SpikeWebhookConnection else {
+        guard let connection = connections[connectionUUID] else {
             spikeReject(with: SpikeWrapperException(), reject: reject)
             return
         }
@@ -419,7 +324,7 @@ class SpikeSdk: RCTEventEmitter {
                                   dataTypes: [String],
                                   resolve: @escaping RCTPromiseResolveBlock,
                                   reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = connections[connectionUUID] as? SpikeWebhookConnection else {
+        guard let connection = connections[connectionUUID] else {
             spikeReject(with: SpikeWrapperException(), reject: reject)
             return
         }
@@ -441,7 +346,7 @@ class SpikeSdk: RCTEventEmitter {
     func getBackgroundDeliveryDataTypes(connectionUUID: String,
                                         resolve: @escaping RCTPromiseResolveBlock,
                                         reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = connections[connectionUUID] as? SpikeWebhookConnection else {
+        guard let connection = connections[connectionUUID] else {
             spikeReject(with: SpikeWrapperException(), reject: reject)
             return
         }
@@ -463,7 +368,7 @@ class SpikeSdk: RCTEventEmitter {
     func setListener(connectionUUID: String,
                      resolve: @escaping RCTPromiseResolveBlock,
                      reject: @escaping RCTPromiseRejectBlock) {
-        guard let connection = connections[connectionUUID] as? SpikeWebhookConnection else {
+        guard let connection = connections[connectionUUID] else {
             spikeReject(with: SpikeWrapperException(), reject: reject)
             return
         }
@@ -507,7 +412,7 @@ class SpikeSdk: RCTEventEmitter {
         }
     }
 
-    private func createListener(connectionUUID: String) -> SpikeWebhookConnectionListener {
+    private func createListener(connectionUUID: String) -> SpikeBackgroundDeliveriesLogger {
         return SpikeConnectionListener(connectionUUID: connectionUUID) { [weak self] connectionUUID, log in
             let body = [
                 "connectionUUID": connectionUUID,

package/lib/commonjs/Spike.js

@@ -3,53 +3,23 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.unpackConnection = exports.setEnvironment = exports.initialize = exports.getBackgroundConnections = exports.ensurePermissionsAreGranted = exports.createWebhookConnection = exports.createConnection = void 0;
+exports.getBackgroundConnections = exports.ensurePermissionsAreGranted = exports.createConnection = void 0;
 var _reactNative = require("react-native");
 var _SpikeConnection = require("./SpikeConnection");
 var _SpikeException = require("./SpikeException");
 var _SpikeSdk = require("./SpikeSdk");
-var _SpikeWebhookConnection = require("./SpikeWebhookConnection");
-const setEnvironment = async env => {
-  if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
-  await _SpikeSdk.SpikeSdk.setEnvironment(env);
-};
-exports.setEnvironment = setEnvironment;
-const createConnection = async function (appId, authToken, customerEndUserId) {
-  let logger = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+const createConnection = async (config, logger) => {
   if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
   const connectionUUID = generateUUID();
   const spikeConnection = new _SpikeConnection.SpikeConnection(connectionUUID, logger);
-  await _SpikeSdk.SpikeSdk.createConnection(connectionUUID, appId, authToken, customerEndUserId, !!logger);
+  await _SpikeSdk.SpikeSdk.createConnection(connectionUUID, config.appId, config.authToken, config.customerEndUserId, config.callbackUrl ?? null, config.env ?? 'PROD', !!logger);
   return spikeConnection;
 };
 exports.createConnection = createConnection;
-const createWebhookConnection = async function (appId, authToken, customerEndUserId, callbackUrl) {
-  let logger = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
-  if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
-  const connectionUUID = generateUUID();
-  const spikeConnection = new _SpikeWebhookConnection.SpikeWebhookConnection(connectionUUID, logger);
-  await _SpikeSdk.SpikeSdk.createWebhookConnection(connectionUUID, appId, authToken, customerEndUserId, callbackUrl, !!logger);
-  return spikeConnection;
-};
-exports.createWebhookConnection = createWebhookConnection;
-const unpackConnection = async function (connection) {
-  let logger = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-  if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
-  const connectionUUID = generateUUID();
-  const webhookConnection = new _SpikeWebhookConnection.SpikeWebhookConnection(connectionUUID, logger);
-  await _SpikeSdk.SpikeSdk.unpackConnection(connectionUUID, connection, !!logger);
-  try {
-    await webhookConnection.getCallbackUrl();
-    return webhookConnection;
-  } catch (error) {
-    return webhookConnection;
-  }
-};
-exports.unpackConnection = unpackConnection;
 const getBackgroundConnections = async () => {
   if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
   const connectionUUIDs = await _SpikeSdk.SpikeSdk.getBackgroundConnections();
-  const connections = connectionUUIDs.map(uuid => new _SpikeWebhookConnection.SpikeWebhookConnection(uuid));
+  const connections = connectionUUIDs.map(uuid => new _SpikeConnection.SpikeConnection(uuid));
   return connections;
 };
 exports.getBackgroundConnections = getBackgroundConnections;
@@ -59,11 +29,6 @@ const ensurePermissionsAreGranted = async permissions => {
   await _SpikeSdk.SpikeSdk.ensurePermissionsAreGranted(permissions.map(permissionType => permissionType.rawValue));
 };
 exports.ensurePermissionsAreGranted = ensurePermissionsAreGranted;
-const initialize = () => {
-  if (!_SpikeSdk.SpikeSdk) throw new _SpikeException.SpikeException();
-  _SpikeSdk.SpikeSdk.initialize();
-};
-exports.initialize = initialize;
 function generateUUID() {
   const S4 = function () {
     let str = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVXZ';