From df673322ca7dee905306eae8915d7b205490d210 Mon Sep 17 00:00:00 2001
From: Adron Hall <adronhall@gmail.com>
Date: Wed, 16 Sep 2026 12:41:23 -0700
Subject: [PATCH] feat(messages): refresh link metadata after publishing
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

ComposeView now fires POST /api/messages/{id}/metadata after a successful
publish, matching the web composer, so a new post's OpenGraph previews
populate without waiting for something else to backfill them.

The call is guarded on the posted content actually containing a link and is
fire-and-forget: it is never awaited on the publish path and every failure is
swallowed, so it cannot surface an error or delay the success alert. The edit
path deliberately does not call it — no route accepts a content edit today
(see #76).

URL detection is extracted from the composer's live-preview property into
firstDetectedHTTPURL(in:) so the preview card and the publish guard share one
answer and the guard is directly testable.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017bss5MgZa7Jvj2m9zdaUd1
---
 InterlinedList.xcodeproj/project.pbxproj      |  4 +
 InterlinedList/Views/ComposeView.swift        | 46 +++++++---
 .../ComposeLinkDetectionTests.swift           | 88 +++++++++++++++++++
 3 files changed, 126 insertions(+), 12 deletions(-)
 create mode 100644 InterlinedListTests/ModelTests/ComposeLinkDetectionTests.swift

diff --git a/InterlinedList.xcodeproj/project.pbxproj b/InterlinedList.xcodeproj/project.pbxproj
index 6883ba6..b912dd9 100644
--- a/InterlinedList.xcodeproj/project.pbxproj
+++ b/InterlinedList.xcodeproj/project.pbxproj
@@ -59,6 +59,7 @@
 		61621697746E8CF1769E9C80 /* IdentityHealth.swift in Sources */ = {isa = PBXBuildFile; fileRef = 80D1D19E4DB2D914AD6551D7 /* IdentityHealth.swift */; };
 		5F39C031ED69D47574ACF17F /* APIClientGitHubMetadataTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 94499C7F9007F4B2CE90CA91 /* APIClientGitHubMetadataTests.swift */; };
 		64F5804ECC25725FD1E58E84 /* APIClientModerationTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 6A569D8DB8DFD3CC59072FDB /* APIClientModerationTests.swift */; };
+		C0FFEE9102ABCDEF00000091 /* ComposeLinkDetectionTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = C0FFEE9101ABCDEF00000091 /* ComposeLinkDetectionTests.swift */; };
 		6749119D27FA93BE00D5A27F /* FeedTruncationTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 05A695D62B746B092CF51AFA /* FeedTruncationTests.swift */; };
 		6A89622E299B0D172D5B5556 /* GitHubModelTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = C337406C10876F331B1888E3 /* GitHubModelTests.swift */; };
 		6C10CC420377B0E8AE5C82DB /* GapModelsTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 93642F79C3049C4A2ECC8AFF /* GapModelsTests.swift */; };
@@ -250,6 +251,7 @@
 		0221B233F89B966D044C37FA /* ServerLimits.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; path = ServerLimits.swift; sourceTree = "<group>"; };
 		03C47A3ECFD7F4D25F91E3BE /* ShareLinksSheet.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; path = ShareLinksSheet.swift; sourceTree = "<group>"; };
 		03D6C33FD59101503195F14F /* SharedDocumentView.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; path = SharedDocumentView.swift; sourceTree = "<group>"; };
+		C0FFEE9101ABCDEF00000091 /* ComposeLinkDetectionTests.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; path = ComposeLinkDetectionTests.swift; sourceTree = "<group>"; };
 		05A695D62B746B092CF51AFA /* FeedTruncationTests.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; path = FeedTruncationTests.swift; sourceTree = "<group>"; };
 		06CAA8B0033D6DD27ED089CD /* ShareInvitesSheet.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; path = ShareInvitesSheet.swift; sourceTree = "<group>"; };
 		08D80C6D8E2B0C7A3AB7E0B2 /* DocumentLinkView.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; path = DocumentLinkView.swift; sourceTree = "<group>"; };
@@ -780,6 +782,7 @@
 				T1E5T1E5T1E5P030 /* ModerationModelTests.swift */,
 				93642F79C3049C4A2ECC8AFF /* GapModelsTests.swift */,
 				F78B096C366108083D174366 /* MarkdownBlockTests.swift */,
