+412

docs/smoke-test.md

reviewed

··· 1 1 + --- 2 2 + title: Smoke Test Checklist 3 3 + updated: 2026-04-01 4 4 + --- 5 5 + 6 6 + A manual walkthrough to verify core functionality after a build. Each section covers a 7 7 + feature area with steps and expected outcomes. 8 8 + Test on both iOS and Android unless noted otherwise. 9 9 + 10 10 + --- 11 11 + 12 12 + ## 1. Authentication 13 13 + 14 14 + ### OAuth Login 15 15 + 16 16 + - [ ] Launch app → Login screen appears 17 17 + - [ ] Enter a valid handle and tap "Sign in with BlueSky" 18 18 + - [ ] System browser opens → complete OAuth flow 19 19 + - [ ] Redirected back to app → Home feed loads 20 20 + 21 21 + ### App Password Login (Debug only) 22 22 + 23 23 + - [ ] Toggle to app-password mode 24 24 + - [ ] Enter handle + app password (xxxx-xxxx-xxxx-xxxx) 25 25 + - [ ] Tap sign in → Home feed loads 26 26 + 27 27 + ### Session Restore 28 28 + 29 29 + - [ ] Kill and relaunch app → session restores without login prompt 30 30 + - [ ] Token refresh works silently (wait for expiry or force) 31 31 + 32 32 + ### Logout 33 33 + 34 34 + - [ ] Log out from settings → returns to login screen 35 35 + - [ ] Relaunching app shows login screen (session cleared) 36 36 + 37 37 + --- 38 38 + 39 39 + ## 2. Home Feed 40 40 + 41 41 + ### Feed Loading 42 42 + 43 43 + - [ ] Following feed loads with posts on launch 44 44 + - [ ] Pull-to-refresh fetches new posts 45 45 + - [ ] Scroll down → infinite pagination loads more posts 46 46 + 47 47 + ### Post Cards 48 48 + 49 49 + - [ ] Posts display: avatar, name, handle, relative timestamp 50 50 + - [ ] Rich text renders correctly (mentions, links, hashtags highlighted) 51 51 + - [ ] Image embeds display (single + multi-image grids) 52 52 + - [ ] Video embeds display with thumbnail 53 53 + - [ ] Link card embeds render (title, description, thumbnail) 54 54 + - [ ] Quote posts render inline 55 55 + - [ ] Engagement counts shown (likes, reposts, replies) 56 56 + 57 57 + ### Post Actions 58 58 + 59 59 + - [ ] Tap like → icon fills, count increments (optimistic) 60 60 + - [ ] Tap like again → unlike, count decrements 61 61 + - [ ] Tap repost → menu: "Repost" and "Quote Post" 62 62 + - [ ] Repost → count increments 63 63 + - [ ] Tap reply → compose modal opens with reply context 64 64 + - [ ] Tap share → system share sheet 65 65 + - [ ] Overflow → Save post (bookmark icon fills) 66 66 + - [ ] Overflow → Copy link 67 67 + 68 68 + ### Navigation from Feed 69 69 + 70 70 + - [ ] Tap post body → thread view opens 71 71 + - [ ] Tap avatar or name → profile screen opens 72 72 + 73 73 + --- 74 74 + 75 75 + ## 3. Feed Management 76 76 + 77 77 + - [ ] Open feed management from home screen 78 78 + - [ ] Pinned feeds listed (Following + custom generators) 79 79 + - [ ] Drag to reorder feeds → order persists 80 80 + - [ ] Toggle pin off → feed removed from home tabs 81 81 + - [ ] Add a suggested feed → appears in home tabs 82 82 + 83 83 + --- 84 84 + 85 85 + ## 4. Post Composition 86 86 + 87 87 + ### Basic Compose 88 88 + 89 89 + - [ ] Tap compose FAB → compose screen opens 90 90 + - [ ] Type text → character counter updates (max 300 graphemes) 91 91 + - [ ] Mentions auto-highlight as typed 92 92 + - [ ] Links and hashtags auto-highlight 93 93 + - [ ] Submit → post appears in feed 94 94 + 95 95 + ### Media 96 96 + 97 97 + - [ ] Attach 1–4 images → thumbnails shown 98 98 + - [ ] Add alt text to an image 99 99 + - [ ] Remove an image attachment 100 100 + - [ ] Attach a video → upload progress shown 101 101 + - [ ] Images and video are mutually exclusive (UI enforces) 102 102 + 103 103 + ### Reply & Quote 104 104 + 105 105 + - [ ] Compose as reply → parent post context shown above input 106 106 + - [ ] Compose as quote → quoted post shown below input 107 107 + 108 108 + ### Drafts 109 109 + 110 110 + - [ ] Save draft → confirmation shown 111 111 + - [ ] Open drafts → saved draft listed 112 112 + - [ ] Load draft → text and media restored 113 113 + - [ ] Submit loaded draft → posts successfully 114 114 + 115 115 + ### Scheduled Posts 116 116 + 117 117 + - [ ] Schedule a post for a future time → confirmation shown 118 118 + - [ ] Post publishes at scheduled time (background task) 119 119 + 120 120 + ## 5. Search 121 121 + 122 122 + ### Post Search 123 123 + 124 124 + - [ ] Type query → results load 125 125 + - [ ] Sort toggle: "Top" vs "Latest" works 126 126 + - [ ] Tap result → thread view opens 127 127 + 128 128 + ### Actor Search 129 129 + 130 130 + - [ ] Switch to Actors tab → type query 131 131 + - [ ] Autocomplete suggestions appear as you type 132 132 + - [ ] Tap result → profile screen opens 133 133 + 134 134 + ### Starter Pack Search 135 135 + 136 136 + - [ ] Switch to Starter Packs tab → type query 137 137 + - [ ] Results show pack cards 138 138 + - [ ] Tap result → starter pack detail opens 139 139 + 140 140 + ### Search History 141 141 + 142 142 + - [ ] Recent searches appear below search bar 143 143 + - [ ] Tap history item → re-executes search 144 144 + - [ ] Swipe to delete a single entry 145 145 + - [ ] "Clear all" removes all history 146 146 + 147 147 + ## 6. Notifications 148 148 + 149 149 + ### Notification List 150 150 + 151 151 + - [ ] Alerts tab shows notifications (likes, reposts, follows, mentions, replies, quotes) 152 152 + - [ ] Grouped by day 153 153 + - [ ] Unread count badge on nav tab 154 154 + - [ ] Tap notification → navigates to post or profile 155 155 + - [ ] "Mark all as read" clears unread badge 156 156 + 157 157 + ### Unread Polling 158 158 + 159 159 + - [ ] Leave app open → badge count updates (30s poll interval) 160 160 + 161 161 + ## 7. Direct Messages 162 162 + 163 163 + ### Conversation List 164 164 + 165 165 + - [ ] Messages sub-tab shows conversations sorted by recency 166 166 + - [ ] Unread count per conversation displayed 167 167 + - [ ] Requests sub-tab shows unanswered conversations 168 168 + 169 169 + ### Message Thread 170 170 + 171 171 + - [ ] Tap conversation → message thread opens 172 172 + - [ ] Messages paginate (scroll up for older) 173 173 + - [ ] Own messages right-aligned, others left-aligned 174 174 + - [ ] Type and send a message → appears immediately 175 175 + - [ ] Tap message → copy option 176 176 + 177 177 + ### Conversation Actions 178 178 + 179 179 + - [ ] Mute conversation from overflow → muted indicator shown 180 180 + - [ ] Unmute → indicator removed 181 181 + 182 182 + ## 8. Profile 183 183 + 184 184 + ### Own Profile 185 185 + 186 186 + - [ ] Profile tab shows: banner, avatar, display name, handle, bio 187 187 + - [ ] Follower/following/post counts displayed 188 188 + - [ ] Posts tab → author's posts (no replies) 189 189 + - [ ] Replies tab → posts and threads 190 190 + - [ ] Media tab → only posts with media 191 191 + - [ ] Lists tab → lists created by user (Curation | Moderation sub-tabs) 192 192 + - [ ] Packs tab → starter packs created by user 193 193 + 194 194 + ### Other User's Profile 195 195 + 196 196 + - [ ] Tap user anywhere → their profile loads 197 197 + - [ ] Follow button shown → tap to follow → button changes 198 198 + - [ ] Unfollow → button reverts 199 199 + - [ ] Overflow: Mute, Block, Report, Copy DID, Share 200 200 + 201 201 + ### Suggested Follows 202 202 + 203 203 + - [ ] Overflow → "Suggested Follows" → sheet with suggestions 204 204 + - [ ] Follow/unfollow buttons in sheet work 205 205 + 206 206 + ## 9. Profile Context (Constellation) 207 207 + 208 208 + - [ ] Open profile context from profile overflow menu 209 209 + - [ ] **Blocked By** tab: shows count, "Show accounts" expands list 210 210 + - [ ] Paginated account tiles load 211 211 + - [ ] **Blocking** tab: shows outgoing blocks (own profile only) 212 212 + - [ ] Shows "unavailable" message for other profiles 213 213 + - [ ] **Lists** tab: shows lists user is a member of 214 214 + - [ ] List cards display: name, owner, purpose badge, description 215 215 + - [ ] Tap account → navigates to profile 216 216 + - [ ] Tap list → navigates to list detail 217 217 + 218 218 + ## 10. Post Thread 219 219 + 220 220 + - [ ] Thread loads: parent chain above, replies below 221 221 + - [ ] Root post visually highlighted 222 222 + - [ ] Nested reply chains render correctly 223 223 + - [ ] All post actions work within thread (like, repost, reply, save) 224 224 + - [ ] Tap profile in thread → profile screen 225 225 + 226 226 + ## 11. Lists 227 227 + 228 228 + ### My Lists 229 229 + 230 230 + - [ ] Navigate to lists screen 231 231 + - [ ] Curation and Moderation tabs separate lists correctly 232 232 + - [ ] Tap list → detail screen 233 233 + 234 234 + ### Create List 235 235 + 236 236 + - [ ] Tap FAB → create dialog 237 237 + - [ ] Enter name (1–64 graphemes), optional description, pick avatar 238 238 + - [ ] Select purpose (curation or moderation) 239 239 + - [ ] Save → list appears in My Lists 240 240 + 241 241 + ### List Detail 242 242 + 243 243 + - [ ] Header: name, avatar, description, creator, member count 244 244 + - [ ] Feed tab (curation lists): shows posts from members 245 245 + - [ ] Members tab: lists member profiles 246 246 + - [ ] Overflow: Edit, Delete, Add/Remove members 247 247 + 248 248 + ### List Members 249 249 + 250 250 + - [ ] Search for actors to add 251 251 + - [ ] Add member → appears in list 252 252 + - [ ] Remove member → removed from list 253 253 + 254 254 + ### Moderation Actions 255 255 + 256 256 + - [ ] Mute list → all members muted 257 257 + - [ ] Block via list → all members blocked 258 258 + 259 259 + ## 12. Starter Packs 260 260 + 261 261 + ### Starter Pack Detail 262 262 + 263 263 + - [ ] Header: name, description, creator 264 264 + - [ ] Stats: joined this week, joined all-time 265 265 + - [ ] Sample members displayed (up to 12) 266 266 + - [ ] Recommended feeds displayed (up to 3) 267 267 + - [ ] "See all members" → navigates to list members 268 268 + - [ ] "Follow all" → follows all members (with confirmation) 269 269 + 270 270 + ### Create Starter Pack 271 271 + 272 272 + - [ ] Tap create from own profile's Packs tab 273 273 + - [ ] Enter name (max 50 graphemes), optional description 274 274 + - [ ] Search and add members 275 275 + - [ ] Pick up to 3 feeds 276 276 + - [ ] Save → pack appears on profile 277 277 + 278 278 + ### Edit / Delete 279 279 + 280 280 + - [ ] Edit pack → update name, description, feeds 281 281 + - [ ] Delete pack → removed from profile 282 282 + 283 283 + ## 13. Media 284 284 + 285 285 + ### Image Viewer 286 286 + 287 287 + - [ ] Tap image → full-screen viewer 288 288 + - [ ] Pinch to zoom, pan around 289 289 + - [ ] Multi-image post → swipe between images 290 290 + - [ ] Alt text shown at bottom (if present) 291 291 + - [ ] Download → saved to gallery 292 292 + - [ ] Share → system sheet 293 293 + - [ ] Swipe down → dismiss viewer 294 294 + 295 295 + ### Video Player 296 296 + 297 297 + - [ ] Tap video → full-screen player 298 298 + - [ ] Play/pause, seek bar, mute controls work 299 299 + - [ ] Elapsed/total time displayed 300 300 + - [ ] Fullscreen toggle works 301 301 + 302 302 + ### Long-Press Context Menu 303 303 + 304 304 + - [ ] Long-press image thumbnail → Save / Share options 305 305 + 306 306 + --- 307 307 + 308 308 + ## 14. Saved Posts 309 309 + 310 310 + - [ ] Navigate to saved posts screen 311 311 + - [ ] Previously saved posts listed 312 312 + - [ ] Tap post → thread view 313 313 + - [ ] Unsave → removed from list 314 314 + - [ ] Empty state shown when no saved posts 315 315 + 316 316 + --- 317 317 + 318 318 + ## 15. Moderation & Labelers 319 319 + 320 320 + ### Content Filtering 321 321 + 322 322 + - [ ] Blurred content shows click-through overlay 323 323 + - [ ] Alert badge renders on warned content 324 324 + - [ ] Filtered content hidden from feeds 325 325 + - [ ] Media blur shows blurred images, text visible 326 326 + 327 327 + ### Labeler Management 328 328 + 329 329 + - [ ] Settings → Moderation → labeler list shown 330 330 + - [ ] Tap labeler → detail with label definitions 331 331 + - [ ] Toggle per-label preference (ignore/warn/hide) 332 332 + - [ ] Subscribe to new labeler 333 333 + - [ ] Unsubscribe from labeler 334 334 + - [ ] Adult content toggle gates 18+ labels 335 335 + 336 336 + --- 337 337 + 338 338 + ## 16. Connectivity & Offline 339 339 + 340 340 + ### Network Loss 341 341 + 342 342 + - [ ] Disable network → offline banner appears at top 343 343 + - [ ] Cached feed data still displays 344 344 + - [ ] Post actions (like, repost, compose) disabled with tooltip 345 345 + - [ ] Notifications/DMs show empty or cached state 346 346 + 347 347 + ### Network Restore 348 348 + 349 349 + - [ ] Re-enable network → banner disappears 350 350 + - [ ] Actions re-enabled 351 351 + - [ ] Pull-to-refresh loads fresh data 352 352 + 353 353 + ### Optimistic Updates 354 354 + 355 355 + - [ ] Like a post on slow connection → UI updates immediately 356 356 + - [ ] If API fails → UI rolls back, error snackbar shown 357 357 + 358 358 + --- 359 359 + 360 360 + ## 17. Settings & Preferences 361 361 + 362 362 + ### Theme 363 363 + 364 364 + - [ ] Change theme palette (Oxocarbon, Catppuccin, Nord, Rosé Pine) 365 365 + - [ ] Toggle Light / Dark / System mode 366 366 + - [ ] Theme applies immediately across all screens 367 367 + 368 368 + ### Account Switching 369 369 + 370 370 + - [ ] Open account switcher → all accounts listed 371 371 + - [ ] Switch to another account → feeds/profile reload for new account 372 372 + - [ ] Add new account → OAuth flow → account added to list 373 373 + 374 374 + ### Dev Tools 375 375 + 376 376 + - [ ] Logs: view logs, filter by level, search text, share log file 377 377 + - [ ] PDS Explorer: resolve handle, browse collections, view record JSON 378 378 + 379 379 + ### About 380 380 + 381 381 + - [ ] App version and build number displayed 382 382 + - [ ] Licenses accessible 383 383 + 384 384 + --- 385 385 + 386 386 + ## 18. Cross-Cutting Concerns 387 387 + 388 388 + ### Navigation 389 389 + 390 390 + - [ ] Bottom nav switches between Home, Search, Alerts, Profile 391 391 + - [ ] Back button / swipe-back navigates correctly through stack 392 392 + - [ ] Deep link to a post URI opens thread view 393 393 + 394 394 + ### Performance 395 395 + 396 396 + - [ ] Feed scroll is smooth (no jank) 397 397 + - [ ] Image loading doesn't block UI 398 398 + - [ ] Search results appear within reasonable time 399 399 + 400 400 + ### Error States 401 401 + 402 402 + - [ ] Invalid handle on login → error message shown 403 403 + - [ ] Network error on post submit → error snackbar, draft preserved 404 404 + - [ ] 404 on deleted post → appropriate error state 405 405 + 406 406 + ### State Persistence 407 407 + 408 408 + - [ ] Kill app mid-scroll → relaunch restores session 409 409 + - [ ] Drafts survive app restart 410 410 + - [ ] Saved posts survive app restart 411 411 + - [ ] Search history survives app restart 412 412 + - [ ] Theme selection survives app restart

+14 -14

docs/tasks/phase-5.md

reviewed

··· 1 1 --- 2 2 title: Phase 5 Task Breakdown 3 3 - updated: 2026-03-31 3 3 + updated: 2026-04-01 4 4 --- 5 5 6 6 # Phase 5 Milestones ··· 106 106 107 107 ### UI 108 108 109 109 - - [ ] Profile screen overflow menu - add "Profile Context" entry (available for all profiles) 110 110 - - [ ] Route: `/profile-context?did={DID}` in `app_router.dart` 111 111 - - [ ] `ProfileContextScreen` - `AppBar` (title + handle subtitle), `TabBar` with 3 tabs, `BlocProvider` creating cubit 112 112 - - [ ] **Blocked By tab** - count header, "Show accounts" expand, paginated profile tiles (avatar, name, handle), tap → profile navigation, contextualizing note text 113 113 - - [ ] **Blocking tab** - same layout; hidden or explanatory text when viewing other profiles 114 114 - - [ ] **Lists tab** - list cards (name, owner, purpose badge, member count, description), grouped by purpose, tap → `/list?uri=` 115 115 - - [ ] Per-tab states: skeleton shimmer (loading), contextual empty state, inline error with retry 116 116 - - [ ] Pull-to-refresh per tab 117 117 - - [ ] Infinite scroll pagination per tab 109 109 + - [x] Profile screen overflow menu - add "Profile Context" entry (available for all profiles) 110 110 + - [x] Route: `/profile-context?did={DID}` in `app_router.dart` 111 111 + - [x] `ProfileContextScreen` - `AppBar` (title + handle subtitle), `TabBar` with 3 tabs, `BlocProvider` creating cubit 112 112 + - [x] **Blocked By tab** - count header, "Show accounts" expand, paginated profile tiles (avatar, name, handle), tap → profile navigation, contextualizing note text 113 113 + - [x] **Blocking tab** - same layout; hidden or explanatory text when viewing other profiles 114 114 + - [x] **Lists tab** - list cards (name, owner, purpose badge, member count, description), grouped by purpose, tap → `/list?uri=` 115 115 + - [x] Per-tab states: skeleton shimmer (loading), contextual empty state, inline error with retry 116 116 + - [x] Pull-to-refresh per tab 117 117 + - [x] Infinite scroll pagination per tab 118 118 119 119 ### Tests 120 120 121 121 - - [ ] Unit tests: `ConstellationClient` - each endpoint method, error handling, timeout, URL construction 122 122 - - [ ] Unit tests: `ProfileContextRepository` - DID hydration batching, list URI derivation, cursor passthrough 123 123 - - [ ] Unit tests: `ProfileContextCubit` - state transitions for each tab, own-profile vs other-profile logic, pagination appending 124 124 - - [ ] Widget tests: screen renders 3 tabs, blocked-by count + expand, profile tiles render and navigate, list cards render and navigate, empty states, error + retry, blocking tab hidden for non-own profiles 121 121 + - [x] Unit tests: `ConstellationClient` - each endpoint method, error handling, timeout, URL construction 122 122 + - [x] Unit tests: `ProfileContextRepository` - DID hydration batching, list URI derivation, cursor passthrough 123 123 + - [x] Unit tests: `ProfileContextCubit` - state transitions for each tab, own-profile vs other-profile logic, pagination appending 124 124 + - [x] Widget tests: screen renders 3 tabs, blocked-by count + expand, profile tiles render and navigate, list cards render and navigate, empty states, error + retry, blocking tab hidden for non-own profiles

+3 -1

ios/Runner.xcodeproj/project.pbxproj

reviewed

