refactor(#1375): typed params for subscription.*, usage.bars and vault.* (#1386)

app/src/main/java/com/m57/hermescontrol/data/ws/BillingRepository.kt

@@ -8,6 +8,11 @@ import com.m57.hermescontrol.data.model.SubscriptionStateResponse
 import com.m57.hermescontrol.data.model.SubscriptionUpgradeResponse
 import com.m57.hermescontrol.data.model.UsageBarsResponse
 import com.m57.hermescontrol.data.remote.OkHttpProvider
+import com.m57.hermescontrol.data.ws.contract.EmptyParams
+import com.m57.hermescontrol.data.ws.contract.RpcMethods
+import com.m57.hermescontrol.data.ws.contract.SubscriptionChangeParams
+import com.m57.hermescontrol.data.ws.contract.SubscriptionPreviewParams
+import com.m57.hermescontrol.data.ws.contract.SubscriptionUpgradeParams
 import kotlinx.serialization.json.JsonArray
 import kotlinx.serialization.json.JsonElement
 import kotlinx.serialization.json.JsonNull
@@ -90,50 +95,47 @@ object BillingRepository {
         }
 
     suspend fun getSubscriptionState(): SubscriptionStateResponse? {
-        val result = HermesWsClient.request(WsMethods.SUBSCRIPTION_STATE).await()
+        val result = HermesWsClient.call(RpcMethods.SUBSCRIPTION_STATE, EmptyParams)
         return decode(result)
     }
 
     suspend fun getUsageBars(): UsageBarsResponse? {
-        val result = HermesWsClient.request(WsMethods.USAGE_BARS).await()
+        val result = HermesWsClient.call(RpcMethods.USAGE_BARS, EmptyParams)
         return decode(result)
     }
 
     suspend fun previewSubscription(subscriptionTypeId: String): SubscriptionPreviewResponse? {
         val result =
-            HermesWsClient
-                .request(
-                    WsMethods.SUBSCRIPTION_PREVIEW,
-                    mapOf("subscription_type_id" to subscriptionTypeId),
-                ).await()
+            HermesWsClient.call(
+                RpcMethods.SUBSCRIPTION_PREVIEW,
+                SubscriptionPreviewParams(subscriptionTypeId = subscriptionTypeId),
+            )
         return decode(result)
     }
 
     suspend fun changeSubscription(request: SubscriptionChangeRequest): SubscriptionChangeResponse? {
         val result =
-            HermesWsClient
-                .request(
-                    WsMethods.SUBSCRIPTION_CHANGE,
-                    buildMap {
-                        request.subscription_type_id?.let { put("subscription_type_id", it) }
-                        request.cancel?.let { put("cancel", it) }
-                    },
-                ).await()
+            HermesWsClient.call(
+                RpcMethods.SUBSCRIPTION_CHANGE,
+                SubscriptionChangeParams(
+                    subscriptionTypeId = request.subscription_type_id,
+                    cancel = request.cancel,
+                ),
+            )
         return decode(result)
     }
 
     suspend fun resumeSubscription(): SubscriptionResumeResponse? {
-        val result = HermesWsClient.request(WsMethods.SUBSCRIPTION_RESUME).await()
+        val result = HermesWsClient.call(RpcMethods.SUBSCRIPTION_RESUME, EmptyParams)
         return decode(result)
     }
 
     suspend fun upgradeSubscription(subscriptionTypeId: String): SubscriptionUpgradeResponse? {
         val result =
-            HermesWsClient
-                .request(
-                    WsMethods.SUBSCRIPTION_UPGRADE,
-                    mapOf("subscription_type_id" to subscriptionTypeId),
-                ).await()
+            HermesWsClient.call(
+                RpcMethods.SUBSCRIPTION_UPGRADE,
+                SubscriptionUpgradeParams(subscriptionTypeId = subscriptionTypeId),
+            )
         return decode(result)
     }
 }

app/src/main/java/com/m57/hermescontrol/data/ws/VaultRepository.kt

@@ -8,6 +8,11 @@ import com.m57.hermescontrol.data.model.VaultSourceSetResponse
 import com.m57.hermescontrol.data.model.VaultSourcesResponse
 import com.m57.hermescontrol.data.model.VaultUnlockResponse
 import com.m57.hermescontrol.data.remote.OkHttpProvider
