3.3.0-alpha02 (#192)

Author: Nek-12

.idea/runConfigurations/Debugger_Desktop.xml

@@ -1,9 +1,11 @@
 package pro.respawn.flowmvi.api
 
 import kotlinx.coroutines.channels.BufferOverflow
+import pro.respawn.flowmvi.annotation.InternalFlowMVIAPI
 import pro.respawn.flowmvi.dsl.StoreConfigurationBuilder
 import pro.respawn.flowmvi.logging.StoreLogger
 import kotlin.coroutines.CoroutineContext
+import kotlin.uuid.Uuid
 
 /**
  * A configuration of the [Store].
@@ -27,6 +29,9 @@ public data class StoreConfiguration<out S : MVIState> internal constructor(
     val name: String?,
 ) {
 
+    @InternalFlowMVIAPI
+    val id: Uuid = Uuid.random()
+
     @Deprecated(
         "Please use the StateStrategy directly",
         ReplaceWith("this.stateStrategy is StateStrategy.Atomic")

.idea/runConfigurations/Debugger_Run_and_Detach.xml

@@ -10,7 +10,7 @@ kotlin {
         this,
         // not supported by all needed ktor artifacts?
         watchOs = false,
-        wasmJs = false,
+        wasmJs = true,
         wasmWasi = false,
     )
 }

.junie/.onboarding_migrated

@@ -29,6 +29,8 @@ import pro.respawn.flowmvi.debugger.model.ClientEvent.StoreConnected
 import pro.respawn.flowmvi.debugger.model.ServerEvent
 import pro.respawn.flowmvi.dsl.store
 import pro.respawn.flowmvi.logging.StoreLogLevel
+import pro.respawn.flowmvi.logging.StoreLogger
+import pro.respawn.flowmvi.logging.invoke
 import pro.respawn.flowmvi.logging.log
 import pro.respawn.flowmvi.plugins.enableLogging
 import pro.respawn.flowmvi.plugins.init
@@ -40,17 +42,17 @@ import kotlin.uuid.Uuid
 internal typealias DebugClientStore = Store<EmptyState, ClientEvent, ServerEvent>
 
 internal fun debugClientStore(
-    clientName: String,
+    clientId: Uuid,
+    clientKey: String?,
     client: HttpClient,
     host: String,
     port: Int,
     reconnectionDelay: Duration,
     logEvents: Boolean = false,
 ) = store(EmptyState) {
-    val id = Uuid.random()
     val session = MutableStateFlow<DefaultClientWebSocketSession?>(null)
     configure {
-        name = "${clientName}Debugger"
+        name = clientKey ?: "Debugger"
         coroutineContext = Dispatchers.Default
         debuggable = true
         parallelIntents = false // ensure the order of events matches server's expectations
@@ -73,23 +75,19 @@ internal fun debugClientStore(
                 }
             },
         ) {
-            log(StoreLogLevel.Trace) { "Starting connection at $host:$port/$id" }
             val _ = client.webSocketSession(
                 method = HttpMethod.Get,
                 host = host,
                 port = port,
-                path = "/$id",
+                path = "/$clientId",
             ).apply {
                 session.update {
                     it?.close()
                     this
                 }
-                sendSerialized<ClientEvent>(StoreConnected(clientName, id))
+                sendSerialized<ClientEvent>(StoreConnected(clientKey, clientId))
                 log(StoreLogLevel.Trace) { "Established connection to ${call.request.url}" }
-                awaitEvents {
-                    log(StoreLogLevel.Trace) { "Received event: $it" }
-                    if (it.storeId == id) action(it)
-                }
+                awaitEvents(config.logger) { if (it.storeId == clientId) action(it) }
             }
         }
     }
@@ -124,6 +122,21 @@ private inline fun CoroutineScope.launchConnectionLoop(
     }
 }
 
-private suspend inline fun DefaultClientWebSocketSession.awaitEvents(onEvent: (ServerEvent) -> Unit) {
-    while (isActive) onEvent(receiveDeserialized<ServerEvent>())
+@Suppress("TooGenericExceptionCaught") // intentional - resilient event loop
+private suspend inline fun DefaultClientWebSocketSession.awaitEvents(
+    log: StoreLogger,
+    onEvent: (ServerEvent) -> Unit
+) {
+    while (isActive) {
+        try {
+            val event = receiveDeserialized<ServerEvent>()
+            log(StoreLogLevel.Trace) { "Received event: $event" }
+            onEvent(event)
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
+            log(e, StoreLogLevel.Warn)
+            continue
+        }
+    }
 }

.junie/memory/errors.md

@@ -0,0 +1,43 @@
+package pro.respawn.flowmvi.debugger.client
+
+import io.ktor.client.HttpClient
+import io.ktor.client.request.post
+import io.ktor.client.request.setBody
+import io.ktor.http.ContentType
+import io.ktor.http.contentType
+import io.ktor.http.path
+import io.ktor.utils.io.CancellationException
+import pro.respawn.flowmvi.debugger.DebuggerDefaults
+import pro.respawn.flowmvi.metrics.MetricsSink
+
+/**
+ * Creates a [MetricsSink] that sends store metrics to the FlowMVI Debugger server.
+ *
+ * @param client The [HttpClient] to use for sending metrics.
+ * @param host The debugger server host. Defaults to [DebuggerDefaults.ClientHost].
+ * @param port The debugger server port. Defaults to [DebuggerDefaults.Port].
+ * @param onError A callback invoked when an error occurs while sending metrics. By default, errors are swallowed.
+ * @return A [MetricsSink] that forwards metrics to the debugger server.
+ */
+public fun DebuggerSink(
+    client: HttpClient,
+    host: String = DebuggerDefaults.ClientHost,
+    port: Int = DebuggerDefaults.Port,
+    onError: (e: Exception) -> Unit = { /* swallow */ },
+): MetricsSink = MetricsSink { snapshot ->
+    val storeId = snapshot.meta.storeId ?: return@MetricsSink
+    runCatching {
+        client.post {
+            url.host = host
+            url.port = port
+            contentType(ContentType.Application.Json)
+            url.path(storeId.toString(), "metrics")
+            setBody(snapshot)
+        }
+    }.onFailure {
+        when (it) {
+            !is Exception, is CancellationException -> throw it
+            else -> onError(it)
+        }
+    }
+}