Dismiss on unrecoverable

Author: kiftio

platforms/android/lib/src/main/java/com/shopify/checkoutkit/CheckoutProtocol.kt

@@ -4,6 +4,7 @@ import android.net.Uri
 import android.os.Looper
 import androidx.core.net.toUri
 import com.shopify.checkoutkit.ShopifyCheckoutKit.log
+import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.SerializationException
 import kotlinx.serialization.json.Json
@@ -48,16 +49,7 @@ public object CheckoutProtocol {
     public val totalsChange: NotificationDescriptor<Checkout> = checkoutDescriptor("ec.totals.change")
     public val error: NotificationDescriptor<ErrorResponse> = NotificationDescriptor(
         method = "ec.error",
-        decode = { params ->
-            (params as? JsonObject)?.get("error")?.let {
-                try {
-                    json.decodeFromJsonElement<ErrorResponse>(it)
-                } catch (e: SerializationException) {
-                    log.d(BaseWebView.ECP_LOG_TAG, "Failed to decode ec.error params: $e  raw=$it")
-                    null
-                }
-            }
-        }
+        decode = ::decodeErrorResponse,
     )
 
     // Delegations — request-response. Merchant-overridable: if a consumer registers a
@@ -89,6 +81,29 @@ public object CheckoutProtocol {
             }
         )
 