+import com.m57.hermescontrol.data.ws.contract.EmptyParams
+import com.m57.hermescontrol.data.ws.contract.RpcMethods
+import com.m57.hermescontrol.data.ws.contract.VaultLockParams
+import com.m57.hermescontrol.data.ws.contract.VaultSourceSetParams
+import com.m57.hermescontrol.data.ws.contract.VaultUnlockParams
 import kotlinx.serialization.json.JsonArray
 import kotlinx.serialization.json.JsonElement
 import kotlinx.serialization.json.JsonNull
@@ -48,7 +53,7 @@ object VaultRepository {
         }
 
     suspend fun getSources(): List<VaultSource> {
-        val result = HermesWsClient.request(WsMethods.VAULT_SOURCES).await()
+        val result = HermesWsClient.call(RpcMethods.VAULT_SOURCES, EmptyParams)
         return decode<VaultSourcesResponse>(result)?.sources ?: emptyList()
     }
 
@@ -57,11 +62,10 @@ object VaultRepository {
         enabled: Boolean,
     ): Boolean {
         val result =
-            HermesWsClient
-                .request(
-                    WsMethods.VAULT_SOURCE_SET,
-                    mapOf("name" to name, "enabled" to enabled),
-                ).await()
+            HermesWsClient.call(
+                RpcMethods.VAULT_SOURCE_SET,
+                VaultSourceSetParams(name = name, enabled = enabled),
+            )
         return decode<VaultSourceSetResponse>(result)?.enabled == enabled
     }
 
@@ -70,22 +74,21 @@ object VaultRepository {
         password: String,
     ): Boolean {
         val result =
-            HermesWsClient
-                .request(
-                    WsMethods.VAULT_UNLOCK,
-                    mapOf("name" to name, "password" to password),
-                ).await()
+            HermesWsClient.call(
+                RpcMethods.VAULT_UNLOCK,
+                VaultUnlockParams(name = name, password = password),
+            )
         return decode<VaultUnlockResponse>(result)?.unlocked == true
     }
 
     suspend fun lockSource(name: String? = null): Boolean {
-        val params = if (name != null) mapOf("name" to name) else emptyMap<String, Any>()
-        val result = HermesWsClient.request(WsMethods.VAULT_LOCK, params).await()
+        val params = VaultLockParams(name = name)
+        val result = HermesWsClient.call(RpcMethods.VAULT_LOCK, params)
         return decode<VaultLockResponse>(result)?.locked == true
     }
 
     suspend fun listItems(): List<VaultItem> {
-        val result = HermesWsClient.request(WsMethods.VAULT_LIST).await()
+        val result = HermesWsClient.call(RpcMethods.VAULT_LIST, EmptyParams)
         return decode<VaultListResponse>(result)?.items ?: emptyList()
     }
 }

app/src/main/java/com/m57/hermescontrol/data/ws/contract/BillingVault.kt

@@ -0,0 +1,40 @@
+package com.m57.hermescontrol.data.ws.contract
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data object EmptyParams
+
+@Serializable
+data class SubscriptionPreviewParams(
+    @SerialName("subscription_type_id") val subscriptionTypeId: String? = null,
+)
+
+@Serializable
+data class SubscriptionChangeParams(
+    @SerialName("subscription_type_id") val subscriptionTypeId: String? = null,
+    @SerialName("cancel") val cancel: Boolean? = null,
+)
+
+@Serializable
+data class SubscriptionUpgradeParams(
+    @SerialName("subscription_type_id") val subscriptionTypeId: String? = null,
+)
+
+@Serializable
+data class VaultSourceSetParams(
+    @SerialName("name") val name: String? = null,
+    @SerialName("enabled") val enabled: Boolean? = null,
+)
+
+@Serializable
+data class VaultUnlockParams(
+    @SerialName("name") val name: String? = null,
+    @SerialName("password") val password: String? = null,
+)
+
+@Serializable
+data class VaultLockParams(
+    @SerialName("name") val name: String? = null,
+)