··· 161 161 90899372CAA28BD74B2D49A1 /* Pods-RunnerTests.release.xcconfig */, 162 162 AA7C2CE85592DCD41249030A /* Pods-RunnerTests.profile.xcconfig */, 163 163 ); 164 164 - name = Pods; 165 164 path = Pods; 166 165 sourceTree = "<group>"; 167 166 }; ··· 490 489 CLANG_ENABLE_MODULES = YES; 491 490 CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; 492 491 ENABLE_BITCODE = NO; 492 492 + EXCLUDED_ARCHS = ""; 493 493 INFOPLIST_FILE = Runner/Info.plist; 494 494 LD_RUNPATH_SEARCH_PATHS = ( 495 495 "$(inherited)", ··· 672 672 CLANG_ENABLE_MODULES = YES; 673 673 CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; 674 674 ENABLE_BITCODE = NO; 675 675 + EXCLUDED_ARCHS = ""; 675 676 INFOPLIST_FILE = Runner/Info.plist; 676 677 LD_RUNPATH_SEARCH_PATHS = ( 677 678 "$(inherited)", ··· 694 695 CLANG_ENABLE_MODULES = YES; 695 696 CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; 696 697 ENABLE_BITCODE = NO; 698 698 + EXCLUDED_ARCHS = ""; 697 699 INFOPLIST_FILE = Runner/Info.plist; 698 700 LD_RUNPATH_SEARCH_PATHS = ( 699 701 "$(inherited)",

+33 -8

lib/core/network/constellation_client.dart

reviewed

··· 46 46 47 47 class ConstellationClient { 48 48 ConstellationClient({String? baseUrl, http.Client? httpClient}) 49 49 - : _baseUrl = baseUrl ?? _defaultBaseUrl, 49 49 + : _baseUrl = _normalizeBaseUrl(baseUrl), 50 50 _httpClient = httpClient ?? http.Client(); 51 51 52 52 final String _baseUrl; 53 53 final http.Client _httpClient; 54 54 55 55 + String get baseUrl => _baseUrl; 56 56 + 57 57 + static String _normalizeBaseUrl(String? baseUrl) { 58 58 + final trimmed = baseUrl?.trim(); 59 59 + if (trimmed == null || trimmed.isEmpty) { 60 60 + return _defaultBaseUrl; 61 61 + } 62 62 + 63 63 + return trimmed.replaceFirst(RegExp(r'/+$'), ''); 64 64 + } 65 65 + 55 66 Uri _xrpcUri(String endpoint, Map<String, String?> params) { 56 67 final filtered = <String, String>{}; 57 68 for (final entry in params.entries) { ··· 71 82 return jsonDecode(response.body) as Map<String, dynamic>; 72 83 } 73 84 85 85 + List<dynamic> _listField(Map<String, dynamic> data, String key) { 86 86 + final value = data[key]; 87 87 + if (value == null) return const []; 88 88 + return value as List<dynamic>; 89 89 + } 90 90 + 91 91 + List<dynamic> _listFieldAny(Map<String, dynamic> data, List<String> keys) { 92 92 + for (final key in keys) { 93 93 + if (data.containsKey(key) && data[key] != null) { 94 94 + return data[key] as List<dynamic>; 95 95 + } 96 96 + } 97 97 + return const []; 98 98 + } 99 99 + 74 100 Future<int> getBacklinksCount(String subject, String source) async { 75 101 final uri = _xrpcUri('blue.microcosm.links.getBacklinksCount', {'subject': subject, 'source': source}); 76 102 final data = await _get(uri); ··· 92 118 final data = await _get(uri); 93 119 return ( 94 120 total: data['total'] as int, 95 95 - dids: (data['dids'] as List<dynamic>).cast<String>(), 121 121 + dids: _listField(data, 'dids').cast<String>(), 96 122 cursor: data['cursor'] as String?, 97 123 ); 98 124 } ··· 110 136 'cursor': cursor, 111 137 }); 112 138 final data = await _get(uri); 113 113 - final records = (data['linking_records'] as List<dynamic>) 114 114 - .map((r) => ConstellationLinkRecord.fromJson(r as Map<String, dynamic>)) 115 115 - .toList(); 139 139 + final records = _listFieldAny(data, [ 140 140 + 'records', 141 141 + 'linking_records', 142 142 + ]).map((r) => ConstellationLinkRecord.fromJson(r as Map<String, dynamic>)).toList(); 116 143 return (total: data['total'] as int, records: records, cursor: data['cursor'] as String?); 117 144 } 118 145 ··· 131 158 'cursor': cursor, 132 159 }); 133 160 final data = await _get(uri); 134 134 - final items = (data['items'] as List<dynamic>) 135 135 - .map((i) => ManyToManyItem.fromJson(i as Map<String, dynamic>)) 136 136 - .toList(); 161 161 + final items = _listField(data, 'items').map((i) => ManyToManyItem.fromJson(i as Map<String, dynamic>)).toList(); 137 162 return (items: items, cursor: data['cursor'] as String?); 138 163 } 139 164 }

+1

lib/core/router/app_router.dart

reviewed

