Attempt to implement live session navigation

Author: carson-katri

Sources/LiveViewNative/Coordinators/LiveSessionCoordinator.swift

@@ -110,32 +110,48 @@ public class LiveSessionCoordinator<R: RootRegistry>: ObservableObject {
             default:
                 false
             }
+            print(next.last!.coordinator.url)
+            print(next.last!.url)
+            print(isDisconnected)
             if next.last!.coordinator.url != next.last!.url || isDisconnected {
                 Task {
-                    if prev.count > next.count {
-                        // back navigation
-                        print("Back navigate", next.last!.url)
-                        try await prev.last?.coordinator.disconnect()
-                        let liveChannel = try await self.liveSocket!.joinLiveviewChannel(
-                            .some([
-                                "_format": .str(string: LiveSessionParameters.platform),
-                                "_interface": .object(object: LiveSessionParameters.platformParams)
-                            ]),
-                            next.last!.url.absoluteString
-                        )
-                        try await next.last!.coordinator.join(liveChannel)
-                    } else if next.count > prev.count && prev.count > 0 {
-                        print("Forward navigation to \(next.last!.url)")
-                        // forward navigation (from `redirect` or `<NavigationLink>`)
-                        try await prev.last?.coordinator.disconnect()
-                        let liveChannel = try await self.liveSocket!.joinLiveviewChannel(
-                            .some([
-                                "_format": .str(string: LiveSessionParameters.platform),
-                                "_interface": .object(object: LiveSessionParameters.platformParams)
-                            ]),
-                            next.last!.url.absoluteString
-                        )
-                        try await next.last?.coordinator.join(liveChannel)
+                    do {
+                        if prev.count > next.count {
+                            // back navigation
+                            try await prev.last?.coordinator.disconnect()
+                            let liveChannel = try await self.liveSocket!.joinLiveviewChannel(
+                                .some([
+                                    "_format": .str(string: LiveSessionParameters.platform),
+                                    "_interface": .object(object: LiveSessionParameters.platformParams)
+                                ]),
+                                next.last!.url.absoluteString
+                            )
+                            try await next.last!.coordinator.join(liveChannel)
+                        } else if next.count > prev.count && prev.count > 0 {
+                            // forward navigation (from `redirect` or `<NavigationLink>`)
+                            try await prev.last?.coordinator.disconnect()
+                            let liveChannel = try await self.liveSocket!.joinLiveviewChannel(
+                                .some([
+                                    "_format": .str(string: LiveSessionParameters.platform),
+                                    "_interface": .object(object: LiveSessionParameters.platformParams)
+                                ]),
+                                next.last!.url.absoluteString
+                            )
+                            try await next.last?.coordinator.join(liveChannel)
+                        }
+                    } catch let error as LiveSocketError {
+                        switch error {
+                        case .Phoenix(error: "server rejected join {\"reason\":\"unauthorized\"}"),
+                             .Phoenix(error: "server rejected join {\"reason\":\"stale\"}"):
+                            try await self.disconnect(preserveNavigationPath: true)
+                            let originalURL = self.url
+                            self.url = next.last!.url
+                            try await self.connect(httpMethod: nil, httpBody: nil)
+                            self.url = originalURL
+                        default:
+                            logger.error("\(error)")
+                            throw error
+                        }
                     }
                 }
             }
@@ -323,184 +339,6 @@ public class LiveSessionCoordinator<R: RootRegistry>: ObservableObject {
             .sink(receiveValue: handler)
             .store(in: &eventHandlers)
     }
-
-    /// Request the dead render with the given `request`.
-    ///
-    /// Returns the dead render HTML and the HTTP response information (including the final URL after redirects).
-    func deadRender(
-        for request: URLRequest,
-        domValues: DOMValues?
-    ) async throws -> (String, HTTPURLResponse) {
-        
-        var request = request
-        request.url = request.url!.appendingLiveViewItems()
-        request.allHTTPHeaderFields = configuration.headers
-        
-        if let domValues {
-            request.setValue(domValues.phxCSRFToken, forHTTPHeaderField: "x-csrf-token")
-        }
-
-        let data: Data
-        let response: URLResponse
-        do {
-            (data, response) = try await urlSession.data(for: request)
-        } catch {
-            throw LiveConnectionError.initialFetchError(error)
-        }
-
-        guard let response = response as? HTTPURLResponse,
-              response.statusCode == 200,
-              let html = String(data: data, encoding: .utf8)
-        else {
-            if let html = String(data: data, encoding: .utf8)
-            {
-                if try extractLiveReloadFrame(SwiftSoup.parse(html)) {
-                    await connectLiveReloadSocket(urlSessionConfiguration: urlSession.configuration)
-                }
-                throw LiveConnectionError.initialFetchUnexpectedResponse(response, html)
-            } else {
-                throw LiveConnectionError.initialFetchUnexpectedResponse(response)
-            }
-        }
-        return (html, response)
-    }
-
-    struct DOMValues {
-        let phxCSRFToken: String
-        let phxSession: String
-        let phxStatic: String
-        let phxView: String
-        let phxID: String
-        let liveReloadEnabled: Bool
-    }
-    
-    nonisolated private func extractLiveReloadFrame(_ doc: SwiftSoup.Document) throws -> Bool {
-        !(try doc.select("iframe[src=\"/phoenix/live_reload/frame\"]").isEmpty())
-    }
-
-    private func extractDOMValues(_ doc: SwiftSoup.Document) throws -> DOMValues {
-        let csrfToken = try doc.select("csrf-token")
-        guard !csrfToken.isEmpty() else {
-            throw LiveConnectionError.initialParseError(missingOrInvalid: .csrfToken)
-        }
-
-        let mainDivRes = try doc.select("div[data-phx-main]")
-        guard !mainDivRes.isEmpty() else {
-            throw LiveConnectionError.initialParseError(missingOrInvalid: .phxMain)
-        }
-        let mainDiv = mainDivRes[0]
-        return .init(
-            phxCSRFToken: try csrfToken[0].attr("value"),
-            phxSession: try mainDiv.attr("data-phx-session"),
-            phxStatic: try mainDiv.attr("data-phx-static"),
-            phxView: try mainDiv.attr("data-phx-view"),
-            phxID: try mainDiv.attr("id"),
-            liveReloadEnabled: try extractLiveReloadFrame(doc)
-        )
-    }
-
-    @MainActor
-    private func connectSocket(_ domValues: DOMValues) async throws {
-        var wsEndpoint = await URLComponents(url: self.url, resolvingAgainstBaseURL: true)!
-        wsEndpoint.scheme = await self.url.scheme == "https" ? "wss" : "ws"
-        wsEndpoint.path = "/live/websocket"
-        let configuration = await self.urlSession.configuration
-        let socket = Socket(
-            endPoint: wsEndpoint.string!,
-            transport: {
-                URLSessionTransport(url: $0, configuration: configuration)
-            },
-            paramsClosure: {
-                [
-                    "_csrf_token": domValues.phxCSRFToken,
-                    "_format": "swiftui"
-                ]
-            }
-        )
-        
-        socket.onClose { @Sendable in logger.debug("[Socket] Closed") }
-        socket.logger = { @Sendable message in logger.debug("[Socket] \(message)") }
-        
-        try await withCheckedThrowingContinuation { [weak self] (continuation: CheckedContinuation<Void, any Error>) in
-            guard let self else {
-                return continuation.resume(throwing: LiveConnectionError.sessionCoordinatorReleased)
-            }
-            
-            // set to `reconnecting` when the socket asks for the delay duration.
-            socket.reconnectAfter = { @Sendable [weak self] tries in
-                Task { @MainActor [weak self] in
-                    self?.state = .reconnecting
-                }
-                return Defaults.reconnectSteppedBackOff(tries)
-            }
-            socket.onOpen { [weak self] in
-                Task { @MainActor [weak self] in
-                    guard case .reconnecting = await self?.state else { return }
-                    self?.state = .connected
-                }
-            }
-            
-            var refs = [String]()
-            
-            refs.append(socket.onOpen { [weak self, weak socket] in
-                guard let socket else { return }
-                guard self != nil else {
-                    socket.disconnect()
-                    return
-                }
-                logger.debug("[Socket] Opened")
-                socket.off(refs)
-                continuation.resume()
-            })
-            refs.append(socket.onError { [weak self, weak socket, refs] (error, response) in
-                guard let socket else { return }
-                guard self != nil else {
-                    socket.disconnect()
-                    return
-                }
-                logger.error("[Socket] Error: \(String(describing: error))")
-                socket.off(refs)
-            })
-        }
-        self.socket?.onClose { logger.debug("[Socket] Closed") }
-        self.socket?.logger = { message in logger.debug("[Socket] \(message)") }
-
-        self.state = .connected
-
-        if domValues.liveReloadEnabled {
-            await self.connectLiveReloadSocket(urlSessionConfiguration: urlSession.configuration)
-        }
-    }
-    
-    private nonisolated func connectLiveReloadSocket(urlSessionConfiguration: URLSessionConfiguration) async {
-        await MainActor.run {
-            if let liveReloadSocket = self.liveReloadSocket {
-                liveReloadSocket.disconnect()
-                self.liveReloadSocket = nil
-            }
-
-        var liveReloadEndpoint = URLComponents(url: self.url, resolvingAgainstBaseURL: true)!
-        liveReloadEndpoint.scheme = self.url.scheme == "https" ? "wss" : "ws"
-        liveReloadEndpoint.path = "/phoenix/live_reload/socket"
-        self.liveReloadSocket = Socket(endPoint: liveReloadEndpoint.string!, transport: {
-            URLSessionTransport(url: $0, configuration: urlSessionConfiguration)
-        })
-        liveReloadSocket!.connect()
-        self.liveReloadChannel = liveReloadSocket!.channel("phoenix:live_reload")
-        self.liveReloadChannel!.join().receive("ok") { msg in
-            logger.debug("[LiveReload] connected to channel")
-        }.receive("error") { msg in
-            logger.debug("[LiveReload] error connecting to channel: \(msg.payload)")
-        }
-        self.liveReloadChannel!.on("assets_change") { [weak self] _ in
-            logger.debug("[LiveReload] assets changed, reloading")
-            Task {
-                await StylesheetCache.shared.removeAll()
-                // need to fully reconnect (rather than just re-join channel) because the elixir code reloader only triggers on http reqs
-                await self?.reconnect()
-            }
-        }
-    }
 
     func redirect(
         _ redirect: LiveRedirect,
@@ -520,8 +358,16 @@ public class LiveSessionCoordinator<R: RootRegistry>: ObservableObject {
                         self.url = redirect.to
                     }
                     coordinator.document = navigationPath.last!.coordinator.document
-//                    await navigationPath.last?.coordinator.disconnect()
+                    try await coordinator.disconnect()
                     navigationPath[navigationPath.count - 1] = entry
+                    let liveChannel = try await self.liveSocket!.joinLiveviewChannel(
+                        .some([
+                            "_format": .str(string: LiveSessionParameters.platform),
+                            "_interface": .object(object: LiveSessionParameters.platformParams)
+                        ]),
+                        entry.url.absoluteString
+                    )
+                    try await coordinator.join(liveChannel)
 //                    try await coordinator.connect(domValues: self.domValues, redirect: true)
                 }
             }

Sources/LiveViewNative/Coordinators/LiveViewCoordinator.swift

@@ -254,10 +254,10 @@ public class LiveViewCoordinator<R: RootRegistry>: ObservableObject {
                         else { return }
                         try await self.session.redirect(.init(kind: .push, to: destination, mode: .replaceTop))
                     default:
-                        print("Unhandled event: \(event)")
+                        logger.error("Unhandled event: \(String(describing: event))")
                     }
                 } catch {
-                    print("Event handling error: \(error)")
+                    logger.error("Event handling error: \(error.localizedDescription)")
                 }
             }
         }

Sources/LiveViewNative/Views/Layout Containers/Presentation Containers/NavigationLink.swift

@@ -138,17 +138,16 @@ struct NavigationLink<Root: RootRegistry>: View {
                 SwiftUI.Button {
                     Task { @MainActor in
                         // send the `live_patch` event
-                        try await $liveElement.context.coordinator.doPushEvent("live_patch", payload: [
-                            "url": url.absoluteString
-                        ])
+                        try await $liveElement.context.coordinator.doPushEvent("live_patch", payload: .jsonPayload(json: .object(object: [
+                            "url": .str(string: url.absoluteString)
+                        ])))
                         // update the navigation path
                         let kind: LiveRedirect.Kind = switch linkState {
                         case .push:
                             .push
                         case .replace:
                             .replace
                         }
-                        print(kind)
                         try await $liveElement.context.coordinator.session.redirect(
                             .init(
                                 kind: kind,