Streamline profile loading

Avoid getting stuck when hitting errors fetching accounts and relationships.

Do a minimal update when fetching the relationship.

Contributes to #1560

Author: whattherestimefor

Mastodon/In Progress New Layout and Datamodel/MastodonNavigationRouter.swift

@@ -233,9 +233,12 @@ enum MastodonNavigationDestination {
                 Task {
                     let relationshipFetchID = account.id
                     if let authBox = AuthenticationServiceProvider.shared.currentActiveUser.value {
-                        Task {
-                            guard let relationship = try await APIService.shared.relationship(forAccountIds: [relationshipFetchID], authenticationBox: authBox).value.first else { return }
-                            viewModel.set(account: account, relationship: .isNotMe(MastodonAccount.RelationshipInfo(relationship, fetchedAt: .now)), navigator: self)
+                        do {
+                            let relationship = try await APIService.shared.relationship(forAccountIds: [relationshipFetchID], authenticationBox: authBox).value.first
+                            guard let relationship else { return }
+                            viewModel.updateRelationship(.isNotMe(MastodonAccount.RelationshipInfo(relationship, fetchedAt: .now)))
+                        } catch {
+                            didReceiveError(error)
                         }
                     }
                 }

Mastodon/In Progress New Layout and Datamodel/Profile/ProfileView.swift

@@ -1197,7 +1197,7 @@ extension ProfileViewModel: FeedCoordinatorUpdatable {
         switch update {
         case .relationship(let updatedRelationship):
             if let relationship = relationshipViewModel.relationship, updatedRelationship.refersToSameAccount(as: relationship) {
-                relationshipViewModel.prepareForDisplay(relationship: updatedRelationship, theirAccountIsLocked: account?.locked ?? false)
+                updateRelationship(updatedRelationship)
             }
         case .deletedPost, .hashtag, .post:
             break
@@ -1207,6 +1207,10 @@ extension ProfileViewModel: FeedCoordinatorUpdatable {
             }
         }
     }
+    
+    func updateRelationship(_ updatedRelationship: MastodonAccount.Relationship) {
+        relationshipViewModel.prepareForDisplay(relationship: updatedRelationship, theirAccountIsLocked: account?.locked ?? false)
+    }
 }
 
 struct VerticalPositionKey: PreferenceKey {

Mastodon/In Progress New Layout and Datamodel/Timeline/TimelineListViewController.swift

@@ -817,6 +817,7 @@ enum MastodonTimelineSheet {
 @Observable class TimelineListViewModel {
 
     private(set) var authenticatedUser: MastodonAuthenticationBox? = AuthenticationServiceProvider.shared.currentActiveUser.value
+    private weak var navigator: MastodonNavigationRouter?
 
     var unreadCount: Int = 0
     private(set) var waitingReplacementItems: [TimelineItem]?
@@ -1148,6 +1149,7 @@ enum MastodonTimelineSheet {
     init(timeline: MastodonTimelineType, navigator: MastodonNavigationRouter, asyncRefreshViewModel: AsyncRefreshViewModel?) {
         self._asyncRefreshViewModel = asyncRefreshViewModel
         self._timeline = timeline
+        self.navigator = navigator
 
         self.instanceConfigurationUpdateSubscription = AuthenticationServiceProvider.shared.instanceConfigurationUpdates
             .receive(on: DispatchQueue.main)
@@ -1684,75 +1686,81 @@ extension TimelineListViewModel {
 
         guard let authenticatedUser else { return }
         Task {
-            let fetchedAccounts = try await APIService.shared.accountsInfo(userIDs: Array(_accountsToFetch), authenticationBox: authenticatedUser)
-            let fetchedRelationships = try await feedLoader.fetchRelationships(Array(_relationshipsToFetch))
 
-            @MainActor
-            func updateCollectionModel(_ collectionModel: CollectionViewModel) {
-                if let account = fetchedAccounts.first(where: { $0.id == collectionModel.collection.accountId }) {
-                    collectionModel.updateAuthorAccount(MastodonAccount.fromEntity(account, authenticatedDomain: authenticatedUser.domain))
-                }
-                if let relationship = fetchedRelationships.first(where: { $0.info?.id == collectionModel.collection.accountId }) {
-                    collectionModel.prepareForDisplay(withRelationship: relationship)
-                }
-                collectionModel.updateAvatarUrls(fetchedAccounts)
+            defer {
+                currentlyPreparingForDisplay = nil
+                completion?()
             }
 
-            for postModel in toPrep {
-                if postModel.fullPost?.actionablePost?.metaData.author.id == authenticatedUser.userID {
-                    postModel.prepareForDisplay(relationship: .isMe, theirAccountIsLocked: postModel.fullPost?.actionablePost?.metaData.author.locked ?? false)
-                } else {
-                    let relationship = fetchedRelationships.first(where: {
-                        $0.info?.id == postModel.initialDisplayInfo.actionableAuthorId
-                    }) ?? feedLoader.myRelationship(to: postModel.initialDisplayInfo.actionableAuthorId)
-                    
-                    postModel.prepareForDisplay(relationship: relationship, theirAccountIsLocked: postModel.fullPost?.actionablePost?.metaData.author.locked ?? false)
-                }
-                if let collectionViewModel = postModel.collectionViewModel {
-                    updateCollectionModel(collectionViewModel)
+            do {
+                let fetchedAccounts = try await APIService.shared.accountsInfo(userIDs: Array(_accountsToFetch), authenticationBox: authenticatedUser)
+                let fetchedRelationships = try await feedLoader.fetchRelationships(Array(_relationshipsToFetch))
+                
+                @MainActor
+                func updateCollectionModel(_ collectionModel: CollectionViewModel) {
+                    if let account = fetchedAccounts.first(where: { $0.id == collectionModel.collection.accountId }) {
+                        collectionModel.updateAuthorAccount(MastodonAccount.fromEntity(account, authenticatedDomain: authenticatedUser.domain))
+                    }
+                    if let relationship = fetchedRelationships.first(where: { $0.info?.id == collectionModel.collection.accountId }) {
+                        collectionModel.prepareForDisplay(withRelationship: relationship)
+                    }
+                    collectionModel.updateAvatarUrls(fetchedAccounts)
                 }
-                postModel.displayPrepStatus = .donePreparing
-            }
-            
-            for item in batch {
-                switch item {
-                case .notification(let notificationViewModel):
-                    let accountRelatingTo = notificationViewModel.needsRelationshipTo
-                    if let relationship = fetchedRelationships.first(where: { fetched in
-                        guard let fetchedID = fetched.info?.id else { return false }
-                        return fetchedID == accountRelatingTo?.id
-                    }) {
-                        notificationViewModel.prepareForDisplay(relationship: relationship, theirAccountIsLocked: accountRelatingTo?.locked ?? false)
+                
+                for postModel in toPrep {
+                    if postModel.fullPost?.actionablePost?.metaData.author.id == authenticatedUser.userID {
+                        postModel.prepareForDisplay(relationship: .isMe, theirAccountIsLocked: postModel.fullPost?.actionablePost?.metaData.author.locked ?? false)
+                    } else {
+                        let relationship = fetchedRelationships.first(where: {
+                            $0.info?.id == postModel.initialDisplayInfo.actionableAuthorId
+                        }) ?? feedLoader.myRelationship(to: postModel.initialDisplayInfo.actionableAuthorId)
+                        
+                        postModel.prepareForDisplay(relationship: relationship, theirAccountIsLocked: postModel.fullPost?.actionablePost?.metaData.author.locked ?? false)
                     }
-                    notificationViewModel.actionHandler = self
-                    notificationViewModel.displayPrepStatus = .donePreparing
-                    if let collectionModel = notificationViewModel.inlineCollectionViewModel {
-                        updateCollectionModel(collectionModel)
+                    if let collectionViewModel = postModel.collectionViewModel {
+                        updateCollectionModel(collectionViewModel)
                     }
-                case .account(let accountViewModel):
-                    if let relationship = fetchedRelationships.first(where: { $0.info?.id == accountViewModel.id }) {
-                        if accountViewModel.actionHandler == nil {
-                            accountViewModel.actionHandler = self
+                    postModel.displayPrepStatus = .donePreparing
+                }
+                
+                for item in batch {
+                    switch item {
+                    case .notification(let notificationViewModel):
+                        let accountRelatingTo = notificationViewModel.needsRelationshipTo
+                        if let relationship = fetchedRelationships.first(where: { fetched in
+                            guard let fetchedID = fetched.info?.id else { return false }
+                            return fetchedID == accountRelatingTo?.id
+                        }) {
+                            notificationViewModel.prepareForDisplay(relationship: relationship, theirAccountIsLocked: accountRelatingTo?.locked ?? false)
+                        }
+                        notificationViewModel.actionHandler = self
+                        notificationViewModel.displayPrepStatus = .donePreparing
+                        if let collectionModel = notificationViewModel.inlineCollectionViewModel {
+                            updateCollectionModel(collectionModel)
+                        }
+                    case .account(let accountViewModel):
+                        if let relationship = fetchedRelationships.first(where: { $0.info?.id == accountViewModel.id }) {
+                            if accountViewModel.actionHandler == nil {
+                                accountViewModel.actionHandler = self
+                            }
+                            accountViewModel.prepareForDisplay(withRelationship: relationship)
+                        } else if accountViewModel.id == AuthenticationServiceProvider.shared.currentActiveUser.value?.userID {
+                            accountViewModel.prepareForDisplay(withRelationship: .isMe)
                         }
-                        accountViewModel.prepareForDisplay(withRelationship: relationship)
-                    } else if accountViewModel.id == AuthenticationServiceProvider.shared.currentActiveUser.value?.userID {
-                        accountViewModel.prepareForDisplay(withRelationship: .isMe)
+                    case .post, .pinnedPosts:
+                        // handled above
+                        break
+                    case .hashtag:
+                        break
+                    case .collection(let collectionViewModel):
+                        updateCollectionModel(collectionViewModel)
+                    case .heading, .filteredNotificationsInfo, .loadingIndicator, .noItem:
+                        break
                     }
-                case .post, .pinnedPosts:
-                    // handled above
-                    break
-                case .hashtag:
-                    break
-                case .collection(let collectionViewModel):
-                    updateCollectionModel(collectionViewModel)
-                case .heading, .filteredNotificationsInfo, .loadingIndicator, .noItem:
-                    break
                 }
+            } catch {
+                navigator?.didReceiveError(error)
             }
-            
-            currentlyPreparingForDisplay = nil
-            
-            completion?()
         }
     }
 }