react-native-spike-sdk 0.2.9 → 1.0.0

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

@@ -1,18 +1,423 @@
 package com.spikesdk
 
+import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+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
+import kotlinx.coroutines.launch
+import java.time.OffsetDateTime
 
 class SpikeSdkModule(reactContext: ReactApplicationContext) :
-  ReactContextBaseJavaModule(reactContext) {
+    ReactContextBaseJavaModule(reactContext) {
+
+    private val connections = mutableMapOf<String, SpikeConnection>()
+
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+
+    private val gson = GsonBuilder().setPrettyPrinting().registerTypeAdapter(
+        OffsetDateTime::class.java,
+        JsonDeserializer { json, _, _ ->
+            OffsetDateTime.parse(json.asJsonPrimitive.asString)
+        }
+    ).create()
+
+    override fun getName(): String {
+        return NAME
+    }
+
+    @ReactMethod
+    fun createConnection(
+        uuid: String,
+        appId: String,
+        authToken: String,
+        customerEndUserId: String,
+        useLogger: Boolean,
+        promise: Promise
+    ) {
+        scope.launch {
+            try {
+                val logger = if (useLogger) {
+                    createLogger(uuid)
+                } else {
+                    null
+                }
+                connections[uuid] = SpikeConnection.createConnection(
+                    context = reactApplicationContext,
+                    authToken = authToken,
+                    customerEndUserId = customerEndUserId,
+                    appId = appId,
+                    logger = logger,
+                )
+                promise.resolve(uuid)
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun getAppId(uuid: String, promise: Promise) {
+        try {
+            val connection = connections[uuid] ?: return promise.reject(
+                SpikeExceptions.SpikeException(
+                    "Connection not found"
+                ).mapException(), "Connection not found"
+            )
+            val appId = connection.getAppId()
+            promise.resolve(appId)
+        } catch (e: SpikeExceptions) {
+            promise.reject(e.mapException(), e.message)
+        }
+    }
+
+    @ReactMethod
+    fun getSpikeEndUserId(uuid: String, promise: Promise) {
+        try {
+            val connection = connections[uuid] ?: return promise.reject(
+                SpikeExceptions.SpikeException(
+                    "Connection not found"
+                ).mapException(), "Connection not found"
+            )
+            val spikeEndUserId = connection.getSpikeUserId()
+            promise.resolve(spikeEndUserId)
+        } catch (e: SpikeExceptions) {
+            promise.reject(e.mapException(), e.message)
+        }
+    }
+
+    @ReactMethod
+    fun getCustomerEndUserId(uuid: String, promise: Promise) {
+        try {
+            val connection = connections[uuid] ?: return promise.reject(
+                SpikeExceptions.SpikeException(
+                    "Connection not found"
+                ).mapException(), "Connection not found"
+            )
+            val customerEndUserId = connection.getCustomerUserId()
+            promise.resolve(customerEndUserId)
+        } catch (e: SpikeExceptions) {
+            promise.reject(e.mapException(), e.message)
+        }
+    }
+
+    @ReactMethod
+    fun getCallbackUrl(uuid: String, promise: Promise) {
+        try {
+            val connection = (connections[uuid] as? SpikeWebhookConnection) ?: return promise.reject(
+                SpikeExceptions.SpikeException(
+                    "Connection not found"
+                ).mapException(), "Connection not found"
+            )
+            val callbackUrl = connection.getPostbackUrl()
+            promise.resolve(callbackUrl)
+        } catch (e: SpikeExceptions) {
+            promise.reject(e.mapException(), e.message)
+        }
+    }
+
+
+
+    @ReactMethod
+    fun close(uuid: String, promise: Promise) {
+        scope.launch {
+            try {
+                val connection = connections[uuid] ?: return@launch promise.reject(
+                    SpikeExceptions.SpikeException(
+                        "Connection not found"
+                    ).mapException(), "Connection not found"
+                )
+                connection.close()
+                promise.resolve(true)
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
+        }
+    }
+
+    @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,
+        dataType: String,
+        fromDateMillis: Double,
+        toDateMillis: Double,
+        promise: Promise
+    ) {
+        scope.launch {
+            try {
+                val result = connections[connectionUUID]?.extractData(
+                    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)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun extractAndPostDataInRange(
+        connectionUUID: String,
+        dataType: String,
+        fromDateMillis: Double,
+        toDateMillis: Double,
+        promise: Promise
+    ) {
+        scope.launch {
+            try {
+                val result =
+                    (connections[connectionUUID] as? SpikeWebhookConnection)?.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)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun extractData(
+        connectionUUID: String,
+        dataType: String,
+        promise: Promise
+    ) {
+        scope.launch {
+            try {
+                val result = connections[connectionUUID]?.extractData(
+                    dataType = dataType.toSpikeDataType()
+                )
+                promise.resolve(gson.toJson(result))
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun extractAndPostData(
+        connectionUUID: String,
+        dataType: String,
+        promise: Promise
+    ) {
+        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
+                )
+                promise.resolve(uuid)
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun manageHealthConnect(connectionUUID: String, promise: Promise) {
+        try {
+            val connection = connections[connectionUUID] ?: return promise.reject(
+                SpikeExceptions.SpikeException(
+                    "Connection not found"
+                ).mapException(), "Connection not found"
+            )
+            connection.manageHealthConnect()
+            promise.resolve(true)
+        } catch (e: SpikeExceptions) {
+            promise.reject(e.mapException(), e.message)
+        }
+    }
+
+    @ReactMethod
+    fun checkPermissionsGranted(connectionUUID: String, promise: Promise) {
+        scope.launch {
+            try {
+                val permissionsGranted: Boolean =
+                    connections[connectionUUID]?.hasHealthPermissionsGranted()
+                        ?: return@launch promise.resolve(true)
+                promise.resolve(permissionsGranted)
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun getHealthConnectAvailability(connectionUUID: String, promise: Promise) {
+        scope.launch {
+            try {
+                val availability = connections[connectionUUID]?.getHealthConnectAvailability()
+                    ?: return@launch promise.resolve(true)
+                promise.resolve(availability.toStringType())
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun revokeAllPermissions(connectionUUID: String, promise: Promise) {
+        scope.launch {
+            try {
+                connections[connectionUUID]?.revokeAllPermissions()
+                promise.resolve(true)
+            } catch (e: SpikeExceptions) {
+                promise.reject(e.mapException(), e.message)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun requestHealthPermissions(connectionUUID: String, promise: Promise) {
+        val connection = connections[connectionUUID] ?: return promise.reject(
+            SpikeExceptions.SpikeException(
+                "Connection not found"
+            ).mapException(), "Connection not found"
+        )
+
+        val permissions = connection.getRequiredHealthPermissionsMetadata()
+
+        val intent = connection.requestReadAuthorization().createIntent(
+            context = reactApplicationContext, permissions
+        )
+
+        reactApplicationContext.currentActivity?.startActivityForResult(
+            intent,
+            REQUEST_CODE
+        )
+        promise.resolve(true)
+    }
+
+    private fun createLogger(connectionUUID: String): SpikeLogger {
+        return SpikeConnectionLogger(connectionUUID) { _, logLevel, message ->
+            val body = WritableNativeMap().apply {
+                putString("connectionUUID", connectionUUID)
+                putString("message", message)
+            }
+
+            when (logLevel) {
+                SpikeLogLevel.DEBUG -> sendEvent(
+                    reactContext = reactApplicationContext,
+                    eventName = logLevel.jsEventName,
+                    params = body
+                )
+
+                SpikeLogLevel.ERROR -> sendEvent(
+                    reactContext = reactApplicationContext,
+                    eventName = logLevel.jsEventName,
+                    params = body
+                )
+
+                SpikeLogLevel.INFO -> sendEvent(
+                    reactContext = reactApplicationContext,
+                    eventName = logLevel.jsEventName,
+                    params = body
+                )
+            }
+        }
+    }
+
+    private fun sendEvent(reactContext: ReactContext, eventName: String, params: WritableMap?) {
+        reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(eventName, params)
+    }
 
-  override fun getName(): String {
-    return NAME
-  }
+    companion object {
+        const val NAME = "SpikeSdk"
+        const val REQUEST_CODE = 4200
+    }
 
-  companion object {
-    const val NAME = "SpikeSdk"
-  }
 }

package/ios/SpikeConnectionListener.swift

@@ -0,0 +1,17 @@
+import Foundation
+import SpikeSDK
+
+class SpikeConnectionListener: SpikeWebhookConnectionListener {
+    
+    private let connectionUUID: String
+    private var onFailure: (String, SpikeWebhookJob, SpikeException) -> Void
+    
+    init(connectionUUID: String, onFailure: @escaping (String, SpikeWebhookJob, SpikeException) -> Void) {
+        self.connectionUUID = connectionUUID
+        self.onFailure = onFailure
+    }
+    
+    func onSubmissionFailure(webhookJob: SpikeWebhookJob, exception: SpikeException) {
+        onFailure(connectionUUID, webhookJob, exception)
+    }
+}

package/ios/SpikeConnectionLogger.swift

@@ -0,0 +1,43 @@
+import Foundation
+import SpikeSDK
+
+enum SpikeLogLevel {
+    case debug
+    case info
+    case error
+}
+
+class SpikeConnectionLogger: SpikeLogger {
+    
+    private let connectionUUID: String
+    private var onLog: (String, SpikeLogLevel, String) -> Void
+    
+    init(connectionUUID: String, onLog: @escaping (String, SpikeLogLevel, String) -> Void) {
+        self.connectionUUID = connectionUUID
+        self.onLog = onLog
+    }
+    
+    func isDebugEnabled() -> Bool {
+        return true
+    }
+    
+    func isInfoEnabled() -> Bool {
+        return true
+    }
+    
+    func isErrorEnabled() -> Bool {
+        return true
+    }
+    
+    func debug(connection: SpikeConnection, message: String) {
+        onLog(connectionUUID, .debug, message)
+    }
+    
+    func info(connection: SpikeConnection, message: String) {
+        onLog(connectionUUID, .debug, message)
+    }
+    
+    func error(connection: SpikeConnection, message: String) {
+        onLog(connectionUUID, .debug, message)
+    }
+}

package/ios/SpikeDataTypeMapper.swift

@@ -0,0 +1,207 @@
+import Foundation
+import SpikeSDK
+
+class SpikeDataTypeMapper {
+    
+    static func mapDataType(_ dataType: String) -> any SpikeDataType {
+        switch dataType {
+        case "activities_summary":
+            return SpikeDataTypes.activitiesSummary
+        case "activities_stream":
+            return SpikeDataTypes.activitiesStream
+        case "breathing":
+            return SpikeDataTypes.breathing
+        case "calories":
+            return SpikeDataTypes.calories
+        case "distance":
+            return SpikeDataTypes.distance
+        case "glucose":
+            return SpikeDataTypes.glucose
+        case "heart":
+            return SpikeDataTypes.heart
+        case "oxygen_saturation":
+            return SpikeDataTypes.oxygenSaturation
+        case "sleep":
+            return SpikeDataTypes.sleep
+        case "steps":
+            return SpikeDataTypes.steps
+        default:
+            return SpikeDataTypes.activitiesSummary
+        }
+    }
+
+    static func mapDataTypeToString(_ dataType: any SpikeDataType) -> String {
+        switch dataType {
+        case is SpikeActivitiesSummaryDataType:
+            return "activities_summary"
+        case is SpikeActivitiesStreamDataType:
+            return "activities_stream"
+        case is SpikeBreathingDataType:
+            return "breathing"
+        case is SpikeCaloriesDataType:
+            return "calories"
+        case is SpikeDistanceDataType:
+            return "distance"
+        case is SpikeGlucoseDataType:
+            return "glucose"
+        case is SpikeHeartDataType:
+            return "heart"
+        case is SpikeOxygenSaturationDataType:
+            return "oxygen_saturation"
+        case is SpikeSleepDataType:
+            return "sleep"
+        case is SpikeStepsDataType:
+            return "steps"
+        default:
+            return "activities_summary"
+        }
+    }
+
+    static func extractData(_ dataType: String, connection: SpikeConnection) async throws -> String? {
+        switch dataType {
+        case "activities_summary":
+            let value = try await connection.extractData(SpikeDataTypes.activitiesSummary)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "activities_stream":
+            let value = try await connection.extractData(SpikeDataTypes.activitiesStream)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "breathing":
+            let value = try await connection.extractData(SpikeDataTypes.breathing)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "calories":
+            let value = try await connection.extractData(SpikeDataTypes.calories)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "distance":
+            let value = try await connection.extractData(SpikeDataTypes.distance)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "glucose":
+            let value = try await connection.extractData(SpikeDataTypes.glucose)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "heart":
+            let value = try await connection.extractData(SpikeDataTypes.heart)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "oxygen_saturation":
+            let value = try await connection.extractData(SpikeDataTypes.oxygenSaturation)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "sleep":
+            let value = try await connection.extractData(SpikeDataTypes.sleep)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "steps":
+            let value = try await connection.extractData(SpikeDataTypes.steps)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        default:
+            return nil
+        }
+    }
+
+    static func extractDataInRange(_ dataType: String, connection: SpikeConnection, from: Date, to: Date) async throws -> String? {
+        switch dataType {
+        case "activities_summary":
+            let value = try await connection.extractData(SpikeDataTypes.activitiesSummary, from: from, to: to)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "activities_stream":
+            let value = try await connection.extractData(SpikeDataTypes.activitiesStream, from: from, to: to)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "breathing":
+            let value = try await connection.extractData(SpikeDataTypes.breathing, from: from, to: to)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "calories":
+            let value = try await connection.extractData(SpikeDataTypes.calories, from: from, to: to)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "distance":
+            let value = try await connection.extractData(SpikeDataTypes.distance, from: from, to: to)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "glucose":
+            let value = try await connection.extractData(SpikeDataTypes.glucose, from: from, to: to)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "heart":
+            let value = try await connection.extractData(SpikeDataTypes.heart, from: from, to: to)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "oxygen_saturation":
+            let value = try await connection.extractData(SpikeDataTypes.oxygenSaturation, from: from, to: to)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "sleep":
+            let value = try await connection.extractData(SpikeDataTypes.sleep, from: from, to: to)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "steps":
+            let value = try await connection.extractData(SpikeDataTypes.steps, from: from, to: to)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        default:
+            return nil
+        }
+    }
+
+    static func extractAndPostData(_ dataType: String, connection: SpikeWebhookConnection) async throws -> String? {
+        switch dataType {
+        case "activities_summary":
+            let value = try await connection.extractAndPostData(SpikeDataTypes.activitiesSummary)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "activities_stream":
+            let value = try await connection.extractAndPostData(SpikeDataTypes.activitiesStream)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "breathing":
+            let value = try await connection.extractAndPostData(SpikeDataTypes.breathing)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "calories":
+            let value = try await connection.extractAndPostData(SpikeDataTypes.calories)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "distance":
+            let value = try await connection.extractAndPostData(SpikeDataTypes.distance)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "glucose":
+            let value = try await connection.extractAndPostData(SpikeDataTypes.glucose)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "heart":
+            let value = try await connection.extractAndPostData(SpikeDataTypes.heart)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "oxygen_saturation":
+            let value = try await connection.extractAndPostData(SpikeDataTypes.oxygenSaturation)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "sleep":
+            let value = try await connection.extractAndPostData(SpikeDataTypes.sleep)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "steps":
+            let value = try await connection.extractAndPostData(SpikeDataTypes.steps)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        default:
+            return nil
+        }
+    }
+
+    static func extractAndPostDataInRange(_ dataType: String, connection: SpikeWebhookConnection, from: Date, to: Date) async throws -> String? {
+        switch dataType {
+        case "activities_summary":
+            let value = try await connection.extractAndPostData(SpikeDataTypes.activitiesSummary, from: from, to: to)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "activities_stream":
+            let value = try await connection.extractAndPostData(SpikeDataTypes.activitiesStream, from: from, to: to)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "breathing":
+            let value = try await connection.extractAndPostData(SpikeDataTypes.breathing, from: from, to: to)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "calories":
+            let value = try await connection.extractAndPostData(SpikeDataTypes.calories, from: from, to: to)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "distance":
+            let value = try await connection.extractAndPostData(SpikeDataTypes.distance, from: from, to: to)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "glucose":
+            let value = try await connection.extractAndPostData(SpikeDataTypes.glucose, from: from, to: to)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "heart":
+            let value = try await connection.extractAndPostData(SpikeDataTypes.heart, from: from, to: to)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "oxygen_saturation":
+            let value = try await connection.extractAndPostData(SpikeDataTypes.oxygenSaturation, from: from, to: to)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "sleep":
+            let value = try await connection.extractAndPostData(SpikeDataTypes.sleep, from: from, to: to)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        case "steps":
+            let value = try await connection.extractAndPostData(SpikeDataTypes.steps, from: from, to: to)
+            return try? String(data: JSONEncoder().encode(value), encoding: .utf8)
+        default:
+            return nil
+        }
+    }
+}