+				C0FFEE9101ABCDEF00000091 /* ComposeLinkDetectionTests.swift */,
 				05A695D62B746B092CF51AFA /* FeedTruncationTests.swift */,
 				EE6BD1CB3C5C5C494971E0B4 /* DirectMessageModelTests.swift */,
 				A5C9FAA36F8413788E1776C7 /* LinkedInTargetModelTests.swift */,
@@ -1105,6 +1108,7 @@
 				2101251E75F418E9EB28DA8F /* ImageUploadProcessorTests.swift in Sources */,
 				09037C64E9D988371F29AD75 /* ComposeImageUploaderTests.swift in Sources */,
 				98CC00030F4340A4BD821FC4 /* MarkdownBlockTests.swift in Sources */,
+				C0FFEE9102ABCDEF00000091 /* ComposeLinkDetectionTests.swift in Sources */,
 				6749119D27FA93BE00D5A27F /* FeedTruncationTests.swift in Sources */,
 				362DEA03EA2CDD9E135B1411 /* APIClientDirectMessagesTests.swift in Sources */,
 				874DE298749DF285984F1182 /* DirectMessageModelTests.swift in Sources */,
diff --git a/InterlinedList/Views/ComposeView.swift b/InterlinedList/Views/ComposeView.swift
index b519b11..0276d82 100644
--- a/InterlinedList/Views/ComposeView.swift
+++ b/InterlinedList/Views/ComposeView.swift
@@ -289,18 +289,7 @@ struct ComposeView: View {
 
     /// The first `http(s)` URL in the draft, used to drive a live preview card.
     /// Recomputed on each content change; cheap enough for per-keystroke use.
-    private var firstDetectedURL: String? {
-        guard !content.isEmpty,
-              let detector = try? NSDataDetector(types: NSTextCheckingResult.CheckingType.link.rawValue)
-        else { return nil }
-        let range = NSRange(content.startIndex..<content.endIndex, in: content)
-        guard let match = detector.firstMatch(in: content, options: [], range: range),
-              let url = match.url,
-              let scheme = url.scheme?.lowercased(),
-              scheme == "http" || scheme == "https"
-        else { return nil }
-        return url.absoluteString
-    }
+    private var firstDetectedURL: String? { firstDetectedHTTPURL(in: content) }
 
     private func loadLinkPreview(_ url: String) async {
         do {
@@ -786,6 +775,9 @@ struct ComposeView: View {
                 store.insertFeedMessage(result.message)
             }
             showSuccess = true
+            if firstDetectedHTTPURL(in: text) != nil {
+                refreshLinkMetadata(for: result.message.id)
+            }
             if isReply || isRepost {
                 dismiss()
             }
@@ -803,4 +795,34 @@ struct ComposeView: View {
             errorMessage = "Connection failed. Please try again."
         }
     }
+
+    /// Asks the server to fetch OpenGraph metadata for a just-published message's
+    /// links, matching what the web composer does, so the preview populates without
+    /// waiting on something else to backfill it. Fire-and-forget by design: the
+    /// preview is a secondary datum, so a failure must never surface on the publish
+    /// path or delay the success alert — not even a 401, which isn't escalated here
+    /// because the post that just succeeded proves the session is live.
+    ///
+    /// Not called from the edit path: there is no route that accepts a content edit
+    /// today (`PATCH /api/messages/{id}` reschedules), so an edited message's links
+    /// can't change server-side anyway. See issue #76.
+    private func refreshLinkMetadata(for messageId: String) {
+        Task { _ = try? await APIClient.shared.refreshMessageMetadata(messageId: messageId) }
+    }
+}
+
+/// The first `http(s)` URL in `text`, or `nil` when it contains none. The composer's
+/// live preview card and the post-publish metadata refresh both key off this, and
+/// they have to agree on whether the message carries a link at all.
+func firstDetectedHTTPURL(in text: String) -> String? {
+    guard !text.isEmpty,
+          let detector = try? NSDataDetector(types: NSTextCheckingResult.CheckingType.link.rawValue)
+    else { return nil }
+    let range = NSRange(text.startIndex..<text.endIndex, in: text)
+    guard let match = detector.firstMatch(in: text, options: [], range: range),
+          let url = match.url,
+          let scheme = url.scheme?.lowercased(),
+          scheme == "http" || scheme == "https"
+    else { return nil }
+    return url.absoluteString
 }
diff --git a/InterlinedListTests/ModelTests/ComposeLinkDetectionTests.swift b/InterlinedListTests/ModelTests/ComposeLinkDetectionTests.swift
new file mode 100644
index 0000000..5149e1f
--- /dev/null
+++ b/InterlinedListTests/ModelTests/ComposeLinkDetectionTests.swift
@@ -0,0 +1,88 @@
+import XCTest
+@testable import InterlinedList
+
+/// `firstDetectedHTTPURL(in:)` is the composer's single answer to "does this draft
+/// carry a link?" — it gates both the live preview card and the post-publish
+/// metadata refresh, so a link-free message must produce no request at all.
+final class ComposeLinkDetectionTests: XCTestCase {
+
+    // MARK: - Detection
+
+    func test_firstDetectedHTTPURL_emptyContent_returnsNil() {
+        XCTAssertNil(firstDetectedHTTPURL(in: ""))
+    }
+
+    func test_firstDetectedHTTPURL_plainProse_returnsNil() {
+        XCTAssertNil(firstDetectedHTTPURL(in: "no links here, just words and a period."))
+    }
+
+    func test_firstDetectedHTTPURL_httpsURL_returnsAbsoluteString() {
+        XCTAssertEqual(
+            firstDetectedHTTPURL(in: "look at https://interlinedlist.com/about please"),
+            "https://interlinedlist.com/about"
+        )
+    }
+
+    func test_firstDetectedHTTPURL_httpURL_returnsAbsoluteString() {
+        XCTAssertEqual(firstDetectedHTTPURL(in: "http://example.com"), "http://example.com")
+    }
+
+    func test_firstDetectedHTTPURL_multipleURLs_returnsTheFirst() {
+        let text = "https://one.example.com and then https://two.example.com"
+        XCTAssertEqual(firstDetectedHTTPURL(in: text), "https://one.example.com")
+    }
+
+    func test_firstDetectedHTTPURL_mailtoLink_returnsNil() {
+        XCTAssertNil(firstDetectedHTTPURL(in: "mail me at someone@example.com"))
+    }
+
+    // MARK: - Publish guard
+
+    /// The guard as `postMessage` applies it: no detected URL ⇒ no metadata request.
+    private func publishAndRefreshIfLinked(
+        _ content: String,
+        using client: APIClient,
+        messageId: String = "m1"
+    ) async {
+        guard firstDetectedHTTPURL(in: content) != nil else { return }
+        _ = try? await client.refreshMessageMetadata(messageId: messageId)
+    }
+
+    func test_publishGuard_contentWithoutLink_issuesNoRequest() async {
+        let session = MockURLSession()
+        let sut = APIClient(session: session)
+        sut.setBearerToken("tok")
+        session.stub(json: #"{"metadata":{"links":[]}}"#)
+
+        await publishAndRefreshIfLinked("just a thought, no links at all", using: sut)
+
+        XCTAssertNil(session.lastRequest)
+        XCTAssertTrue(session.requestHistory.isEmpty)
+    }
+
+    func test_publishGuard_contentWithLink_postsToMetadataRoute() async {
+        let session = MockURLSession()
+        let sut = APIClient(session: session)
+        sut.setBearerToken("tok")
+        session.stub(json: #"{"metadata":{"links":[{"url":"https://example.com","title":"E","description":null,"image":null}]}}"#)
+
+        await publishAndRefreshIfLinked("read this https://example.com", using: sut, messageId: "m42")
+
+        XCTAssertEqual(session.requestHistory.count, 1)
+        XCTAssertEqual(session.lastRequest?.httpMethod, "POST")
+        XCTAssertTrue(session.lastRequest?.url?.path.hasSuffix("/api/messages/m42/metadata") == true)
+    }
+
+    /// A failed refresh is swallowed on the publish path: the caller ignores the
+    /// throw, so a 401 or a 500 can never surface an error after a successful post.
+    func test_publishGuard_failureIsSwallowed() async {
+        let session = MockURLSession()
+        let sut = APIClient(session: session)
+        sut.setBearerToken("tok")
+        session.stub(json: #"{"error":"nope"}"#, statusCode: 500)
+
+        await publishAndRefreshIfLinked("read this https://example.com", using: sut)
+
+        XCTAssertEqual(session.requestHistory.count, 1)
+    }
+}