When using offline caching, don't mask HTTP redirects. This lets Turbo see the resulting redirect and properly propose a redirect "replace" visit.

Author: jayohms

turbo/src/main/kotlin/dev/hotwire/turbo/http/TurboHttpRepository.kt

@@ -28,7 +28,8 @@ internal class TurboHttpRepository(private val coroutineScope: CoroutineScope) {
 
     data class Result(
         val response: WebResourceResponse?,
-        val offline: Boolean
+        val offline: Boolean,
+        val redirectToLocation: String? = null
     )
 
     internal fun preCache(
@@ -74,15 +75,26 @@ internal class TurboHttpRepository(private val coroutineScope: CoroutineScope) {
         return try {
             val response = issueRequest(resourceRequest)
 
+            // Cache based on the response's request url, which may have been a redirect
+            val responseUrl = response?.request?.url.toString()
+            val isRedirect = url != responseUrl
+
             // Let the app cache the response
             val resourceResponse = resourceResponse(response)
             val cachedResponse = resourceResponse?.let {
-                requestHandler.cacheResponse(url, it)
+                requestHandler.cacheResponse(responseUrl, it)
             }
 
-            Result(cachedResponse ?: resourceResponse, false)
+            Result(
+                response = cachedResponse ?: resourceResponse,
+                offline = false,
+                redirectToLocation = if (isRedirect) responseUrl else null
+            )
         } catch (e: IOException) {
-            Result(requestHandler.getCachedResponse(url, allowStaleResponse = true), true)
+            Result(
+                response = requestHandler.getCachedResponse(url, allowStaleResponse = true),
+                offline = true
+            )
         }
     }
 

turbo/src/main/kotlin/dev/hotwire/turbo/session/TurboSession.kt

@@ -657,15 +657,28 @@ class TurboSession internal constructor(
             }
 
             val url = request.url.toString()
+            val isCurrentVisitRequest = url == currentVisit?.location
             val result = httpRepository.fetch(requestHandler, request)
 
-            currentVisit?.let { visit ->
-                if (visit.location == url) {
-                    visit.completedOffline = result.offline
-                }
+            return if (isCurrentVisitRequest && result.redirectToLocation != null) {
+                // Let Turbo see the redirect, so a redirect "replace" visit can be proposed
+                logEvent("shouldInterceptRequest",
+                    "location" to url,
+                    "redirectToLocation" to result.redirectToLocation,
+                    "statusCode" to (result.response?.statusCode ?: "<none>")
+                )
+                null
+            } else if (isCurrentVisitRequest) {
+                logEvent("shouldInterceptRequest",
+                    "location" to url,
+                    "statusCode" to (result.response?.statusCode ?: "<none>"),
+                    "completedOffline" to result.offline
+                )
+                currentVisit?.completedOffline = result.offline
+                result.response
+            } else {
+                result.response
             }
-
-            return result.response
         }
 
         override fun onReceivedError(view: WebView, request: WebResourceRequest, error: WebResourceErrorCompat) {