BlueSky & more on desktop
lazurite.stormlightlabs.org/
tauri
rust
typescript
bluesky
appview
atproto
solid
feat: diagnostics commands and constellation client
+1432
-38
+46
src-tauri/src/commands/diagnostics.rs
+46
src-tauri/src/commands/diagnostics.rs
···
1
+
#![allow(clippy::needless_pass_by_value)]
2
+
3
+
use crate::diagnostics;
4
+
use crate::error::AppError;
5
+
use crate::state::AppState;
6
+
use tauri::State;
7
+
8
+
#[tauri::command]
9
+
pub async fn get_account_lists(
10
+
did: String, state: State<'_, AppState>,
11
+
) -> Result<diagnostics::AccountListsResult, AppError> {
12
+
diagnostics::get_account_lists(did, &state).await
13
+
}
14
+
15
+
#[tauri::command]
16
+
pub async fn get_account_labels(did: String) -> Result<diagnostics::AccountLabelsResult, AppError> {
17
+
diagnostics::get_account_labels(did).await
18
+
}
19
+
20
+
#[tauri::command]
21
+
pub async fn get_account_blocked_by(
22
+
did: String, limit: Option<u32>, cursor: Option<String>, state: State<'_, AppState>,
23
+
) -> Result<diagnostics::AccountBlockedByResult, AppError> {
24
+
diagnostics::get_account_blocked_by(did, limit, cursor, &state).await
25
+
}
26
+
27
+
#[tauri::command]
28
+
pub async fn get_account_blocking(
29
+
did: String, cursor: Option<String>,
30
+
) -> Result<diagnostics::AccountBlockingResult, AppError> {
31
+
diagnostics::get_account_blocking(did, cursor).await
32
+
}
33
+
34
+
#[tauri::command]
35
+
pub async fn get_account_starter_packs(
36
+
did: String, state: State<'_, AppState>,
37
+
) -> Result<diagnostics::AccountStarterPacksResult, AppError> {
38
+
diagnostics::get_account_starter_packs(did, &state).await
39
+
}
40
+
41
+
#[tauri::command]
42
+
pub async fn get_record_backlinks(
43
+
uri: String, state: State<'_, AppState>,
44
+
) -> Result<diagnostics::RecordBacklinksResult, AppError> {
45
+
diagnostics::get_record_backlinks(uri, &state).await
46
+
}
+1
src-tauri/src/commands/mod.rs
+1
src-tauri/src/commands/mod.rs
+10
src-tauri/src/commands/settings.rs
+10
src-tauri/src/commands/settings.rs
···
11
11
}
12
12
13
13
#[tauri::command]
14
+
pub fn get_constellation_url(state: State<'_, AppState>) -> Result<String, AppError> {
15
+
settings::get_constellation_url(&state)
16
+
}
17
+
18
+
#[tauri::command]
14
19
pub fn update_setting(key: String, value: String, app: AppHandle, state: State<'_, AppState>) -> Result<(), AppError> {
15
20
settings::update_setting(&key, &value, &state, &app)
21
+
}
22
+
23
+
#[tauri::command]
24
+
pub fn set_constellation_url(url: String, app: AppHandle, state: State<'_, AppState>) -> Result<(), AppError> {
25
+
settings::set_constellation_url(&url, &state, &app)
16
26
}
17
27
18
28
#[tauri::command]
+226
src-tauri/src/constellation.rs
+226
src-tauri/src/constellation.rs
···
1
+
use crate::error::{AppError, Result};
2
+
use reqwest::{Client, StatusCode, Url};
3
+
use serde::de::DeserializeOwned;
4
+
use serde::{Deserialize, Serialize};
5
+
use tauri_plugin_log::log;
6
+
7
+
const DEFAULT_TIMEOUT_SECS: u64 = 10;
8
+
const USER_AGENT: &str = "lazurite-desktop";
9
+
const GET_BACKLINKS_COUNT_NSID: &str = "blue.microcosm.links.getBacklinksCount";
10
+
const GET_BACKLINKS_NSID: &str = "blue.microcosm.links.getBacklinks";
11
+
const GET_DISTINCT_NSID: &str = "blue.microcosm.links.getDistinct";
12
+
const GET_BACKLINK_DIDS_NSID: &str = "blue.microcosm.links.getBacklinkDids";
13
+
const GET_MANY_TO_MANY_COUNTS_NSID: &str = "blue.microcosm.links.getManyToManyCounts";
14
+
const GET_MANY_TO_MANY_NSID: &str = "blue.microcosm.links.getManyToMany";
15
+
16
+
#[derive(Debug, Clone)]
17
+
pub struct ConstellationClient {
18
+
base_url: Url,
19
+
http: Client,
20
+
}
21
+
22
+
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
23
+
pub struct BacklinksCountResponse {
24
+
pub total: u64,
25
+
}
26
+
27
+
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
28
+
#[serde(rename_all = "camelCase")]
29
+
pub struct ConstellationLinkRecord {
30
+
pub did: String,
31
+
pub collection: String,
32
+
pub rkey: String,
33
+
}
34
+
35
+
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
36
+
pub struct BacklinksResponse {
37
+
pub total: u64,
38
+
#[serde(default)]
39
+
pub records: Vec<ConstellationLinkRecord>,
40
+
pub cursor: Option<String>,
41
+
}
42
+
43
+
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
44
+
pub struct DistinctDidsResponse {
45
+
pub total: u64,
46
+
#[serde(default, alias = "linking_dids", alias = "linkingDids")]
47
+
pub dids: Vec<String>,
48
+
pub cursor: Option<String>,
49
+
}
50
+
51
+
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
52
+
pub struct ManyToManyCountsResponse {
53
+
#[serde(default)]
54
+
pub counts_by_other_subject: Vec<ManyToManyCount>,
55
+
}
56
+
57
+
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
58
+
pub struct ManyToManyCount {
59
+
#[serde(alias = "otherSubject")]
60
+
pub subject: String,
61
+
pub total: u64,
62
+
pub distinct: u64,
63
+
}
64
+
65
+
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
66
+
pub struct ManyToManyResponse {
67
+
#[serde(default)]
68
+
pub items: Vec<ManyToManyItem>,
69
+
pub cursor: Option<String>,
70
+
}
71
+
72
+
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
73
+
#[serde(rename_all = "camelCase")]
74
+
pub struct ManyToManyItem {
75
+
pub link_record: ConstellationLinkRecord,
76
+
pub other_subject: String,
77
+
}
78
+
79
+
impl ConstellationClient {
80
+
pub fn new(base_url: &str) -> Result<Self> {
81
+
let parsed = Url::parse(base_url)
82
+
.map_err(|error| AppError::validation(format!("invalid Constellation URL: {error}")))?;
83
+
84
+
match parsed.scheme() {
85
+
"http" | "https" => {}
86
+
_ => return Err(AppError::validation("Constellation URL must use http or https")),
87
+
}
88
+
89
+
if parsed.host_str().is_none() {
90
+
return Err(AppError::validation("Constellation URL must include a host"));
91
+
}
92
+
93
+
let http = Client::builder()
94
+
.timeout(std::time::Duration::from_secs(DEFAULT_TIMEOUT_SECS))
95
+
.user_agent(USER_AGENT)
96
+
.build()?;
97
+
98
+
Ok(Self { base_url: parsed, http })
99
+
}
100
+
101
+
pub async fn get_backlinks_count(&self, subject: String, source: String) -> Result<BacklinksCountResponse> {
102
+
self.get_json(GET_BACKLINKS_COUNT_NSID, &[("subject", subject), ("source", source)])
103
+
.await
104
+
}
105
+
106
+
pub async fn get_backlinks(
107
+
&self, subject: String, source: String, limit: Option<u32>, cursor: Option<String>,
108
+
) -> Result<BacklinksResponse> {
109
+
let mut query = vec![("subject", subject), ("source", source)];
110
+
if let Some(limit) = limit {
111
+
query.push(("limit", limit.to_string()));
112
+
}
113
+
if let Some(cursor) = cursor {
114
+
query.push(("cursor", cursor));
115
+
}
116
+
117
+
self.get_json(GET_BACKLINKS_NSID, &query).await
118
+
}
119
+
120
+
pub async fn get_distinct_dids(
121
+
&self, subject: String, source: String, limit: Option<u32>, cursor: Option<String>,
122
+
) -> Result<DistinctDidsResponse> {
123
+
let mut query = vec![("subject", subject.clone()), ("source", source.clone())];
124
+
if let Some(limit) = limit {
125
+
query.push(("limit", limit.to_string()));
126
+
}
127
+
if let Some(cursor) = cursor.clone() {
128
+
query.push(("cursor", cursor));
129
+
}
130
+
131
+
let response = self.send(GET_DISTINCT_NSID, &query).await?;
132
+
if response.status() == StatusCode::NOT_FOUND {
133
+
log::warn!(
134
+
"Constellation {} returned 404; falling back to {}",
135
+
GET_DISTINCT_NSID,
136
+
GET_BACKLINK_DIDS_NSID
137
+
);
138
+
return self.get_json(GET_BACKLINK_DIDS_NSID, &query).await;
139
+
}
140
+
141
+
Self::decode_json(response, GET_DISTINCT_NSID).await
142
+
}
143
+
144
+
pub async fn get_many_to_many_counts(
145
+
&self, subject: String, source: String, path_to_other: String,
146
+
) -> Result<ManyToManyCountsResponse> {
147
+
self.get_json(
148
+
GET_MANY_TO_MANY_COUNTS_NSID,
149
+
&[("subject", subject), ("source", source), ("pathToOther", path_to_other)],
150
+
)
151
+
.await
152
+
}
153
+
154
+
pub async fn get_many_to_many(
155
+
&self, subject: String, source: String, path_to_other: String, limit: Option<u32>, cursor: Option<String>,
156
+
) -> Result<ManyToManyResponse> {
157
+
let mut query = vec![("subject", subject), ("source", source), ("pathToOther", path_to_other)];
158
+
if let Some(limit) = limit {
159
+
query.push(("limit", limit.to_string()));
160
+
}
161
+
if let Some(cursor) = cursor {
162
+
query.push(("cursor", cursor));
163
+
}
164
+
165
+
self.get_json(GET_MANY_TO_MANY_NSID, &query).await
166
+
}
167
+
168
+
async fn get_json<T>(&self, endpoint: &str, query: &[(&str, String)]) -> Result<T>
169
+
where
170
+
T: DeserializeOwned,
171
+
{
172
+
let response = self.send(endpoint, query).await?;
173
+
Self::decode_json(response, endpoint).await
174
+
}
175
+
176
+
async fn send(&self, endpoint: &str, query: &[(&str, String)]) -> Result<reqwest::Response> {
177
+
let mut url = self.base_url.clone();
178
+
url.set_path(&format!("/xrpc/{endpoint}"));
179
+
180
+
self.http.get(url).query(query).send().await.map_err(AppError::from)
181
+
}
182
+
183
+
async fn decode_json<T>(response: reqwest::Response, endpoint: &str) -> Result<T>
184
+
where
185
+
T: DeserializeOwned,
186
+
{
187
+
let status = response.status();
188
+
if !status.is_success() {
189
+
let body = response.text().await.unwrap_or_default();
190
+
log::warn!("Constellation {endpoint} failed with {status}: {body}");
191
+
return Err(AppError::validation(
192
+
"The diagnostics service returned an unexpected response.",
193
+
));
194
+
}
195
+
196
+
response.json::<T>().await.map_err(|error| {
197
+
log::error!("failed to decode Constellation {endpoint} response: {error}");
198
+
AppError::validation("The diagnostics service returned data Lazurite could not read.")
199
+
})
200
+
}
201
+
}
202
+
203
+
#[cfg(test)]
204
+
mod tests {
205
+
use super::{DistinctDidsResponse, ManyToManyCountsResponse};
206
+
207
+
#[test]
208
+
fn distinct_response_accepts_backlink_dids_shape() {
209
+
let parsed: DistinctDidsResponse =
210
+
serde_json::from_str(r#"{"total":2,"linking_dids":["did:plc:one","did:plc:two"],"cursor":"abc"}"#)
211
+
.expect("backlink dids response should deserialize");
212
+
213
+
assert_eq!(parsed.dids, vec!["did:plc:one", "did:plc:two"]);
214
+
assert_eq!(parsed.cursor.as_deref(), Some("abc"));
215
+
}
216
+
217
+
#[test]
218
+
fn many_to_many_counts_accepts_subject_field() {
219
+
let parsed: ManyToManyCountsResponse = serde_json::from_str(
220
+
r#"{"counts_by_other_subject":[{"subject":"at://did/list/1","total":1,"distinct":1}]}"#,
221
+
)
222
+
.expect("many-to-many counts should deserialize");
223
+
224
+
assert_eq!(parsed.counts_by_other_subject[0].subject, "at://did/list/1");
225
+
}
226
+
}
+10
-13
src-tauri/src/conversations.rs
+10
-13
src-tauri/src/conversations.rs
···
60
60
async fn ensure_chat_scope(state: &AppState) -> Result<()> {
61
61
let did = active_did(state)?;
62
62
let parsed_did = Did::new(&did).map_err(|_| AppError::validation("invalid active account DID"))?;
63
-
let account = state
64
-
.auth_store
65
-
.get_account(&did)?
66
-
.ok_or_else(|| {
67
-
log::error!("active account missing from auth store");
68
-
AppError::validation("no active account")
69
-
})?;
63
+
let account = state.auth_store.get_account(&did)?.ok_or_else(|| {
64
+
log::error!("active account missing from auth store");
65
+
AppError::validation("no active account")
66
+
})?;
70
67
let session_id = account.session_id.ok_or_else(|| {
71
68
log::error!("active account missing session id");
72
69
AppError::validation("no active account session")
···
97
94
CallOptions { atproto_proxy: Some(CHAT_PROXY.into()), ..Default::default() }
98
95
}
99
96
100
-
fn map_chat_error(error: ClientError, default_message: &'static str, context: &'static str) -> AppError {
97
+
fn map_chat_error(error: &ClientError, default_message: &'static str, context: &'static str) -> AppError {
101
98
if let ClientErrorKind::Http { status } = error.kind() {
102
99
if *status == StatusCode::FORBIDDEN {
103
100
log::warn!("{context} forbidden, likely missing DM scope");
···
120
117
let output = session
121
118
.send_with_opts(req.build(), chat_opts())
122
119
.await
123
-
.map_err(|error| map_chat_error(error, "Could not load conversations.", "listConvos error"))?
120
+
.map_err(|error| map_chat_error(&error, "Could not load conversations.", "listConvos error"))?
124
121
.into_output()
125
122
.map_err(|error| {
126
123
log::error!("listConvos output error: {error}");
···
150
147
let output = session
151
148
.send_with_opts(req, chat_opts())
152
149
.await
153
-
.map_err(|error| map_chat_error(error, "Could not open this conversation.", "getConvoForMembers error"))?
150
+
.map_err(|error| map_chat_error(&error, "Could not open this conversation.", "getConvoForMembers error"))?
154
151
.into_output()
155
152
.map_err(|error| {
156
153
log::error!("getConvoForMembers output error: {error}");
···
179
176
let output = session
180
177
.send_with_opts(req.build(), chat_opts())
181
178
.await
182
-
.map_err(|error| map_chat_error(error, "Could not load messages.", "getMessages error"))?
179
+
.map_err(|error| map_chat_error(&error, "Could not load messages.", "getMessages error"))?
183
180
.into_output()
184
181
.map_err(|error| {
185
182
log::error!("getMessages output error: {error}");
···
205
202
let output = session
206
203
.send_with_opts(req, chat_opts())
207
204
.await
208
-
.map_err(|error| map_chat_error(error, "Could not send this message.", "sendMessage error"))?
205
+
.map_err(|error| map_chat_error(&error, "Could not send this message.", "sendMessage error"))?
209
206
.into_output()
210
207
.map_err(|error| {
211
208
log::error!("sendMessage output error: {error}");
···
233
230
.await
234
231
.map_err(|error| {
235
232
map_chat_error(
236
-
error,
233
+
&error,
237
234
"Could not update the read status for this conversation.",
238
235
"updateRead error",
239
236
)
+564
src-tauri/src/diagnostics.rs
+564
src-tauri/src/diagnostics.rs
···
1
+
use crate::constellation::{BacklinksResponse, ConstellationClient, ConstellationLinkRecord};
2
+
use crate::error::{AppError, Result};
3
+
use crate::explorer;
4
+
use crate::settings;
5
+
use crate::state::AppState;
6
+
use jacquard::api::app_bsky::actor::get_profiles::GetProfiles;
7
+
use jacquard::api::app_bsky::graph::get_list::GetList;
8
+
use jacquard::api::app_bsky::graph::get_starter_packs::GetStarterPacks;
9
+
use jacquard::api::com_atproto::label::query_labels::QueryLabels;
10
+
use jacquard::client::{Agent, UnauthenticatedSession};
11
+
use jacquard::identity::JacquardResolver;
12
+
use jacquard::types::aturi::AtUri;
13
+
use jacquard::types::did::Did;
14
+
use jacquard::types::ident::AtIdentifier;
15
+
use jacquard::xrpc::XrpcClient;
16
+
use jacquard::IntoStatic;
17
+
use serde::{Deserialize, Serialize};
18
+
use serde_json::Value;
19
+
use std::collections::{BTreeMap, BTreeSet, HashMap};
20
+
use tauri_plugin_log::log;
21
+
22
+
const LIST_MEMBERSHIP_SOURCE: &str = "app.bsky.graph.listitem:subject";
23
+
const LIST_MEMBERSHIP_PATH_TO_OTHER: &str = "list";
24
+
const BLOCK_SOURCE: &str = "app.bsky.graph.block:subject";
25
+
const STARTER_PACK_SOURCE: &str = "app.bsky.graph.starterpack:listItemsSample[].subject";
26
+
const BLOCK_COLLECTION: &str = "app.bsky.graph.block";
27
+
const LIKES_SOURCE: &str = "app.bsky.feed.like:subject.uri";
28
+
const REPOSTS_SOURCE: &str = "app.bsky.feed.repost:subject.uri";
29
+
const REPLIES_SOURCE: &str = "app.bsky.feed.post:reply.parent.uri";
30
+
const QUOTES_SOURCE: &str = "app.bsky.feed.post:embed.record.uri";
31
+
const PUBLIC_BATCH_LIMIT: usize = 25;
32
+
const ACCOUNT_LIST_PAGE_LIMIT: u32 = 100;
33
+
const ACCOUNT_LIST_MAX_ITEMS: usize = 200;
34
+
const STARTER_PACK_LIMIT: u32 = 100;
35
+
const STARTER_PACK_MAX_ITEMS: usize = 200;
36
+
const BACKLINK_PREVIEW_LIMIT: u32 = 25;
37
+
const BLOCK_PREVIEW_LIMIT: u32 = 50;
38
+
const LABEL_LIMIT: i64 = 100;
39
+
40
+
type PublicClient = Agent<UnauthenticatedSession<JacquardResolver>>;
41
+
42
+
#[derive(Debug, Clone, Serialize)]
43
+
#[serde(rename_all = "camelCase")]
44
+
pub struct AccountListsResult {
45
+
pub total: usize,
46
+
pub lists: Vec<Value>,
47
+
pub truncated: bool,
48
+
}
49
+
50
+
#[derive(Debug, Clone, Serialize)]
51
+
#[serde(rename_all = "camelCase")]
52
+
pub struct AccountLabelsResult {
53
+
pub labels: Vec<Value>,
54
+
pub source_profiles: BTreeMap<String, Value>,
55
+
pub cursor: Option<String>,
56
+
}
57
+
58
+
#[derive(Debug, Clone, Serialize)]
59
+
#[serde(rename_all = "camelCase")]
60
+
pub struct DidProfileItem {
61
+
pub did: String,
62
+
pub profile: Option<Value>,
63
+
}
64
+
65
+
#[derive(Debug, Clone, Serialize)]
66
+
#[serde(rename_all = "camelCase")]
67
+
pub struct AccountBlockedByResult {
68
+
pub total: u64,
69
+
pub items: Vec<DidProfileItem>,
70
+
pub cursor: Option<String>,
71
+
}
72
+
73
+
#[derive(Debug, Clone, Serialize)]
74
+
#[serde(rename_all = "camelCase")]
75
+
pub struct AccountBlockingResult {
76
+
pub items: Vec<AccountBlockingItem>,
77
+
pub cursor: Option<String>,
78
+
}
79
+
80
+
#[derive(Debug, Clone, Serialize)]
81
+
#[serde(rename_all = "camelCase")]
82
+
pub struct AccountBlockingItem {
83
+
pub uri: String,
84
+
pub cid: String,
85
+
pub subject_did: String,
86
+
pub created_at: Option<String>,
87
+
pub value: Value,
88
+
pub profile: Option<Value>,
89
+
}
90
+
91
+
#[derive(Debug, Clone, Serialize)]
92
+
#[serde(rename_all = "camelCase")]
93
+
pub struct AccountStarterPacksResult {
94
+
pub total: u64,
95
+
pub starter_packs: Vec<Value>,
96
+
pub truncated: bool,
97
+
}
98
+
99
+
#[derive(Debug, Clone, Serialize)]
100
+
#[serde(rename_all = "camelCase")]
101
+
pub struct RecordBacklinksResult {
102
+
pub likes: BacklinkGroup,
103
+
pub reposts: BacklinkGroup,
104
+
pub replies: BacklinkGroup,
105
+
pub quotes: BacklinkGroup,
106
+
}
107
+
108
+
#[derive(Debug, Clone, Serialize)]
109
+
#[serde(rename_all = "camelCase")]
110
+
pub struct BacklinkGroup {
111
+
pub total: u64,
112
+
pub records: Vec<BacklinkRecordItem>,
113
+
pub cursor: Option<String>,
114
+
}
115
+
116
+
#[derive(Debug, Clone, Serialize)]
117
+
#[serde(rename_all = "camelCase")]
118
+
pub struct BacklinkRecordItem {
119
+
pub uri: String,
120
+
pub did: String,
121
+
pub collection: String,
122
+
pub rkey: String,
123
+
pub profile: Option<Value>,
124
+
}
125
+
126
+
#[derive(Debug, Clone, Deserialize)]
127
+
#[serde(rename_all = "camelCase")]
128
+
struct RepoListRecordsOutput {
129
+
cursor: Option<String>,
130
+
#[serde(default)]
131
+
records: Vec<RepoRecord>,
132
+
}
133
+
134
+
#[derive(Debug, Clone, Deserialize)]
135
+
#[serde(rename_all = "camelCase")]
136
+
struct RepoRecord {
137
+
uri: String,
138
+
cid: String,
139
+
value: Value,
140
+
}
141
+
142
+
pub async fn get_account_lists(did: String, state: &AppState) -> Result<AccountListsResult> {
143
+
let normalized_did = normalize_did(&did)?;
144
+
let client = constellation_client(state)?;
145
+
let counts = client
146
+
.get_many_to_many_counts(
147
+
normalized_did.clone(),
148
+
LIST_MEMBERSHIP_SOURCE.to_string(),
149
+
LIST_MEMBERSHIP_PATH_TO_OTHER.to_string(),
150
+
)
151
+
.await
152
+
.map_err(|error| diagnostics_error("Couldn't load lists for this account.", error))?;
153
+
154
+
let mut list_uris = Vec::new();
155
+
let mut cursor = None;
156
+
let mut truncated = false;
157
+
158
+
while list_uris.len() < ACCOUNT_LIST_MAX_ITEMS {
159
+
let response = client
160
+
.get_many_to_many(
161
+
normalized_did.clone(),
162
+
LIST_MEMBERSHIP_SOURCE.to_string(),
163
+
LIST_MEMBERSHIP_PATH_TO_OTHER.to_string(),
164
+
Some(ACCOUNT_LIST_PAGE_LIMIT),
165
+
cursor.clone(),
166
+
)
167
+
.await
168
+
.map_err(|error| diagnostics_error("Couldn't load lists for this account.", error))?;
169
+
170
+
if response.items.is_empty() {
171
+
break;
172
+
}
173
+
174
+
for item in response.items {
175
+
if list_uris.len() >= ACCOUNT_LIST_MAX_ITEMS {
176
+
truncated = true;
177
+
break;
178
+
}
179
+
list_uris.push(item.other_subject);
180
+
}
181
+
182
+
match response.cursor {
183
+
Some(next_cursor) if list_uris.len() < ACCOUNT_LIST_MAX_ITEMS => cursor = Some(next_cursor),
184
+
Some(_) => {
185
+
truncated = true;
186
+
break;
187
+
}
188
+
None => break,
189
+
}
190
+
}
191
+
192
+
let unique_list_uris = dedupe_preserve_order(list_uris);
193
+
let lists = fetch_lists(&unique_list_uris).await?;
194
+
195
+
Ok(AccountListsResult { total: counts.counts_by_other_subject.len(), lists, truncated })
196
+
}
197
+
198
+
pub async fn get_account_labels(did: String) -> Result<AccountLabelsResult> {
199
+
let normalized_did = normalize_did(&did)?;
200
+
let client = public_client();
201
+
let output = client
202
+
.send(
203
+
QueryLabels::new()
204
+
.uri_patterns(vec![normalized_did.clone().into()])
205
+
.limit(LABEL_LIMIT)
206
+
.build(),
207
+
)
208
+
.await
209
+
.map_err(|error| diagnostics_error("Couldn't load labels for this account.", error))?
210
+
.into_output()
211
+
.map_err(|error| diagnostics_error("Couldn't read labels for this account.", error))?
212
+
.into_static();
213
+
214
+
let labels = output
215
+
.labels
216
+
.iter()
217
+
.map(serde_json::to_value)
218
+
.collect::<std::result::Result<Vec<_>, _>>()?;
219
+
220
+
let source_dids = output
221
+
.labels
222
+
.iter()
223
+
.map(|label| label.src.to_string())
224
+
.collect::<Vec<_>>();
225
+
let source_profiles = fetch_profiles_map(&source_dids).await?;
226
+
227
+
Ok(AccountLabelsResult { labels, source_profiles, cursor: output.cursor.map(|cursor| cursor.to_string()) })
228
+
}
229
+
230
+
pub async fn get_account_blocked_by(
231
+
did: String, limit: Option<u32>, cursor: Option<String>, state: &AppState,
232
+
) -> Result<AccountBlockedByResult> {
233
+
let normalized_did = normalize_did(&did)?;
234
+
let client = constellation_client(state)?;
235
+
let response = client
236
+
.get_distinct_dids(
237
+
normalized_did,
238
+
BLOCK_SOURCE.to_string(),
239
+
limit.or(Some(BLOCK_PREVIEW_LIMIT)),
240
+
cursor,
241
+
)
242
+
.await
243
+
.map_err(|error| diagnostics_error("Couldn't load the accounts blocking this profile.", error))?;
244
+
245
+
let profiles = fetch_profiles_map(&response.dids).await?;
246
+
let items = response
247
+
.dids
248
+
.into_iter()
249
+
.map(|entry_did| DidProfileItem { profile: profiles.get(&entry_did).cloned(), did: entry_did })
250
+
.collect();
251
+
252
+
Ok(AccountBlockedByResult { total: response.total, items, cursor: response.cursor })
253
+
}
254
+
255
+
pub async fn get_account_blocking(did: String, cursor: Option<String>) -> Result<AccountBlockingResult> {
256
+
let normalized_did = normalize_did(&did)?;
257
+
let output = explorer::list_records(normalized_did.clone(), BLOCK_COLLECTION.to_string(), cursor)
258
+
.await
259
+
.map_err(|error| diagnostics_error("Couldn't load this account's block records.", error))?;
260
+
let parsed: RepoListRecordsOutput = serde_json::from_value(output).map_err(|error| {
261
+
log::error!("failed to decode block listRecords output: {error}");
262
+
AppError::validation("Lazurite couldn't read this account's block records.")
263
+
})?;
264
+
265
+
let subject_dids = parsed
266
+
.records
267
+
.iter()
268
+
.filter_map(|record| extract_subject_did(&record.value))
269
+
.collect::<Vec<_>>();
270
+
let profiles = fetch_profiles_map(&subject_dids).await?;
271
+
272
+
let items = parsed
273
+
.records
274
+
.into_iter()
275
+
.filter_map(|record| {
276
+
let subject_did = extract_subject_did(&record.value)?;
277
+
Some(AccountBlockingItem {
278
+
created_at: extract_created_at(&record.value),
279
+
profile: profiles.get(&subject_did).cloned(),
280
+
uri: record.uri,
281
+
cid: record.cid,
282
+
subject_did,
283
+
value: record.value,
284
+
})
285
+
})
286
+
.collect();
287
+
288
+
Ok(AccountBlockingResult { items, cursor: parsed.cursor })
289
+
}
290
+
291
+
pub async fn get_account_starter_packs(did: String, state: &AppState) -> Result<AccountStarterPacksResult> {
292
+
let normalized_did = normalize_did(&did)?;
293
+
let client = constellation_client(state)?;
294
+
let count = client
295
+
.get_backlinks_count(normalized_did.clone(), STARTER_PACK_SOURCE.to_string())
296
+
.await
297
+
.map_err(|error| diagnostics_error("Couldn't load starter packs for this account.", error))?;
298
+
299
+
let mut pack_uris = Vec::new();
300
+
let mut cursor = None;
301
+
let mut truncated = false;
302
+
303
+
while pack_uris.len() < STARTER_PACK_MAX_ITEMS {
304
+
let response = client
305
+
.get_backlinks(
306
+
normalized_did.clone(),
307
+
STARTER_PACK_SOURCE.to_string(),
308
+
Some(STARTER_PACK_LIMIT),
309
+
cursor.clone(),
310
+
)
311
+
.await
312
+
.map_err(|error| diagnostics_error("Couldn't load starter packs for this account.", error))?;
313
+
314
+
if response.records.is_empty() {
315
+
break;
316
+
}
317
+
318
+
for record in response.records {
319
+
if pack_uris.len() >= STARTER_PACK_MAX_ITEMS {
320
+
truncated = true;
321
+
break;
322
+
}
323
+
pack_uris.push(link_record_uri(&record));
324
+
}
325
+
326
+
match response.cursor {
327
+
Some(next_cursor) if pack_uris.len() < STARTER_PACK_MAX_ITEMS => cursor = Some(next_cursor),
328
+
Some(_) => {
329
+
truncated = true;
330
+
break;
331
+
}
332
+
None => break,
333
+
}
334
+
}
335
+
336
+
let starter_packs = fetch_starter_packs(&dedupe_preserve_order(pack_uris)).await?;
337
+
Ok(AccountStarterPacksResult { total: count.total, starter_packs, truncated })
338
+
}
339
+
340
+
pub async fn get_record_backlinks(uri: String, state: &AppState) -> Result<RecordBacklinksResult> {
341
+
let normalized_uri = normalize_at_uri(&uri)?;
342
+
let client = constellation_client(state)?;
343
+
344
+
let likes = fetch_backlink_group(&client, &normalized_uri, LIKES_SOURCE).await?;
345
+
let reposts = fetch_backlink_group(&client, &normalized_uri, REPOSTS_SOURCE).await?;
346
+
let replies = fetch_backlink_group(&client, &normalized_uri, REPLIES_SOURCE).await?;
347
+
let quotes = fetch_backlink_group(&client, &normalized_uri, QUOTES_SOURCE).await?;
348
+
349
+
Ok(RecordBacklinksResult { likes, reposts, replies, quotes })
350
+
}
351
+
352
+
fn constellation_client(state: &AppState) -> Result<ConstellationClient> {
353
+
ConstellationClient::new(&settings::get_constellation_url(state)?)
354
+
}
355
+
356
+
fn public_client() -> PublicClient {
357
+
Agent::new(UnauthenticatedSession::new_public())
358
+
}
359
+
360
+
fn normalize_did(input: &str) -> Result<String> {
361
+
let trimmed = input.trim();
362
+
if trimmed.is_empty() {
363
+
return Err(AppError::validation("A DID is required."));
364
+
}
365
+
366
+
Did::new(trimmed)
367
+
.map(|did| did.to_string())
368
+
.map_err(|_| AppError::validation("Enter a valid DID."))
369
+
}
370
+
371
+
fn normalize_at_uri(input: &str) -> Result<String> {
372
+
let trimmed = input.trim();
373
+
if trimmed.is_empty() {
374
+
return Err(AppError::validation("A record URI is required."));
375
+
}
376
+
377
+
AtUri::new(trimmed)
378
+
.map(|uri| uri.to_string())
379
+
.map_err(|_| AppError::validation("Enter a valid AT-URI."))
380
+
}
381
+
382
+
fn diagnostics_error(message: &'static str, error: impl std::fmt::Display) -> AppError {
383
+
log::error!("{message} {error}");
384
+
AppError::validation(message)
385
+
}
386
+
387
+
fn link_record_uri(record: &ConstellationLinkRecord) -> String {
388
+
format!("at://{}/{}/{}", record.did, record.collection, record.rkey)
389
+
}
390
+
391
+
fn dedupe_preserve_order(values: Vec<String>) -> Vec<String> {
392
+
let mut seen = BTreeSet::new();
393
+
let mut deduped = Vec::new();
394
+
395
+
for value in values {
396
+
if seen.insert(value.clone()) {
397
+
deduped.push(value);
398
+
}
399
+
}
400
+
401
+
deduped
402
+
}
403
+
404
+
fn did_identifier(did: &str) -> Result<AtIdentifier<'static>> {
405
+
Ok(AtIdentifier::Did(Did::new(did)?.into_static()))
406
+
}
407
+
408
+
async fn fetch_profiles_map(dids: &[String]) -> Result<BTreeMap<String, Value>> {
409
+
let unique_dids = dedupe_preserve_order(dids.to_vec());
410
+
if unique_dids.is_empty() {
411
+
return Ok(BTreeMap::new());
412
+
}
413
+
414
+
let client = public_client();
415
+
let mut profiles = BTreeMap::new();
416
+
417
+
for chunk in unique_dids.chunks(PUBLIC_BATCH_LIMIT) {
418
+
let actors = chunk
419
+
.iter()
420
+
.map(|did| did_identifier(did))
421
+
.collect::<Result<Vec<_>>>()?;
422
+
let output = client
423
+
.send(GetProfiles::new().actors(actors).build())
424
+
.await
425
+
.map_err(|error| diagnostics_error("Couldn't load account profiles.", error))?
426
+
.into_output()
427
+
.map_err(|error| diagnostics_error("Couldn't read account profiles.", error))?
428
+
.into_static();
429
+
430
+
for profile in output.profiles {
431
+
profiles.insert(profile.did.to_string(), serde_json::to_value(profile)?);
432
+
}
433
+
}
434
+
435
+
Ok(profiles)
436
+
}
437
+
438
+
async fn fetch_lists(list_uris: &[String]) -> Result<Vec<Value>> {
439
+
let client = public_client();
440
+
let mut lists = Vec::new();
441
+
442
+
for list_uri in list_uris {
443
+
let parsed_uri = AtUri::new(list_uri).map_err(|_| AppError::validation("A list URI was invalid."))?;
444
+
let output = client
445
+
.send(GetList::new().list(parsed_uri.into_static()).limit(1).build())
446
+
.await
447
+
.map_err(|error| diagnostics_error("Couldn't load one of the matching lists.", error))?
448
+
.into_output()
449
+
.map_err(|error| diagnostics_error("Couldn't read one of the matching lists.", error))?
450
+
.into_static();
451
+
lists.push(serde_json::to_value(output.list)?);
452
+
}
453
+
454
+
Ok(lists)
455
+
}
456
+
457
+
async fn fetch_starter_packs(uris: &[String]) -> Result<Vec<Value>> {
458
+
if uris.is_empty() {
459
+
return Ok(Vec::new());
460
+
}
461
+
462
+
let client = public_client();
463
+
let mut starter_packs = Vec::new();
464
+
465
+
for chunk in uris.chunks(PUBLIC_BATCH_LIMIT) {
466
+
let parsed_uris = chunk
467
+
.iter()
468
+
.map(|uri| {
469
+
AtUri::new(uri)
470
+
.map(IntoStatic::into_static)
471
+
.map_err(|_| AppError::validation("A starter pack URI was invalid."))
472
+
})
473
+
.collect::<Result<Vec<_>>>()?;
474
+
let output = client
475
+
.send(GetStarterPacks::new().uris(parsed_uris).build())
476
+
.await
477
+
.map_err(|error| diagnostics_error("Couldn't load starter packs for this account.", error))?
478
+
.into_output()
479
+
.map_err(|error| diagnostics_error("Couldn't read starter pack details.", error))?
480
+
.into_static();
481
+
482
+
for starter_pack in output.starter_packs {
483
+
starter_packs.push(serde_json::to_value(starter_pack)?);
484
+
}
485
+
}
486
+
487
+
Ok(starter_packs)
488
+
}
489
+
490
+
async fn fetch_backlink_group(client: &ConstellationClient, subject: &str, source: &str) -> Result<BacklinkGroup> {
491
+
let response = client
492
+
.get_backlinks(
493
+
subject.to_string(),
494
+
source.to_string(),
495
+
Some(BACKLINK_PREVIEW_LIMIT),
496
+
None,
497
+
)
498
+
.await
499
+
.map_err(|error| diagnostics_error("Couldn't load record backlinks right now.", error))?;
500
+
501
+
build_backlink_group(response).await
502
+
}
503
+
504
+
async fn build_backlink_group(response: BacklinksResponse) -> Result<BacklinkGroup> {
505
+
let dids = response
506
+
.records
507
+
.iter()
508
+
.map(|record| record.did.clone())
509
+
.collect::<Vec<_>>();
510
+
let profiles = fetch_profiles_lookup(&dids).await?;
511
+
512
+
let records = response
513
+
.records
514
+
.into_iter()
515
+
.map(|record| BacklinkRecordItem {
516
+
uri: link_record_uri(&record),
517
+
profile: profiles.get(&record.did).cloned(),
518
+
did: record.did,
519
+
collection: record.collection,
520
+
rkey: record.rkey,
521
+
})
522
+
.collect();
523
+
524
+
Ok(BacklinkGroup { total: response.total, records, cursor: response.cursor })
525
+
}
526
+
527
+
async fn fetch_profiles_lookup(dids: &[String]) -> Result<HashMap<String, Value>> {
528
+
Ok(fetch_profiles_map(dids).await?.into_iter().collect())
529
+
}
530
+
531
+
fn extract_subject_did(value: &Value) -> Option<String> {
532
+
value.get("subject").and_then(Value::as_str).map(str::to_string)
533
+
}
534
+
535
+
fn extract_created_at(value: &Value) -> Option<String> {
536
+
value.get("createdAt").and_then(Value::as_str).map(str::to_string)
537
+
}
538
+
539
+
#[cfg(test)]
540
+
mod tests {
541
+
use super::{dedupe_preserve_order, extract_created_at, extract_subject_did};
542
+
use serde_json::json;
543
+
544
+
#[test]
545
+
fn dedupe_preserve_order_keeps_first_occurrence() {
546
+
let values = vec!["at://one".to_string(), "at://two".to_string(), "at://one".to_string()];
547
+
548
+
assert_eq!(
549
+
dedupe_preserve_order(values),
550
+
vec!["at://one".to_string(), "at://two".to_string()]
551
+
);
552
+
}
553
+
554
+
#[test]
555
+
fn extract_subject_and_created_at_from_block_value() {
556
+
let value = json!({
557
+
"subject": "did:plc:blocked",
558
+
"createdAt": "2025-01-01T00:00:00Z"
559
+
});
560
+
561
+
assert_eq!(extract_subject_did(&value).as_deref(), Some("did:plc:blocked"));
562
+
assert_eq!(extract_created_at(&value).as_deref(), Some("2025-01-01T00:00:00Z"));
563
+
}
564
+
}
+17
-10
src-tauri/src/feed.rs
+17
-10
src-tauri/src/feed.rs
···
717
717
let session = get_session(state).await?;
718
718
let active_did = active_did(state)?;
719
719
720
-
let follow = Follow::new().created_at(Datetime::now()).subject(Did::new(&did)?).build();
720
+
let follow = Follow::new()
721
+
.created_at(Datetime::now())
722
+
.subject(Did::new(&did)?)
723
+
.build();
721
724
722
725
let record_json = serde_json::to_value(&follow)?;
723
-
let record_data =
724
-
Data::from_json_owned(record_json).map_err(|_| AppError::validation("serialize follow"))?;
726
+
let record_data = Data::from_json_owned(record_json).map_err(|_| AppError::validation("serialize follow"))?;
725
727
726
728
let repo = AtIdentifier::Did(Did::new(&active_did)?);
727
729
let collection = Nsid::new("app.bsky.graph.follow").map_err(|_| AppError::validation("nsid"))?;
728
730
729
731
let output = session
730
-
.send(CreateRecord::new().repo(repo).collection(collection).record(record_data).build())
732
+
.send(
733
+
CreateRecord::new()
734
+
.repo(repo)
735
+
.collection(collection)
736
+
.record(record_data)
737
+
.build(),
738
+
)
731
739
.await
732
740
.map_err(|error| {
733
741
log::error!("createRecord (follow) error: {error}");
···
746
754
let session = get_session(state).await?;
747
755
let did = active_did(state)?;
748
756
749
-
let at_uri =
750
-
AtUri::new(&follow_uri).map_err(|_| AppError::validation("invalid follow URI"))?;
751
-
let RecordKey(rkey) =
752
-
at_uri.rkey().ok_or_else(|| AppError::Validation("follow URI has no rkey".into()))?;
757
+
let at_uri = AtUri::new(&follow_uri).map_err(|_| AppError::validation("invalid follow URI"))?;
758
+
let RecordKey(rkey) = at_uri
759
+
.rkey()
760
+
.ok_or_else(|| AppError::Validation("follow URI has no rkey".into()))?;
753
761
let rkey_str = rkey.to_string();
754
762
755
763
let repo = AtIdentifier::Did(Did::new(&did)?);
756
-
let collection =
757
-
Nsid::new("app.bsky.graph.follow").map_err(|_| AppError::validation("nsid"))?;
764
+
let collection = Nsid::new("app.bsky.graph.follow").map_err(|_| AppError::validation("nsid"))?;
758
765
let rkey = RecordKey::any(&rkey_str).map_err(|_| AppError::validation("invalid rkey"))?;
759
766
760
767
session
+10
src-tauri/src/lib.rs
+10
src-tauri/src/lib.rs
···
1
1
mod auth;
2
2
mod columns;
3
3
mod commands;
4
+
mod constellation;
4
5
mod conversations;
5
6
mod db;
7
+
mod diagnostics;
6
8
mod error;
7
9
mod explorer;
8
10
mod feed;
···
122
124
cmd::search::get_embeddings_config,
123
125
cmd::search::prepare_embeddings_model,
124
126
cmd::settings::get_settings,
127
+
cmd::settings::get_constellation_url,
125
128
cmd::settings::update_setting,
129
+
cmd::settings::set_constellation_url,
126
130
cmd::settings::get_cache_size,
127
131
cmd::settings::clear_cache,
128
132
cmd::settings::export_data,
129
133
cmd::settings::reset_app,
130
134
cmd::settings::get_log_entries,
135
+
cmd::diagnostics::get_account_lists,
136
+
cmd::diagnostics::get_account_labels,
137
+
cmd::diagnostics::get_account_blocked_by,
138
+
cmd::diagnostics::get_account_blocking,
139
+
cmd::diagnostics::get_account_starter_packs,
140
+
cmd::diagnostics::get_record_backlinks,
131
141
cmd::columns::get_columns,
132
142
cmd::columns::add_column,
133
143
cmd::columns::remove_column,
+8
src-tauri/src/settings.rs
+8
src-tauri/src/settings.rs
···
556
556
db_get_all_settings(&conn)
557
557
}
558
558
559
+
pub fn get_constellation_url(state: &AppState) -> Result<String> {
560
+
Ok(get_settings(state)?.constellation_url)
561
+
}
562
+
559
563
pub fn update_setting(key: &str, value: &str, state: &AppState, app: &AppHandle) -> Result<()> {
560
564
let valid_key = match SettingsKey::from_str(key) {
561
565
Some(valid_key) if SettingsKey::valid_keys().contains(&valid_key) => valid_key,
···
573
577
574
578
apply_post_persist_side_effects(valid_key, &normalized_value, app);
575
579
Ok(())
580
+
}
581
+
582
+
pub fn set_constellation_url(url: &str, state: &AppState, app: &AppHandle) -> Result<()> {
583
+
update_setting(SettingsKey::ConstellationUrl.as_str(), url, state, app)
576
584
}
577
585
578
586
pub fn get_cache_size(state: &AppState) -> Result<CacheSize> {