//! Each account's private preferences: `app.bsky.actor.getPreferences` and //! `putPreferences`, as `spec/PROXY.md` says. //! //! An account's preferences are kept behind a lock of their own, and each //! `putPreferences` is an entry in `accounts.log` holding the whole list, //! appended under that lock so that the log has an account's lists in the //! order they were put; the answer waits, with no lock held, until the //! entry is on disk. use crate::proxy::{self, Request}; use crate::sessions::{self, ACCESS, Bearer, Token}; use crate::{Handler, Resp, Service, Shared, XrpcError, durable, internal, invalid, read, write}; use pds_repo::data::{civil_from_days, datetime_millis}; use serde_json::{Map, Value as Json, json}; use std::collections::HashMap; use std::sync::{Arc, Mutex, MutexGuard, PoisonError, RwLock}; /// The kind of `accounts.log` entry that holds an account's preferences. pub(crate) const ENTRY: &str = "preferences"; const PERSONAL: &str = "app.bsky.actor.defs#personalDetailsPref"; const DECLARED_AGE: &str = "app.bsky.actor.defs#declaredAgePref"; /// Every account's preferences, by DID. #[derive(Default)] pub(crate) struct Preferences(RwLock>>>>); fn lock(k: &Mutex>) -> MutexGuard<'_, Vec> { k.lock().unwrap_or_else(PoisonError::into_inner) } /// The preferences an entry of the kind `ENTRY` holds. pub(crate) fn parse(e: &Json) -> Result, String> { e["preferences"] .as_array() .filter(|p| p.iter().all(|p| p["$type"].is_string())) .cloned() .ok_or_else(|| format!("preferences that are not a list of objects with a $type: {e}")) } impl Preferences { fn keep(&self, did: &str) -> Arc>> { if let Some(k) = read(&self.0).get(did) { return k.clone(); } write(&self.0).entry(did.to_string()).or_default().clone() } /// An account's preferences, as its entries of the service log leave /// them: what an account loaded has (`directory`). pub fn put(&self, did: &str, prefs: Vec) { write(&self.0).insert(did.to_string(), Arc::new(Mutex::new(prefs))); } /// Forget a deleted account's preferences, logged with its deletion. pub fn forget(&self, did: &str) { write(&self.0).remove(did); } /// Every account's preferences that has any, to compare across restarts. #[cfg(test)] pub fn snapshot(&self) -> std::collections::BTreeMap> { read(&self.0) .iter() .map(|(did, k)| (did.clone(), lock(k).clone())) .filter(|(_, p)| !p.is_empty()) .collect() } } pub(crate) fn handler(nsid: &str) -> Option { Some(match nsid { "app.bsky.actor.getPreferences" => { Handler::Proxy(|s, r, _| Box::pin(get_preferences(s, r))) } "app.bsky.actor.putPreferences" => { Handler::Proxy(|s, r, b| Box::pin(put_preferences(s, r, b))) } _ => return None, }) } fn is(p: &Json, t: &str) -> bool { p["$type"] == t } /// The age, in whole years in UTC, of one born at `birth` (in milliseconds since the epoch) at `now`. fn age(birth: i64, now: i64) -> i64 { let date = |ms: i64| civil_from_days(ms.div_euclid(86_400_000)); let ((by, bm, bd), (y, m, d)) = (date(birth), date(now)); y - by - i64::from((m, d) < (bm, bd)) } /// The token a method the server serves for the app takes: an access token, /// and for `getPreferences` a taken-down account's too (`spec/LIFECYCLE.md`). pub(crate) fn token(s: &Service, nsid: &str, b: Bearer) -> Result { match nsid { "app.bsky.actor.getPreferences" => sessions::takendown_ok_token(s, b), _ => sessions::access_token(s, b), } } async fn get_preferences(s: Shared, r: Request) -> Result { let t = sessions::takendown_ok_token(&s, r.bearer())?; if proxy::names_other(&s, r.proxy.as_deref()) { let target = proxy::target(&s, r.proxy.as_deref()).await?; let got = proxy::forward_query( &s, &r, &target, Some((&t.did, &target.did, "app.bsky.actor.getPreferences")), ) .await?; return Ok(proxy::answered(got, true)); } let (kept, n) = { let keep = s.prefs.keep(&t.did); let kept = lock(&keep).clone(); (kept, s.log.written()) }; let full = t.scope == ACCESS; let birth = kept .iter() .find(|p| is(p, PERSONAL)) .and_then(|p| p["birthDate"].as_str()) .and_then(datetime_millis); let mut out: Vec = kept .into_iter() .filter(|p| full || !is(p, PERSONAL)) .collect(); if let Some(birth) = birth { let now = std::time::SystemTime::now() .duration_since(std::time::UNIX_EPOCH) .unwrap_or_default() .as_millis() as i64; let age = age(birth, now); out.push(json!({ "$type": DECLARED_AGE, "isOverAge13": age >= 13, "isOverAge16": age >= 16, "isOverAge18": age >= 18 })); } durable(s.log.clone(), n).await?; Ok(Resp::Json(json!({ "preferences": out }))) } /// `putPreferences`, its token and input checked, its rate limits paid and /// the free space found enough (`limits::guard`). async fn put_preferences( s: Shared, r: Request, input: Map, ) -> Result { let t = sessions::access_token(&s, r.bearer())?; // The reference forwards only queries. if proxy::names_other(&s, r.proxy.as_deref()) { return internal(); } let Some(given) = input.get("preferences").and_then(Json::as_array) else { return invalid("Input/preferences must be an array"); }; for p in given { let t = p["$type"].as_str().unwrap_or_default(); if !(t == "app.bsky" || t.starts_with("app.bsky.")) { return invalid(format!( "Some preferences are not in the app.bsky namespace: {t:?}" )); } } let full = t.scope == ACCESS; if !full && given.iter().any(|p| is(p, PERSONAL)) { return invalid("Do not have authorization to set preferences."); } let Some(a) = s.account(&t.did) else { return crate::lifecycle::account_not_found(); }; let n = { // Held while the put is logged, as a deletion holds it while it is: // no put is logged after its account's deletion (`spec/LIFECYCLE.md`). let state = read(&a.state); if state.deleted { return crate::lifecycle::account_not_found(); } let keep = s.prefs.keep(&t.did); let mut k = lock(&keep); let mut next: Vec = if full { vec![] } else { k.iter().filter(|p| is(p, PERSONAL)).cloned().collect() }; next.extend(given.iter().filter(|p| !is(p, DECLARED_AGE)).cloned()); let n = match s .log .append(&[json!({ "t": ENTRY, "did": t.did, "preferences": next })]) { Ok(n) => n, Err(e) => { crate::ops::failed("writing accounts.log failed", e); return internal(); } }; *k = next; n }; durable(s.log.clone(), n).await?; Ok(Resp::Nothing) } #[cfg(test)] mod tests { use super::*; use crate::testing::*; fn ms(s: &str) -> i64 { datetime_millis(s).unwrap() } #[test] fn ages() { let now = ms("2026-11-09T12:00:00Z"); assert_eq!(age(ms("2008-11-09T00:00:00Z"), now), 18); assert_eq!(age(ms("2008-11-10T00:00:00Z"), now), 17); assert_eq!(age(ms("2013-11-08T00:00:00Z"), now), 13); // In UTC: 23:00 at -05:00 is the next day. assert_eq!(age(ms("2008-11-09T23:00:00-05:00"), now), 17); } /// Preferences as the server answers them, by session. async fn get(s: &Shared, token: &str) -> Json { call(s, "app.bsky.actor.getPreferences", Some(token), Json::Null) .await .unwrap()["preferences"] .clone() } #[tokio::test] async fn put_and_get() { let plc = plc().await; let dir = scratch("prefs"); let cfg = || { let mut c = config(&plc); c.proxy.appview = Some(proxy::AppView { url: "http://127.0.0.1:1".into(), did: "did:web:appview.test".into(), }); c }; let s = Arc::new(crate::Service::open(&dir, cfg()).unwrap()); let (did, full) = create(&s, "alice").await; let app = call( &s, "com.atproto.server.createAppPassword", Some(&full), json!({ "name": "phone" }), ) .await .unwrap(); let login = json!({ "identifier": "alice.test", "password": app["password"] }); let phone = call(&s, "com.atproto.server.createSession", None, login) .await .unwrap()["accessJwt"] .as_str() .unwrap() .to_string(); assert_eq!(get(&s, &full).await, json!([])); let put = |token: &str, prefs: Json| { let (s, token) = (s.clone(), token.to_string()); async move { call( &s, "app.bsky.actor.putPreferences", Some(&token), json!({ "preferences": prefs, "other": 1 }), ) .await } }; let personal = json!({ "$type": PERSONAL, "birthDate": "2000-01-01T00:00:00.000Z" }); let adult = json!({ "$type": "app.bsky.actor.defs#adultContentPref" }); let other = json!({ "$type": "app.bsky.x y", "anything": [1] }); let declared = json!({ "$type": DECLARED_AGE, "isOverAge13": false }); assert_eq!( put(&full, json!([personal, adult, other, declared, adult])).await, Ok(Json::Null) ); let age = json!({ "$type": DECLARED_AGE, "isOverAge13": true, "isOverAge16": true, "isOverAge18": true }); let filled = json!({ "$type": "app.bsky.actor.defs#adultContentPref", "enabled": false }); assert_eq!( get(&s, &full).await, json!([personal, filled, other, filled, age]) ); // An app password's session sees no personal details, but the age they make. assert_eq!(get(&s, &phone).await, json!([filled, other, filled, age])); // It cannot write them, and keeps them when it puts the rest. assert_eq!( put(&phone, json!([personal])).await, Err("InvalidRequest".into()) ); assert_eq!(put(&phone, json!([other])).await, Ok(Json::Null)); assert_eq!(get(&s, &full).await, json!([personal, other, age])); // Refusals, each leaving the preferences as they were. for bad in [ json!([{ "$type": "com.example.pref" }]), json!([{ "$type": "" }]), json!([{ "enabled": true }]), json!([{ "$type": PERSONAL, "birthDate": "2000-01-01" }]), json!([{ "$type": "app.bsky.actor.defs#interestsPref", "tags": ["x".repeat(65)] }]), json!({}), ] { assert_eq!( put(&full, bad.clone()).await, Err("InvalidRequest".into()), "{bad}" ); } assert_eq!( call(&s, "app.bsky.actor.putPreferences", Some(&full), json!({})).await, Err("InvalidRequest".into()) ); assert_eq!( call( &s, "app.bsky.actor.putPreferences", None, json!({ "preferences": [] }) ) .await, Err("AuthMissing".into()) ); assert_eq!( call(&s, "app.bsky.actor.getPreferences", None, Json::Null).await, Err("AuthMissing".into()) ); assert_eq!(get(&s, &full).await, json!([personal, other, age])); // Another account's are its own. let (_, bob) = create(&s, "bob").await; assert_eq!(get(&s, &bob).await, json!([])); // They survive a restart. drop(s); let s = Arc::new(crate::Service::open(&dir, cfg()).unwrap()); assert_eq!(get(&s, &full).await, json!([personal, other, age])); assert_eq!(s.prefs.snapshot().keys().collect::>(), [&did]); let _ = std::fs::remove_dir_all(&dir); } }