app/src/main/java/com/m57/hermescontrol/data/ws/contract/RpcMethod.kt

@@ -150,6 +150,84 @@ object RpcMethods {
             JsonElement.serializer(),
         )
 
+    // Passthrough JsonElement results: callers keep their existing legacy parsers.
+    val SUBSCRIPTION_STATE: RpcMethod<EmptyParams, JsonElement> =
+        RpcMethod(
+            WsMethods.SUBSCRIPTION_STATE,
+            EmptyParams.serializer(),
+            JsonElement.serializer(),
+        )
+
+    val SUBSCRIPTION_PREVIEW: RpcMethod<SubscriptionPreviewParams, JsonElement> =
+        RpcMethod(
+            WsMethods.SUBSCRIPTION_PREVIEW,
+            SubscriptionPreviewParams.serializer(),
+            JsonElement.serializer(),
+        )
+
+    val SUBSCRIPTION_CHANGE: RpcMethod<SubscriptionChangeParams, JsonElement> =
+        RpcMethod(
+            WsMethods.SUBSCRIPTION_CHANGE,
+            SubscriptionChangeParams.serializer(),
+            JsonElement.serializer(),
+        )
+
+    val SUBSCRIPTION_UPGRADE: RpcMethod<SubscriptionUpgradeParams, JsonElement> =
+        RpcMethod(
+            WsMethods.SUBSCRIPTION_UPGRADE,
+            SubscriptionUpgradeParams.serializer(),
+            JsonElement.serializer(),
+        )
+
+    val SUBSCRIPTION_RESUME: RpcMethod<EmptyParams, JsonElement> =
+        RpcMethod(
+            WsMethods.SUBSCRIPTION_RESUME,
+            EmptyParams.serializer(),
+            JsonElement.serializer(),
+        )
+
+    val USAGE_BARS: RpcMethod<EmptyParams, JsonElement> =
+        RpcMethod(
+            WsMethods.USAGE_BARS,
+            EmptyParams.serializer(),
+            JsonElement.serializer(),
+        )
+
+    val VAULT_LIST: RpcMethod<EmptyParams, JsonElement> =
+        RpcMethod(
+            WsMethods.VAULT_LIST,
+            EmptyParams.serializer(),
+            JsonElement.serializer(),
+        )
+
+    val VAULT_SOURCES: RpcMethod<EmptyParams, JsonElement> =
+        RpcMethod(
+            WsMethods.VAULT_SOURCES,
+            EmptyParams.serializer(),
+            JsonElement.serializer(),
+        )
+
+    val VAULT_SOURCE_SET: RpcMethod<VaultSourceSetParams, JsonElement> =
+        RpcMethod(
+            WsMethods.VAULT_SOURCE_SET,
+            VaultSourceSetParams.serializer(),
+            JsonElement.serializer(),
+        )
+
+    val VAULT_UNLOCK: RpcMethod<VaultUnlockParams, JsonElement> =
+        RpcMethod(
+            WsMethods.VAULT_UNLOCK,
+            VaultUnlockParams.serializer(),
+            JsonElement.serializer(),
+        )
+
+    val VAULT_LOCK: RpcMethod<VaultLockParams, JsonElement> =
+        RpcMethod(
+            WsMethods.VAULT_LOCK,
+            VaultLockParams.serializer(),
+            JsonElement.serializer(),
+        )
+
     /** Every typed method. GatewayContractTest iterates this; future migrations append here. */
     val all: List<RpcMethod<*, *>> =
         listOf(
@@ -171,5 +249,16 @@ object RpcMethods {
             APPROVAL_RECEIVED,
             APPROVAL_RESPOND,
             SESSION_ACTIVE_LIST,
+            SUBSCRIPTION_STATE,
+            SUBSCRIPTION_PREVIEW,
+            SUBSCRIPTION_CHANGE,
+            SUBSCRIPTION_UPGRADE,
+            SUBSCRIPTION_RESUME,
+            USAGE_BARS,
+            VAULT_LIST,
+            VAULT_SOURCES,
+            VAULT_SOURCE_SET,
+            VAULT_UNLOCK,
+            VAULT_LOCK,
         )
 }