··· 195 195 final constellationUrl = context.read<SettingsCubit>().state.constellationUrl; 196 196 final repository = ProfileContextRepository( 197 197 bluesky: context.read<Bluesky>(), 198 198 + publicBluesky: Bluesky.anonymous(service: profileContextPublicAppViewService), 198 199 constellationClient: ConstellationClient(baseUrl: constellationUrl), 199 200 ); 200 201 return BlocProvider(

+2 -1

lib/features/profile/bloc/profile_bloc.dart

reviewed

··· 36 36 emit(state.copyWith(isRefreshing: true)); 37 37 38 38 try { 39 39 - final profile = await _profileRepository.getProfile(currentProfile.did); 39 39 + final actor = currentProfile.handle.isNotEmpty ? currentProfile.handle : currentProfile.did; 40 40 + final profile = await _profileRepository.getProfile(actor); 40 41 emit(ProfileState.loaded(profile: profile)); 41 42 } catch (error) { 42 43 emit(state.copyWith(isRefreshing: false));

+44 -14

lib/features/profile/cubit/profile_context_cubit.dart

reviewed

··· 14 14 15 15 final ProfileContextRepository _repository; 16 16 17 17 - /// Loads blocked-by and lists-on counts in parallel for tab header badges. 17 17 + /// Loads tab counts in parallel for the header badges. 18 18 Future<void> init() async { 19 19 - try { 20 20 - final results = await Future.wait([ 21 21 - _repository.getBlockedByCount(state.did), 22 22 - _repository.getListsOnCount(state.did), 23 23 - ]); 24 24 - emit(state.copyWith(blockedByCount: results[0], listsOnCount: results[1])); 25 25 - } catch (error) { 26 26 - log.w('failed to load initial counts: $error'); 27 27 - } 19 19 + final futures = <Future<int?>>[ 20 20 + _loadCount(() => _repository.getBlockedByCount(state.did), 'blocked-by'), 21 21 + _loadCount(() => _repository.getListsOnCount(state.did), 'lists-on'), 22 22 + if (state.isOwnProfile) _loadCount(() => _repository.getBlockingCount(state.did), 'blocking'), 23 23 + ]; 24 24 + final results = await Future.wait(futures); 25 25 + 26 26 + emit( 27 27 + state.copyWith( 28 28 + blockedByCount: results[0] ?? state.blockedByCount, 29 29 + listsOnCount: results[1] ?? state.listsOnCount, 30 30 + blockingCount: state.isOwnProfile ? (results[2] ?? state.blockingCount) : state.blockingCount, 31 31 + ), 32 32 + ); 28 33 } 29 34 30 35 /// Fetches a page of profiles that have blocked the viewed user and appends ··· 39 44 emit( 40 45 state.copyWith( 41 46 blockedByStatus: ProfileContextTabStatus.loaded, 42 42 - blockedByProfiles: [...state.blockedByProfiles, ...result.profiles], 47 47 + blockedByEntries: [...state.blockedByEntries, ...result.entries], 43 48 blockedByCount: result.total, 44 49 blockedByCursor: result.cursor, 45 50 blockedByHasMore: result.cursor != null, ··· 70 75 state.copyWith( 71 76 blockingStatus: ProfileContextTabStatus.loaded, 72 77 blockingProfiles: merged, 73 73 - blockingCount: merged.length, 78 78 + blockingUnavailable: _mergeUnavailable(state.blockingUnavailable, result.unavailable), 79 79 + blockingCount: merged.length > state.blockingCount ? merged.length : state.blockingCount, 74 80 blockingCursor: result.cursor, 75 81 blockingHasMore: result.cursor != null, 76 82 ), ··· 112 118 Future<void> refreshBlockedBy() async { 113 119 emit( 114 120 state.copyWith( 115 115 - blockedByProfiles: [], 121 121 + blockedByEntries: [], 116 122 blockedByCursor: null, 117 123 blockedByHasMore: false, 118 124 blockedByStatus: ProfileContextTabStatus.initial, ··· 128 134 emit( 129 135 state.copyWith( 130 136 blockingProfiles: [], 137 137 + blockingUnavailable: [], 131 138 blockingCursor: null, 132 139 blockingHasMore: false, 133 140 blockingStatus: ProfileContextTabStatus.initial, 134 141 blockingError: null, 135 135 - blockingCount: 0, 136 142 ), 137 143 ); 138 144 await loadBlocking(); 145 145 + final refreshedCount = await _loadCount(() => _repository.getBlockingCount(state.did), 'blocking'); 146 146 + if (refreshedCount != null) { 147 147 + emit(state.copyWith(blockingCount: refreshedCount)); 148 148 + } 139 149 } 140 150 141 151 /// Resets the lists-on list and reloads from the first page. ··· 150 160 ), 151 161 ); 152 162 await loadListsOn(); 163 163 + } 164 164 + 165 165 + Future<int?> _loadCount(Future<int> Function() loader, String label) async { 166 166 + try { 167 167 + return await loader(); 168 168 + } catch (error) { 169 169 + log.w('failed to load $label count: $error'); 170 170 + return null; 171 171 + } 172 172 + } 173 173 + 174 174 + List<UnavailableProfileRef> _mergeUnavailable( 175 175 + List<UnavailableProfileRef> existing, 176 176 + List<UnavailableProfileRef> incoming, 177 177 + ) { 178 178 + final merged = <String, UnavailableProfileRef>{for (final item in existing) item.did: item}; 179 179 + for (final item in incoming) { 180 180 + merged[item.did] = item; 181 181 + } 182 182 + return merged.values.toList(); 153 183 } 154 184 }

+10 -5

lib/features/profile/cubit/profile_context_state.dart

reviewed

··· 12 12 this.blockingCount = 0, 13 13 this.listsOnCount = 0, 14 14 this.blockedByStatus = ProfileContextTabStatus.initial, 15 15 - this.blockedByProfiles = const [], 15 15 + this.blockedByEntries = const [], 16 16 this.blockedByCursor, 17 17 this.blockedByHasMore = false, 18 18 this.blockedByError, 19 19 this.blockingStatus = ProfileContextTabStatus.initial, 20 20 this.blockingProfiles = const [], 21 21 + this.blockingUnavailable = const [], 21 22 this.blockingCursor, 22 23 this.blockingHasMore = false, 23 24 this.blockingError, ··· 39 40 final int listsOnCount; 40 41 41 42 final ProfileContextTabStatus blockedByStatus; 42 42 - final List<ProfileView> blockedByProfiles; 43 43 + final List<BlockedByEntry> blockedByEntries; 43 44 final String? blockedByCursor; 44 45 final bool blockedByHasMore; 45 46 final String? blockedByError; 46 47 47 48 final ProfileContextTabStatus blockingStatus; 48 49 final List<ProfileView> blockingProfiles; 50 50 + final List<UnavailableProfileRef> blockingUnavailable; 49 51 final String? blockingCursor; 50 52 final bool blockingHasMore; 51 53 final String? blockingError; ··· 61 63 int? blockingCount, 62 64 int? listsOnCount, 63 65 ProfileContextTabStatus? blockedByStatus, 64 64 - List<ProfileView>? blockedByProfiles, 66 66 + List<BlockedByEntry>? blockedByEntries, 65 67 Object? blockedByCursor = _profileContextNoValue, 66 68 bool? blockedByHasMore, 67 69 Object? blockedByError = _profileContextNoValue, 68 70 ProfileContextTabStatus? blockingStatus, 69 71 List<ProfileView>? blockingProfiles, 72 72 + List<UnavailableProfileRef>? blockingUnavailable, 70 73 Object? blockingCursor = _profileContextNoValue, 71 74 bool? blockingHasMore, 72 75 Object? blockingError = _profileContextNoValue, ··· 83 86 blockingCount: blockingCount ?? this.blockingCount, 84 87 listsOnCount: listsOnCount ?? this.listsOnCount, 85 88 blockedByStatus: blockedByStatus ?? this.blockedByStatus, 86 86 - blockedByProfiles: blockedByProfiles ?? this.blockedByProfiles, 89 89 + blockedByEntries: blockedByEntries ?? this.blockedByEntries, 87 90 blockedByCursor: identical(blockedByCursor, _profileContextNoValue) 88 91 ? this.blockedByCursor 89 92 : blockedByCursor as String?, ··· 93 96 : blockedByError as String?, 94 97 blockingStatus: blockingStatus ?? this.blockingStatus, 95 98 blockingProfiles: blockingProfiles ?? this.blockingProfiles, 99 99 + blockingUnavailable: blockingUnavailable ?? this.blockingUnavailable, 96 100 blockingCursor: identical(blockingCursor, _profileContextNoValue) 97 101 ? this.blockingCursor 98 102 : blockingCursor as String?, ··· 114 118 blockingCount, 115 119 listsOnCount, 116 120 blockedByStatus, 117 117 - blockedByProfiles, 121 121 + blockedByEntries, 118 122 blockedByCursor, 119 123 blockedByHasMore, 120 124 blockedByError, 121 125 blockingStatus, 122 126 blockingProfiles, 127 127 + blockingUnavailable, 123 128 blockingCursor, 124 129 blockingHasMore, 125 130 blockingError,

+315 -33

lib/features/profile/data/profile_context_repository.dart

reviewed

··· 1 1 import 'package:atproto_core/atproto_core.dart' show AtUri; 2 2 import 'package:bluesky/app_bsky_actor_defs.dart'; 3 3 import 'package:bluesky/app_bsky_graph_defs.dart'; 4 4 + import 'package:equatable/equatable.dart'; 5 5 + import 'package:lazurite/core/logging/app_logger.dart'; 4 6 import 'package:lazurite/core/network/constellation_client.dart'; 5 7 8 8 + const profileContextPublicAppViewService = 'public.api.bsky.app'; 9 9 + const _blockedByPageSize = 16; 10 10 + const _listsPageSize = 16; 11 11 + 12 12 + class UnavailableProfileRef extends Equatable { 13 13 + const UnavailableProfileRef({required this.did, required this.reason}); 14 14 + 15 15 + final String did; 16 16 + final String reason; 17 17 + 18 18 + @override 19 19 + List<Object?> get props => [did, reason]; 20 20 + } 21 21 + 22 22 + class BlockedByEntry extends Equatable { 23 23 + BlockedByEntry.profile({required ProfileView this.profile}) : did = profile.did, unavailableReason = null; 24 24 + 25 25 + const BlockedByEntry.unavailable({required this.did, required this.unavailableReason}) : profile = null; 26 26 + 27 27 + final String did; 28 28 + final ProfileView? profile; 29 29 + final String? unavailableReason; 30 30 + 31 31 + bool get isAvailable => profile != null; 32 32 + 33 33 + @override 34 34 + List<Object?> get props => [did, profile, unavailableReason]; 35 35 + } 36 36 + 6 37 class ProfileContextRepository { 7 7 - ProfileContextRepository({required dynamic bluesky, required ConstellationClient constellationClient}) 8 8 - : _bluesky = bluesky, 9 9 - _constellation = constellationClient; 38 38 + ProfileContextRepository({ 39 39 + required dynamic bluesky, 40 40 + dynamic publicBluesky, 41 41 + required ConstellationClient constellationClient, 42 42 + }) : _bluesky = bluesky, 43 43 + _publicBluesky = publicBluesky ?? bluesky, 44 44 + _constellation = constellationClient; 10 45 11 46 final dynamic _bluesky; 47 47 + final dynamic _publicBluesky; 12 48 final ConstellationClient _constellation; 13 49 14 50 /// Returns the number of accounts that have blocked [did]. ··· 23 59 24 60 /// Returns a page of profiles that have blocked [did], along with the total 25 61 /// count and a cursor for the next page. 26 26 - Future<({List<ProfileView> profiles, String? cursor, int total})> getBlockedByProfiles( 62 62 + Future<({List<BlockedByEntry> entries, String? cursor, int total})> getBlockedByProfiles( 27 63 String did, { 28 64 String? cursor, 29 65 }) async { 30 30 - final result = await _constellation.getDistinct( 31 31 - did, 32 32 - 'app.bsky.graph.block:subject', 33 33 - cursor: cursor, 66 66 + final offset = int.tryParse(cursor ?? '0') ?? 0; 67 67 + log.i('ProfileContextRepository: blocked-by load start for $did offset=$offset via ${_constellation.baseUrl}'); 68 68 + final collected = await _collectBlockedByDids(did); 69 69 + final hydrated = await _hydrateProfiles(collected.dids); 70 70 + final unavailableByDid = <String, String>{for (final entry in hydrated.unavailable) entry.did: entry.reason}; 71 71 + final profileByDid = <String, ProfileView>{for (final profile in hydrated.profiles) profile.did: profile}; 72 72 + 73 73 + final pageDids = collected.dids.skip(offset).take(_blockedByPageSize).toList(); 74 74 + final entries = <BlockedByEntry>[]; 75 75 + for (final pageDid in pageDids) { 76 76 + final profile = profileByDid[pageDid]; 77 77 + if (profile != null) { 78 78 + entries.add(BlockedByEntry.profile(profile: profile)); 79 79 + continue; 80 80 + } 81 81 + 82 82 + final unavailableReason = unavailableByDid[pageDid]; 83 83 + if (unavailableReason != null) { 84 84 + entries.add(BlockedByEntry.unavailable(did: pageDid, unavailableReason: unavailableReason)); 85 85 + } 86 86 + } 87 87 + 88 88 + final nextOffset = offset + _blockedByPageSize; 89 89 + log.i( 90 90 + 'ProfileContextRepository: blocked-by load complete for $did total=${collected.total} dids=${collected.dids.length} resolved=${hydrated.profiles.length} unavailable=${hydrated.unavailable.length} returned=${entries.length}', 91 91 + ); 92 92 + return ( 93 93 + entries: entries, 94 94 + cursor: nextOffset < collected.dids.length ? '$nextOffset' : null, 95 95 + total: collected.total, 34 96 ); 35 35 - final profiles = await _hydrateProfiles(result.dids); 36 36 - return (profiles: profiles, cursor: result.cursor, total: result.total); 97 97 + } 98 98 + 99 99 + /// Returns the total number of accounts that [did] is blocking. 100 100 + Future<int> getBlockingCount(String did) async { 101 101 + var total = 0; 102 102 + String? cursor; 103 103 + 104 104 + do { 105 105 + final response = await _bluesky.atproto.repo.listRecords( 106 106 + repo: did, 107 107 + collection: 'app.bsky.graph.block', 108 108 + limit: 100, 109 109 + cursor: cursor, 110 110 + ); 111 111 + 112 112 + total += (response.data.records as List<dynamic>).length; 113 113 + cursor = response.data.cursor as String?; 114 114 + } while (cursor != null); 115 115 + 116 116 + return total; 37 117 } 38 118 39 119 /// Returns a page of profiles that [did] is blocking, along with a cursor. 40 120 /// Uses `com.atproto.repo.listRecords` on the actor's own repo. 41 121 /// [total] reflects the number of profiles hydrated in this page. 42 42 - Future<({List<ProfileView> profiles, String? cursor, int total})> getBlockingProfiles( 43 43 - String did, { 44 44 - String? cursor, 45 45 - }) async { 122 122 + Future<({List<ProfileView> profiles, List<UnavailableProfileRef> unavailable, String? cursor, int total})> 123 123 + getBlockingProfiles(String did, {String? cursor}) async { 46 124 final response = await _bluesky.atproto.repo.listRecords( 47 125 repo: did, 48 126 collection: 'app.bsky.graph.block', ··· 50 128 cursor: cursor, 51 129 ); 52 130 53 53 - final subjectDids = (response.data.records as List<dynamic>) 54 54 - .map((r) => r.value['subject'] as String) 55 55 - .toList(); 56 56 - final profiles = await _hydrateProfiles(subjectDids); 57 57 - return (profiles: profiles, cursor: response.data.cursor as String?, total: profiles.length); 131 131 + final subjectDids = (response.data.records as List<dynamic>).map((r) => r.value['subject'] as String).toList(); 132 132 + final hydrated = await _hydrateProfiles(subjectDids); 133 133 + return ( 134 134 + profiles: hydrated.profiles, 135 135 + unavailable: hydrated.unavailable, 136 136 + cursor: response.data.cursor as String?, 137 137 + total: hydrated.profiles.length, 138 138 + ); 58 139 } 59 140 60 141 /// Returns a page of lists that [did] is a member of, along with the total ··· 65 146 did, 66 147 'app.bsky.graph.listitem:subject', 67 148 'list', 149 149 + limit: _listsPageSize, 68 150 cursor: cursor, 69 151 ); 70 152 71 71 - final lists = await Future.wait( 72 72 - result.items.map((item) async { 73 73 - final uri = AtUri.parse(item.otherSubject); 74 74 - final response = await _bluesky.graph.getList(list: uri, limit: 1); 75 75 - return response.data.list as ListView; 76 76 - }), 77 77 - ); 153 153 + final uniqueListUris = <String>{}; 154 154 + final listUris = <String>[]; 155 155 + for (final item in result.items) { 156 156 + if (uniqueListUris.add(item.otherSubject)) { 157 157 + listUris.add(item.otherSubject); 158 158 + } 159 159 + } 160 160 + 161 161 + final lists = <ListView>[]; 162 162 + for (final uriString in listUris) { 163 163 + try { 164 164 + final uri = AtUri.parse(uriString); 165 165 + final response = await _publicBluesky.graph.getList(list: uri, limit: 1); 166 166 + lists.add(response.data.list as ListView); 167 167 + } catch (error, stackTrace) { 168 168 + log.w( 169 169 + 'skipping invalid or unavailable list in profile context: $uriString', 170 170 + error: error, 171 171 + stackTrace: stackTrace, 172 172 + ); 173 173 + } 174 174 + } 78 175 79 176 return (lists: lists, cursor: result.cursor, total: total); 80 177 } 81 178 82 179 /// Hydrates [dids] into [ProfileView] objects in batches of 25. 83 83 - Future<List<ProfileView>> _hydrateProfiles(List<String> dids) async { 84 84 - if (dids.isEmpty) return []; 180 180 + Future<({List<ProfileView> profiles, List<UnavailableProfileRef> unavailable})> _hydrateProfiles( 181 181 + List<String> dids, 182 182 + ) async { 183 183 + final normalizedDids = _normalizeDids(dids); 184 184 + if (normalizedDids.isEmpty) { 185 185 + return (profiles: <ProfileView>[], unavailable: <UnavailableProfileRef>[]); 186 186 + } 187 187 + 85 188 final allProfiles = <ProfileView>[]; 86 86 - for (var i = 0; i < dids.length; i += 25) { 87 87 - final batch = dids.sublist(i, (i + 25).clamp(0, dids.length)); 88 88 - final response = await _bluesky.actor.getProfiles(actors: batch); 89 89 - allProfiles.addAll(response.data.profiles as List<ProfileView>); 189 189 + final unavailable = <UnavailableProfileRef>[]; 190 190 + for (var i = 0; i < normalizedDids.length; i += 25) { 191 191 + final batch = normalizedDids.sublist(i, (i + 25).clamp(0, normalizedDids.length)); 192 192 + final resolvedProfiles = <String, ProfileView>{}; 193 193 + log.d( 194 194 + 'ProfileContextRepository: blocked-by public batch ${i ~/ 25 + 1} size=${batch.length} dids=${batch.join(',')}', 195 195 + ); 196 196 + try { 197 197 + final response = await _publicBluesky.actor.getProfiles(actors: batch); 198 198 + for (final profile in response.data.profiles as List<dynamic>) { 199 199 + final converted = _asProfileView(profile); 200 200 + if (converted != null) { 201 201 + resolvedProfiles[converted.did] = converted; 202 202 + } 203 203 + } 204 204 + } catch (error, stackTrace) { 205 205 + log.w( 206 206 + 'ProfileContextRepository: blocked-by public batch failed, falling back to per-DID lookups for ${batch.length} actors', 207 207 + error: error, 208 208 + stackTrace: stackTrace, 209 209 + ); 210 210 + } 211 211 + 212 212 + for (final did in batch) { 213 213 + final existing = resolvedProfiles[did]; 214 214 + if (existing != null) { 215 215 + log.d('ProfileContextRepository: blocked-by public batch resolved $did'); 216 216 + allProfiles.add(existing); 217 217 + continue; 218 218 + } 219 219 + 220 220 + try { 221 221 + final response = await _publicBluesky.actor.getProfile(actor: did); 222 222 + final converted = _asProfileView(response.data); 223 223 + if (converted != null) { 224 224 + log.d('ProfileContextRepository: blocked-by per-DID resolved $did'); 225 225 + allProfiles.add(converted); 226 226 + } else { 227 227 + const reason = 'Public profile lookup failed'; 228 228 + unavailable.add(UnavailableProfileRef(did: did, reason: reason)); 229 229 + log.w('ProfileContextRepository: blocked-by per-DID returned an unsupported profile shape for $did'); 230 230 + } 231 231 + } catch (error, stackTrace) { 232 232 + final reason = _publicProfileFailureReason(error); 233 233 + unavailable.add(UnavailableProfileRef(did: did, reason: reason)); 234 234 + log.w( 235 235 + 'ProfileContextRepository: blocked-by per-DID failed for $did: $reason', 236 236 + error: error, 237 237 + stackTrace: stackTrace, 238 238 + ); 239 239 + } 240 240 + } 90 241 } 91 91 - return allProfiles; 242 242 + return (profiles: allProfiles, unavailable: unavailable); 92 243 } 244 244 + 245 245 + Future<({List<String> dids, int total})> _collectBlockedByDids(String did) async { 246 246 + try { 247 247 + final dids = <String>[]; 248 248 + final seen = <String>{}; 249 249 + var total = 0; 250 250 + String? cursor; 251 251 + log.i('ProfileContextRepository: blocked-by using getDistinct for $did'); 252 252 + 253 253 + do { 254 254 + final result = await _constellation.getDistinct( 255 255 + did, 256 256 + 'app.bsky.graph.block:subject', 257 257 + limit: _blockedByPageSize, 258 258 + cursor: cursor, 259 259 + ); 260 260 + final inputCursor = cursor; 261 261 + if (total == 0) { 262 262 + total = result.total; 263 263 + log.i('ProfileContextRepository: blocked-by count for $did is $total'); 264 264 + } 265 265 + for (final rawDid in result.dids) { 266 266 + final normalizedDid = _normalizeDid(rawDid); 267 267 + if (normalizedDid != null && seen.add(normalizedDid)) { 268 268 + dids.add(normalizedDid); 269 269 + } 270 270 + } 271 271 + cursor = result.cursor; 272 272 + log.d( 273 273 + 'ProfileContextRepository: blocked-by getDistinct page cursorIn=${inputCursor ?? 'null'} records=${result.dids.length} uniqueTotal=${dids.length} cursorOut=${cursor ?? 'null'}', 274 274 + ); 275 275 + } while (cursor != null); 276 276 + 277 277 + log.i('ProfileContextRepository: blocked-by collected ${dids.length} unique DIDs from getDistinct for $did'); 278 278 + return (dids: dids, total: total); 279 279 + } on ConstellationException catch (error) { 280 280 + if (!_isNotFound(error)) rethrow; 281 281 + log.w('ProfileContextRepository: blocked-by getDistinct returned 404 for $did, falling back to getBacklinks'); 282 282 + 283 283 + final dids = <String>[]; 284 284 + final seen = <String>{}; 285 285 + var total = 0; 286 286 + String? cursor; 287 287 + 288 288 + do { 289 289 + final result = await _constellation.getBacklinks( 290 290 + did, 291 291 + 'app.bsky.graph.block:subject', 292 292 + limit: _blockedByPageSize, 293 293 + cursor: cursor, 294 294 + ); 295 295 + final inputCursor = cursor; 296 296 + if (total == 0) { 297 297 + total = result.total; 298 298 + log.i('ProfileContextRepository: blocked-by count for $did is $total'); 299 299 + } 300 300 + for (final record in result.records) { 301 301 + final normalizedDid = _normalizeDid(record.did); 302 302 + if (normalizedDid != null && seen.add(normalizedDid)) { 303 303 + dids.add(normalizedDid); 304 304 + } 305 305 + } 306 306 + cursor = result.cursor; 307 307 + log.d( 308 308 + 'ProfileContextRepository: blocked-by getBacklinks page cursorIn=${inputCursor ?? 'null'} records=${result.records.length} uniqueTotal=${dids.length} cursorOut=${cursor ?? 'null'}', 309 309 + ); 310 310 + } while (cursor != null); 311 311 + 312 312 + log.i('ProfileContextRepository: blocked-by collected ${dids.length} unique DIDs from getBacklinks for $did'); 313 313 + return (dids: dids, total: total); 314 314 + } 315 315 + } 316 316 + 317 317 + List<String> _normalizeDids(List<String> dids) { 318 318 + final normalized = <String>[]; 319 319 + final seen = <String>{}; 320 320 + for (final did in dids) { 321 321 + final value = _normalizeDid(did); 322 322 + if (value != null && seen.add(value)) { 323 323 + normalized.add(value); 324 324 + } 325 325 + } 326 326 + return normalized; 327 327 + } 328 328 + 329 329 + String? _normalizeDid(String did) { 330 330 + final trimmed = did.trim(); 331 331 + if (trimmed.isEmpty) return null; 332 332 + return trimmed; 333 333 + } 334 334 + 335 335 + String _publicProfileFailureReason(Object error) { 336 336 + final message = error.toString(); 337 337 + final lowerMessage = message.toLowerCase(); 338 338 + if (message.contains('AccountTakedown') || lowerMessage.contains('account has been suspended')) { 339 339 + return 'Suspended account'; 340 340 + } 341 341 + if (message.contains('HTTP 404') || lowerMessage.contains('not found')) { 342 342 + return 'Profile unavailable'; 343 343 + } 344 344 + return 'Public profile lookup failed'; 345 345 + } 346 346 + 347 347 + ProfileView? _asProfileView(dynamic profile) { 348 348 + if (profile is ProfileView) { 349 349 + return profile; 350 350 + } 351 351 + 352 352 + if (profile is ProfileViewDetailed) { 353 353 + return ProfileView( 354 354 + did: profile.did, 355 355 + handle: profile.handle, 356 356 + displayName: profile.displayName, 357 357 + pronouns: profile.pronouns, 358 358 + description: profile.description, 359 359 + avatar: profile.avatar, 360 360 + associated: profile.associated, 361 361 + indexedAt: profile.indexedAt, 362 362 + createdAt: profile.createdAt, 363 363 + viewer: profile.viewer, 364 364 + labels: profile.labels, 365 365 + verification: profile.verification, 366 366 + status: profile.status, 367 367 + debug: profile.debug, 368 368 + ); 369 369 + } 370 370 + 371 371 + return null; 372 372 + } 373 373 + 374 374 + bool _isNotFound(ConstellationException error) => error.message.startsWith('HTTP 404'); 93 375 }

+479 -181

lib/features/profile/presentation/profile_context_screen.dart

reviewed

··· 1 1 import 'package:bluesky/app_bsky_actor_defs.dart'; 2 2 + import 'package:bluesky/app_bsky_graph_defs.dart' as bsky_graph; 2 3 import 'package:flutter/material.dart'; 3 4 import 'package:flutter_bloc/flutter_bloc.dart'; 4 5 import 'package:go_router/go_router.dart'; 5 5 - import 'package:lazurite/features/lists/presentation/widgets/list_row_tile.dart'; 6 6 import 'package:lazurite/features/moderation/presentation/widgets/moderated_avatar.dart'; 7 7 import 'package:lazurite/features/profile/cubit/profile_context_cubit.dart'; 8 8 + import 'package:lazurite/features/profile/data/profile_context_repository.dart'; 8 9 9 10 class ProfileContextScreen extends StatefulWidget { 10 11 const ProfileContextScreen({super.key, required this.handle}); ··· 113 114 114 115 return RefreshIndicator( 115 116 onRefresh: cubit.refreshBlockedBy, 116 116 - child: CustomScrollView( 117 117 - slivers: [ 118 118 - // Contextualizing note at the top. 119 119 - const SliverToBoxAdapter( 120 120 - child: Padding( 121 121 - padding: EdgeInsets.fromLTRB(16, 16, 16, 8), 122 122 - child: Text( 123 123 - 'Blocks are a normal part of social media. ' 124 124 - 'This data is public on the AT Protocol.', 125 125 - textAlign: TextAlign.center, 117 117 + child: NotificationListener<ScrollNotification>( 118 118 + onNotification: (notification) => _maybeLoadMore( 119 119 + notification: notification, 120 120 + status: state.blockedByStatus, 121 121 + hasMore: state.blockedByHasMore, 122 122 + cursor: state.blockedByCursor, 123 123 + onLoadMore: (cursor) => cubit.loadBlockedBy(cursor: cursor), 124 124 + ), 125 125 + child: CustomScrollView( 126 126 + physics: const AlwaysScrollableScrollPhysics(), 127 127 + slivers: [ 128 128 + // Contextualizing note at the top. 129 129 + const SliverToBoxAdapter( 130 130 + child: Padding( 131 131 + padding: EdgeInsets.fromLTRB(16, 16, 16, 8), 132 132 + child: Text( 133 133 + 'Blocks are a normal part of social media. ' 134 134 + 'This data is public on the AT Protocol.', 135 135 + textAlign: TextAlign.center, 136 136 + ), 126 137 ), 127 138 ), 128 128 - ), 129 129 - // Count header + expand button. 130 130 - SliverToBoxAdapter( 131 131 - child: Padding( 132 132 - padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8), 133 133 - child: Row( 134 134 - children: [ 135 135 - Text( 136 136 - '${state.blockedByCount} account${state.blockedByCount == 1 ? '' : 's'}', 137 137 - style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.w700), 138 138 - ), 139 139 - const Spacer(), 140 140 - if (state.blockedByStatus == ProfileContextTabStatus.initial) 141 141 - TextButton.icon( 142 142 - key: const Key('blocked_by_show_accounts'), 143 143 - onPressed: () => cubit.loadBlockedBy(), 144 144 - icon: const Icon(Icons.expand_more), 145 145 - label: const Text('Show accounts'), 139 139 + // Count header + expand button. 140 140 + SliverToBoxAdapter( 141 141 + child: Padding( 142 142 + padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8), 143 143 + child: Row( 144 144 + children: [ 145 145 + Text( 146 146 + '${state.blockedByCount} account${state.blockedByCount == 1 ? '' : 's'}', 147 147 + style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.w700), 146 148 ), 147 147 - ], 148 148 - ), 149 149 - ), 150 150 - ), 151 151 - // Content based on status. 152 152 - if (state.blockedByStatus == ProfileContextTabStatus.loading && state.blockedByProfiles.isEmpty) 153 153 - const SliverFillRemaining(hasScrollBody: false, child: Center(child: _ShimmerList())) 154 154 - else if (state.blockedByStatus == ProfileContextTabStatus.error && state.blockedByProfiles.isEmpty) 155 155 - SliverFillRemaining( 156 156 - hasScrollBody: false, 157 157 - child: Center( 158 158 - child: _ErrorRetry( 159 159 - message: state.blockedByError ?? 'Failed to load accounts', 160 160 - onRetry: () => cubit.loadBlockedBy(), 149 149 + const Spacer(), 150 150 + if (state.blockedByStatus == ProfileContextTabStatus.initial) 151 151 + TextButton.icon( 152 152 + key: const Key('blocked_by_show_accounts'), 153 153 + onPressed: () => cubit.loadBlockedBy(), 154 154 + icon: const Icon(Icons.expand_more), 155 155 + label: const Text('Show accounts'), 156 156 + ), 157 157 + ], 161 158 ), 162 159 ), 163 163 - ) 164 164 - else if (state.blockedByStatus == ProfileContextTabStatus.loaded && state.blockedByProfiles.isEmpty) 165 165 - const SliverFillRemaining( 166 166 - hasScrollBody: false, 167 167 - child: Center(child: Text('No accounts have blocked this user')), 168 168 - ) 169 169 - else ...[ 170 170 - SliverList.builder( 171 171 - itemCount: state.blockedByProfiles.length, 172 172 - itemBuilder: (context, index) { 173 173 - final profile = state.blockedByProfiles[index]; 174 174 - return _ProfileTile( 175 175 - key: ValueKey('blocked_by_${profile.did}'), 176 176 - profile: profile, 177 177 - onTap: () => context.push('/profile/view?actor=${profile.did}'), 178 178 - ); 179 179 - }, 180 160 ), 181 181 - if (state.blockedByStatus == ProfileContextTabStatus.loading) 182 182 - const SliverToBoxAdapter( 183 183 - child: Padding( 184 184 - padding: EdgeInsets.all(16), 185 185 - child: Center(child: CircularProgressIndicator()), 161 161 + // Content based on status. 162 162 + if (state.blockedByStatus == ProfileContextTabStatus.loading && state.blockedByEntries.isEmpty) 163 163 + const SliverFillRemaining(hasScrollBody: false, child: Center(child: _ShimmerList())) 164 164 + else if (state.blockedByStatus == ProfileContextTabStatus.error && state.blockedByEntries.isEmpty) 165 165 + SliverFillRemaining( 166 166 + hasScrollBody: false, 167 167 + child: Center( 168 168 + child: _ErrorRetry( 169 169 + message: state.blockedByError ?? 'Failed to load accounts', 170 170 + onRetry: () => cubit.loadBlockedBy(), 171 171 + ), 186 172 ), 187 173 ) 188 188 - else if (state.blockedByStatus == ProfileContextTabStatus.error) 189 189 - SliverToBoxAdapter( 190 190 - child: Padding( 191 191 - padding: const EdgeInsets.all(16), 192 192 - child: _ErrorRetry( 193 193 - message: state.blockedByError ?? 'Failed to load more', 194 194 - onRetry: () => cubit.loadBlockedBy(cursor: state.blockedByCursor), 174 174 + else if (state.blockedByStatus == ProfileContextTabStatus.loaded && state.blockedByEntries.isEmpty) 175 175 + SliverFillRemaining( 176 176 + hasScrollBody: false, 177 177 + child: Center( 178 178 + child: Text( 179 179 + state.blockedByCount > 0 180 180 + ? 'Found ${state.blockedByCount} blocked-by accounts, but public Bluesky profile details could not be loaded.' 181 181 + : 'No accounts have blocked this user', 182 182 + textAlign: TextAlign.center, 195 183 ), 196 184 ), 197 185 ) 198 198 - else if (state.blockedByHasMore) 199 199 - SliverToBoxAdapter( 200 200 - child: Padding( 201 201 - padding: const EdgeInsets.all(16), 202 202 - child: Center( 203 203 - child: TextButton( 204 204 - onPressed: () => cubit.loadBlockedBy(cursor: state.blockedByCursor), 205 205 - child: const Text('Load more'), 186 186 + else ...[ 187 187 + SliverList.builder( 188 188 + itemCount: state.blockedByEntries.length, 189 189 + itemBuilder: (context, index) { 190 190 + final entry = state.blockedByEntries[index]; 191 191 + if (entry.profile != null) { 192 192 + final profile = entry.profile!; 193 193 + return _ProfileTile( 194 194 + key: ValueKey('blocked_by_${profile.did}'), 195 195 + profile: profile, 196 196 + onTap: () => 197 197 + context.push('/profile/view?actor=${Uri.encodeQueryComponent(_profileActor(profile))}'), 198 198 + ); 199 199 + } 200 200 + 201 201 + return _UnavailableProfileTile( 202 202 + key: ValueKey('blocked_by_unavailable_${entry.did}'), 203 203 + did: entry.did, 204 204 + reason: entry.unavailableReason ?? 'Profile unavailable', 205 205 + ); 206 206 + }, 207 207 + ), 208 208 + if (state.blockedByStatus == ProfileContextTabStatus.loading) 209 209 + const SliverToBoxAdapter( 210 210 + child: Padding( 211 211 + padding: EdgeInsets.all(16), 212 212 + child: Center(child: CircularProgressIndicator()), 213 213 + ), 214 214 + ) 215 215 + else if (state.blockedByStatus == ProfileContextTabStatus.error) 216 216 + SliverToBoxAdapter( 217 217 + child: Padding( 218 218 + padding: const EdgeInsets.all(16), 219 219 + child: _ErrorRetry( 220 220 + message: state.blockedByError ?? 'Failed to load more', 221 221 + onRetry: () => cubit.loadBlockedBy(cursor: state.blockedByCursor), 206 222 ), 207 223 ), 208 224 ), 209 209 - ), 225 225 + ], 210 226 ], 211 211 - ], 227 227 + ), 212 228 ), 213 229 ); 214 230 } ··· 241 257 242 258 return RefreshIndicator( 243 259 onRefresh: cubit.refreshBlocking, 244 244 - child: CustomScrollView( 245 245 - slivers: [ 246 246 - if (state.blockingStatus == ProfileContextTabStatus.initial || 247 247 - (state.blockingStatus == ProfileContextTabStatus.loading && state.blockingProfiles.isEmpty)) 248 248 - const SliverFillRemaining(hasScrollBody: false, child: Center(child: _ShimmerList())) 249 249 - else if (state.blockingStatus == ProfileContextTabStatus.error && state.blockingProfiles.isEmpty) 250 250 - SliverFillRemaining( 251 251 - hasScrollBody: false, 252 252 - child: Center( 253 253 - child: _ErrorRetry( 254 254 - message: state.blockingError ?? 'Failed to load accounts', 255 255 - onRetry: () => cubit.loadBlocking(), 260 260 + child: NotificationListener<ScrollNotification>( 261 261 + onNotification: (notification) => _maybeLoadMore( 262 262 + notification: notification, 263 263 + status: state.blockingStatus, 264 264 + hasMore: state.blockingHasMore, 265 265 + cursor: state.blockingCursor, 266 266 + onLoadMore: (cursor) => cubit.loadBlocking(cursor: cursor), 267 267 + ), 268 268 + child: CustomScrollView( 269 269 + physics: const AlwaysScrollableScrollPhysics(), 270 270 + slivers: [ 271 271 + SliverToBoxAdapter( 272 272 + child: Padding( 273 273 + padding: const EdgeInsets.fromLTRB(16, 16, 16, 8), 274 274 + child: Text( 275 275 + '${state.blockingCount} account${state.blockingCount == 1 ? '' : 's'}', 276 276 + style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.w700), 256 277 ), 257 278 ), 258 258 - ) 259 259 - else if (state.blockingStatus == ProfileContextTabStatus.loaded && state.blockingProfiles.isEmpty) 260 260 - const SliverFillRemaining(hasScrollBody: false, child: Center(child: Text('Not blocking anyone'))) 261 261 - else ...[ 262 262 - SliverList.builder( 263 263 - itemCount: state.blockingProfiles.length, 264 264 - itemBuilder: (context, index) { 265 265 - final profile = state.blockingProfiles[index]; 266 266 - return _ProfileTile( 267 267 - key: ValueKey('blocking_${profile.did}'), 268 268 - profile: profile, 269 269 - onTap: () => context.push('/profile/view?actor=${profile.did}'), 270 270 - ); 271 271 - }, 272 279 ), 273 273 - if (state.blockingStatus == ProfileContextTabStatus.loading) 274 274 - const SliverToBoxAdapter( 280 280 + if (state.blockingUnavailable.isNotEmpty) 281 281 + SliverToBoxAdapter( 275 282 child: Padding( 276 276 - padding: EdgeInsets.all(16), 277 277 - child: Center(child: CircularProgressIndicator()), 283 283 + padding: const EdgeInsets.fromLTRB(16, 0, 16, 8), 284 284 + child: _UnavailableAccountsCard(entries: state.blockingUnavailable), 285 285 + ), 286 286 + ), 287 287 + if (state.blockingStatus == ProfileContextTabStatus.initial || 288 288 + (state.blockingStatus == ProfileContextTabStatus.loading && state.blockingProfiles.isEmpty)) 289 289 + const SliverFillRemaining(hasScrollBody: false, child: Center(child: _ShimmerList())) 290 290 + else if (state.blockingStatus == ProfileContextTabStatus.error && state.blockingProfiles.isEmpty) 291 291 + SliverFillRemaining( 292 292 + hasScrollBody: false, 293 293 + child: Center( 294 294 + child: _ErrorRetry( 295 295 + message: state.blockingError ?? 'Failed to load accounts', 296 296 + onRetry: () => cubit.loadBlocking(), 297 297 + ), 278 298 ), 279 299 ) 280 280 - else if (state.blockingStatus == ProfileContextTabStatus.error) 281 281 - SliverToBoxAdapter( 282 282 - child: Padding( 283 283 - padding: const EdgeInsets.all(16), 284 284 - child: _ErrorRetry( 285 285 - message: state.blockingError ?? 'Failed to load more', 286 286 - onRetry: () => cubit.loadBlocking(cursor: state.blockingCursor), 300 300 + else if (state.blockingStatus == ProfileContextTabStatus.loaded && state.blockingProfiles.isEmpty) 301 301 + SliverFillRemaining( 302 302 + hasScrollBody: false, 303 303 + child: Center( 304 304 + child: Text( 305 305 + state.blockingUnavailable.isNotEmpty 306 306 + ? 'Some blocked accounts are suspended or unavailable.' 307 307 + : 'Not blocking anyone', 308 308 + textAlign: TextAlign.center, 287 309 ), 288 310 ), 289 311 ) 290 290 - else if (state.blockingHasMore) 291 291 - SliverToBoxAdapter( 292 292 - child: Padding( 293 293 - padding: const EdgeInsets.all(16), 294 294 - child: Center( 295 295 - child: TextButton( 296 296 - onPressed: () => cubit.loadBlocking(cursor: state.blockingCursor), 297 297 - child: const Text('Load more'), 312 312 + else ...[ 313 313 + SliverList.builder( 314 314 + itemCount: state.blockingProfiles.length, 315 315 + itemBuilder: (context, index) { 316 316 + final profile = state.blockingProfiles[index]; 317 317 + return _ProfileTile( 318 318 + key: ValueKey('blocking_${profile.did}'), 319 319 + profile: profile, 320 320 + onTap: () => 321 321 + context.push('/profile/view?actor=${Uri.encodeQueryComponent(_profileActor(profile))}'), 322 322 + ); 323 323 + }, 324 324 + ), 325 325 + if (state.blockingStatus == ProfileContextTabStatus.loading) 326 326 + const SliverToBoxAdapter( 327 327 + child: Padding( 328 328 + padding: EdgeInsets.all(16), 329 329 + child: Center(child: CircularProgressIndicator()), 330 330 + ), 331 331 + ) 332 332 + else if (state.blockingStatus == ProfileContextTabStatus.error) 333 333 + SliverToBoxAdapter( 334 334 + child: Padding( 335 335 + padding: const EdgeInsets.all(16), 336 336 + child: _ErrorRetry( 337 337 + message: state.blockingError ?? 'Failed to load more', 338 338 + onRetry: () => cubit.loadBlocking(cursor: state.blockingCursor), 298 339 ), 299 340 ), 300 341 ), 301 301 - ), 342 342 + ], 302 343 ], 303 303 - ], 344 344 + ), 304 345 ), 305 346 ); 306 347 } ··· 321 362 322 363 return RefreshIndicator( 323 364 onRefresh: cubit.refreshListsOn, 324 324 - child: CustomScrollView( 325 325 - slivers: [ 326 326 - if (state.listsOnStatus == ProfileContextTabStatus.initial || 327 327 - (state.listsOnStatus == ProfileContextTabStatus.loading && state.listsOn.isEmpty)) 328 328 - const SliverFillRemaining(hasScrollBody: false, child: Center(child: _ShimmerList())) 329 329 - else if (state.listsOnStatus == ProfileContextTabStatus.error && state.listsOn.isEmpty) 330 330 - SliverFillRemaining( 331 331 - hasScrollBody: false, 332 332 - child: Center( 333 333 - child: _ErrorRetry( 334 334 - message: state.listsOnError ?? 'Failed to load lists', 335 335 - onRetry: () => cubit.loadListsOn(), 336 336 - ), 337 337 - ), 338 338 - ) 339 339 - else if (state.listsOnStatus == ProfileContextTabStatus.loaded && state.listsOn.isEmpty) 340 340 - const SliverFillRemaining(hasScrollBody: false, child: Center(child: Text('Not on any lists'))) 341 341 - else ...[ 342 342 - SliverList.builder( 343 343 - itemCount: state.listsOn.length, 344 344 - itemBuilder: (context, index) { 345 345 - final list = state.listsOn[index]; 346 346 - return ListRowTile( 347 347 - key: ValueKey('list_on_${list.uri}'), 348 348 - list: list, 349 349 - onTap: () => context.push('/list?uri=${Uri.encodeComponent(list.uri.toString())}'), 350 350 - ); 351 351 - }, 352 352 - ), 353 353 - if (state.listsOnStatus == ProfileContextTabStatus.loading) 354 354 - const SliverToBoxAdapter( 355 355 - child: Padding( 356 356 - padding: EdgeInsets.all(16), 357 357 - child: Center(child: CircularProgressIndicator()), 358 358 - ), 359 359 - ) 360 360 - else if (state.listsOnStatus == ProfileContextTabStatus.error) 361 361 - SliverToBoxAdapter( 362 362 - child: Padding( 363 363 - padding: const EdgeInsets.all(16), 365 365 + child: NotificationListener<ScrollNotification>( 366 366 + onNotification: (notification) => _maybeLoadMore( 367 367 + notification: notification, 368 368 + status: state.listsOnStatus, 369 369 + hasMore: state.listsOnHasMore, 370 370 + cursor: state.listsOnCursor, 371 371 + onLoadMore: (cursor) => cubit.loadListsOn(cursor: cursor), 372 372 + ), 373 373 + child: CustomScrollView( 374 374 + physics: const AlwaysScrollableScrollPhysics(), 375 375 + slivers: [ 376 376 + if (state.listsOnStatus == ProfileContextTabStatus.initial || 377 377 + (state.listsOnStatus == ProfileContextTabStatus.loading && state.listsOn.isEmpty)) 378 378 + const SliverFillRemaining(hasScrollBody: false, child: Center(child: _ShimmerList())) 379 379 + else if (state.listsOnStatus == ProfileContextTabStatus.error && state.listsOn.isEmpty) 380 380 + SliverFillRemaining( 381 381 + hasScrollBody: false, 382 382 + child: Center( 364 383 child: _ErrorRetry( 365 365 - message: state.listsOnError ?? 'Failed to load more', 366 366 - onRetry: () => cubit.loadListsOn(cursor: state.listsOnCursor), 384 384 + message: state.listsOnError ?? 'Failed to load lists', 385 385 + onRetry: () => cubit.loadListsOn(), 367 386 ), 368 387 ), 369 388 ) 370 370 - else if (state.listsOnHasMore) 371 371 - SliverToBoxAdapter( 372 372 - child: Padding( 373 373 - padding: const EdgeInsets.all(16), 374 374 - child: Center( 375 375 - child: TextButton( 376 376 - onPressed: () => cubit.loadListsOn(cursor: state.listsOnCursor), 377 377 - child: const Text('Load more'), 389 389 + else if (state.listsOnStatus == ProfileContextTabStatus.loaded && state.listsOn.isEmpty) 390 390 + const SliverFillRemaining(hasScrollBody: false, child: Center(child: Text('Not on any lists'))) 391 391 + else ...[ 392 392 + ..._buildListSections( 393 393 + context, 394 394 + state.listsOn, 395 395 + (list) => context.push('/list?uri=${Uri.encodeComponent(list.uri.toString())}'), 396 396 + ), 397 397 + if (state.listsOnStatus == ProfileContextTabStatus.loading) 398 398 + const SliverToBoxAdapter( 399 399 + child: Padding( 400 400 + padding: EdgeInsets.all(16), 401 401 + child: Center(child: CircularProgressIndicator()), 402 402 + ), 403 403 + ) 404 404 + else if (state.listsOnStatus == ProfileContextTabStatus.error) 405 405 + SliverToBoxAdapter( 406 406 + child: Padding( 407 407 + padding: const EdgeInsets.all(16), 408 408 + child: _ErrorRetry( 409 409 + message: state.listsOnError ?? 'Failed to load more', 410 410 + onRetry: () => cubit.loadListsOn(cursor: state.listsOnCursor), 378 411 ), 379 412 ), 380 413 ), 381 381 - ), 414 414 + ], 382 415 ], 383 383 - ], 416 416 + ), 384 417 ), 385 418 ); 386 419 } ··· 415 448 if (parts.isEmpty || parts.first.isEmpty) return '?'; 416 449 if (parts.length == 1) return parts.first.substring(0, 1).toUpperCase(); 417 450 return '${parts.first.substring(0, 1)}${parts.last.substring(0, 1)}'.toUpperCase(); 451 451 + } 452 452 + } 453 453 + 454 454 + class _UnavailableAccountsCard extends StatelessWidget { 455 455 + const _UnavailableAccountsCard({required this.entries}); 456 456 + 457 457 + final List<UnavailableProfileRef> entries; 458 458 + 459 459 + @override 460 460 + Widget build(BuildContext context) { 461 461 + final colorScheme = Theme.of(context).colorScheme; 462 462 + return Card( 463 463 + child: Padding( 464 464 + padding: const EdgeInsets.symmetric(vertical: 8), 465 465 + child: Column( 466 466 + crossAxisAlignment: CrossAxisAlignment.start, 467 467 + children: [ 468 468 + ListTile( 469 469 + leading: const Icon(Icons.warning_amber_rounded), 470 470 + title: Text('Unavailable accounts (${entries.length})'), 471 471 + subtitle: const Text('These accounts are suspended or their public profile could not be fetched.'), 472 472 + ), 473 473 + for (final entry in entries) 474 474 + ListTile( 475 475 + dense: true, 476 476 + leading: Icon(Icons.person_off_outlined, color: colorScheme.onSurfaceVariant), 477 477 + title: Text(entry.did, maxLines: 1, overflow: TextOverflow.ellipsis), 478 478 + subtitle: Text(entry.reason), 479 479 + ), 480 480 + ], 481 481 + ), 482 482 + ), 483 483 + ); 484 484 + } 485 485 + } 486 486 + 487 487 + class _UnavailableProfileTile extends StatelessWidget { 488 488 + const _UnavailableProfileTile({super.key, required this.did, required this.reason}); 489 489 + 490 490 + final String did; 491 491 + final String reason; 492 492 + 493 493 + @override 494 494 + Widget build(BuildContext context) { 495 495 + final colorScheme = Theme.of(context).colorScheme; 496 496 + return ListTile( 497 497 + leading: Icon(Icons.person_off_outlined, color: colorScheme.onSurfaceVariant), 498 498 + title: Text(did, maxLines: 1, overflow: TextOverflow.ellipsis), 499 499 + subtitle: Text(reason), 500 500 + enabled: false, 501 501 + ); 502 502 + } 503 503 + } 504 504 + 505 505 + String _profileActor(ProfileView profile) { 506 506 + final handle = profile.handle.trim(); 507 507 + return handle.isNotEmpty ? handle : profile.did; 508 508 + } 509 509 + 510 510 + bool _maybeLoadMore({ 511 511 + required ScrollNotification notification, 512 512 + required ProfileContextTabStatus status, 513 513 + required bool hasMore, 514 514 + required String? cursor, 515 515 + required ValueChanged<String?> onLoadMore, 516 516 + }) { 517 517 + if (notification.metrics.extentAfter > 300 || 518 518 + status == ProfileContextTabStatus.loading || 519 519 + !hasMore || 520 520 + cursor == null) { 521 521 + return false; 522 522 + } 523 523 + 524 524 + onLoadMore(cursor); 525 525 + return false; 526 526 + } 527 527 + 528 528 + List<Widget> _buildListSections( 529 529 + BuildContext context, 530 530 + List<bsky_graph.ListView> lists, 531 531 + ValueChanged<bsky_graph.ListView> onTap, 532 532 + ) { 533 533 + final sections = _groupListsByPurpose(lists); 534 534 + return [ 535 535 + for (final section in sections) ...[ 536 536 + SliverToBoxAdapter( 537 537 + child: Padding( 538 538 + padding: const EdgeInsets.fromLTRB(16, 16, 16, 8), 539 539 + child: Text( 540 540 + section.title, 541 541 + style: Theme.of(context).textTheme.titleSmall?.copyWith(fontWeight: FontWeight.w700), 542 542 + ), 543 543 + ), 544 544 + ), 545 545 + SliverList.builder( 546 546 + itemCount: section.lists.length, 547 547 + itemBuilder: (context, index) { 548 548 + final list = section.lists[index]; 549 549 + return _ListContextCard(key: ValueKey('list_on_${list.uri}'), list: list, onTap: () => onTap(list)); 550 550 + }, 551 551 + ), 552 552 + ], 553 553 + ]; 554 554 + } 555 555 + 556 556 + List<({String title, List<bsky_graph.ListView> lists})> _groupListsByPurpose(List<bsky_graph.ListView> lists) { 557 557 + final buckets = <_ListPurposeGroup, List<bsky_graph.ListView>>{ 558 558 + _ListPurposeGroup.curation: [], 559 559 + _ListPurposeGroup.moderation: [], 560 560 + _ListPurposeGroup.reference: [], 561 561 + _ListPurposeGroup.other: [], 562 562 + }; 563 563 + 564 564 + for (final list in lists) { 565 565 + buckets[_purposeGroupFor(list)]!.add(list); 566 566 + } 567 567 + 568 568 + return [ 569 569 + (title: 'Curation Lists', lists: buckets[_ListPurposeGroup.curation]!), 570 570 + (title: 'Moderation Lists', lists: buckets[_ListPurposeGroup.moderation]!), 571 571 + (title: 'Reference Lists', lists: buckets[_ListPurposeGroup.reference]!), 572 572 + (title: 'Other Lists', lists: buckets[_ListPurposeGroup.other]!), 573 573 + ].where((section) => section.lists.isNotEmpty).toList(); 574 574 + } 575 575 + 576 576 + _ListPurposeGroup _purposeGroupFor(bsky_graph.ListView list) { 577 577 + switch (list.purpose.knownValue) { 578 578 + case bsky_graph.KnownListPurpose.appBskyGraphDefsCuratelist: 579 579 + return _ListPurposeGroup.curation; 580 580 + case bsky_graph.KnownListPurpose.appBskyGraphDefsModlist: 581 581 + return _ListPurposeGroup.moderation; 582 582 + case bsky_graph.KnownListPurpose.appBskyGraphDefsReferencelist: 583 583 + return _ListPurposeGroup.reference; 584 584 + case null: 585 585 + return _ListPurposeGroup.other; 586 586 + } 587 587 + } 588 588 + 589 589 + enum _ListPurposeGroup { curation, moderation, reference, other } 590 590 + 591 591 + class _ListContextCard extends StatelessWidget { 592 592 + const _ListContextCard({super.key, required this.list, this.onTap}); 593 593 + 594 594 + final bsky_graph.ListView list; 595 595 + final VoidCallback? onTap; 596 596 + 597 597 + @override 598 598 + Widget build(BuildContext context) { 599 599 + final colorScheme = Theme.of(context).colorScheme; 600 600 + final description = list.description?.trim(); 601 601 + 602 602 + return Padding( 603 603 + padding: const EdgeInsets.fromLTRB(16, 0, 16, 12), 604 604 + child: Card( 605 605 + margin: EdgeInsets.zero, 606 606 + clipBehavior: Clip.antiAlias, 607 607 + child: InkWell( 608 608 + onTap: onTap, 609 609 + child: Padding( 610 610 + padding: const EdgeInsets.all(16), 611 611 + child: Column( 612 612 + crossAxisAlignment: CrossAxisAlignment.start, 613 613 + children: [ 614 614 + Row( 615 615 + crossAxisAlignment: CrossAxisAlignment.start, 616 616 + children: [ 617 617 + CircleAvatar( 618 618 + backgroundImage: list.avatar != null ? NetworkImage(list.avatar!) : null, 619 619 + backgroundColor: colorScheme.surfaceContainerHighest, 620 620 + child: list.avatar == null ? Icon(Icons.list, color: colorScheme.onSurfaceVariant) : null, 621 621 + ), 622 622 + const SizedBox(width: 12), 623 623 + Expanded( 624 624 + child: Column( 625 625 + crossAxisAlignment: CrossAxisAlignment.start, 626 626 + children: [ 627 627 + Text(list.name, maxLines: 1, overflow: TextOverflow.ellipsis), 628 628 + const SizedBox(height: 4), 629 629 + Text( 630 630 + '@${list.creator.handle}', 631 631 + maxLines: 1, 632 632 + overflow: TextOverflow.ellipsis, 633 633 + style: Theme.of(context).textTheme.bodySmall?.copyWith(color: colorScheme.onSurfaceVariant), 634 634 + ), 635 635 + ], 636 636 + ), 637 637 + ), 638 638 + const SizedBox(width: 12), 639 639 + _ListPurposeBadge(purpose: list.purpose.knownValue), 640 640 + ], 641 641 + ), 642 642 + const SizedBox(height: 12), 643 643 + _ListMetaChip( 644 644 + icon: Icons.group_outlined, 645 645 + label: '${list.listItemCount ?? 0} member${(list.listItemCount ?? 0) == 1 ? '' : 's'}', 646 646 + ), 647 647 + if (description != null && description.isNotEmpty) ...[ 648 648 + const SizedBox(height: 12), 649 649 + Text(description, maxLines: 2, overflow: TextOverflow.ellipsis), 650 650 + ], 651 651 + ], 652 652 + ), 653 653 + ), 654 654 + ), 655 655 + ), 656 656 + ); 657 657 + } 658 658 + } 659 659 + 660 660 + class _ListPurposeBadge extends StatelessWidget { 661 661 + const _ListPurposeBadge({required this.purpose}); 662 662 + 663 663 + final bsky_graph.KnownListPurpose? purpose; 664 664 + 665 665 + @override 666 666 + Widget build(BuildContext context) { 667 667 + final colorScheme = Theme.of(context).colorScheme; 668 668 + final (label, color) = switch (purpose) { 669 669 + bsky_graph.KnownListPurpose.appBskyGraphDefsCuratelist => ('CURATE', colorScheme.primary), 670 670 + bsky_graph.KnownListPurpose.appBskyGraphDefsModlist => ('MOD', colorScheme.error), 671 671 + bsky_graph.KnownListPurpose.appBskyGraphDefsReferencelist => ('REFERENCE', colorScheme.tertiary), 672 672 + null => ('LIST', colorScheme.secondary), 673 673 + }; 674 674 + 675 675 + return Container( 676 676 + padding: const EdgeInsets.symmetric(horizontal: 10, vertical: 6), 677 677 + decoration: BoxDecoration( 678 678 + color: color.withValues(alpha: 0.1), 679 679 + borderRadius: BorderRadius.circular(999), 680 680 + border: Border.all(color: color.withValues(alpha: 0.25)), 681 681 + ), 682 682 + child: Text( 683 683 + label, 684 684 + style: Theme.of( 685 685 + context, 686 686 + ).textTheme.labelSmall?.copyWith(fontWeight: FontWeight.w700, color: color, letterSpacing: 0.6), 687 687 + ), 688 688 + ); 689 689 + } 690 690 + } 691 691 + 692 692 + class _ListMetaChip extends StatelessWidget { 693 693 + const _ListMetaChip({required this.icon, required this.label}); 694 694 + 695 695 + final IconData icon; 696 696 + final String label; 697 697 + 698 698 + @override 699 699 + Widget build(BuildContext context) { 700 700 + final colorScheme = Theme.of(context).colorScheme; 701 701 + 702 702 + return DecoratedBox( 703 703 + decoration: BoxDecoration(color: colorScheme.surfaceContainerHighest, borderRadius: BorderRadius.circular(999)), 704 704 + child: Padding( 705 705 + padding: const EdgeInsets.symmetric(horizontal: 10, vertical: 6), 706 706 + child: Row( 707 707 + mainAxisSize: MainAxisSize.min, 708 708 + children: [ 709 709 + Icon(icon, size: 16, color: colorScheme.onSurfaceVariant), 710 710 + const SizedBox(width: 6), 711 711 + Text(label, style: Theme.of(context).textTheme.labelMedium?.copyWith(color: colorScheme.onSurfaceVariant)), 712 712 + ], 713 713 + ), 714 714 + ), 715 715 + ); 418 716 } 419 717 } 420 718

+16 -9

lib/main.dart

reviewed

··· 66 66 67 67 log.i('AppLogger: App started'); 68 68 69 69 - runApp( 70 70 - LazuriteApp( 71 71 - authBloc: authBloc, 72 72 - database: database, 73 73 - settingsCubit: settingsCubit, 74 74 - connectivityCubit: connectivityCubit, 75 75 - accountSwitcherCubit: accountSwitcherCubit, 76 76 - ), 77 77 - ); 69 69 + runApp(LazuriteApp.from(authBloc, database, settingsCubit, connectivityCubit, accountSwitcherCubit)); 78 70 } 79 71 80 72 class LazuriteApp extends StatefulWidget { ··· 92 84 final SettingsCubit settingsCubit; 93 85 final ConnectivityCubit connectivityCubit; 94 86 final AccountSwitcherCubit accountSwitcherCubit; 87 87 + 88 88 + /// factory constructor with positional params 89 89 + static LazuriteApp from( 90 90 + AuthBloc authBloc, 91 91 + AppDatabase database, 92 92 + SettingsCubit settingsCubit, 93 93 + ConnectivityCubit connectivityCubit, 94 94 + AccountSwitcherCubit accountSwitcherCubit, 95 95 + ) => LazuriteApp( 96 96 + authBloc: authBloc, 97 97 + database: database, 98 98 + settingsCubit: settingsCubit, 99 99 + connectivityCubit: connectivityCubit, 100 100 + accountSwitcherCubit: accountSwitcherCubit, 101 101 + ); 95 102 96 103 @override 97 104 State<LazuriteApp> createState() => _LazuriteAppState();

+2 -1

scripts/package.json

reviewed

··· 8 8 "scripts": { 9 9 "start": "bun run index.ts", 10 10 "build": "bun build index.ts --outfile=dist/splash-gen --target=bun", 11 11 - "generate": "bun run index.ts" 11 11 + "generate": "bun run index.ts", 12 12 + "profile-context": "bun run profile-context.ts" 12 13 }, 13 14 "devDependencies": { 14 15 "@types/bun": "latest"

+318

scripts/profile-context.ts

reviewed

··· 1 1 + #!/usr/bin/env bun 2 2 + 3 3 + import { parseArgs } from "util"; 4 4 + 5 5 + const MICROCOSM_XRPC_BASE = "https://constellation.microcosm.blue/xrpc"; 6 6 + const PUBLIC_BSKY_XRPC_BASE = "https://public.api.bsky.app/xrpc"; 7 7 + const BLOCK_SOURCE = "app.bsky.graph.block:subject"; 8 8 + const BACKLINK_LIMIT = 16; 9 9 + const PROFILE_BATCH_SIZE = 25; 10 10 + 11 11 + type JsonMap = Record<string, unknown>; 12 12 + 13 13 + type FetchResult = { 14 14 + status: number; 15 15 + ok: boolean; 16 16 + text: string; 17 17 + data: JsonMap | null; 18 18 + }; 19 19 + 20 20 + type OrderedEntry = 21 21 + | { 22 22 + did: string; 23 23 + status: "resolved"; 24 24 + handle: string; 25 25 + displayName: string | null; 26 26 + } 27 27 + | { 28 28 + did: string; 29 29 + status: "unavailable"; 30 30 + reason: string; 31 31 + }; 32 32 + 33 33 + function buildXrpcUrl(base: string, method: string, params: Record<string, string | number | null | undefined>): URL { 34 34 + const url = new URL(`${base}/${method}`); 35 35 + for (const [key, value] of Object.entries(params)) { 36 36 + if (value !== null && value !== undefined) { 37 37 + url.searchParams.set(key, String(value)); 38 38 + } 39 39 + } 40 40 + return url; 41 41 + } 42 42 + 43 43 + async function fetchJson(url: URL): Promise<FetchResult> { 44 44 + const response = await fetch(url, { 45 45 + headers: { 46 46 + Accept: "application/json", 47 47 + "User-Agent": "lazurite", 48 48 + }, 49 49 + }); 50 50 + const text = await response.text(); 51 51 + 52 52 + let data: JsonMap | null = null; 53 53 + try { 54 54 + data = text.length > 0 ? (JSON.parse(text) as JsonMap) : null; 55 55 + } catch { 56 56 + data = null; 57 57 + } 58 58 + 59 59 + return { 60 60 + status: response.status, 61 61 + ok: response.ok, 62 62 + text, 63 63 + data, 64 64 + }; 65 65 + } 66 66 + 67 67 + function getListFieldAny(data: JsonMap | null, keys: string[]): unknown[] { 68 68 + if (!data) return []; 69 69 + 70 70 + for (const key of keys) { 71 71 + const value = data[key]; 72 72 + if (Array.isArray(value)) { 73 73 + return value; 74 74 + } 75 75 + } 76 76 + 77 77 + return []; 78 78 + } 79 79 + 80 80 + function asString(value: unknown): string | null { 81 81 + return typeof value === "string" && value.trim().length > 0 ? value.trim() : null; 82 82 + } 83 83 + 84 84 + function classifyProfileFailure(result: FetchResult): string { 85 85 + const error = asString(result.data?.error); 86 86 + const message = asString(result.data?.message) ?? result.text; 87 87 + const combined = `${error ?? ""} ${message}`.toLowerCase(); 88 88 + 89 89 + if (combined.includes("accounttakedown") || combined.includes("suspended")) { 90 90 + return "Suspended account"; 91 91 + } 92 92 + if (result.status === 404 || combined.includes("not found")) { 93 93 + return "Profile unavailable"; 94 94 + } 95 95 + return "Public profile lookup failed"; 96 96 + } 97 97 + 98 98 + function chunk<T>(items: T[], size: number): T[][] { 99 99 + const output: T[][] = []; 100 100 + for (let index = 0; index < items.length; index += size) { 101 101 + output.push(items.slice(index, index + size)); 102 102 + } 103 103 + return output; 104 104 + } 105 105 + 106 106 + async function fetchBlockedByCount(did: string): Promise<number> { 107 107 + const url = buildXrpcUrl(MICROCOSM_XRPC_BASE, "blue.microcosm.links.getBacklinksCount", { 108 108 + subject: did, 109 109 + source: BLOCK_SOURCE, 110 110 + }); 111 111 + const result = await fetchJson(url); 112 112 + 113 113 + if (!result.ok || typeof result.data?.total !== "number") { 114 114 + throw new Error(`getBacklinksCount failed (${result.status}): ${result.text}`); 115 115 + } 116 116 + 117 117 + return result.data.total as number; 118 118 + } 119 119 + 120 120 + async function fetchDistinct(did: string): Promise<FetchResult> { 121 121 + const url = buildXrpcUrl(MICROCOSM_XRPC_BASE, "blue.microcosm.links.getDistinct", { 122 122 + subject: did, 123 123 + source: BLOCK_SOURCE, 124 124 + limit: BACKLINK_LIMIT, 125 125 + }); 126 126 + return fetchJson(url); 127 127 + } 128 128 + 129 129 + async function fetchAllBacklinkDids( 130 130 + did: string, 131 131 + ): Promise<{ orderedDids: string[]; pages: Array<{ page: number; cursorIn: string | null; cursorOut: string | null; recordCount: number }> }> { 132 132 + const orderedDids: string[] = []; 133 133 + const seen = new Set<string>(); 134 134 + const pages: Array<{ page: number; cursorIn: string | null; cursorOut: string | null; recordCount: number }> = []; 135 135 + 136 136 + let cursor: string | null = null; 137 137 + let page = 1; 138 138 + 139 139 + do { 140 140 + const url = buildXrpcUrl(MICROCOSM_XRPC_BASE, "blue.microcosm.links.getBacklinks", { 141 141 + subject: did, 142 142 + source: BLOCK_SOURCE, 143 143 + limit: BACKLINK_LIMIT, 144 144 + cursor, 145 145 + }); 146 146 + const result = await fetchJson(url); 147 147 + if (!result.ok) { 148 148 + throw new Error(`getBacklinks failed (${result.status}) on page ${page}: ${result.text}`); 149 149 + } 150 150 + 151 151 + const records = getListFieldAny(result.data, ["records", "linking_records"]); 152 152 + for (const record of records) { 153 153 + if (record && typeof record === "object") { 154 154 + const blockerDid = asString((record as JsonMap).did); 155 155 + if (blockerDid && !seen.has(blockerDid)) { 156 156 + seen.add(blockerDid); 157 157 + orderedDids.push(blockerDid); 158 158 + } 159 159 + } 160 160 + } 161 161 + 162 162 + const nextCursor = asString(result.data?.cursor); 163 163 + pages.push({ 164 164 + page, 165 165 + cursorIn: cursor, 166 166 + cursorOut: nextCursor, 167 167 + recordCount: records.length, 168 168 + }); 169 169 + cursor = nextCursor; 170 170 + page += 1; 171 171 + } while (cursor !== null); 172 172 + 173 173 + return { orderedDids, pages }; 174 174 + } 175 175 + 176 176 + async function fetchProfilesBatch(dids: string[]): Promise<Map<string, OrderedEntry>> { 177 177 + const resolved = new Map<string, OrderedEntry>(); 178 178 + 179 179 + for (const batch of chunk(dids, PROFILE_BATCH_SIZE)) { 180 180 + const url = new URL(`${PUBLIC_BSKY_XRPC_BASE}/app.bsky.actor.getProfiles`); 181 181 + for (const did of batch) { 182 182 + url.searchParams.append("actors", did); 183 183 + } 184 184 + 185 185 + const batchResult = await fetchJson(url); 186 186 + const batchProfiles = batchResult.ok ? getListFieldAny(batchResult.data, ["profiles"]) : []; 187 187 + const batchResolved = new Map<string, OrderedEntry>(); 188 188 + 189 189 + for (const profile of batchProfiles) { 190 190 + if (!profile || typeof profile !== "object") continue; 191 191 + const record = profile as JsonMap; 192 192 + const did = asString(record.did); 193 193 + const handle = asString(record.handle); 194 194 + if (!did || !handle) continue; 195 195 + 196 196 + batchResolved.set(did, { 197 197 + did, 198 198 + status: "resolved", 199 199 + handle, 200 200 + displayName: asString(record.displayName), 201 201 + }); 202 202 + } 203 203 + 204 204 + for (const did of batch) { 205 205 + const existing = batchResolved.get(did); 206 206 + if (existing) { 207 207 + resolved.set(did, existing); 208 208 + continue; 209 209 + } 210 210 + 211 211 + const singleUrl = buildXrpcUrl(PUBLIC_BSKY_XRPC_BASE, "app.bsky.actor.getProfile", { 212 212 + actor: did, 213 213 + }); 214 214 + const singleResult = await fetchJson(singleUrl); 215 215 + 216 216 + if (singleResult.ok) { 217 217 + const handle = asString(singleResult.data?.handle); 218 218 + if (handle) { 219 219 + resolved.set(did, { 220 220 + did, 221 221 + status: "resolved", 222 222 + handle, 223 223 + displayName: asString(singleResult.data?.displayName), 224 224 + }); 225 225 + continue; 226 226 + } 227 227 + } 228 228 + 229 229 + resolved.set(did, { 230 230 + did, 231 231 + status: "unavailable", 232 232 + reason: classifyProfileFailure(singleResult), 233 233 + }); 234 234 + } 235 235 + } 236 236 + 237 237 + return resolved; 238 238 + } 239 239 + 240 240 + function printUsage(): void { 241 241 + console.error("Usage: bun run profile-context.ts --did <did:plc:...>"); 242 242 + } 243 243 + 244 244 + async function main(): Promise<void> { 245 245 + const { values } = parseArgs({ 246 246 + args: Bun.argv.slice(2), 247 247 + options: { 248 248 + did: { 249 249 + type: "string", 250 250 + }, 251 251 + help: { 252 252 + type: "boolean", 253 253 + short: "h", 254 254 + default: false, 255 255 + }, 256 256 + }, 257 257 + strict: true, 258 258 + allowPositionals: false, 259 259 + }); 260 260 + 261 261 + if (values.help) { 262 262 + printUsage(); 263 263 + process.exit(0); 264 264 + } 265 265 + 266 266 + const did = asString(values.did); 267 267 + if (!did) { 268 268 + printUsage(); 269 269 + process.exit(1); 270 270 + } 271 271 + 272 272 + const count = await fetchBlockedByCount(did); 273 273 + const distinct = await fetchDistinct(did); 274 274 + const backlinks = await fetchAllBacklinkDids(did); 275 275 + const hydrated = await fetchProfilesBatch(backlinks.orderedDids); 276 276 + const orderedEntries = backlinks.orderedDids.map((blockerDid) => { 277 277 + return ( 278 278 + hydrated.get(blockerDid) ?? { 279 279 + did: blockerDid, 280 280 + status: "unavailable" as const, 281 281 + reason: "Public profile lookup failed", 282 282 + } 283 283 + ); 284 284 + }); 285 285 + 286 286 + const resolvedCount = orderedEntries.filter((entry) => entry.status === "resolved").length; 287 287 + const unavailableEntries = orderedEntries.filter((entry) => entry.status === "unavailable"); 288 288 + 289 289 + console.log(`Target DID: ${did}`); 290 290 + console.log(`Microcosm blocked-by count: ${count}`); 291 291 + console.log( 292 292 + `Microcosm getDistinct: HTTP ${distinct.status}${distinct.ok ? "" : ` ${distinct.text.trim()}`}`, 293 293 + ); 294 294 + console.log(""); 295 295 + console.log("Backlink pages:"); 296 296 + for (const page of backlinks.pages) { 297 297 + console.log( 298 298 + ` page ${page.page}: cursorIn=${page.cursorIn ?? "null"} records=${page.recordCount} cursorOut=${page.cursorOut ?? "null"}`, 299 299 + ); 300 300 + } 301 301 + console.log(""); 302 302 + console.log(`Collected blocker DIDs: ${backlinks.orderedDids.length}`); 303 303 + console.log(`Resolved public profiles: ${resolvedCount}`); 304 304 + console.log(`Unavailable public profiles: ${unavailableEntries.length}`); 305 305 + console.log(""); 306 306 + console.log("Ordered results:"); 307 307 + orderedEntries.forEach((entry, index) => { 308 308 + if (entry.status === "resolved") { 309 309 + const display = entry.displayName ? ` (${entry.displayName})` : ""; 310 310 + console.log(`${String(index + 1).padStart(2, "0")}. RESOLVED ${entry.did} -> @${entry.handle}${display}`); 311 311 + return; 312 312 + } 313 313 + 314 314 + console.log(`${String(index + 1).padStart(2, "0")}. UNAVAILABLE ${entry.did} -> ${entry.reason}`); 315 315 + }); 316 316 + } 317 317 + 318 318 + await main();

+2 -1

scripts/tsconfig.json

reviewed

··· 17 17 "noImplicitOverride": true, 18 18 "noUnusedLocals": false, 19 19 "noUnusedParameters": false, 20 20 - "noPropertyAccessFromIndexSignature": false 20 20 + "noPropertyAccessFromIndexSignature": false, 21 21 + "types": ["bun"] 21 22 } 22 23 }

+66

test/core/network/constellation_client_test.dart

reviewed

··· 39 39 expect(capturedUri?.host, 'my.instance.example'); 40 40 }); 41 41 42 42 + test('trims trailing slashes from custom base URL', () async { 43 43 + Uri? capturedUri; 44 44 + final client = ConstellationClient( 45 45 + baseUrl: 'https://my.instance.example///', 46 46 + httpClient: MockClient((request) async { 47 47 + capturedUri = request.url; 48 48 + return http.Response(jsonEncode({'total': 0}), 200); 49 49 + }), 50 50 + ); 51 51 + 52 52 + await client.getBacklinksCount('did:plc:test', 'app.bsky.graph.block:subject'); 53 53 + 54 54 + expect( 55 55 + capturedUri.toString(), 56 56 + 'https://my.instance.example/xrpc/blue.microcosm.links.getBacklinksCount?subject=did%3Aplc%3Atest&source=app.bsky.graph.block%3Asubject', 57 57 + ); 58 58 + }); 59 59 + 42 60 test('builds XRPC path correctly', () async { 43 61 Uri? capturedUri; 44 62 final client = ConstellationClient( ··· 142 160 expect(result.cursor, isNull); 143 161 }); 144 162 163 163 + test('treats null dids as empty list', () async { 164 164 + final responseBody = jsonEncode({'total': 1, 'dids': null}); 165 165 + final client = ConstellationClient(httpClient: MockClient((_) async => http.Response(responseBody, 200))); 166 166 + 167 167 + final result = await client.getDistinct('did:plc:abc', 'source'); 168 168 + 169 169 + expect(result.dids, isEmpty); 170 170 + }); 171 171 + 145 172 test('passes limit and cursor as query parameters', () async { 146 173 Uri? capturedUri; 147 174 final client = ConstellationClient( ··· 180 207 }); 181 208 182 209 group('getBacklinks', () { 210 210 + test('prefers records payload when returned by Microcosm', () async { 211 211 + final responseBody = jsonEncode({ 212 212 + 'total': 2, 213 213 + 'records': [ 214 214 + {'did': 'did:plc:aaa', 'collection': 'app.bsky.graph.block', 'rkey': 'rkey1'}, 215 215 + {'did': 'did:plc:bbb', 'collection': 'app.bsky.graph.block', 'rkey': 'rkey2'}, 216 216 + ], 217 217 + 'linking_records': [ 218 218 + {'did': 'did:plc:ignored', 'collection': 'app.bsky.graph.block', 'rkey': 'ignored'}, 219 219 + ], 220 220 + 'cursor': 'cursor-xyz', 221 221 + }); 222 222 + final client = ConstellationClient(httpClient: MockClient((_) async => http.Response(responseBody, 200))); 223 223 + 224 224 + final result = await client.getBacklinks('did:plc:abc', 'app.bsky.graph.block:subject'); 225 225 + 226 226 + expect(result.total, 2); 227 227 + expect(result.records.map((record) => record.did).toList(), ['did:plc:aaa', 'did:plc:bbb']); 228 228 + expect(result.cursor, 'cursor-xyz'); 229 229 + }); 230 230 + 183 231 test('returns total, records and cursor from response', () async { 184 232 final responseBody = jsonEncode({ 185 233 'total': 2, ··· 209 257 210 258 expect(result.records, isEmpty); 211 259 expect(result.cursor, isNull); 260 260 + }); 261 261 + 262 262 + test('treats null linking_records as empty list', () async { 263 263 + final responseBody = jsonEncode({'total': 0, 'linking_records': null}); 264 264 + final client = ConstellationClient(httpClient: MockClient((_) async => http.Response(responseBody, 200))); 265 265 + 266 266 + final result = await client.getBacklinks('did:plc:abc', 'source'); 267 267 + 268 268 + expect(result.records, isEmpty); 212 269 }); 213 270 214 271 test('passes limit and cursor as query parameters', () async { ··· 276 333 final result = await client.getManyToMany('did:plc:abc', 'source', 'list'); 277 334 278 335 expect(result.cursor, isNull); 336 336 + }); 337 337 + 338 338 + test('treats null items as empty list', () async { 339 339 + final responseBody = jsonEncode({'items': null}); 340 340 + final client = ConstellationClient(httpClient: MockClient((_) async => http.Response(responseBody, 200))); 341 341 + 342 342 + final result = await client.getManyToMany('did:plc:abc', 'source', 'list'); 343 343 + 344 344 + expect(result.items, isEmpty); 279 345 }); 280 346 281 347 test('throws ConstellationException on error response', () async {

+38

test/features/profile/bloc/profile_bloc_test.dart

reviewed

··· 1 1 + import 'package:bloc_test/bloc_test.dart'; 2 2 + import 'package:bluesky/app_bsky_actor_defs.dart'; 3 3 + import 'package:flutter_test/flutter_test.dart'; 4 4 + import 'package:lazurite/features/profile/bloc/profile_bloc.dart'; 5 5 + import 'package:lazurite/features/profile/data/profile_repository.dart'; 6 6 + import 'package:mocktail/mocktail.dart'; 7 7 + 8 8 + class MockProfileRepository extends Mock implements ProfileRepository {} 9 9 + 10 10 + ProfileViewDetailed _profile({String did = 'did:plc:alice', String handle = 'alice.bsky.social'}) { 11 11 + return ProfileViewDetailed(did: did, handle: handle, indexedAt: DateTime.utc(2026)); 12 12 + } 13 13 + 14 14 + void main() { 15 15 + late MockProfileRepository repository; 16 16 + 17 17 + setUp(() { 18 18 + repository = MockProfileRepository(); 19 19 + }); 20 20 + 21 21 + blocTest<ProfileBloc, ProfileState>( 22 22 + 'refresh uses handle when available', 23 23 + build: () => ProfileBloc(profileRepository: repository), 24 24 + seed: () => ProfileState.loaded(profile: _profile()), 25 25 + setUp: () { 26 26 + when(() => repository.getProfile('alice.bsky.social')).thenAnswer((_) async => _profile()); 27 27 + }, 28 28 + act: (bloc) => bloc.add(const ProfileRefreshRequested()), 29 29 + expect: () => [ 30 30 + predicate<ProfileState>((state) => state.isRefreshing), 31 31 + predicate<ProfileState>((state) => state.status == ProfileStatus.loaded && !state.isRefreshing), 32 32 + ], 33 33 + verify: (_) { 34 34 + verify(() => repository.getProfile('alice.bsky.social')).called(1); 35 35 + verifyNever(() => repository.getProfile('did:plc:alice')); 36 36 + }, 37 37 + ); 38 38 + }

+88 -18

test/features/profile/cubit/profile_context_cubit_test.dart

reviewed

··· 63 63 ); 64 64 65 65 blocTest<ProfileContextCubit, ProfileContextState>( 66 66 - 'emits nothing when counts fail (best-effort)', 67 67 - build: buildCubit, 66 66 + 'loads blockingCount too for own profile', 67 67 + build: () => buildCubit(isOwnProfile: true), 68 68 + setUp: () { 69 69 + when(() => mockRepository.getBlockedByCount(_did)).thenAnswer((_) async => 42); 70 70 + when(() => mockRepository.getListsOnCount(_did)).thenAnswer((_) async => 7); 71 71 + when(() => mockRepository.getBlockingCount(_did)).thenAnswer((_) async => 3); 72 72 + }, 73 73 + act: (cubit) => cubit.init(), 74 74 + expect: () => [ 75 75 + predicate<ProfileContextState>((s) => s.blockedByCount == 42 && s.listsOnCount == 7 && s.blockingCount == 3), 76 76 + ], 77 77 + ); 78 78 + 79 79 + blocTest<ProfileContextCubit, ProfileContextState>( 80 80 + 'preserves successful counts when one loader fails', 81 81 + build: () => buildCubit(isOwnProfile: true), 68 82 setUp: () { 69 83 when(() => mockRepository.getBlockedByCount(any())).thenThrow(Exception('network error')); 70 70 - when(() => mockRepository.getListsOnCount(any())).thenThrow(Exception('network error')); 84 84 + when(() => mockRepository.getListsOnCount(_did)).thenAnswer((_) async => 7); 85 85 + when(() => mockRepository.getBlockingCount(_did)).thenAnswer((_) async => 3); 71 86 }, 72 87 act: (cubit) => cubit.init(), 73 73 - expect: () => [], 88 88 + expect: () => [ 89 89 + predicate<ProfileContextState>((s) => s.blockedByCount == 0 && s.listsOnCount == 7 && s.blockingCount == 3), 90 90 + ], 74 91 ); 75 92 }); 76 93 ··· 82 99 'emits loading then loaded with profiles on success', 83 100 build: buildCubit, 84 101 setUp: () { 85 85 - when( 86 86 - () => mockRepository.getBlockedByProfiles(_did, cursor: null), 87 87 - ).thenAnswer((_) async => (profiles: [profile1, profile2], cursor: 'next', total: 10)); 102 102 + when(() => mockRepository.getBlockedByProfiles(_did, cursor: null)).thenAnswer( 103 103 + (_) async => ( 104 104 + entries: [ 105 105 + BlockedByEntry.profile(profile: profile1), 106 106 + BlockedByEntry.profile(profile: profile2), 107 107 + ], 108 108 + cursor: 'next', 109 109 + total: 10, 110 110 + ), 111 111 + ); 88 112 }, 89 113 act: (cubit) => cubit.loadBlockedBy(), 90 114 expect: () => [ ··· 92 116 predicate<ProfileContextState>( 93 117 (s) => 94 118 s.blockedByStatus == ProfileContextTabStatus.loaded && 95 95 - s.blockedByProfiles.length == 2 && 119 119 + s.blockedByEntries.length == 2 && 96 120 s.blockedByCount == 10 && 97 121 s.blockedByCursor == 'next' && 98 122 s.blockedByHasMore, ··· 105 129 build: buildCubit, 106 130 seed: () => const ProfileContextState.initial(did: _did, isOwnProfile: false).copyWith( 107 131 blockedByStatus: ProfileContextTabStatus.loaded, 108 108 - blockedByProfiles: [_profile('did:plc:first')], 132 132 + blockedByEntries: [BlockedByEntry.profile(profile: _profile('did:plc:first'))], 109 133 blockedByCursor: 'cursor-1', 110 134 blockedByHasMore: true, 111 135 ), 112 136 setUp: () { 113 137 when( 114 138 () => mockRepository.getBlockedByProfiles(_did, cursor: 'cursor-1'), 115 115 - ).thenAnswer((_) async => (profiles: [profile1], cursor: null, total: 2)); 139 139 + ).thenAnswer((_) async => (entries: [BlockedByEntry.profile(profile: profile1)], cursor: null, total: 2)); 116 140 }, 117 141 act: (cubit) => cubit.loadBlockedBy(cursor: 'cursor-1'), 118 142 expect: () => [ ··· 120 144 predicate<ProfileContextState>( 121 145 (s) => 122 146 s.blockedByStatus == ProfileContextTabStatus.loaded && 123 123 - s.blockedByProfiles.length == 2 && 147 147 + s.blockedByEntries.length == 2 && 124 148 s.blockedByCursor == null && 125 149 !s.blockedByHasMore, 126 150 ), ··· 128 152 ); 129 153 130 154 blocTest<ProfileContextCubit, ProfileContextState>( 155 155 + 'tracks unavailable blocked-by accounts without breaking loaded state', 156 156 + build: buildCubit, 157 157 + setUp: () { 158 158 + when(() => mockRepository.getBlockedByProfiles(_did, cursor: null)).thenAnswer( 159 159 + (_) async => ( 160 160 + entries: [ 161 161 + BlockedByEntry.profile( 162 162 + profile: const ProfileView(did: 'did:plc:blocker1', handle: 'did:plc:blocker1.bsky.social'), 163 163 + ), 164 164 + const BlockedByEntry.unavailable(did: 'did:plc:suspended', unavailableReason: 'Suspended account'), 165 165 + ], 166 166 + cursor: null, 167 167 + total: 2, 168 168 + ), 169 169 + ); 170 170 + }, 171 171 + act: (cubit) => cubit.loadBlockedBy(), 172 172 + expect: () => [ 173 173 + predicate<ProfileContextState>((s) => s.blockedByStatus == ProfileContextTabStatus.loading), 174 174 + predicate<ProfileContextState>( 175 175 + (s) => 176 176 + s.blockedByStatus == ProfileContextTabStatus.loaded && 177 177 + s.blockedByEntries.length == 2 && 178 178 + s.blockedByEntries.last.did == 'did:plc:suspended' && 179 179 + s.blockedByEntries.last.unavailableReason == 'Suspended account', 180 180 + ), 181 181 + ], 182 182 + ); 183 183 + 184 184 + blocTest<ProfileContextCubit, ProfileContextState>( 131 185 'emits error state on failure', 132 186 build: buildCubit, 133 187 setUp: () { ··· 142 196 (s) => 143 197 s.blockedByStatus == ProfileContextTabStatus.error && 144 198 s.blockedByError != null && 145 145 - s.blockedByProfiles.isEmpty, 199 199 + s.blockedByEntries.isEmpty, 146 200 ), 147 201 ], 148 202 ); ··· 166 220 'emits loading then loaded with profiles on success for own profile', 167 221 build: () => buildCubit(isOwnProfile: true), 168 222 setUp: () { 169 169 - when( 170 170 - () => mockRepository.getBlockingProfiles(_did, cursor: null), 171 171 - ).thenAnswer((_) async => (profiles: [profile1], cursor: 'next', total: 1)); 223 223 + when(() => mockRepository.getBlockingProfiles(_did, cursor: null)).thenAnswer( 224 224 + (_) async => (profiles: [profile1], unavailable: <UnavailableProfileRef>[], cursor: 'next', total: 1), 225 225 + ); 172 226 }, 173 227 act: (cubit) => cubit.loadBlocking(), 174 228 expect: () => [ ··· 202 256 blockingCount: 1, 203 257 ), 204 258 setUp: () { 205 205 - when( 206 206 - () => mockRepository.getBlockingProfiles(_did, cursor: 'cursor-1'), 207 207 - ).thenAnswer((_) async => (profiles: [profile1], cursor: null, total: 1)); 259 259 + when(() => mockRepository.getBlockingProfiles(_did, cursor: 'cursor-1')).thenAnswer( 260 260 + (_) async => (profiles: [profile1], unavailable: <UnavailableProfileRef>[], cursor: null, total: 1), 261 261 + ); 208 262 }, 209 263 act: (cubit) => cubit.loadBlocking(cursor: 'cursor-1'), 210 264 expect: () => [ 211 265 predicate<ProfileContextState>((s) => s.blockingStatus == ProfileContextTabStatus.loading), 212 266 predicate<ProfileContextState>((s) => s.blockingProfiles.length == 2 && s.blockingCount == 2), 267 267 + ], 268 268 + ); 269 269 + 270 270 + blocTest<ProfileContextCubit, ProfileContextState>( 271 271 + 'does not shrink blockingCount when a known total already exists', 272 272 + build: () => buildCubit(isOwnProfile: true), 273 273 + seed: () => const ProfileContextState.initial(did: _did, isOwnProfile: true).copyWith(blockingCount: 5), 274 274 + setUp: () { 275 275 + when(() => mockRepository.getBlockingProfiles(_did, cursor: null)).thenAnswer( 276 276 + (_) async => (profiles: [profile1], unavailable: <UnavailableProfileRef>[], cursor: 'next', total: 1), 277 277 + ); 278 278 + }, 279 279 + act: (cubit) => cubit.loadBlocking(), 280 280 + expect: () => [ 281 281 + predicate<ProfileContextState>((s) => s.blockingStatus == ProfileContextTabStatus.loading), 282 282 + predicate<ProfileContextState>((s) => s.blockingProfiles.length == 1 && s.blockingCount == 5), 213 283 ], 214 284 ); 215 285

+622 -21

test/features/profile/data/profile_context_repository_test.dart

reviewed

··· 13 13 return ProfileView(did: did, handle: handle, indexedAt: DateTime.utc(2026, 1, 1)); 14 14 } 15 15 16 16 + ProfileViewDetailed _buildProfileViewDetailed(String did, String handle) { 17 17 + return ProfileViewDetailed( 18 18 + did: did, 19 19 + handle: handle, 20 20 + displayName: 'Detailed $did', 21 21 + description: 'Bio for $did', 22 22 + indexedAt: DateTime.utc(2026, 1, 1), 23 23 + ); 24 24 + } 25 25 + 16 26 ListView _buildListView(String uriStr, String name) { 17 27 return ListView( 18 28 uri: AtUri.parse(uriStr), ··· 48 58 } 49 59 50 60 class _FakeActorService { 51 51 - _FakeActorService({required this.profiles}); 61 61 + _FakeActorService({required this.profiles, Map<String, dynamic>? profileByActor, Map<String, Object>? errorsByActor}) 62 62 + : _profileByActor = profileByActor ?? const {}, 63 63 + _errorsByActor = errorsByActor ?? const {}; 52 64 53 53 - final List<ProfileView> profiles; 65 65 + final List<dynamic> profiles; 66 66 + final Map<String, dynamic> _profileByActor; 67 67 + final Map<String, Object> _errorsByActor; 54 68 55 69 Future<_FakeResponse<_FakeProfilesOutput>> getProfiles({ 56 70 required List<String> actors, 71 71 + String? $service, 57 72 Map<String, String>? $headers, 58 73 }) async { 59 74 final matched = profiles.where((p) => actors.contains(p.did) || actors.contains(p.handle)).toList(); 60 75 return _FakeResponse(_FakeProfilesOutput(matched)); 61 76 } 77 77 + 78 78 + Future<_FakeResponse<dynamic>> getProfile({ 79 79 + required String actor, 80 80 + String? $service, 81 81 + Map<String, String>? $headers, 82 82 + }) async { 83 83 + final error = _errorsByActor[actor]; 84 84 + if (error != null) throw error; 85 85 + final profile = _profileByActor[actor]; 86 86 + if (profile == null) throw Exception('Profile not found: $actor'); 87 87 + return _FakeResponse(profile); 88 88 + } 89 89 + } 90 90 + 91 91 + class _ThrowingActorService { 92 92 + Future<_FakeResponse<_FakeProfilesOutput>> getProfiles({ 93 93 + required List<String> actors, 94 94 + String? $service, 95 95 + Map<String, String>? $headers, 96 96 + }) async { 97 97 + throw Exception('Authenticated actor client should not be used for public profile hydration'); 98 98 + } 99 99 + 100 100 + Future<_FakeResponse<dynamic>> getProfile({ 101 101 + required String actor, 102 102 + String? $service, 103 103 + Map<String, String>? $headers, 104 104 + }) async { 105 105 + throw Exception('Authenticated actor client should not be used for public profile hydration'); 106 106 + } 107 107 + } 108 108 + 109 109 + class _BatchThrowingActorService { 110 110 + _BatchThrowingActorService({required Map<String, dynamic> profileByActor}) : _profileByActor = profileByActor; 111 111 + 112 112 + final Map<String, dynamic> _profileByActor; 113 113 + 114 114 + Future<_FakeResponse<_FakeProfilesOutput>> getProfiles({ 115 115 + required List<String> actors, 116 116 + String? $service, 117 117 + Map<String, String>? $headers, 118 118 + }) async { 119 119 + throw Exception('Batch lookup failed'); 120 120 + } 121 121 + 122 122 + Future<_FakeResponse<dynamic>> getProfile({ 123 123 + required String actor, 124 124 + String? $service, 125 125 + Map<String, String>? $headers, 126 126 + }) async { 127 127 + final profile = _profileByActor[actor]; 128 128 + if (profile == null) throw Exception('Profile not found: $actor'); 129 129 + return _FakeResponse(profile); 130 130 + } 62 131 } 63 132 64 133 class _FakeProfilesOutput { 65 134 _FakeProfilesOutput(this.profiles); 66 135 67 67 - final List<ProfileView> profiles; 136 136 + final List<dynamic> profiles; 68 137 } 69 138 70 139 class _FakeGraphService { ··· 75 144 Future<_FakeResponse<_FakeGetListOutput>> getList({ 76 145 required AtUri list, 77 146 int limit = 50, 147 147 + String? $service, 78 148 Map<String, String>? $headers, 79 149 }) async { 80 150 final listView = lists[list.toString()]; ··· 83 153 } 84 154 } 85 155 156 156 + class _ThrowingGraphService { 157 157 + Future<_FakeResponse<_FakeGetListOutput>> getList({ 158 158 + required AtUri list, 159 159 + int limit = 50, 160 160 + String? $service, 161 161 + Map<String, String>? $headers, 162 162 + }) async { 163 163 + throw Exception('Authenticated graph client should not be used for public list hydration'); 164 164 + } 165 165 + } 166 166 + 86 167 class _FakeGetListOutput { 87 168 _FakeGetListOutput(this.list); 88 169 ··· 174 255 final result = await repo.getBlockedByProfiles('did:plc:target'); 175 256 176 257 expect(result.total, 2); 177 177 - expect(result.profiles.length, 2); 178 178 - expect(result.profiles.map((p) => p.did), containsAll(['did:plc:alice', 'did:plc:bob'])); 258 258 + expect(result.entries, hasLength(2)); 259 259 + expect(result.entries.map((entry) => entry.did), containsAll(['did:plc:alice', 'did:plc:bob'])); 260 260 + expect(result.entries.every((entry) => entry.isAvailable), isTrue); 179 261 expect(result.cursor, isNull); 180 262 }); 181 263 182 182 - test('passes cursor to getDistinct and returns cursor from response', () async { 183 183 - String? capturedCursor; 264 264 + test('converts detailed profiles returned by getProfiles into ProfileView', () async { 265 265 + final aliceProfile = _buildProfileViewDetailed('did:plc:alice', 'alice.bsky.social'); 266 266 + 267 267 + final constellation = _constellationWithResponses((_) { 268 268 + return { 269 269 + 'total': 1, 270 270 + 'dids': ['did:plc:alice'], 271 271 + }; 272 272 + }); 273 273 + 274 274 + final repo = ProfileContextRepository( 275 275 + bluesky: _buildBluesky(profiles: [aliceProfile]), 276 276 + constellationClient: constellation, 277 277 + ); 278 278 + 279 279 + final result = await repo.getBlockedByProfiles('did:plc:target'); 280 280 + 281 281 + expect(result.entries, hasLength(1)); 282 282 + expect(result.entries.first.profile?.did, 'did:plc:alice'); 283 283 + expect(result.entries.first.profile?.handle, 'alice.bsky.social'); 284 284 + expect(result.entries.first.profile?.displayName, 'Detailed did:plc:alice'); 285 285 + }); 286 286 + 287 287 + test('falls back to getProfile for DIDs missing from getProfiles', () async { 288 288 + final repo = ProfileContextRepository( 289 289 + bluesky: _FakeBluesky( 290 290 + actor: _ThrowingActorService(), 291 291 + graph: _FakeGraphService(), 292 292 + atproto: _FakeAtProto(repo: _FakeRepoService(records: [])), 293 293 + ), 294 294 + publicBluesky: _FakeBluesky( 295 295 + actor: _FakeActorService( 296 296 + profiles: const [], 297 297 + profileByActor: {'did:plc:alice': _buildProfileViewDetailed('did:plc:alice', 'alice.bsky.social')}, 298 298 + ), 299 299 + graph: _FakeGraphService(), 300 300 + atproto: _FakeAtProto(repo: _FakeRepoService(records: [])), 301 301 + ), 302 302 + constellationClient: _constellationWithResponses((_) { 303 303 + return { 304 304 + 'total': 1, 305 305 + 'dids': ['did:plc:alice'], 306 306 + }; 307 307 + }), 308 308 + ); 309 309 + 310 310 + final result = await repo.getBlockedByProfiles('did:plc:target'); 311 311 + 312 312 + expect(result.entries, hasLength(1)); 313 313 + expect(result.entries.first.profile?.did, 'did:plc:alice'); 314 314 + expect(result.entries.first.profile?.handle, 'alice.bsky.social'); 315 315 + }); 316 316 + 317 317 + test('falls back to per-DID getProfile when batch getProfiles fails', () async { 318 318 + final repo = ProfileContextRepository( 319 319 + bluesky: _FakeBluesky( 320 320 + actor: _ThrowingActorService(), 321 321 + graph: _FakeGraphService(), 322 322 + atproto: _FakeAtProto(repo: _FakeRepoService(records: [])), 323 323 + ), 324 324 + publicBluesky: _FakeBluesky( 325 325 + actor: _BatchThrowingActorService( 326 326 + profileByActor: {'did:plc:alice': _buildProfileViewDetailed('did:plc:alice', 'alice.bsky.social')}, 327 327 + ), 328 328 + graph: _FakeGraphService(), 329 329 + atproto: _FakeAtProto(repo: _FakeRepoService(records: [])), 330 330 + ), 331 331 + constellationClient: _constellationWithResponses((_) { 332 332 + return { 333 333 + 'total': 2, 334 334 + 'dids': ['did:plc:alice', 'did:plc:suspended'], 335 335 + }; 336 336 + }), 337 337 + ); 338 338 + 339 339 + final result = await repo.getBlockedByProfiles('did:plc:target'); 340 340 + 341 341 + expect(result.total, 2); 342 342 + expect(result.entries, hasLength(2)); 343 343 + expect(result.entries.first.profile?.did, 'did:plc:alice'); 344 344 + expect(result.entries.last.did, 'did:plc:suspended'); 345 345 + expect(result.entries.last.unavailableReason, 'Profile unavailable'); 346 346 + }); 347 347 + 348 348 + test('uses public bluesky client for batch profile hydration', () async { 349 349 + final repo = ProfileContextRepository( 350 350 + bluesky: _FakeBluesky( 351 351 + actor: _ThrowingActorService(), 352 352 + graph: _FakeGraphService(), 353 353 + atproto: _FakeAtProto(repo: _FakeRepoService(records: [])), 354 354 + ), 355 355 + publicBluesky: _FakeBluesky( 356 356 + actor: _FakeActorService(profiles: [_buildProfileViewDetailed('did:plc:alice', 'alice.bsky.social')]), 357 357 + graph: _FakeGraphService(), 358 358 + atproto: _FakeAtProto(repo: _FakeRepoService(records: [])), 359 359 + ), 360 360 + constellationClient: _constellationWithResponses((_) { 361 361 + return { 362 362 + 'total': 1, 363 363 + 'dids': ['did:plc:alice'], 364 364 + }; 365 365 + }), 366 366 + ); 367 367 + 368 368 + await repo.getBlockedByProfiles('did:plc:target'); 369 369 + }); 370 370 + 371 371 + test('uses local offset cursor after collecting blocked-by DIDs', () async { 372 372 + var getDistinctCalls = 0; 373 373 + String? capturedLimit; 184 374 final constellation = _constellationWithResponses((uri) { 185 185 - capturedCursor = uri.queryParameters['cursor']; 186 186 - return {'total': 10, 'dids': [], 'cursor': 'page2'}; 375 375 + getDistinctCalls += 1; 376 376 + capturedLimit = uri.queryParameters['limit']; 377 377 + if (getDistinctCalls == 1) { 378 378 + expect(uri.queryParameters['cursor'], isNull); 379 379 + return { 380 380 + 'total': 3, 381 381 + 'dids': ['did:plc:one', 'did:plc:two'], 382 382 + 'cursor': 'page2', 383 383 + }; 384 384 + } 385 385 + expect(uri.queryParameters['cursor'], 'page2'); 386 386 + return { 387 387 + 'total': 3, 388 388 + 'dids': ['did:plc:three'], 389 389 + 'cursor': null, 390 390 + }; 187 391 }); 188 392 189 189 - final repo = ProfileContextRepository(bluesky: _buildBluesky(), constellationClient: constellation); 393 393 + final repo = ProfileContextRepository( 394 394 + bluesky: _buildBluesky( 395 395 + profiles: [ 396 396 + _buildProfileView('did:plc:one', 'one.bsky.social'), 397 397 + _buildProfileView('did:plc:two', 'two.bsky.social'), 398 398 + _buildProfileView('did:plc:three', 'three.bsky.social'), 399 399 + ], 400 400 + ), 401 401 + constellationClient: constellation, 402 402 + ); 403 403 + 404 404 + final result = await repo.getBlockedByProfiles('did:plc:target', cursor: '2'); 405 405 + 406 406 + expect(getDistinctCalls, 2); 407 407 + expect(capturedLimit, '16'); 408 408 + expect(result.entries.map((entry) => entry.did), ['did:plc:three']); 409 409 + expect(result.cursor, isNull); 410 410 + }); 411 411 + 412 412 + test('falls back to getBacklinks when getDistinct returns 404', () async { 413 413 + final aliceProfile = _buildProfileViewDetailed('did:plc:alice', 'alice.bsky.social'); 414 414 + final bobProfile = _buildProfileViewDetailed('did:plc:bob', 'bob.bsky.social'); 190 415 191 191 - final result = await repo.getBlockedByProfiles('did:plc:target', cursor: 'page1'); 416 416 + final constellation = ConstellationClient( 417 417 + httpClient: MockClient((request) async { 418 418 + if (request.url.path.contains('getDistinct')) { 419 419 + return http.Response('Not Found', 404); 420 420 + } 421 421 + 422 422 + if (request.url.path.contains('getBacklinks')) { 423 423 + return http.Response( 424 424 + jsonEncode({ 425 425 + 'total': 3, 426 426 + 'records': [ 427 427 + {'did': 'did:plc:alice', 'collection': 'app.bsky.graph.block', 'rkey': '1'}, 428 428 + {'did': 'did:plc:bob', 'collection': 'app.bsky.graph.block', 'rkey': '2'}, 429 429 + {'did': 'did:plc:alice', 'collection': 'app.bsky.graph.block', 'rkey': '3'}, 430 430 + ], 431 431 + }), 432 432 + 200, 433 433 + ); 434 434 + } 435 435 + 436 436 + throw Exception('Unexpected endpoint: ${request.url.path}'); 437 437 + }), 438 438 + ); 439 439 + 440 440 + final repo = ProfileContextRepository( 441 441 + bluesky: _buildBluesky(profiles: [aliceProfile, bobProfile]), 442 442 + constellationClient: constellation, 443 443 + ); 444 444 + 445 445 + final result = await repo.getBlockedByProfiles('did:plc:target'); 446 446 + 447 447 + expect(result.total, 3); 448 448 + expect(result.cursor, isNull); 449 449 + expect(result.entries.map((entry) => entry.did).toList(), ['did:plc:alice', 'did:plc:bob']); 450 450 + }); 451 451 + 452 452 + test('collects blocked-by DIDs across pages before hydrating', () async { 453 453 + var getDistinctCalls = 0; 454 454 + final repo = ProfileContextRepository( 455 455 + bluesky: _FakeBluesky( 456 456 + actor: _ThrowingActorService(), 457 457 + graph: _FakeGraphService(), 458 458 + atproto: _FakeAtProto(repo: _FakeRepoService(records: [])), 459 459 + ), 460 460 + publicBluesky: _FakeBluesky( 461 461 + actor: _FakeActorService( 462 462 + profiles: [_buildProfileViewDetailed('did:plc:alice', 'alice.bsky.social')], 463 463 + profileByActor: const {}, 464 464 + ), 465 465 + graph: _FakeGraphService(), 466 466 + atproto: _FakeAtProto(repo: _FakeRepoService(records: [])), 467 467 + ), 468 468 + constellationClient: _constellationWithResponses((uri) { 469 469 + if (!uri.path.contains('getDistinct')) { 470 470 + throw Exception('Unexpected endpoint: ${uri.path}'); 471 471 + } 472 472 + 473 473 + getDistinctCalls += 1; 474 474 + if (getDistinctCalls == 1) { 475 475 + expect(uri.queryParameters['cursor'], isNull); 476 476 + return { 477 477 + 'total': 23, 478 478 + 'dids': ['did:plc:suspended'], 479 479 + 'cursor': 'page-2', 480 480 + }; 481 481 + } 482 482 + 483 483 + expect(uri.queryParameters['cursor'], 'page-2'); 484 484 + return { 485 485 + 'total': 23, 486 486 + 'dids': ['did:plc:alice'], 487 487 + 'cursor': null, 488 488 + }; 489 489 + }), 490 490 + ); 491 491 + 492 492 + final result = await repo.getBlockedByProfiles('did:plc:target'); 192 493 193 193 - expect(capturedCursor, 'page1'); 194 194 - expect(result.cursor, 'page2'); 494 494 + expect(getDistinctCalls, 2); 495 495 + expect(result.total, 23); 496 496 + expect(result.cursor, isNull); 497 497 + expect(result.entries.map((entry) => entry.did), ['did:plc:suspended', 'did:plc:alice']); 498 498 + expect(result.entries.first.unavailableReason, 'Profile unavailable'); 499 499 + expect(result.entries.last.profile?.did, 'did:plc:alice'); 195 500 }); 196 501 197 502 test('hydrates profiles in batches of 25', () async { ··· 213 518 final result = await repo.getBlockedByProfiles('did:plc:target'); 214 519 215 520 expect(batchSizes, [25, 5]); 216 216 - expect(result.profiles.length, 30); 521 521 + expect(result.entries.length, 16); 522 522 + expect(result.cursor, '16'); 217 523 }); 218 524 219 525 test('returns empty profiles when no DIDs returned', () async { ··· 222 528 223 529 final result = await repo.getBlockedByProfiles('did:plc:target'); 224 530 225 225 - expect(result.profiles, isEmpty); 531 531 + expect(result.entries, isEmpty); 226 532 expect(result.total, 0); 227 533 }); 534 534 + 535 535 + test('preserves blocked-by order across two local pages and marks suspended accounts inline', () async { 536 536 + const unavailableDidOne = 'did:plc:tsy5hmbt5lruc5jjaqglajtp'; 537 537 + const unavailableDidTwo = 'did:plc:hcton3oag5fbmtx2r55wduei'; 538 538 + final orderedDids = <String>[ 539 539 + 'did:plc:blocker00', 540 540 + 'did:plc:blocker01', 541 541 + 'did:plc:blocker02', 542 542 + 'did:plc:blocker03', 543 543 + unavailableDidOne, 544 544 + 'did:plc:blocker05', 545 545 + 'did:plc:blocker06', 546 546 + 'did:plc:blocker07', 547 547 + 'did:plc:blocker08', 548 548 + 'did:plc:blocker09', 549 549 + 'did:plc:blocker10', 550 550 + 'did:plc:blocker11', 551 551 + 'did:plc:blocker12', 552 552 + 'did:plc:blocker13', 553 553 + 'did:plc:blocker14', 554 554 + 'did:plc:blocker15', 555 555 + 'did:plc:blocker16', 556 556 + 'did:plc:blocker17', 557 557 + 'did:plc:blocker18', 558 558 + unavailableDidTwo, 559 559 + 'did:plc:blocker20', 560 560 + 'did:plc:blocker21', 561 561 + 'did:plc:blocker22', 562 562 + ]; 563 563 + final resolvedProfiles = orderedDids 564 564 + .where((did) => did != unavailableDidOne && did != unavailableDidTwo) 565 565 + .map((did) => _buildProfileViewDetailed(did, '$did.bsky.social')) 566 566 + .toList(); 567 567 + 568 568 + final constellation = ConstellationClient( 569 569 + httpClient: MockClient((request) async { 570 570 + if (request.url.path.contains('getDistinct')) { 571 571 + return http.Response('Not Found', 404); 572 572 + } 573 573 + 574 574 + if (request.url.path.contains('getBacklinks')) { 575 575 + final cursor = request.url.queryParameters['cursor']; 576 576 + final pageDids = cursor == null ? orderedDids.take(16).toList() : orderedDids.skip(16).toList(); 577 577 + return http.Response( 578 578 + jsonEncode({ 579 579 + 'total': 23, 580 580 + 'records': [ 581 581 + for (var i = 0; i < pageDids.length; i++) 582 582 + {'did': pageDids[i], 'collection': 'app.bsky.graph.block', 'rkey': '${cursor ?? 'page-1'}-$i'}, 583 583 + ], 584 584 + 'cursor': cursor == null ? '190209' : null, 585 585 + }), 586 586 + 200, 587 587 + ); 588 588 + } 589 589 + 590 590 + throw Exception('Unexpected endpoint: ${request.url.path}'); 591 591 + }), 592 592 + ); 593 593 + 594 594 + final repo = ProfileContextRepository( 595 595 + bluesky: _FakeBluesky( 596 596 + actor: _ThrowingActorService(), 597 597 + graph: _FakeGraphService(), 598 598 + atproto: _FakeAtProto(repo: _FakeRepoService(records: [])), 599 599 + ), 600 600 + publicBluesky: _FakeBluesky( 601 601 + actor: _FakeActorService( 602 602 + profiles: resolvedProfiles, 603 603 + errorsByActor: const { 604 604 + unavailableDidOne: ConstellationException('HTTP 400: AccountTakedown'), 605 605 + unavailableDidTwo: ConstellationException('HTTP 400: AccountTakedown'), 606 606 + }, 607 607 + ), 608 608 + graph: _FakeGraphService(), 609 609 + atproto: _FakeAtProto(repo: _FakeRepoService(records: [])), 610 610 + ), 611 611 + constellationClient: constellation, 612 612 + ); 613 613 + 614 614 + final firstPage = await repo.getBlockedByProfiles('did:plc:xg2vq45muivyy3xwatcehspu'); 615 615 + final secondPage = await repo.getBlockedByProfiles( 616 616 + 'did:plc:xg2vq45muivyy3xwatcehspu', 617 617 + cursor: firstPage.cursor, 618 618 + ); 619 619 + final allEntries = [...firstPage.entries, ...secondPage.entries]; 620 620 + 621 621 + expect(firstPage.total, 23); 622 622 + expect(firstPage.cursor, '16'); 623 623 + expect(secondPage.cursor, isNull); 624 624 + expect(allEntries, hasLength(23)); 625 625 + expect(allEntries.map((entry) => entry.did).toList(), orderedDids); 626 626 + expect(allEntries.where((entry) => entry.isAvailable), hasLength(21)); 627 627 + expect(allEntries.where((entry) => !entry.isAvailable).map((entry) => entry.did).toList(), [ 628 628 + unavailableDidOne, 629 629 + unavailableDidTwo, 630 630 + ]); 631 631 + expect( 632 632 + allEntries 633 633 + .where((entry) => !entry.isAvailable) 634 634 + .every((entry) => entry.unavailableReason == 'Suspended account'), 635 635 + isTrue, 636 636 + ); 637 637 + }); 228 638 }); 229 639 230 640 group('getBlockingProfiles', () { ··· 285 695 }); 286 696 }); 287 697 698 698 + group('getBlockingCount', () { 699 699 + test('counts records across every listRecords page', () async { 700 700 + final repo = ProfileContextRepository( 701 701 + bluesky: _FakeBluesky( 702 702 + actor: _FakeActorService(profiles: []), 703 703 + graph: _FakeGraphService(), 704 704 + atproto: _FakeAtProto( 705 705 + repo: _PaginatedRepoService( 706 706 + pages: [ 707 707 + _FakeListRecordsOutput( 708 708 + records: [ 709 709 + _FakeRecord({'subject': 'did:plc:one'}), 710 710 + _FakeRecord({'subject': 'did:plc:two'}), 711 711 + ], 712 712 + cursor: 'page-2', 713 713 + ), 714 714 + _FakeListRecordsOutput( 715 715 + records: [ 716 716 + _FakeRecord({'subject': 'did:plc:three'}), 717 717 + ], 718 718 + ), 719 719 + ], 720 720 + ), 721 721 + ), 722 722 + ), 723 723 + constellationClient: _alwaysThrowConstellation(), 724 724 + ); 725 725 + 726 726 + final result = await repo.getBlockingCount('did:plc:actor'); 727 727 + 728 728 + expect(result, 3); 729 729 + }); 730 730 + }); 731 731 + 288 732 group('getListsOn', () { 289 733 test('returns lists hydrated from getManyToMany results', () async { 290 734 const listUri = 'at://did:plc:owner/app.bsky.graph.list/listkey'; ··· 307 751 }); 308 752 309 753 final repo = ProfileContextRepository( 310 310 - bluesky: _buildBluesky(lists: {listUri: listView}), 754 754 + bluesky: _FakeBluesky( 755 755 + actor: _FakeActorService(profiles: const []), 756 756 + graph: _ThrowingGraphService(), 757 757 + atproto: _FakeAtProto(repo: _FakeRepoService(records: [])), 758 758 + ), 759 759 + publicBluesky: _FakeBluesky( 760 760 + actor: _FakeActorService(profiles: const []), 761 761 + graph: _FakeGraphService(lists: {listUri: listView}), 762 762 + atproto: _FakeAtProto(repo: _FakeRepoService(records: [])), 763 763 + ), 311 764 constellationClient: constellation, 312 765 ); 313 766 ··· 339 792 340 793 test('passes cursor to getManyToMany and returns response cursor', () async { 341 794 String? capturedCursor; 795 795 + String? capturedLimit; 342 796 final constellation = _constellationWithResponses((uri) { 343 797 if (uri.path.contains('getBacklinksCount')) return {'total': 0}; 344 798 if (uri.path.contains('getManyToMany')) { 345 799 capturedCursor = uri.queryParameters['cursor']; 800 800 + capturedLimit = uri.queryParameters['limit']; 346 801 return {'items': [], 'cursor': 'next-page'}; 347 802 } 348 803 return {}; ··· 353 808 final result = await repo.getListsOn('did:plc:target', cursor: 'page1'); 354 809 355 810 expect(capturedCursor, 'page1'); 811 811 + expect(capturedLimit, '16'); 356 812 expect(result.cursor, 'next-page'); 357 813 }); 358 814 ··· 398 854 399 855 expect(capturedUri.toString(), listUri); 400 856 }); 857 857 + 858 858 + test('deduplicates list URIs before hydrating metadata', () async { 859 859 + const listUri = 'at://did:plc:owner/app.bsky.graph.list/abc123'; 860 860 + final listView = _buildListView(listUri, 'Test List'); 861 861 + 862 862 + var getListCalls = 0; 863 863 + 864 864 + final repo = ProfileContextRepository( 865 865 + bluesky: _FakeBluesky( 866 866 + actor: _FakeActorService(profiles: []), 867 867 + graph: _CountingGraphService(lists: {listUri: listView}, onGetList: () => getListCalls += 1), 868 868 + atproto: _FakeAtProto(repo: _FakeRepoService(records: [])), 869 869 + ), 870 870 + constellationClient: _constellationWithResponses((uri) { 871 871 + if (uri.path.contains('getBacklinksCount')) return {'total': 2}; 872 872 + return { 873 873 + 'items': [ 874 874 + { 875 875 + 'linkRecord': {'did': 'did:plc:owner', 'collection': 'app.bsky.graph.listitem', 'rkey': 'rk-1'}, 876 876 + 'otherSubject': listUri, 877 877 + }, 878 878 + { 879 879 + 'linkRecord': {'did': 'did:plc:owner', 'collection': 'app.bsky.graph.listitem', 'rkey': 'rk-2'}, 880 880 + 'otherSubject': listUri, 881 881 + }, 882 882 + ], 883 883 + }; 884 884 + }), 885 885 + ); 886 886 + 887 887 + final result = await repo.getListsOn('did:plc:target'); 888 888 + 889 889 + expect(getListCalls, 1); 890 890 + expect(result.lists, [listView]); 891 891 + }); 892 892 + 893 893 + test('skips lists that fail hydration instead of failing the whole page', () async { 894 894 + const goodListUri = 'at://did:plc:owner/app.bsky.graph.list/good'; 895 895 + const missingListUri = 'at://did:plc:owner/app.bsky.graph.list/missing'; 896 896 + final goodListView = _buildListView(goodListUri, 'Good List'); 897 897 + 898 898 + final repo = ProfileContextRepository( 899 899 + bluesky: _buildBluesky(lists: {goodListUri: goodListView}), 900 900 + constellationClient: _constellationWithResponses((uri) { 901 901 + if (uri.path.contains('getBacklinksCount')) return {'total': 2}; 902 902 + return { 903 903 + 'items': [ 904 904 + { 905 905 + 'linkRecord': {'did': 'did:plc:owner', 'collection': 'app.bsky.graph.listitem', 'rkey': 'good'}, 906 906 + 'otherSubject': goodListUri, 907 907 + }, 908 908 + { 909 909 + 'linkRecord': {'did': 'did:plc:owner', 'collection': 'app.bsky.graph.listitem', 'rkey': 'bad'}, 910 910 + 'otherSubject': missingListUri, 911 911 + }, 912 912 + ], 913 913 + }; 914 914 + }), 915 915 + ); 916 916 + 917 917 + final result = await repo.getListsOn('did:plc:target'); 918 918 + 919 919 + expect(result.total, 2); 920 920 + expect(result.lists, [goodListView]); 921 921 + }); 922 922 + }); 923 923 + 924 924 + group('_hydrateProfiles normalization behavior via public APIs', () { 925 925 + test('trims and deduplicates DIDs before public hydration', () async { 926 926 + final capturedActors = <List<String>>[]; 927 927 + final repo = ProfileContextRepository( 928 928 + bluesky: _FakeBluesky( 929 929 + actor: _ThrowingActorService(), 930 930 + graph: _FakeGraphService(), 931 931 + atproto: _FakeAtProto(repo: _FakeRepoService(records: [])), 932 932 + ), 933 933 + publicBluesky: _FakeBluesky( 934 934 + actor: _BatchTrackingActorService( 935 935 + profiles: [_buildProfileView('did:plc:alice', 'alice.bsky.social')], 936 936 + batchSizes: [], 937 937 + onGetProfiles: (actors) => capturedActors.add(actors), 938 938 + ), 939 939 + graph: _FakeGraphService(), 940 940 + atproto: _FakeAtProto(repo: _FakeRepoService(records: [])), 941 941 + ), 942 942 + constellationClient: _constellationWithResponses((_) { 943 943 + return { 944 944 + 'total': 3, 945 945 + 'dids': [' did:plc:alice ', 'did:plc:alice', ' '], 946 946 + }; 947 947 + }), 948 948 + ); 949 949 + 950 950 + final result = await repo.getBlockedByProfiles('did:plc:target'); 951 951 + 952 952 + expect(capturedActors, [ 953 953 + ['did:plc:alice'], 954 954 + ]); 955 955 + expect(result.entries, hasLength(1)); 956 956 + expect(result.entries.first.profile?.did, 'did:plc:alice'); 957 957 + }); 401 958 }); 402 959 }); 403 960 } 404 961 405 962 _FakeBluesky _buildBluesky({ 406 406 - List<ProfileView> profiles = const [], 963 963 + List<dynamic> profiles = const [], 964 964 + Map<String, dynamic> profileByActor = const {}, 407 965 Map<String, ListView> lists = const {}, 408 966 List<Map<String, dynamic>> blockRecords = const [], 409 967 String? blockRecordsCursor, 410 968 }) { 411 969 return _FakeBluesky( 412 412 - actor: _FakeActorService(profiles: profiles), 970 970 + actor: _FakeActorService(profiles: profiles, profileByActor: profileByActor), 413 971 graph: _FakeGraphService(lists: lists), 414 972 atproto: _FakeAtProto( 415 973 repo: _FakeRepoService(records: blockRecords, cursor: blockRecordsCursor), ··· 424 982 } 425 983 426 984 class _BatchTrackingActorService { 427 427 - _BatchTrackingActorService({required this.profiles, required this.batchSizes}); 985 985 + _BatchTrackingActorService({required this.profiles, required this.batchSizes, this.onGetProfiles}); 428 986 429 429 - final List<ProfileView> profiles; 987 987 + final List<dynamic> profiles; 430 988 final List<int> batchSizes; 989 989 + final void Function(List<String> actors)? onGetProfiles; 431 990 432 991 Future<_FakeResponse<_FakeProfilesOutput>> getProfiles({ 433 992 required List<String> actors, 993 993 + String? $service, 434 994 Map<String, String>? $headers, 435 995 }) async { 436 996 batchSizes.add(actors.length); 437 437 - final matched = profiles.where((p) => actors.contains(p.did)).toList(); 997 997 + onGetProfiles?.call(actors); 998 998 + final matched = profiles.where((p) => actors.contains(p.did as String)).toList(); 438 999 return _FakeResponse(_FakeProfilesOutput(matched)); 439 1000 } 440 1001 } ··· 462 1023 } 463 1024 } 464 1025 1026 1026 + class _PaginatedRepoService { 1027 1027 + _PaginatedRepoService({required this.pages}); 1028 1028 + 1029 1029 + final List<_FakeListRecordsOutput> pages; 1030 1030 + var _pageIndex = 0; 1031 1031 + 1032 1032 + Future<_FakeResponse<_FakeListRecordsOutput>> listRecords({ 1033 1033 + required String repo, 1034 1034 + required String collection, 1035 1035 + int limit = 50, 1036 1036 + String? cursor, 1037 1037 + }) async { 1038 1038 + final page = pages[_pageIndex]; 1039 1039 + if (_pageIndex < pages.length - 1) { 1040 1040 + _pageIndex += 1; 1041 1041 + } 1042 1042 + return _FakeResponse(page); 1043 1043 + } 1044 1044 + } 1045 1045 + 465 1046 class _UriCapturingGraphService { 466 1047 _UriCapturingGraphService({required this.lists, required this.onGetList}); 467 1048 ··· 471 1052 Future<_FakeResponse<_FakeGetListOutput>> getList({ 472 1053 required AtUri list, 473 1054 int limit = 50, 1055 1055 + String? $service, 474 1056 Map<String, String>? $headers, 475 1057 }) async { 476 1058 onGetList(list); ··· 479 1061 return _FakeResponse(_FakeGetListOutput(listView)); 480 1062 } 481 1063 } 1064 1064 + 1065 1065 + class _CountingGraphService { 1066 1066 + _CountingGraphService({required this.lists, required this.onGetList}); 1067 1067 + 1068 1068 + final Map<String, ListView> lists; 1069 1069 + final void Function() onGetList; 1070 1070 + 1071 1071 + Future<_FakeResponse<_FakeGetListOutput>> getList({ 1072 1072 + required AtUri list, 1073 1073 + int limit = 50, 1074 1074 + String? $service, 1075 1075 + Map<String, String>? $headers, 1076 1076 + }) async { 1077 1077 + onGetList(); 1078 1078 + final listView = lists[list.toString()]; 1079 1079 + if (listView == null) throw Exception('List not found: $list'); 1080 1080 + return _FakeResponse(_FakeGetListOutput(listView)); 1081 1081 + } 1082 1082 + }

+149 -30

test/features/profile/presentation/profile_context_screen_test.dart

reviewed

··· 21 21 ProfileView _profile(String did) => 22 22 ProfileView(did: did, handle: '$did.bsky.social', displayName: 'User $did', indexedAt: DateTime.utc(2026)); 23 23 24 24 - bsky_graph.ListView _list(String rkey) => bsky_graph.ListView( 24 24 + bsky_graph.ListView _list( 25 25 + String rkey, { 26 26 + bsky_graph.KnownListPurpose purpose = bsky_graph.KnownListPurpose.appBskyGraphDefsCuratelist, 27 27 + String? description, 28 28 + int? memberCount, 29 29 + String creatorHandle = 'owner.bsky.social', 30 30 + }) => bsky_graph.ListView( 25 31 uri: AtUri.parse('at://did:plc:owner/app.bsky.graph.list/$rkey'), 26 32 cid: 'cid-$rkey', 27 27 - creator: const ProfileView(did: 'did:plc:owner', handle: 'owner.bsky.social'), 33 33 + creator: ProfileView(did: 'did:plc:owner', handle: creatorHandle), 28 34 name: 'List $rkey', 29 29 - purpose: const bsky_graph.ListPurpose.knownValue(data: bsky_graph.KnownListPurpose.appBskyGraphDefsCuratelist), 35 35 + purpose: bsky_graph.ListPurpose.knownValue(data: purpose), 36 36 + description: description, 37 37 + listItemCount: memberCount, 30 38 indexedAt: DateTime.utc(2026), 31 39 ); 32 40 ··· 51 59 when(() => cubit.refreshListsOn()).thenAnswer((_) async {}); 52 60 }); 53 61 54 54 - Widget buildSubject({ 55 55 - required ProfileContextState state, 56 56 - List<NavigatorObserver> observers = const [], 57 57 - String? Function(BuildContext, GoRouterState)? redirect, 58 58 - }) { 62 62 + Widget buildSubject({required ProfileContextState state, List<NavigatorObserver> observers = const []}) { 59 63 when(() => cubit.state).thenReturn(state); 60 64 whenListen(cubit, const Stream<ProfileContextState>.empty(), initialState: state); 61 65 ··· 71 75 routes: [ 72 76 GoRoute( 73 77 path: 'profile/view', 74 74 - builder: (context, state) => const Scaffold(body: Text('Profile View')), 78 78 + builder: (context, state) => Scaffold(body: Text('Profile View ${state.uri.queryParameters['actor']}')), 75 79 ), 76 80 GoRoute( 77 81 path: 'list', ··· 137 141 final profiles = [_profile('did:plc:user1'), _profile('did:plc:user2')]; 138 142 final state = initialState().copyWith( 139 143 blockedByStatus: ProfileContextTabStatus.loaded, 140 140 - blockedByProfiles: profiles, 144 144 + blockedByEntries: profiles.map((profile) => BlockedByEntry.profile(profile: profile)).toList(), 141 145 ); 142 146 await tester.pumpWidget(buildSubject(state: state)); 143 147 ··· 149 153 final profiles = [_profile('did:plc:user1')]; 150 154 final state = initialState().copyWith( 151 155 blockedByStatus: ProfileContextTabStatus.loaded, 152 152 - blockedByProfiles: profiles, 156 156 + blockedByEntries: profiles.map((profile) => BlockedByEntry.profile(profile: profile)).toList(), 153 157 ); 154 158 155 155 - String? pushedRoute; 156 156 - final observer = _TestNavigatorObserver(onPush: (route, _) => pushedRoute = route.settings.name); 157 157 - 158 158 - await tester.pumpWidget(buildSubject(state: state, observers: [observer])); 159 159 + await tester.pumpWidget(buildSubject(state: state)); 159 160 await tester.tap(find.text('User did:plc:user1')); 160 161 await tester.pumpAndSettle(); 161 162 162 162 - expect(pushedRoute, '/profile/view'); 163 163 - expect(find.text('Profile View'), findsOneWidget); 163 163 + expect(find.text('Profile View did:plc:user1.bsky.social'), findsOneWidget); 164 164 + }); 165 165 + 166 166 + testWidgets('loads next blocked-by page when scrolled near the end', (tester) async { 167 167 + final profiles = List.generate(20, (index) => _profile('did:plc:user$index')); 168 168 + final state = initialState().copyWith( 169 169 + blockedByStatus: ProfileContextTabStatus.loaded, 170 170 + blockedByEntries: profiles.map((profile) => BlockedByEntry.profile(profile: profile)).toList(), 171 171 + blockedByCursor: 'next-page', 172 172 + blockedByHasMore: true, 173 173 + ); 174 174 + await tester.pumpWidget(buildSubject(state: state)); 175 175 + 176 176 + await tester.drag(find.byType(CustomScrollView).first, const Offset(0, -4000)); 177 177 + await tester.pump(); 178 178 + 179 179 + verify(() => cubit.loadBlockedBy(cursor: 'next-page')).called(greaterThanOrEqualTo(1)); 164 180 }); 165 181 166 182 testWidgets('shows contextualizing note', (tester) async { ··· 170 186 }); 171 187 172 188 testWidgets('shows empty state when loaded with no profiles', (tester) async { 173 173 - final state = initialState().copyWith(blockedByStatus: ProfileContextTabStatus.loaded, blockedByProfiles: []); 189 189 + final state = initialState().copyWith(blockedByStatus: ProfileContextTabStatus.loaded, blockedByEntries: []); 174 190 await tester.pumpWidget(buildSubject(state: state)); 175 191 176 192 expect(find.text('No accounts have blocked this user'), findsOneWidget); 177 193 }); 178 194 195 195 + testWidgets('shows unresolved-details message when count is non-zero but no profiles resolved', (tester) async { 196 196 + final state = initialState().copyWith( 197 197 + blockedByStatus: ProfileContextTabStatus.loaded, 198 198 + blockedByCount: 23, 199 199 + blockedByEntries: [], 200 200 + ); 201 201 + await tester.pumpWidget(buildSubject(state: state)); 202 202 + 203 203 + expect(find.textContaining('public Bluesky profile details could not be loaded'), findsOneWidget); 204 204 + }); 205 205 + 206 206 + testWidgets('shows unavailable blocked-by rows inline with resolved profiles', (tester) async { 207 207 + final state = initialState().copyWith( 208 208 + blockedByStatus: ProfileContextTabStatus.loaded, 209 209 + blockedByCount: 23, 210 210 + blockedByEntries: [ 211 211 + BlockedByEntry.profile(profile: _profile('did:plc:user1')), 212 212 + const BlockedByEntry.unavailable(did: 'did:plc:suspended', unavailableReason: 'Suspended account'), 213 213 + ], 214 214 + ); 215 215 + await tester.pumpWidget(buildSubject(state: state)); 216 216 + 217 217 + expect(find.byKey(const ValueKey('blocked_by_did:plc:user1')), findsOneWidget); 218 218 + expect(find.byKey(const ValueKey('blocked_by_unavailable_did:plc:suspended')), findsOneWidget); 219 219 + expect(find.text('did:plc:suspended'), findsOneWidget); 220 220 + expect(find.text('Suspended account'), findsOneWidget); 221 221 + expect(find.text('User did:plc:user1'), findsOneWidget); 222 222 + expect(find.text('23 accounts'), findsOneWidget); 223 223 + }); 224 224 + 225 225 + testWidgets('unavailable blocked-by rows are non-navigable', (tester) async { 226 226 + final state = initialState().copyWith( 227 227 + blockedByStatus: ProfileContextTabStatus.loaded, 228 228 + blockedByCount: 1, 229 229 + blockedByEntries: const [ 230 230 + BlockedByEntry.unavailable(did: 'did:plc:suspended', unavailableReason: 'Suspended account'), 231 231 + ], 232 232 + ); 233 233 + await tester.pumpWidget(buildSubject(state: state)); 234 234 + 235 235 + await tester.tap(find.text('did:plc:suspended')); 236 236 + await tester.pumpAndSettle(); 237 237 + 238 238 + expect(find.textContaining('Profile View'), findsNothing); 239 239 + }); 240 240 + 179 241 testWidgets('shows error and retry button on error state', (tester) async { 180 242 final state = initialState().copyWith( 181 243 blockedByStatus: ProfileContextTabStatus.error, ··· 221 283 expect(find.text('User did:plc:blocked1'), findsOneWidget); 222 284 }); 223 285 286 286 + testWidgets('shows count header for own profile', (tester) async { 287 287 + final state = const ProfileContextState.initial( 288 288 + did: _did, 289 289 + isOwnProfile: true, 290 290 + ).copyWith(blockingCount: 4, blockingStatus: ProfileContextTabStatus.loaded); 291 291 + await tester.pumpWidget(buildSubject(state: state)); 292 292 + 293 293 + await tester.tap(find.text('Blocking (4)')); 294 294 + await tester.pumpAndSettle(); 295 295 + 296 296 + expect(find.text('4 accounts'), findsOneWidget); 297 297 + }); 298 298 + 299 299 + testWidgets('shows unavailable-account card on blocking tab', (tester) async { 300 300 + final state = const ProfileContextState.initial(did: _did, isOwnProfile: true).copyWith( 301 301 + blockingStatus: ProfileContextTabStatus.loaded, 302 302 + blockingUnavailable: const [ 303 303 + UnavailableProfileRef(did: 'did:plc:takedown', reason: 'Suspended or taken-down account'), 304 304 + ], 305 305 + ); 306 306 + await tester.pumpWidget(buildSubject(state: state)); 307 307 + 308 308 + await tester.tap(find.text('Blocking')); 309 309 + await tester.pumpAndSettle(); 310 310 + 311 311 + expect(find.text('Unavailable accounts (1)'), findsOneWidget); 312 312 + expect(find.text('did:plc:takedown'), findsOneWidget); 313 313 + }); 314 314 + 224 315 testWidgets('shows empty state for own profile when loaded with no profiles', (tester) async { 225 316 final state = const ProfileContextState.initial( 226 317 did: _did, ··· 276 367 await tester.tap(find.text('User did:plc:blocked1')); 277 368 await tester.pumpAndSettle(); 278 369 279 279 - expect(find.text('Profile View'), findsOneWidget); 370 370 + expect(find.text('Profile View did:plc:blocked1.bsky.social'), findsOneWidget); 280 371 }); 281 372 }); 282 373 ··· 293 384 expect(find.text('List rkey2'), findsOneWidget); 294 385 }); 295 386 387 387 + testWidgets('groups lists by purpose and shows owner, purpose, and description', (tester) async { 388 388 + final lists = [ 389 389 + _list( 390 390 + 'curate', 391 391 + purpose: bsky_graph.KnownListPurpose.appBskyGraphDefsCuratelist, 392 392 + description: 'Curated follows', 393 393 + memberCount: 12, 394 394 + creatorHandle: 'curator.bsky.social', 395 395 + ), 396 396 + _list( 397 397 + 'mod', 398 398 + purpose: bsky_graph.KnownListPurpose.appBskyGraphDefsModlist, 399 399 + description: 'Moderation context', 400 400 + memberCount: 3, 401 401 + creatorHandle: 'moderator.bsky.social', 402 402 + ), 403 403 + _list( 404 404 + 'ref', 405 405 + purpose: bsky_graph.KnownListPurpose.appBskyGraphDefsReferencelist, 406 406 + memberCount: 8, 407 407 + creatorHandle: 'reference.bsky.social', 408 408 + ), 409 409 + ]; 410 410 + final state = initialState().copyWith(listsOnStatus: ProfileContextTabStatus.loaded, listsOn: lists); 411 411 + await tester.pumpWidget(buildSubject(state: state)); 412 412 + 413 413 + await tester.tap(find.text('Lists')); 414 414 + await tester.pumpAndSettle(); 415 415 + 416 416 + expect(find.text('Curation Lists'), findsOneWidget); 417 417 + expect(find.text('Moderation Lists'), findsOneWidget); 418 418 + expect(find.text('Reference Lists'), findsOneWidget); 419 419 + expect(find.text('@curator.bsky.social'), findsOneWidget); 420 420 + expect(find.text('Curated follows'), findsOneWidget); 421 421 + expect(find.text('CURATE'), findsOneWidget); 422 422 + expect(find.text('MOD'), findsOneWidget); 423 423 + expect(find.text('REFERENCE'), findsOneWidget); 424 424 + }); 425 425 + 296 426 testWidgets('list card navigates to /list on tap', (tester) async { 297 427 final lists = [_list('rkey1')]; 298 428 final state = initialState().copyWith(listsOnStatus: ProfileContextTabStatus.loaded, listsOn: lists); ··· 344 474 }); 345 475 }); 346 476 } 347 347 - 348 348 - class _TestNavigatorObserver extends NavigatorObserver { 349 349 - _TestNavigatorObserver({this.onPush}); 350 350 - 351 351 - final void Function(Route<dynamic>, Route<dynamic>?)? onPush; 352 352 - 353 353 - @override 354 354 - void didPush(Route<dynamic> route, Route<dynamic>? previousRoute) { 355 355 - onPush?.call(route, previousRoute); 356 356 - } 357 357 - }