Enhancing Library Usability with Communication Error Handling in Queries and Mutations

query/src/main/java/me/pavi2410/useCompose/query/hooks.kt

@@ -10,47 +10,65 @@ sealed interface QueryState<out T> {
     data class Content<T>(val data: T) : QueryState<T>
 }
 
-sealed interface MutationState<T> {
+sealed interface MutationState<out T> {
     object Idle : MutationState<Nothing>
     object Loading : MutationState<Nothing>
-    data class Error(val message: Throwable) : MutationState<Nothing>
-    data class Content<T>(val data: T) : MutationState<T>
+    object Success : MutationState<Nothing>
+    data class Error(val th: Throwable) : MutationState<Nothing>
+//    data class Content<T>(val data: T) : MutationState<T> // we unknown callback return type
 }
 
-interface Mutation<T> {
+interface Mutation<T>  {
     fun mutate(vararg args: String, callback: (T) -> Unit)
     fun cancel()
-//    val state: MutationState<T>
+    fun reset()
+    val state: MutationState<T>
 }
 
 @Composable
 fun <T> useQuery(query: suspend CoroutineScope.() -> T): State<QueryState<T>> {
     return produceState<QueryState<T>>(initialValue = QueryState.Loading) {
         value = withContext(Dispatchers.IO) {
-            val res = query()
-            QueryState.Content(res)
+            val res : T
+            try {
+                res = query()
+                QueryState.Content(res)
+            }catch (e : Exception){
+                QueryState.Error(e)
+            }
         }
     }
 }
 
 @SuppressLint("ComposableNaming")
 @Composable
 fun <T> useMutation(query: suspend CoroutineScope.(args: Array<out String>) -> T): Mutation<T> {
-//    var mutationState by remember { mutableStateOf(MutationState.Idle) }
+    var mutationState : MutationState<Nothing> by remember { mutableStateOf(MutationState.Idle) }
     val coroutineScope = rememberCoroutineScope()
     return object: Mutation<T> {
         override fun mutate(vararg args: String, callback: (T) -> Unit) {
             coroutineScope.launch {
-//                mutationState = MutationState.Loading
-                callback(query(args))
-//                mutationState = MutationState.Success
+                mutationState = MutationState.Loading
+                try {
+                    callback(query(args))
+                    mutationState = MutationState.Success
+                    MutationState.Success
+                } catch (e : Exception){
+                    mutationState = MutationState.Error(e)
+                    MutationState.Error(e)
+                }
+
             }
         }
         override fun cancel() {
             coroutineScope.cancel()
         }
 
-//        override val state: MutationState<T>
-//            get() = mutationState
+        override  fun reset () {
+            mutationState = MutationState.Idle
+        }
+
+        override val state: MutationState<Nothing>
+            get() = mutationState
     }
-}
+}