+    private fun decodeErrorResponse(params: JsonElement?): ErrorResponse? {
+        val paramsObject = params as? JsonObject ?: return null
+        val payload = paramsObject["error"] ?: paramsObject
+        return try {
+            val rawError = json.decodeFromJsonElement<RawErrorResponse>(payload)
+            rawError.toErrorResponse()
+        } catch (e: Exception) {
+            log.d(BaseWebView.ECP_LOG_TAG, "Failed to decode ec.error params: $e  raw=$payload")
+            null
+        }
+    }
+
+    private fun RawErrorResponse.toErrorResponse(): ErrorResponse {
+        return ErrorResponse(
+            continueURL = continueURL,
+            messages = messages,
+            ucp = ucp ?: ErrorResponseUcp(
+                status = StatusEnum.Error,
+                version = SPEC_VERSION,
+            ),
+        )
+    }
+
     private fun encodeWindowOpenResult(result: WindowOpenResult): JsonObject = when (result) {
         is WindowOpenResult.Success ->
             json.encodeToJsonElement(
@@ -232,6 +247,14 @@ public object CheckoutProtocol {
     private const val LOG_TAG = BaseWebView.ECP_LOG_TAG
     private const val CODE_INVALID_PARAMS = -32602
 
+    @Serializable
+    private data class RawErrorResponse(
+        @SerialName("continue_url")
+        val continueURL: String? = null,
+        val messages: List<MessageElement>,
+        val ucp: ErrorResponseUcp? = null,
+    )
+
     private fun jsonRpcResult(id: JsonElement?, result: JsonElement): String =
         json.encodeToString(
             JsonObject.serializer(),

platforms/android/lib/src/main/java/com/shopify/checkoutkit/EmbeddedCheckoutProtocol.kt

@@ -1,6 +1,5 @@
 package com.shopify.checkoutkit
 
-import android.content.Context
 import android.webkit.JavascriptInterface
 import com.shopify.checkoutkit.ShopifyCheckoutKit.log
 import kotlinx.serialization.Serializable
@@ -29,7 +28,7 @@ internal class EmbeddedCheckoutProtocol(
     @Volatile private var client: CheckoutCommunicationClient? = null,
 ) {
     private val decoder = Json { ignoreUnknownKeys = true }
-    private val defaultClient: CheckoutProtocol.Client = defaultDelegationClient(view.context)
+    private val defaultClient: CheckoutProtocol.Client = defaultDelegationClient()
 
     internal fun setClient(client: CheckoutCommunicationClient?) {
         this.client = client
@@ -135,12 +134,22 @@ internal class EmbeddedCheckoutProtocol(
         }
     }
 
+    /**
+     * Dispatch a message through the consumer client. `ec.error` also runs through the
+     * kit-owned [defaultClient] regardless of the consumer response so unrecoverable
+     * session errors always close checkout while still reaching `CheckoutProtocol.error`.
+     */
     private fun handleClientMessage(method: String, message: String) {
         log.d(LOG_TAG, "Delegating $method to client.")
         onMainThread {
             val response = client?.process(message)
             log.d(LOG_TAG, "  client response: $response")
             response?.let { sendRaw(it) }
+            if (method == METHOD_ERROR) {
+                // Unrecoverable ec.error is kit behavior: emit to the client, then run
+                // the default handler so checkout is dismissed even if the client responded.
+                defaultClient.process(message)?.let { sendRaw(it) }
+            }
         }
     }
 
@@ -169,6 +178,37 @@ internal class EmbeddedCheckoutProtocol(
         }
     }
 
+    /**
+     * Kit-owned client that handles delegations and kit-mandated notifications,
+     * mirroring Swift's `defaultsClient`. Currently:
+     *   - [CheckoutProtocol.windowOpen] - launches the URI via `Intent.ACTION_VIEW`, or
+     *     returns [WindowOpenResult.Rejected] with `window_open_rejected_error` semantics.
+     *   - [CheckoutProtocol.error] - when any message carries `severity: "unrecoverable"`,
+     *     dismiss the kit via the listener. Per UCP spec, `unrecoverable` means no valid
+     *     resource exists to act on, so consumers don't have to wire dismissal in every
+     *     error handler.
+     */
+    private fun defaultDelegationClient(): CheckoutProtocol.Client =
+        CheckoutProtocol.Client()
+            .on(CheckoutProtocol.windowOpen) { request ->
+                when (val result = ExternalUriLauncher.launch(view.context, request.url)) {
+                    is ExternalUriLauncher.Result.Launched -> WindowOpenResult.Success
+                    is ExternalUriLauncher.Result.Rejected -> {
+                        log.d(LOG_TAG, "window.open rejected for ${request.url}: ${result.reason}")
+                        WindowOpenResult.Rejected(reason = result.reason)
+                    }
+                }
+            }
+            .on(CheckoutProtocol.error) { payload ->
+                if (payload.messages.none { it.severity == Severity.Unrecoverable }) return@on
+                log.d(LOG_TAG, "ec.error unrecoverable; dismissing checkout via event processor")
+                view.getListener().onCheckoutViewFailedWithError(
+                    ClientException(
+                        errorDescription = "Embedded checkout reported unrecoverable error.",
+                    ),
+                )
+            }
+
     companion object {
         private const val LOG_TAG = BaseWebView.ECP_LOG_TAG
 
@@ -181,6 +221,7 @@ internal class EmbeddedCheckoutProtocol(
         internal const val METHOD_READY = "ec.ready"
         internal const val METHOD_START = "ec.start"
         internal const val METHOD_COMPLETE = "ec.complete"
+        private const val METHOD_ERROR = "ec.error"
 
         private const val METHOD_WINDOW_OPEN_REQUEST = "ec.window.open_request"
 
@@ -200,24 +241,6 @@ internal class EmbeddedCheckoutProtocol(
 
         private const val CODE_PARSE_ERROR = -32700
         private const val CODE_METHOD_NOT_SUPPORTED = -32601
-
-        /**
-         * The kit's default [CheckoutProtocol.windowOpen] handler.
-         *
-         * Mirrors Swift's `defaultsClient`: launches the URI via `Intent.ACTION_VIEW`
-         * if any activity resolves it, otherwise returns [WindowOpenResult.Rejected]
-         * with `window_open_rejected_error` semantics.
-         */
-        internal fun defaultDelegationClient(context: Context): CheckoutProtocol.Client =
-            CheckoutProtocol.Client().on(CheckoutProtocol.windowOpen) { request ->
-                when (val result = ExternalUriLauncher.launch(context, request.url)) {
-                    is ExternalUriLauncher.Result.Launched -> WindowOpenResult.Success
-                    is ExternalUriLauncher.Result.Rejected -> {
-                        log.d(LOG_TAG, "window.open rejected for ${request.url}: ${result.reason}")
-                        WindowOpenResult.Rejected(reason = result.reason)
-                    }
-                }
-            }
     }
 }
 

platforms/android/lib/src/test/java/com/shopify/checkoutkit/EmbeddedCheckoutProtocolTest.kt

@@ -7,11 +7,13 @@ import android.net.Uri
 import android.os.Looper
 import androidx.activity.ComponentActivity
 import org.assertj.core.api.Assertions.assertThat
+import org.junit.Assert.fail
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.mockito.Mockito
 import org.mockito.kotlin.any
+import org.mockito.kotlin.argThat
 import org.mockito.kotlin.argumentCaptor
 import org.mockito.kotlin.isNull
 import org.mockito.kotlin.mock
@@ -360,20 +362,121 @@ class EmbeddedCheckoutProtocolTest {
 
     // endregion
 
-    // region delegated notifications
+    // region ec.error — severity-driven dismissal
+
+    @Test
+    fun `ec error is forwarded to client regardless of severity`() {
+        val rawMessage = ecErrorMessage(severity = "recoverable")
+        val client = mock<CheckoutCommunicationClient>()
+        ecp.setClient(client)
+
+        ecp.postMessage(rawMessage)
+        shadowOf(Looper.getMainLooper()).runToEndOfTasks()
+
+        verify(client).process(rawMessage)
+    }
+
+    @Test
+    fun `ec error with unrecoverable severity dismisses via listener`() {
+        val rawMessage = ecErrorMessage(severity = "unrecoverable")
+        val client = mock<CheckoutCommunicationClient>()
+        ecp.setClient(client)
+
+        ecp.postMessage(rawMessage)
+        shadowOf(Looper.getMainLooper()).runToEndOfTasks()
+
+        verify(client).process(rawMessage)
+        val captor = argumentCaptor<CheckoutException>()
+        verify(mockListener).onCheckoutViewFailedWithError(captor.capture())
+        assertThat(captor.firstValue).isInstanceOf(ClientException::class.java)
+        assertThat(captor.firstValue.errorDescription)
+            .isEqualTo("Embedded checkout reported unrecoverable error.")
+    }
 
     @Test
-    fun `ec error is delegated to client`() {
-        val rawMessage = """{"jsonrpc":"2.0","method":"ec.error","params":{"error":{"code":-1,"message":"fail"}}}"""
+    fun `ec error with unrecoverable severity dismisses even when client returns response`() {
+        val rawMessage = ecErrorMessage(severity = "unrecoverable")
         val client = mock<CheckoutCommunicationClient>()
+        whenever(client.process(rawMessage)).thenReturn("""{"jsonrpc":"2.0","id":null,"result":{}}""")
         ecp.setClient(client)
 
         ecp.postMessage(rawMessage)
         shadowOf(Looper.getMainLooper()).runToEndOfTasks()
 
         verify(client).process(rawMessage)
+        verify(mockListener).onCheckoutViewFailedWithError(
+            argThat { this is ClientException },
+        )
+    }
+
+    @Test
+    fun `ec error with recoverable severity does not dismiss`() {
+        val rawMessage = ecErrorMessage(severity = "recoverable")
+        ecp.setClient(mock())
+
+        ecp.postMessage(rawMessage)
+        shadowOf(Looper.getMainLooper()).runToEndOfTasks()
+
+        verify(mockListener, never()).onCheckoutViewFailedWithError(any())
     }
 
+    @Test
+    fun `ec error with requires_buyer_input severity does not dismiss`() {
+        val rawMessage = ecErrorMessage(severity = "requires_buyer_input")
+        ecp.setClient(mock())
+
+        ecp.postMessage(rawMessage)
+        shadowOf(Looper.getMainLooper()).runToEndOfTasks()
+
+        verify(mockListener, never()).onCheckoutViewFailedWithError(any())
+    }
+
+    @Test
+    fun `ec error with requires_buyer_review severity does not dismiss`() {
+        val rawMessage = ecErrorMessage(severity = "requires_buyer_review")
+        ecp.setClient(mock())
+
+        ecp.postMessage(rawMessage)
+        shadowOf(Looper.getMainLooper()).runToEndOfTasks()
+
+        verify(mockListener, never()).onCheckoutViewFailedWithError(any())
+    }
+
+    @Test
+    fun `ec error dismisses when any message has unrecoverable severity`() {
+        val messages = """[
+            |{"type":"error","code":"a","content":"x","severity":"recoverable"},
+            |{"type":"error","code":"b","content":"y","severity":"unrecoverable"}
+        |]
+        """.trimMargin()
+        val rawMessage = """{"jsonrpc":"2.0","method":"ec.error","params":{"messages":$messages}}"""
+        ecp.setClient(mock())
+
+        ecp.postMessage(rawMessage)
+        shadowOf(Looper.getMainLooper()).runToEndOfTasks()
+
+        verify(mockListener).onCheckoutViewFailedWithError(
+            argThat { this is ClientException },
+        )
+    }
+
+    @Test
+    fun `ec error without required messages field is ignored by typed handler`() {
+        val rawMessage = """{"jsonrpc":"2.0","method":"ec.error","params":{}}"""
+        val client = CheckoutProtocol.Client()
+            .on(CheckoutProtocol.error) { fail("Malformed ec.error should not dispatch") }
+        ecp.setClient(client)
+
+        ecp.postMessage(rawMessage)
+        shadowOf(Looper.getMainLooper()).runToEndOfTasks()
+
+        verify(mockListener, never()).onCheckoutViewFailedWithError(any())
+    }
+
+    // endregion
+
+    // region delegated notifications
+
     @Test
     fun `ec complete is delegated to client`() {
         val rawMessage = """{"jsonrpc":"2.0","method":"ec.complete","params":{"checkout":{}}}"""
@@ -491,6 +594,12 @@ class EmbeddedCheckoutProtocolTest {
     private fun windowOpenRequest(id: String, url: String): String =
         """{"jsonrpc":"2.0","method":"ec.window.open_request","id":$id,"params":{"url":"$url"}}"""
 
+    private fun ecErrorMessage(severity: String): String {
+        val messages =
+            """[{"type":"error","code":"session_failed","content":"Session failed","severity":"$severity"}]"""
+        return """{"jsonrpc":"2.0","method":"ec.error","params":{"messages":$messages}}"""
+    }
+
     /**
      * Runs [block], drains the main-thread queue, captures the first JS string
      * passed to [CheckoutWebView.evaluateJavascript].