//! The spaces each account is the authority of (`spec/SPACES-POLICIES.md`): //! creating, changing, describing and deleting them, a memberspace's //! member list, taking an account out of the writer set, publishing the //! policy and members to readers, and a space's host-side state as an //! archive. Who a policy authorizes is `space_authz`. //! //! A space's state is its authority's: kept with the account's repository, //! under its lock, each change one frame of its `repo.log` (`ENTRIES`). A //! deleted space is remembered as deleted. use crate::oauth::space_scope::SpaceOp; use crate::space_authz::{Asking, SpaceState}; use crate::space_repo::Staged; use crate::{ Account, Call, Handler, Resp, Service, Shared, Store, XrpcError, durable, err, input, invalid, invalid_token, read, sessions, write, }; use pds_lexicon::Method; use pds_repo::data::{self, V}; use pds_space::{Commit, SpaceRef, star}; use serde_json::{Map, Value as Json, json}; use std::collections::BTreeMap; use std::ops::Bound; use std::sync::Arc; /// The kinds of `repo.log` entry this module keeps, each naming its space /// by `space`. The writer set's (`spaceWriter`, `spaceWriterRemoved`) are /// logged by the notifications' part (`space_notify`). pub(crate) const ENTRIES: &[&str] = &[ "spaceCreate", "spaceUpdate", "spaceDelete", "spaceMember", "spaceUnmember", "spaceImport", "spaceWriter", "spaceWriterRemoved", ]; pub(crate) const PERSONAL: &str = "com.atproto.personalspace.policy"; pub(crate) const MEMBER: &str = "com.atproto.memberspace.policy"; pub(crate) const MANAGED: &str = "com.atproto.managedspace.policy"; /// The published records' collections. pub(crate) const POLICY_RECORD: &str = "com.atproto.space.policy"; pub(crate) const MEMBER_RECORD: &str = "com.atproto.memberspace.member"; /// A space meta archive's profile. const META_TYPE: &str = "atproto-space-meta"; const WRITER: &str = "writer/"; // ---- Policies --------------------------------------------------------------- /// A space's policy, as stored: defaults filled in, and nothing its lexicon /// does not define. #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) enum Policy { Personal, Member { public_read: bool, public_write: bool, publish_policy: bool, publish_members: bool, allowed_apps: Option>, }, Managed { managing_app: String, publish_policy: bool, }, } impl Policy { /// A policy as stored or logged: `UnsupportedPolicy` for a `$type` not /// one of the three. pub fn read(p: &Json) -> Result { let flag = |k: &str| p.get(k).and_then(Json::as_bool).unwrap_or(false); let t = p["$type"].as_str().unwrap_or_default(); match t.strip_suffix("#main").unwrap_or(t) { PERSONAL => Ok(Policy::Personal), MEMBER => Ok(Policy::Member { public_read: flag("publicRead"), public_write: flag("publicWrite"), publish_policy: flag("publishPolicy"), publish_members: flag("publishMembers"), allowed_apps: p.get("allowedApps").and_then(Json::as_array).map(|a| { a.iter() .filter_map(Json::as_str) .map(str::to_string) .collect() }), }), MANAGED => Ok(Policy::Managed { managing_app: p["managingApp"].as_str().unwrap_or_default().to_string(), publish_policy: flag("publishPolicy"), }), _ => err(400, "UnsupportedPolicy", format!("Unsupported policy: {t}")), } } /// A policy given to `createSpace`, `updateSpace` or `importSpaceMeta`, /// once its lexicon took it: read, then `InvalidRequest` for a /// `managingApp` that is no service reference (`service_ref`). fn given(p: &Json) -> Result { let policy = Policy::read(p)?; match &policy { Policy::Managed { managing_app, .. } if !service_ref(managing_app) => { invalid("managingApp must be a service reference, an atproto DID and a #fragment") } _ => Ok(policy), } } /// Whether the policy's lexicon takes `p`: an object with a `$type`, its /// fields of their types. A `$type` not one of the three is taken here. fn lexicon(p: &Json) -> Result<(), String> { let union = json!({ "type": "union", "refs": [PERSONAL, MEMBER, MANAGED] }); pds_lexicon::validate("com.atproto.space.createSpace", &union, p, "policy").map_err(|e| e.0) } /// A policy a checkpoint keeps: its lexicon's, then as given. fn restored(p: &Json) -> Result { Policy::lexicon(p)?; Policy::given(p).map_err(|e| e.message) } /// An archive's policy (`spec/SPACES-POLICIES.md`, "importSpaceMeta", /// step 5): one its lexicon refuses is `InvalidSpaceMeta`; then as given. fn imported(p: &Json) -> Result { Policy::lexicon(p).or_else(|why| bad_meta(format!("Invalid archive policy: {why}")))?; Policy::given(p) } pub fn to_json(&self) -> Json { match self { Policy::Personal => json!({ "$type": PERSONAL }), Policy::Member { public_read, public_write, publish_policy, publish_members, allowed_apps, } => { let mut p = json!({ "$type": MEMBER, "publicRead": public_read, "publicWrite": public_write, "publishPolicy": publish_policy, "publishMembers": publish_members, }); if let Some(apps) = allowed_apps { p["allowedApps"] = json!(apps); } p } Policy::Managed { managing_app, publish_policy, } => { json!({ "$type": MANAGED, "managingApp": managing_app, "publishPolicy": publish_policy }) } } } fn to_drisl(&self) -> Vec { data::encode(&data::from_json(&self.to_json()).expect("a policy is in the data model")) } fn type_of(&self) -> &'static str { match self { Policy::Personal => PERSONAL, Policy::Member { .. } => MEMBER, Policy::Managed { .. } => MANAGED, } } fn publishes_policy(&self) -> bool { matches!( self, Policy::Member { publish_policy: true, .. } | Policy::Managed { publish_policy: true, .. } ) } fn publishes_members(&self) -> bool { matches!( self, Policy::Member { publish_members: true, .. } ) } } /// Whether `app` is a service reference, as a `managingApp` must be /// (`spec/SPACES-POLICIES.md`, "Policies"): `#`, with one /// `#`; the DID a `did:plc` of 24 characters of `a-z` and `2-7`, or a /// `did:web` with no path and no port but on `localhost`; the fragment not /// empty, of the characters RFC 3986 allows in one, `%` followed by two hex /// digits. fn service_ref(app: &str) -> bool { let Some((did, fragment)) = app.split_once('#') else { return false; }; let b = fragment.as_bytes(); let mut i = 0; while i < b.len() { let c = b[i]; if c == b'%' { if !(i + 2 < b.len() && b[i + 1].is_ascii_hexdigit() && b[i + 2].is_ascii_hexdigit()) { return false; } i += 3; } else if c.is_ascii_alphanumeric() || b"-._~!$&'()*+,;=:@/?".contains(&c) { i += 1; } else { return false; } } let did_ok = match did.strip_prefix("did:plc:") { Some(id) => { id.len() == 24 && id .bytes() .all(|c| c.is_ascii_lowercase() || (b'2'..=b'7').contains(&c)) } None => did.starts_with("did:web:") && crate::outbound::atproto_did_web(did), }; !b.is_empty() && did_ok } fn bad_meta(message: impl Into) -> Result { err(400, "InvalidSpaceMeta", message) } /// A member's record key: the DID with its first `%3A` written as `:`, so /// that a `did:web` with a port is a record key. pub(crate) fn member_rkey(did: &str) -> String { did.replacen("%3A", ":", 1) } /// The DID a member's record key is, read back by writing the `:` before a /// `did:web::`'s port as `%3A`; None if that is no DID. fn member_did(rkey: &str) -> Option { let did = match rkey .strip_prefix("did:web:") .and_then(|r| r.split_once(':')) { Some((host, port)) if !port.is_empty() && port.bytes().all(|c| c.is_ascii_digit()) => { format!("did:web:{host}%3A{port}") } _ => rkey.to_string(), }; (data::valid_rkey(rkey) && data::valid_did(&did)).then_some(did) } fn member_record(a: Access) -> Json { json!({ "$type": MEMBER_RECORD, "read": a.read, "write": a.write }) } fn policy_record(p: &Policy) -> Json { json!({ "$type": POLICY_RECORD, "policy": p.to_json() }) } // ---- The state ---------------------------------------------------------------- /// A member's entry. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub(crate) struct Access { pub read: bool, pub write: bool, } /// An entry of the writer set (`spec/SPACES-SYNC.md`, "The writer set"): /// the writer's repo in the space as last notified, the `spaceRev` the /// entry was given when it last changed, and whether the writer was taken /// out of the set since. #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct Writer { pub rev: String, pub data: Vec, pub space_rev: String, pub removed: bool, } /// A live space: its policy, its member list (a memberspace's alone), and /// its writer set, each by DID. #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct Space { pub policy: Policy, pub members: BTreeMap, pub writers: BTreeMap, } impl Space { fn new(policy: Policy) -> Space { Space { policy, members: BTreeMap::new(), writers: BTreeMap::new(), } } } #[derive(Clone, Debug, PartialEq, Eq)] enum Held { Live(Space), Deleted, } /// The spaces an account is the authority of, live or deleted, by URI. #[derive(Clone, Debug, Default, PartialEq, Eq)] pub(crate) struct Authority { spaces: BTreeMap, /// The bytes all of it is counted as in the cache. cost: u64, } impl Authority { pub fn live(&self, uri: &str) -> Option<&Space> { match self.spaces.get(uri) { Some(Held::Live(s)) => Some(s), _ => None, } } pub fn state(&self, uri: &str) -> SpaceState { match self.spaces.get(uri) { Some(Held::Live(_)) => SpaceState::Live, Some(Held::Deleted) => SpaceState::Deleted, None => SpaceState::Unknown, } } /// The URIs of the live spaces in `range`, in ascending order. pub fn live_spaces(&self, range: (Bound, Bound)) -> impl Iterator { self.spaces .range::(range) .filter(|(_, h)| matches!(h, Held::Live(_))) .map(|(uri, _)| uri.as_str()) } fn live_mut(&mut self, uri: &str) -> Result<&mut Space, String> { match self.spaces.get_mut(uri) { Some(Held::Live(s)) => Ok(s), _ => Err(format!("a change to {uri}, which is not live")), } } /// Replay an entry of `repo.log` of the kinds in `ENTRIES`. pub fn replay(&mut self, e: &Json) -> Result<(), String> { self.apply(e).map_err(|why| format!("{why}: {e}")) } /// About the bytes it holds in memory: a total kept as its spaces change. pub(crate) fn cost(&self) -> u64 { self.cost } /// About the bytes the space `uri` takes in memory, by how many /// members, writers and allowed apps it has: `0` if it holds none of it. fn cost_of(&self, uri: &str) -> u64 { let held = match self.spaces.get(uri) { None => return 0, Some(Held::Deleted) => 0, Some(Held::Live(s)) => { let policy = match &s.policy { Policy::Member { allowed_apps: Some(apps), .. } => apps.len() * 96, Policy::Managed { managing_app, .. } => managing_app.len(), _ => 0, }; 160 + policy + s.members.len() * 144 + s.writers.len() * 256 } }; (uri.len() + 96 + held) as u64 } /// Each space as a checkpoint keeps it, in ascending order of URI: a /// live one's archive, as `exportSpaceMeta` answers it but with the /// writer set's removals, or None for one deleted. pub(crate) fn saved(&self) -> impl Iterator>)> { self.spaces.iter().map(|(uri, h)| { ( uri.as_str(), match h { Held::Live(s) => Some(archive(uri, s, true)), Held::Deleted => None, }, ) }) } /// Restore a space of `did`'s a checkpoint keeps: from its archive, read /// as `importSpaceMeta` reads one, its policy, members and writers, the /// removed ones too (`Of::Checkpoint`); or deleted, with none. pub(crate) fn restore( &mut self, did: &str, uri: &str, archive: Option<&[u8]>, ) -> Result<(), String> { let bad = |why: String| format!("space {uri}: {why}"); if SpaceRef::parse(uri).is_none_or(|s| s.authority != did) || self.spaces.contains_key(uri) { return Err(bad("not a space of the account's, or twice".into())); } let held = match archive { None => Held::Deleted, Some(bytes) => { let r = read_archive(bytes, Of::Checkpoint).map_err(|e| bad(e.message))?; if r.space.uri() != uri { return Err(bad(format!("the archive of {}", r.space.uri()))); } let policy = Policy::restored(&r.policy).map_err(|e| bad(format!("its policy: {e}")))?; let members = members_of(&policy, &r.state).map_err(|e| bad(e.message))?; Held::Live(Space { policy, members, writers: r.writers, }) } }; self.spaces.insert(uri.to_string(), held); self.cost += self.cost_of(uri); Ok(()) } /// Make the change an entry records, and count what it leaves of its /// space. A change is checked before it is logged, so one logged /// applies as it did. pub(crate) fn apply(&mut self, e: &Json) -> Result<(), String> { let uri = e["space"].as_str().unwrap_or_default(); let before = self.cost_of(uri); let done = self.change(e); self.cost = self.cost - before + self.cost_of(uri); done } fn change(&mut self, e: &Json) -> Result<(), String> { let text = |k: &str| e[k].as_str().ok_or_else(|| format!("no {k}")); let flag = |k: &str| e[k].as_bool().ok_or_else(|| format!("no {k}")); let policy = || Policy::read(&e["policy"]).map_err(|x| format!("a policy refused: {}", x.message)); let uri = text("space")?; if SpaceRef::parse(uri).is_none() { return Err("a space that is no space-ref".into()); } match text("t")? { "spaceCreate" => { if self.live(uri).is_some() { return Err("a space created that exists".into()); } self.spaces .insert(uri.to_string(), Held::Live(Space::new(policy()?))); } "spaceUpdate" => { let p = policy()?; let s = self.live_mut(uri)?; // Another type migrates the space: its member list goes. if s.policy.type_of() != p.type_of() { s.members.clear(); } s.policy = p; } "spaceDelete" => { self.live_mut(uri)?; self.spaces.insert(uri.to_string(), Held::Deleted); } "spaceMember" => { let (did, a) = ( text("did")?, Access { read: flag("read")?, write: flag("write")?, }, ); let s = self.live_mut(uri)?; if !matches!(s.policy, Policy::Member { .. }) { return Err("a member of a space that is no memberspace".into()); } s.members.insert(did.to_string(), a); } "spaceUnmember" => { let did = text("did")?; self.live_mut(uri)?.members.remove(did); } "spaceWriter" => { let (did, w) = (text("did")?, writer_of(e)?); self.live_mut(uri)?.writers.insert(did.to_string(), w); } "spaceWriterRemoved" => { let (did, space_rev) = (text("did")?, text("spaceRev")?); let w = self .live_mut(uri)? .writers .get_mut(did) .ok_or("a writer removed that is not in the set")?; w.removed = true; w.space_rev = space_rev.to_string(); } "spaceImport" => { let mut s = Space::new(policy()?); for m in e["members"].as_array().ok_or("no members")? { let (Some(did), Some(read), Some(write)) = (m["did"].as_str(), m["read"].as_bool(), m["write"].as_bool()) else { return Err(format!("a member {m}")); }; s.members.insert(did.to_string(), Access { read, write }); } for w in e["writers"].as_array().ok_or("no writers")? { let did = w["did"].as_str().ok_or_else(|| format!("a writer {w}"))?; s.writers.insert(did.to_string(), writer_of(w)?); } self.spaces.insert(uri.to_string(), Held::Live(s)); } t => return Err(format!("an entry of no known type {t}")), } Ok(()) } } /// A writer set's entry in a log entry, not removed. fn writer_entry(did: &str, w: &Writer) -> Json { json!({ "did": did, "rev": w.rev, "data": hex::encode(&w.data), "spaceRev": w.space_rev }) } fn writer_of(e: &Json) -> Result { let (Some(rev), Some(data), Some(space_rev)) = ( e["rev"].as_str(), e["data"].as_str().and_then(|d| hex::decode(d).ok()), e["spaceRev"].as_str(), ) else { return Err(format!("a writer {e}")); }; Ok(Writer { rev: rev.to_string(), data, space_rev: space_rev.to_string(), removed: false, }) } /// The entry that tracks `did`'s write to the space `uri` in its writer /// set, as `w`, not removed: logged by the notifications' part for a /// notification it takes (`space_notify`), applied with `Authority::apply`. pub(crate) fn writer_tracked(uri: &str, did: &str, w: &Writer) -> Json { let mut e = writer_entry(did, w); e["t"] = json!("spaceWriter"); e["space"] = json!(uri); e } /// The entry that marks `did`'s entry in the writer set of the space `uri` /// removed, at `space_rev`, keeping its `repoRev` and `data`: logged as /// `space_notify::remove_writers` makes it. pub(crate) fn writer_removed(uri: &str, did: &str, space_rev: &str) -> Json { json!({ "t": "spaceWriterRemoved", "space": uri, "did": did, "spaceRev": space_rev }) } /// One change to an authority's spaces: the entries it logs, all in one /// frame, made only once that frame is written (a change the log could not /// take leaves nothing of itself); the commits of the authority's space /// repos it makes, heard of (`space_repo::Hooks`) once the frame is on /// disk; and what it owes the syncers, sent then. #[derive(Default)] struct Frame { entries: Vec, /// The entries of the spaces' own state, made in order once written. changes: Vec, staged: Vec, /// The notifications' entries (`space_notify`), made once written. notices: Vec, commits: Vec, sends: Vec, } /// Log the change `e` records in the change's frame, made once the frame is /// written: each method checks a change before it logs it. fn log(frame: &mut Frame, e: Json) { frame.entries.push(e.clone()); frame.changes.push(e); } /// Track `did`'s write to `space` as `w`, as the notifications' part does /// for a notification it takes. Called under the authority's account lock; /// false if the space is not live. #[cfg(test)] pub(crate) fn track_writer(st: &mut Store, space: &SpaceRef, did: &str, w: &Writer) -> bool { let uri = space.uri(); if st.authority.live(&uri).is_none() { return false; } let e = writer_tracked(&uri, did, w); if st.wal.append(std::slice::from_ref(&e)).is_err() { return false; } st.authority .apply(&e) .expect("a change checked before it is logged"); true } // ---- Publishing --------------------------------------------------------------- /// A change to a published record in the authority's own repo in a space. #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) enum Publication { Put { collection: &'static str, rkey: String, record: Json, }, Delete { collection: &'static str, rkey: String, }, } /// The space repo's write path, as publishing uses it: each call is made /// under the authority's account lock, with its store, and what it logs goes /// in the change's frame. pub(crate) trait Publisher { /// The record keys of `collection` in the authority's repo in `space`. fn rkeys(&self, st: &Store, space: &SpaceRef, collection: &str) -> Vec; /// Whether the authority's repo in `space` holds a record of /// `collection` at `rkey`. fn holds(&self, st: &Store, space: &SpaceRef, collection: &str, rkey: &str) -> bool; /// One commit of the authority's repo in `space`, making these changes /// in order, as any write of that repo is made: its log entry, and the /// commit. Never called with none. fn commit( &self, st: &mut Store, space: &SpaceRef, ops: Vec, ) -> (Json, Commit, Staged); /// Delete the authority's repo in `space`: its records, commit and /// operation log. Its log entry, if it had a repo there. fn drop_repo(&self, st: &mut Store, space: &SpaceRef) -> Option<(Json, Staged)>; } /// What the spaces' authority shares across accounts. #[derive(Default)] pub(crate) struct Host { /// The space repo's write path for the published records. pub publisher: crate::space_repo::Publish, /// The managing apps being asked. pub asking: Asking, } /// Write `ops` as one commit of the authority's repo in `space`; none, no commit. fn publish( svc: &Service, st: &mut Store, frame: &mut Frame, space: &SpaceRef, ops: Vec, ) { if !ops.is_empty() { let (entry, commit, staged) = svc.space_authority.publisher.commit(st, space, ops); frame.entries.push(entry); frame.staged.push(staged); frame.commits.push(commit); } } fn put_policy(p: &Policy) -> Publication { Publication::Put { collection: POLICY_RECORD, rkey: "self".into(), record: policy_record(p), } } fn put_member(did: &str, a: Access) -> Publication { Publication::Put { collection: MEMBER_RECORD, rkey: member_rkey(did), record: member_record(a), } } // ---- Who may call ------------------------------------------------------------- /// What an account deactivated or taken down, or a session, may do: each /// method is one of these. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub(crate) enum Kind { /// `createSpace`, `updateSpace`, `deleteSpace`, `putMembers`, `removeMembers`, `removeWriter`. Manage, /// `importSpaceMeta`, and `importRepo` (`space_repo`). Import, /// `getSpace`, `listMembers`. Read, Export, } /// An account's status (`spec/SPACES-POLICIES.md`, "Takedown and deactivation"). #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub(crate) enum Status { Active, Deactivated, TakenDown, } /// An account's status, as `spec/LIFECYCLE.md` keeps it: taken down before /// deactivated. pub(crate) fn status(a: &Account) -> Status { let state = crate::read(&a.state); if state.takedown.is_some() { Status::TakenDown } else if state.deactivated { Status::Deactivated } else { Status::Active } } /// The session a token is of. #[derive(Clone, Copy, Debug, PartialEq, Eq)] enum Session { Password, AppPassword, /// From `createSession` with `allowTakendown`. Takendown, } /// The session a token is of: an OAuth session's is its account's, as a /// password session's, its scope asked by each method /// (`spec/OAUTH-SCOPES.md`, "Spaces"). fn session_of(t: &sessions::Token) -> Session { if t.oauth { return Session::Password; } match t.scope.as_str() { sessions::ACCESS => Session::Password, sessions::TAKENDOWN => Session::Takendown, _ => Session::AppPassword, } } /// Whether a method of `kind` takes a session of `session`, of an account of `status`. fn admit(kind: Kind, session: Session, status: Status) -> Result<(), XrpcError> { match (kind, session) { (Kind::Export, _) | (Kind::Manage | Kind::Read, Session::Password | Session::AppPassword) | (Kind::Import, Session::Password) => {} _ => return invalid_token(), } match (kind, status) { (Kind::Manage, Status::Deactivated) => { err(401, "AccountDeactivated", "Account is deactivated") } (Kind::Manage | Kind::Import, Status::TakenDown) => { err(401, "AccountTakedown", "Account has been taken down") } _ => Ok(()), } } /// The caller's account, from its token, if a method of `kind` takes it. pub(crate) fn caller(svc: &Service, call: &Call, kind: Kind) -> Result, XrpcError> { let t = sessions::takendown_ok_token(svc, call.bearer)?; let Some(a) = svc.account(&t.did) else { return invalid_token(); }; admit(kind, session_of(&t), status(&a))?; Ok(a) } /// Once the call's token and input are checked, it pays its rate limits, /// and a change checks the free space (`limits::guard`; `LIMITS.md`). fn pay(svc: &Service, call: &Call, a: &Account) -> Result<(), XrpcError> { crate::limits::guard(svc, call, Some(&a.did), None) } /// A space the call names, the call's scope asked for `op` on it /// (`spec/OAUTH-SCOPES.md`, "What each method needs"), and the caller its /// authority, else `NotAuthorized`. fn owned(call: &Call, a: &Account, space: &str, op: SpaceOp) -> Result { let Some(sr) = SpaceRef::parse(space) else { return invalid("space must be a valid space-ref"); }; crate::scopes::may_in(call.bearer, &sr, op)?; if sr.authority != a.did { return not_authorized(); } Ok(sr) } fn not_authorized() -> Result { err(400, "NotAuthorized", "Not the authority of the space") } fn not_found() -> Result { err(400, "SpaceNotFound", "Space not found") } fn mismatch() -> Result { err( 400, "PolicyMismatch", "The space is not governed by the memberspace policy", ) } fn text<'a>(b: &'a Map, k: &str) -> &'a str { b.get(k).and_then(Json::as_str).unwrap_or_default() } fn params(call: &Call, m: &Method) -> Result, XrpcError> { m.parse_params(call.params.iter().map(|(k, v)| (k.as_str(), v.as_str()))) .or_else(|e| invalid(e.0)) } /// Make a change to the caller's spaces, under its account's lock, logged /// in one frame; `f` refuses before it logs anything. Answered once what the /// log has then is on disk and the commits it made are heard of. async fn change( svc: &Shared, a: &Account, f: impl FnOnce(&mut Store, &mut Frame) -> Result, ) -> Result { let mut frame = Frame::default(); let (out, wal, written, doomed) = { let mut st = write(&a.store); let out = f(&mut st, &mut frame)?; if !frame.entries.is_empty() { let pos = match crate::blobstore::mark_for(&st) .and_then(|()| crate::space_repo::append(&st, &frame.entries)) { Ok(pos) => pos, Err(e) => { crate::ops::failed_for( crate::ops::Level::Error, "a change to spaces failed", &a.did, e, ); return crate::internal(); } }; for c in &frame.changes { st.authority .apply(c) .expect("a change checked before it is logged"); } for s in std::mem::take(&mut frame.staged) { s.apply(&mut st, pos); } for e in &frame.notices { st.notify .apply(e) .expect("a change checked before it is logged"); } } // A dropped repo's records may have held blobs. ( out, st.wal.clone(), st.wal.written(), st.blobs.take_doomed(), ) }; // The frame is in the log: the rest must happen even if the caller goes away. let (hearing, commits, sends) = (svc.clone(), frame.commits, frame.sends); let finish = crate::ops::spawn(async move { let synced = durable(wal, written).await; if synced.is_ok() { for s in sends { s.go(&hearing); } for c in &commits { hearing.space_hooks.committed(&hearing, c); } } synced }); finish.await.unwrap_or_else(|_| crate::internal())?; crate::blobs::forget(svc, a, doomed); Ok(out) } /// Read the caller's spaces; answered once what they show is on disk. async fn look( a: &Account, f: impl FnOnce(&Store) -> Result, ) -> Result { let (out, wal) = { let st = read(&a.store); (f(&st)?, st.wal.clone()) }; durable(wal.clone(), wal.written()).await?; Ok(out) } // ---- The methods ---------------------------------------------------------------- pub(crate) fn handler(nsid: &str) -> Option { Some(match nsid { "com.atproto.space.createSpace" => Handler::Call(|s, c, m| Box::pin(create_space(s, c, m))), "com.atproto.space.getSpace" => Handler::Call(|s, c, m| Box::pin(get_space(s, c, m))), "com.atproto.space.updateSpace" => Handler::Call(|s, c, m| Box::pin(update_space(s, c, m))), "com.atproto.space.deleteSpace" => Handler::Call(|s, c, m| Box::pin(delete_space(s, c, m))), "com.atproto.space.removeWriter" => { Handler::Call(|s, c, m| Box::pin(remove_writer(s, c, m))) } "com.atproto.space.exportSpaceMeta" => { Handler::Call(|s, c, m| Box::pin(export_space_meta(s, c, m))) } "com.atproto.space.importSpaceMeta" => { Handler::Call(|s, c, _| Box::pin(import_space_meta(s, c))) } "com.atproto.memberspace.putMembers" => { Handler::Call(|s, c, m| Box::pin(put_members(s, c, m))) } "com.atproto.memberspace.removeMembers" => { Handler::Call(|s, c, m| Box::pin(remove_members(s, c, m))) } "com.atproto.memberspace.listMembers" => { Handler::Call(|s, c, m| Box::pin(list_members(s, c, m))) } _ => return None, }) } async fn create_space(svc: &Shared, call: &Call<'_>, m: &Method) -> Result { let a = caller(svc, call, Kind::Manage)?; let b = input(call, m)?; pay(svc, call, &a)?; // The key given, or one made for it now, which the scope is asked of. let skey = match b.get("skey").and_then(Json::as_str) { Some(k) => k.to_string(), None => write(&a.store).repo.tids.next_tid(), }; let typ = text(&b, "spaceType").to_string(); crate::scopes::may_space(call.bearer, &a.did, &typ, &skey, SpaceOp::Manage("create"))?; let policy = Policy::given(&b["policy"])?; let uri = change(svc, &a, |st, frame| { let sr = SpaceRef { authority: a.did.clone(), typ, skey, }; let uri = sr.uri(); if st.authority.live(&uri).is_some() { return err( 400, "SpaceAlreadyExists", "A space with this URI already exists", ); } log( frame, json!({ "t": "spaceCreate", "space": uri, "policy": policy.to_json() }), ); let ops = if policy.publishes_policy() { vec![put_policy(&policy)] } else { vec![] }; publish(svc, st, frame, &sr, ops); Ok(uri) }) .await?; Ok(Resp::Json(json!({ "space": uri }))) } async fn get_space(svc: &Shared, call: &Call<'_>, m: &Method) -> Result { let p = params(call, m)?; let a = caller(svc, call, Kind::Read)?; pay(svc, call, &a)?; let asked = text(&p, "space"); let uri = owned(call, &a, asked, SpaceOp::Read { whole: false })?.uri(); let policy = look(&a, |st| { st.authority .live(&uri) .map_or_else(not_found, |s| Ok(s.policy.to_json())) }) .await?; Ok(Resp::Json(json!({ "space": asked, "policy": policy }))) } async fn update_space(svc: &Shared, call: &Call<'_>, m: &Method) -> Result { let a = caller(svc, call, Kind::Manage)?; let b = input(call, m)?; pay(svc, call, &a)?; let sr = owned(call, &a, text(&b, "space"), SpaceOp::Manage("update"))?; let policy = Policy::given(&b["policy"])?; change(svc, &a, |st, frame| { let uri = sr.uri(); let Some(old) = st.authority.live(&uri) else { return not_found(); }; let members_before = old.policy.publishes_members(); log( frame, json!({ "t": "spaceUpdate", "space": uri, "policy": policy.to_json() }), ); let publisher = &svc.space_authority.publisher; let mut ops = Vec::new(); if policy.publishes_policy() { ops.push(put_policy(&policy)); } else if publisher.holds(st, &sr, POLICY_RECORD, "self") { ops.push(Publication::Delete { collection: POLICY_RECORD, rkey: "self".into(), }); } match (members_before, policy.publishes_members()) { (false, true) => { let s = st.authority.live(&uri).expect("updated"); ops.extend(s.members.iter().map(|(did, a)| put_member(did, *a))); } (true, false) => { ops.extend( publisher .rkeys(st, &sr, MEMBER_RECORD) .into_iter() .map(|rkey| Publication::Delete { collection: MEMBER_RECORD, rkey, }), ); } _ => {} } publish(svc, st, frame, &sr, ops); Ok(()) }) .await?; Ok(Resp::Nothing) } async fn delete_space(svc: &Shared, call: &Call<'_>, m: &Method) -> Result { let a = caller(svc, call, Kind::Manage)?; let b = input(call, m)?; pay(svc, call, &a)?; let sr = owned(call, &a, text(&b, "space"), SpaceOp::Manage("delete"))?; change(svc, &a, |st, frame| { let uri = sr.uri(); match st.authority.state(&uri) { SpaceState::Unknown => return not_found(), SpaceState::Deleted => {} SpaceState::Live => { log(frame, json!({ "t": "spaceDelete", "space": uri })); if let Some((entry, staged)) = svc.space_authority.publisher.drop_repo(st, &sr) { frame.entries.push(entry); frame.staged.push(staged); } // Its registrations are dropped, each owed a deletion notice. let notices = crate::space_notify::space_deleted(svc, st, &uri)?; frame.entries.extend(notices.iter().cloned()); frame.notices.extend(notices); } } Ok(()) }) .await?; crate::space_notify::poke(svc, &a.did); Ok(Resp::Nothing) } async fn remove_writer(svc: &Shared, call: &Call<'_>, m: &Method) -> Result { let a = caller(svc, call, Kind::Manage)?; let b = input(call, m)?; pay(svc, call, &a)?; let sr = owned(call, &a, text(&b, "space"), SpaceOp::Manage("update"))?; let did = text(&b, "repo"); change(svc, &a, |st, frame| { let uri = sr.uri(); if st.authority.live(&uri).is_none() { return not_found(); } take_out_writers(svc, st, frame, &uri, [did]); Ok(()) }) .await?; Ok(Resp::Nothing) } /// `putMembers`: each DID given takes its last entry, a `write: false` one /// out of the writer set too; their records, when members are published, /// written in one commit, each once. An empty list changes nothing. async fn put_members(svc: &Shared, call: &Call<'_>, m: &Method) -> Result { let a = caller(svc, call, Kind::Manage)?; let b = input(call, m)?; pay(svc, call, &a)?; let sr = owned(call, &a, text(&b, "space"), SpaceOp::Manage("update"))?; let given: BTreeMap = b["members"] .as_array() .into_iter() .flatten() .map(|e| { ( e["did"].as_str().unwrap_or_default().to_string(), Access { read: e["read"] == true, write: e["write"] == true, }, ) }) .collect(); change(svc, &a, |st, frame| { let uri = sr.uri(); let Some(s) = st.authority.live(&uri) else { return not_found(); }; if !matches!(s.policy, Policy::Member { .. }) { return mismatch(); } let publishing = s.policy.publishes_members(); // Removals first, each its own entry (`take_out_writers`). let unwriting = given.iter().filter(|(_, a)| !a.write); take_out_writers(svc, st, frame, &uri, unwriting.map(|(did, _)| did.as_str())); for (did, access) in &given { log( frame, json!({ "t": "spaceMember", "space": uri, "did": did, "read": access.read, "write": access.write }), ); } if publishing { let ops = given.iter().map(|(did, a)| put_member(did, *a)).collect(); publish(svc, st, frame, &sr, ops); } Ok(()) }) .await?; Ok(Resp::Nothing) } /// `removeMembers`: each DID given that is a member, off the list and out /// of the writer set, its record deleted if there is one, all in one /// commit; a DID that is no member is left as it is. async fn remove_members(svc: &Shared, call: &Call<'_>, m: &Method) -> Result { let a = caller(svc, call, Kind::Manage)?; let b = input(call, m)?; pay(svc, call, &a)?; let sr = owned(call, &a, text(&b, "space"), SpaceOp::Manage("update"))?; let dids: std::collections::BTreeSet<&str> = b["dids"] .as_array() .into_iter() .flatten() .filter_map(Json::as_str) .collect(); change(svc, &a, |st, frame| { let uri = sr.uri(); let Some(s) = st.authority.live(&uri) else { return not_found(); }; if !matches!(s.policy, Policy::Member { .. }) { return mismatch(); } let removed: Vec<&str> = dids .iter() .copied() .filter(|did| s.members.contains_key(*did)) .collect(); // Removals first, as `putMembers` logs them. take_out_writers(svc, st, frame, &uri, removed.iter().copied()); for did in &removed { log( frame, json!({ "t": "spaceUnmember", "space": uri, "did": did }), ); } let publisher = &svc.space_authority.publisher; let ops = removed .iter() .map(|did| member_rkey(did)) .filter(|rkey| publisher.holds(st, &sr, MEMBER_RECORD, rkey)) .map(|rkey| Publication::Delete { collection: MEMBER_RECORD, rkey, }) .collect(); publish(svc, st, frame, &sr, ops); Ok(()) }) .await?; Ok(Resp::Nothing) } /// Take `dids` out of the writer set of the live space `uri` /// (`space_notify::remove_writers`): each in it and not removed is a /// removal (`spec/SPACES-POLICIES.md`, "The writer set"), logged in the /// change's frame, and sent to the space's syncers once it is on disk. /// `removeWriter`, `putMembers` with `write: false` and `removeMembers` of /// a member each remove a writer through here alone. fn take_out_writers<'a>( svc: &Service, st: &Store, frame: &mut Frame, uri: &str, dids: impl IntoIterator, ) { let r = crate::space_notify::remove_writers(svc, st, uri, dids); for c in r.changes { log(frame, c); } frame.entries.extend(r.entries.iter().cloned()); frame.notices.extend(r.entries); frame.sends.push(r.sends); } async fn list_members(svc: &Shared, call: &Call<'_>, m: &Method) -> Result { let p = params(call, m)?; let a = caller(svc, call, Kind::Read)?; pay(svc, call, &a)?; let uri = owned(call, &a, text(&p, "space"), SpaceOp::Read { whole: false })?.uri(); let limit = p.get("limit").and_then(Json::as_u64).unwrap_or(100) as usize; // An empty cursor is as none; any other must be a DID, checked last. let cursor = p .get("cursor") .and_then(Json::as_str) .filter(|c| !c.is_empty()); let members: Vec = look(&a, |st| { let Some(s) = st.authority.live(&uri) else { return not_found(); }; if !matches!(s.policy, Policy::Member { .. }) { return mismatch(); } let from = match cursor { None => Bound::Unbounded, Some(c) if data::valid_did(c) => Bound::Excluded(c.to_string()), Some(_) => return err(400, "InvalidCursor", "The cursor must be a DID"), }; Ok(s.members .range((from, Bound::Unbounded)) .take(limit) .map(|(did, a)| json!({ "did": did, "read": a.read, "write": a.write })) .collect()) }) .await?; let mut out = json!({ "members": members }); if let Some(last) = members.last() { out["cursor"] = last["did"].clone(); } Ok(Resp::Json(out)) } // ---- Space meta archives -------------------------------------------------------- async fn export_space_meta(svc: &Shared, call: &Call<'_>, m: &Method) -> Result { let p = params(call, m)?; let a = caller(svc, call, Kind::Export)?; pay(svc, call, &a)?; let uri = owned(call, &a, text(&p, "space"), SpaceOp::Read { whole: false })?.uri(); let bytes = look(&a, |st| { st.authority .live(&uri) .map_or_else(not_found, |s| Ok(archive(&uri, s, false))) }) .await?; Ok(Resp::Star(bytes)) } /// The archive of a space's state: its policy, a memberspace's members, /// then its writer set, each section in ascending order of its keys' bytes. /// The writer set's removals are in it only with `removals`, as a /// checkpoint keeps them (`"removed": true`); `exportSpaceMeta` writes the /// entries not removed. fn archive(uri: &str, s: &Space, removals: bool) -> Vec { let meta = V::Map(vec![ ("$type".into(), V::Str(META_TYPE.into())), ("ver".into(), V::Int(1)), ("space".into(), V::Str(uri.into())), ]); let mut pairs: Vec<(Vec, Vec)> = vec![(b"policy".to_vec(), s.policy.to_drisl())]; if matches!(s.policy, Policy::Member { .. }) { let mut members: Vec<(Vec, Vec)> = s .members .iter() .map(|(did, a)| { let v = data::from_json(&member_record(*a)) .expect("a member record is in the data model"); ( format!("{MEMBER_RECORD}/{}", member_rkey(did)).into_bytes(), data::encode(&v), ) }) .collect(); members.sort(); pairs.extend(members); } for (did, w) in s.writers.iter().filter(|(_, w)| removals || !w.removed) { let mut v = vec![ ("repoRev".into(), V::Str(w.rev.clone())), ("data".into(), V::Bytes(w.data.clone())), ("spaceRev".into(), V::Str(w.space_rev.clone())), ]; if w.removed { v.push(("removed".into(), V::Bool(true))); } pairs.push(( format!("{WRITER}{did}").into_bytes(), data::encode(&V::Map(v)), )); } star::write( &meta, pairs.iter().map(|(k, v)| (k.as_slice(), v.as_slice())), ) } /// A map's value of key `k`. fn field<'a>(m: &'a V, k: &str) -> Option<&'a V> { match m { V::Map(m) => m.iter().find(|(key, _)| key == k).map(|(_, v)| v), _ => None, } } /// An archive read as far as it can be without knowing who sent it: its /// space, its policy, the policy state's pairs, and the writer set. struct Read<'a> { space: SpaceRef, policy: Json, state: Vec<(&'a [u8], &'a [u8])>, writers: BTreeMap, } /// What an archive is read as. Either way a writer's repo rev is its /// `repoRev`, as `exportSpaceMeta` writes it. #[derive(Clone, Copy, PartialEq, Eq)] enum Of { /// As `importSpaceMeta` takes one: none removed, the set is taken with /// no removals. Import, /// As a checkpoint keeps one: a writer `"removed": true` removed. Checkpoint, } /// Read an archive (`spec/SPACES-POLICIES.md`, "importSpaceMeta", steps /// 1-3), each fault `InvalidSpaceMeta`: STAR's faults and the limits, then /// the metadata, then the pairs as they come, each value a DRISL map, in /// their sections and order, and the writer set. fn read_archive(bytes: &[u8], of: Of) -> Result, XrpcError> { let a = star::read(bytes, &star::REPO_LIMITS) .or_else(|e| bad_meta(format!("Invalid archive: {e}")))?; let space = match ( field(&a.meta, "$type"), field(&a.meta, "ver"), field(&a.meta, "space"), ) { (Some(V::Str(t)), Some(V::Int(1)), Some(V::Str(space))) if t == META_TYPE => { SpaceRef::parse(space) } _ => None, }; let Some(space) = space else { return bad_meta("Invalid archive metadata"); }; let (mut policy, mut state, mut writers) = (None, Vec::new(), BTreeMap::new()); let mut last: Option<&[u8]> = None; for (i, (k, v)) in a.pairs.iter().enumerate() { let value = match data::decode(v) { Ok(value @ V::Map(_)) => value, _ => return bad_meta("An archive whose value is not a DRISL map"), }; if i == 0 { if *k != b"policy" { return bad_meta("An archive whose first pair is not its policy"); } policy = Some(data::to_json(&value)); continue; } let is_writer = k.starts_with(WRITER.as_bytes()); if *k == b"policy" || (!is_writer && !writers.is_empty()) { return bad_meta("An archive's sections out of order"); } if is_writer && writers.is_empty() { last = None; } if last.is_some_and(|l| l >= *k) { return bad_meta("An archive's keys out of order or repeated"); } last = Some(*k); if !is_writer { state.push((*k, *v)); continue; } let did = std::str::from_utf8(&k[WRITER.len()..]) .ok() .filter(|d| data::valid_did(d)); let tid = |k: &str| match field(&value, k) { Some(V::Str(t)) if pds_repo::valid_tid(t) => Some(t.clone()), _ => None, }; let removed = of == Of::Checkpoint && field(&value, "removed") == Some(&V::Bool(true)); let w = match (field(&value, "data"), tid("repoRev"), tid("spaceRev")) { (Some(V::Bytes(data)), Some(rev), Some(space_rev)) => Some(Writer { rev, data: data.clone(), space_rev, removed, }), _ => None, }; let (Some(did), Some(w)) = (did, w) else { return bad_meta("An archive with a bad writer"); }; writers.insert(did.to_string(), w); } let Some(policy) = policy else { return bad_meta("An archive with no policy"); }; Ok(Read { space, policy, state, writers, }) } /// The policy state's pairs, under `policy` (`spec/SPACES-POLICIES.md`, /// "importSpaceMeta", step 6): a memberspace's members, each a member /// record keyed by a DID; no pair under any other policy. Else /// `InvalidSpaceMeta`. fn members_of( policy: &Policy, state: &[(&[u8], &[u8])], ) -> Result, XrpcError> { let mut members = BTreeMap::new(); let prefix = format!("{MEMBER_RECORD}/"); for (k, v) in state { let did = std::str::from_utf8(k) .ok() .and_then(|k| k.strip_prefix(&prefix)) .and_then(member_did); let (Some(did), Policy::Member { .. }) = (did, policy) else { return bad_meta("An archive with policy state its policy does not keep"); }; let value = data::decode(v).ok(); let f = |k: &str| value.as_ref().and_then(|v| field(v, k)); match (f("$type"), f("read"), f("write")) { (Some(V::Str(t)), Some(V::Bool(read)), Some(V::Bool(write))) if t == MEMBER_RECORD => { members.insert( did, Access { read: *read, write: *write, }, ) } _ => return bad_meta("An archive with a bad member"), }; } Ok(members) } /// `importSpaceMeta`: its body's `Content-Type` with the token, before the /// body is read; then the archive, ownership, its policy and the policy /// state, in that order. It replaces the space whole, its writer set with /// no removals, and publishes nothing. async fn import_space_meta(svc: &Shared, call: &Call<'_>) -> Result { let a = caller(svc, call, Kind::Import)?; let media = call .headers .get(axum::http::header::CONTENT_TYPE) .and_then(|v| v.to_str().ok()) .map(|t| t.split(';').next().unwrap_or_default().trim()); if !media.is_some_and(|t| t.eq_ignore_ascii_case(crate::STAR_TYPE)) { return invalid(format!( "Wrong request encoding (Content-Type): expected {}", crate::STAR_TYPE )); } pay(svc, call, &a)?; let r = read_archive(call.body, Of::Import)?; for m in ["create", "update"] { crate::scopes::may_in(call.bearer, &r.space, SpaceOp::Manage(m))?; } if r.space.authority != a.did { return not_authorized(); } let policy = Policy::imported(&r.policy)?; let members = members_of(&policy, &r.state)?; let entry = json!({ "t": "spaceImport", "space": r.space.uri(), "policy": policy.to_json(), "members": members.iter().map(|(did, a)| json!({ "did": did, "read": a.read, "write": a.write })).collect::>(), "writers": r.writers.iter().map(|(did, w)| writer_entry(did, w)).collect::>(), }); change(svc, &a, |_, frame| { log(frame, entry); Ok(()) }) .await?; Ok(Resp::Nothing) } #[cfg(test)] mod tests { use super::*; use crate::testing::*; use axum::http::{HeaderMap, HeaderValue, Method as Http, header}; const T: &str = "com.example.forum"; const TID: &str = "3jzfcijpj2z2a"; const TID2: &str = "3jzfcijpj2z2b"; const CREATE: &str = "com.atproto.space.createSpace"; const UPDATE: &str = "com.atproto.space.updateSpace"; const DELETE: &str = "com.atproto.space.deleteSpace"; const GET: &str = "com.atproto.space.getSpace"; const REMOVE_WRITER: &str = "com.atproto.space.removeWriter"; const PUT: &str = "com.atproto.memberspace.putMembers"; const REMOVE: &str = "com.atproto.memberspace.removeMembers"; const LIST: &str = "com.atproto.memberspace.listMembers"; fn sp(did: &str, key: &str) -> String { format!("at://{did}/space/{T}/{key}") } fn err_of(name: &str) -> Result { Err(name.to_string()) } /// A call as sent, with its `Content-Type`. async fn send( s: &Shared, nsid: &str, token: Option<&str>, params: &[(&str, &str)], body: &[u8], ctype: Option<&str>, ) -> Result { let mut headers = HeaderMap::new(); if let Some(t) = ctype { headers.insert(header::CONTENT_TYPE, HeaderValue::from_str(t).unwrap()); } let params: Vec<(String, String)> = params .iter() .map(|(k, v)| (k.to_string(), v.to_string())) .collect(); let method = if pds_lexicon::method(nsid).unwrap().kind == pds_lexicon::Kind::Query { Http::GET } else { Http::POST }; let bearer = token.map_or(sessions::Bearer::None, sessions::Bearer::Token); crate::answer( s, &Call { nsid, method: &method, params: ¶ms, body, bearer, headers: &headers, client: "127.0.0.1".into(), charged: Default::default(), http: None, }, ) .await .map_err(|e| e.name.to_string()) } async fn query( s: &Shared, nsid: &str, token: Option<&str>, params: &[(&str, &str)], ) -> Result { match send(s, nsid, token, params, b"", None).await? { Resp::Json(j) | Resp::Headed(j, _) => Ok(j), _ => panic!("{nsid} answered no JSON"), } } async fn export(s: &Shared, token: &str, space: &str) -> Result, String> { match send( s, "com.atproto.space.exportSpaceMeta", Some(token), &[("space", space)], b"", None, ) .await? { Resp::Star(b) => Ok(b), _ => panic!("exportSpaceMeta answered no archive"), } } async fn import_as( s: &Shared, token: Option<&str>, ctype: Option<&str>, body: &[u8], ) -> Result<(), String> { match send( s, "com.atproto.space.importSpaceMeta", token, &[], body, ctype, ) .await? { Resp::Nothing => Ok(()), _ => panic!("importSpaceMeta answered something"), } } async fn import(s: &Shared, token: &str, body: &[u8]) -> Result<(), String> { import_as(s, Some(token), Some(crate::STAR_TYPE), body).await } async fn create_space(s: &Shared, token: &str, key: &str, policy: Json) -> String { let got = call( s, CREATE, Some(token), json!({ "spaceType": T, "skey": key, "policy": policy }), ) .await .unwrap(); got["space"].as_str().unwrap().to_string() } async fn policy_of(s: &Shared, token: &str, space: &str) -> Json { let got = query(s, GET, Some(token), &[("space", space)]) .await .unwrap(); assert_eq!(got["space"], json!(space)); got["policy"].clone() } /// putMembers of one member. async fn put(s: &Shared, token: &str, space: &str, did: &str, read: bool, write: bool) { put_all(s, token, space, &[(did, read, write)]).await; } /// putMembers of a batch, each `(did, read, write)`. async fn put_all(s: &Shared, token: &str, space: &str, batch: &[(&str, bool, bool)]) { let members: Vec = batch .iter() .map(|(did, read, write)| json!({ "did": did, "read": read, "write": write })) .collect(); assert_eq!( call( s, PUT, Some(token), json!({ "space": space, "members": members }) ) .await, Ok(Json::Null) ); } /// removeMembers of a batch. async fn remove(s: &Shared, token: &str, space: &str, dids: &[&str]) { assert_eq!( call( s, REMOVE, Some(token), json!({ "space": space, "dids": dids }) ) .await, Ok(Json::Null) ); } async fn members(s: &Shared, token: &str, space: &str) -> Json { query(s, LIST, Some(token), &[("space", space), ("limit", "1000")]) .await .unwrap()["members"] .clone() } fn writer(n: u8) -> Writer { Writer { rev: TID.into(), data: vec![n; 32], space_rev: TID2.into(), removed: false, } } /// Track `did`'s write to `space`, as the write notifications' part would. fn track(s: &Service, authority: &str, space: &str, did: &str, n: u8) -> bool { let a = s.account(authority).unwrap(); let mut st = write(&a.store); track_writer(&mut st, &SpaceRef::parse(space).unwrap(), did, &writer(n)) } /// The writers in the set, removed ones left out. fn writers(s: &Service, authority: &str, space: &str) -> Vec { read(&s.account(authority).unwrap().store) .authority .live(space) .map(|x| { x.writers .iter() .filter(|(_, w)| !w.removed) .map(|(did, _)| did.clone()) .collect() }) .unwrap_or_default() } async fn app_password_session(s: &Shared, name: &str, token: &str) -> String { let p = call( s, "com.atproto.server.createAppPassword", Some(token), json!({ "name": "spaces" }), ) .await .unwrap(); let body = json!({ "identifier": format!("{name}.test"), "password": p["password"] }); call(s, "com.atproto.server.createSession", None, body) .await .unwrap()["accessJwt"] .as_str() .unwrap() .to_string() } /// Every method's refusals, each in the order the spec checks them. #[tokio::test] async fn refusals_in_order() { let plc = plc().await; let dir = scratch("spaces-refusals"); let s = open(&dir, &plc); let (alice, ta) = create(&s, "alice").await; let (bob, tb) = create(&s, "bob").await; let ms = json!({ "$type": MEMBER }); let unsupported = json!({ "$type": "com.example.policy" }); let bad_app = json!({ "$type": MANAGED, "managingApp": "web:example.com#forum" }); let new = |key: &str, policy: &Json| json!({ "spaceType": T, "skey": key, "policy": policy }); // createSpace: the token, however wrong the input; then the input; then the policy; then whether it exists. assert_eq!( call(&s, CREATE, None, json!({ "spaceType": "nope" })).await, err_of("AuthMissing") ); assert_eq!( call(&s, CREATE, Some("abc.def.ghi"), new("u", &ms)).await, err_of("InvalidToken") ); for bad in [ json!({ "spaceType": "nope", "policy": ms }), json!({ "spaceType": T, "skey": "a b", "policy": ms }), json!({ "spaceType": T, "skey": "k".repeat(513), "policy": ms }), json!({ "spaceType": T }), json!({ "spaceType": T, "policy": 5 }), json!({ "spaceType": T, "policy": {} }), json!({ "spaceType": T, "policy": { "$type": MEMBER, "publicRead": "yes" } }), json!({ "spaceType": T, "policy": { "$type": MEMBER, "allowedApps": "x" } }), json!({ "spaceType": T, "policy": { "$type": MANAGED } }), json!({ "spaceType": T, "policy": { "$type": MANAGED, "managingApp": 5 } }), new("u", &bad_app), ] { assert_eq!( call(&s, CREATE, Some(&ta), bad.clone()).await, err_of("InvalidRequest"), "{bad}" ); } assert_eq!( call(&s, CREATE, Some(&ta), new("u", &unsupported)).await, err_of("UnsupportedPolicy") ); let got = call( &s, CREATE, Some(&ta), json!({ "spaceType": T, "policy": ms }), ) .await .unwrap(); // It answers the space's URI alone. assert_eq!( got.as_object().unwrap().keys().collect::>(), ["space"] ); let tid = SpaceRef::parse(got["space"].as_str().unwrap()).unwrap(); assert!( tid.authority == alice && tid.typ == T && pds_repo::valid_tid(&tid.skey), "{got}" ); let m1 = create_space(&s, &ta, "m1", ms.clone()).await; assert_eq!(m1, sp(&alice, "m1")); assert_eq!( call( &s, CREATE, Some(&ta), new("m1", &json!({ "$type": PERSONAL })) ) .await, err_of("SpaceAlreadyExists") ); assert_eq!( call(&s, CREATE, Some(&ta), new("m1", &unsupported)).await, err_of("UnsupportedPolicy") ); // A space is its whole URI: another type, or another authority, is another space. let other_type = format!("at://{alice}/space/com.example.other/m1"); call( &s, CREATE, Some(&ta), json!({ "spaceType": "com.example.other", "skey": "m1", "policy": ms }), ) .await .unwrap(); create_space(&s, &tb, "m1", json!({ "$type": PERSONAL })).await; // getSpace: its parameters, then the token, then ownership, then the space. assert_eq!( query(&s, GET, None, &[("space", "nope")]).await, err_of("InvalidRequest") ); assert_eq!( query( &s, GET, Some(&ta), &[("space", &format!("at://{alice}/space/{T}"))] ) .await, err_of("InvalidRequest") ); assert_eq!( query(&s, GET, None, &[("space", &m1)]).await, err_of("AuthMissing") ); assert_eq!( query(&s, GET, Some("abc.def.ghi"), &[("space", &m1)]).await, err_of("InvalidToken") ); assert_eq!( query(&s, GET, Some(&tb), &[("space", &m1)]).await, err_of("NotAuthorized") ); assert_eq!( query( &s, GET, Some(&tb), &[("space", &sp("did:plc:nobody", "m1"))] ) .await, err_of("NotAuthorized") ); assert_eq!( query(&s, GET, Some(&ta), &[("space", &sp(&alice, "never"))]).await, err_of("SpaceNotFound") ); assert_eq!( policy_of(&s, &ta, &other_type).await, policy_of(&s, &ta, &m1).await ); assert_eq!( policy_of(&s, &tb, &sp(&bob, "m1")).await, json!({ "$type": PERSONAL }) ); // updateSpace: the token, the input, ownership, the policy, then the space. let upd = |space: &str, policy: &Json| json!({ "space": space, "policy": policy }); let never = sp(&alice, "never"); assert_eq!( call(&s, UPDATE, None, json!({})).await, err_of("AuthMissing") ); assert_eq!( call(&s, UPDATE, Some(&ta), upd("nope", &ms)).await, err_of("InvalidRequest") ); assert_eq!( call( &s, UPDATE, Some(&ta), upd(&m1, &json!({ "$type": MEMBER, "publishMembers": 1 })) ) .await, err_of("InvalidRequest") ); assert_eq!( call(&s, UPDATE, Some(&tb), upd(&m1, &unsupported)).await, err_of("NotAuthorized") ); assert_eq!( call(&s, UPDATE, Some(&ta), upd(&never, &unsupported)).await, err_of("UnsupportedPolicy") ); assert_eq!( call(&s, UPDATE, Some(&ta), upd(&never, &bad_app)).await, err_of("InvalidRequest") ); assert_eq!( call(&s, UPDATE, Some(&ta), upd(&never, &ms)).await, err_of("SpaceNotFound") ); // The member methods: ownership, the space, then its policy's type. let pers = create_space(&s, &ta, "p", json!({ "$type": PERSONAL })).await; for (nsid, body, malformed) in [ ( PUT, json!({ "members": [{ "did": bob, "read": true, "write": true }] }), vec![ json!({ "members": [{ "did": "not a did", "read": true, "write": true }] }), json!({ "members": [{ "did": bob, "read": true }] }), json!({ "did": bob, "read": true, "write": true }), json!({ "members": (0..101).map(|i| json!({ "did": format!("did:plc:m{i}"), "read": true, "write": true })).collect::>() }), ], ), ( REMOVE, json!({ "dids": [bob] }), vec![ json!({ "dids": ["not a did"] }), json!({ "did": bob }), json!({ "dids": (0..101).map(|i| format!("did:plc:m{i}")).collect::>() }), ], ), ] { let with = |space: &str, body: &Json| { let mut b = body.clone(); b["space"] = json!(space); b }; assert_eq!( call(&s, nsid, None, with(&pers, &body)).await, err_of("AuthMissing"), "{nsid}" ); assert_eq!( call(&s, nsid, Some(&ta), with("nope", &body)).await, err_of("InvalidRequest"), "{nsid}" ); // Input the lexicon refuses, before whose space it is. for bad in malformed { assert_eq!( call(&s, nsid, Some(&tb), with(&pers, &bad)).await, err_of("InvalidRequest"), "{nsid} {bad}" ); } assert_eq!( call(&s, nsid, Some(&tb), with(&pers, &body)).await, err_of("NotAuthorized"), "{nsid}" ); assert_eq!( call(&s, nsid, Some(&ta), with(&never, &body)).await, err_of("SpaceNotFound"), "{nsid}" ); assert_eq!( call(&s, nsid, Some(&ta), with(&pers, &body)).await, err_of("PolicyMismatch"), "{nsid}" ); } assert_eq!( query(&s, LIST, Some(&ta), &[("space", "nope")]).await, err_of("InvalidRequest") ); assert_eq!( query(&s, LIST, None, &[("space", &pers)]).await, err_of("AuthMissing") ); assert_eq!( query(&s, LIST, Some(&tb), &[("space", &pers)]).await, err_of("NotAuthorized") ); assert_eq!( query(&s, LIST, Some(&ta), &[("space", &never)]).await, err_of("SpaceNotFound") ); assert_eq!( query(&s, LIST, Some(&ta), &[("space", &pers)]).await, err_of("PolicyMismatch") ); // A cursor that is no DID, checked last. for (token, space, want) in [ (&tb, &pers, "NotAuthorized"), (&ta, &never, "SpaceNotFound"), (&ta, &pers, "PolicyMismatch"), (&ta, &m1, "InvalidCursor"), ] { assert_eq!( query(&s, LIST, Some(token), &[("space", space), ("cursor", "zz")]).await, err_of(want), "{space}" ); } // removeWriter, under any policy. assert_eq!( call( &s, REMOVE_WRITER, Some(&ta), json!({ "space": pers, "repo": "nope" }) ) .await, err_of("InvalidRequest") ); assert_eq!( call( &s, REMOVE_WRITER, Some(&ta), json!({ "space": pers, "did": bob }) ) .await, err_of("InvalidRequest") ); assert_eq!( call( &s, REMOVE_WRITER, Some(&tb), json!({ "space": pers, "repo": bob }) ) .await, err_of("NotAuthorized") ); assert_eq!( call( &s, REMOVE_WRITER, Some(&ta), json!({ "space": never, "repo": bob }) ) .await, err_of("SpaceNotFound") ); assert_eq!( call( &s, REMOVE_WRITER, Some(&ta), json!({ "space": pers, "repo": bob }) ) .await, Ok(Json::Null) ); // exportSpaceMeta. assert_eq!(export(&s, &tb, &pers).await, err_of("NotAuthorized")); assert_eq!(export(&s, &ta, &never).await, err_of("SpaceNotFound")); // deleteSpace: one never created is not found; deleting again changes nothing. assert_eq!( call(&s, DELETE, Some(&tb), json!({ "space": m1 })).await, err_of("NotAuthorized") ); assert_eq!( call(&s, DELETE, Some(&ta), json!({ "space": never })).await, err_of("SpaceNotFound") ); put(&s, &ta, &m1, &bob, true, true).await; assert!(track(&s, &alice, &m1, &bob, 1)); assert_eq!( call(&s, DELETE, Some(&ta), json!({ "space": m1 })).await, Ok(Json::Null) ); assert_eq!( call(&s, DELETE, Some(&ta), json!({ "space": m1 })).await, Ok(Json::Null) ); assert!(!track(&s, &alice, &m1, &bob, 1)); assert_eq!( query(&s, GET, Some(&ta), &[("space", &m1)]).await, err_of("SpaceNotFound") ); assert_eq!( call(&s, UPDATE, Some(&ta), upd(&m1, &ms)).await, err_of("SpaceNotFound") ); assert_eq!( call( &s, PUT, Some(&ta), json!({ "space": m1, "members": [{ "did": bob, "read": true, "write": true }] }) ) .await, err_of("SpaceNotFound") ); assert_eq!( call(&s, REMOVE, Some(&ta), json!({ "space": m1, "dids": [bob] })).await, err_of("SpaceNotFound") ); assert_eq!( query(&s, LIST, Some(&ta), &[("space", &m1)]).await, err_of("SpaceNotFound") ); assert_eq!( call( &s, REMOVE_WRITER, Some(&ta), json!({ "space": m1, "repo": bob }) ) .await, err_of("SpaceNotFound") ); assert_eq!(export(&s, &ta, &m1).await, err_of("SpaceNotFound")); // Created again, it starts afresh: the new policy, no members, no writers. create_space(&s, &ta, "m1", ms.clone()).await; assert_eq!(members(&s, &ta, &m1).await, json!([])); assert!(writers(&s, &alice, &m1).is_empty()); // An app-password session manages spaces as a password session does. let app = app_password_session(&s, "alice", &ta).await; let ap = create_space(&s, &app, "ap", ms.clone()).await; put(&s, &app, &ap, &bob, true, true).await; assert_eq!( members(&s, &app, &ap).await, json!([{ "did": bob, "read": true, "write": true }]) ); assert_eq!(policy_of(&s, &app, &ap).await["$type"], MEMBER); assert_eq!( call( &s, REMOVE_WRITER, Some(&app), json!({ "space": ap, "repo": bob }) ) .await, Ok(Json::Null) ); assert_eq!( call(&s, UPDATE, Some(&app), upd(&ap, &ms)).await, Ok(Json::Null) ); assert!(export(&s, &app, &ap).await.is_ok()); assert_eq!( call(&s, DELETE, Some(&app), json!({ "space": ap })).await, Ok(Json::Null) ); let _ = std::fs::remove_dir_all(&dir); } /// The policy stored, as getSpace answers it: its defaults filled in and /// every field its lexicon does not define dropped; replaced wholesale by /// updateSpace, a migration dropping the member list. #[tokio::test] async fn policies_are_stored_with_defaults() { let plc = plc().await; let dir = scratch("spaces-policies"); let s = open(&dir, &plc); let (alice, ta) = create(&s, "alice").await; let (bob, _) = create(&s, "bob").await; let defaults = json!({ "$type": MEMBER, "publicRead": false, "publicWrite": false, "publishPolicy": false, "publishMembers": false }); for (key, given, stored) in [ ( "p", json!({ "$type": PERSONAL, "x": 1, "publicRead": true }), json!({ "$type": PERSONAL }), ), ( "pm", json!({ "$type": format!("{PERSONAL}#main") }), json!({ "$type": PERSONAL }), ), ("m", json!({ "$type": MEMBER }), defaults.clone()), ( "m2", json!({ "$type": MEMBER, "publicRead": true, "publishMembers": true, "allowedApps": [], "junk": { "a": 1 } }), json!({ "$type": MEMBER, "publicRead": true, "publicWrite": false, "publishPolicy": false, "publishMembers": true, "allowedApps": [] }), ), ( "m3", json!({ "$type": MEMBER, "allowedApps": ["https://a.example/c", "https://b.example/"] }), { let mut p = defaults.clone(); p["allowedApps"] = json!(["https://a.example/c", "https://b.example/"]); p }, ), ( "g", json!({ "$type": MANAGED, "managingApp": "did:web:app.example#forum", "x": 2 }), json!({ "$type": MANAGED, "managingApp": "did:web:app.example#forum", "publishPolicy": false }), ), ( "g2", json!({ "$type": MANAGED, "managingApp": "did:web:localhost%3A2583#x", "publishPolicy": true }), json!({ "$type": MANAGED, "managingApp": "did:web:localhost%3A2583#x", "publishPolicy": true }), ), ] { let uri = create_space(&s, &ta, key, given).await; assert_eq!(policy_of(&s, &ta, &uri).await, stored, "{key}"); } // A managingApp of a form refused, at create and at update. let g = sp(&alice, "g"); for app in ["did:", "did:web:app.example", "x#y"] { let p = json!({ "$type": MANAGED, "managingApp": app }); assert_eq!( call( &s, CREATE, Some(&ta), json!({ "spaceType": T, "skey": "bad", "policy": p }) ) .await, err_of("InvalidRequest"), "{app}" ); assert_eq!( call(&s, UPDATE, Some(&ta), json!({ "space": g, "policy": p })).await, err_of("InvalidRequest"), "{app}" ); } // Replaced wholesale: a field not given takes its default, not its old value. let m2 = sp(&alice, "m2"); put(&s, &ta, &m2, &bob, true, false).await; call( &s, UPDATE, Some(&ta), json!({ "space": m2, "policy": { "$type": MEMBER, "publicWrite": true } }), ) .await .unwrap(); let mut want = defaults.clone(); want["publicWrite"] = json!(true); assert_eq!(policy_of(&s, &ta, &m2).await, want); // The same type keeps the member list; another drops it, and coming back does not restore it. assert_eq!( members(&s, &ta, &m2).await, json!([{ "did": bob, "read": true, "write": false }]) ); call( &s, UPDATE, Some(&ta), json!({ "space": m2, "policy": { "$type": PERSONAL } }), ) .await .unwrap(); assert_eq!(policy_of(&s, &ta, &m2).await, json!({ "$type": PERSONAL })); call( &s, UPDATE, Some(&ta), json!({ "space": m2, "policy": { "$type": MEMBER } }), ) .await .unwrap(); assert_eq!(members(&s, &ta, &m2).await, json!([])); let _ = std::fs::remove_dir_all(&dir); } /// putMembers and removeMembers in batches, and listMembers' pages. #[tokio::test] async fn the_member_list() { let plc = plc().await; let dir = scratch("spaces-members"); let s = open(&dir, &plc); let (alice, ta) = create(&s, "alice").await; let m = create_space(&s, &ta, "m", json!({ "$type": MEMBER })).await; let dids = [ "did:web:localhost%3A2583", "did:plc:bbbb", "did:plc:aaaa", "did:web:example.com", "did:plc:cccc", ]; // In batches, and one at a time. let given: Vec<(&str, bool, bool)> = dids .iter() .enumerate() .map(|(i, did)| (*did, i % 2 == 0, i % 3 == 0)) .collect(); put_all(&s, &ta, &m, &given[..3]).await; for (did, read, write) in &given[3..] { put(&s, &ta, &m, did, *read, *write).await; } // Replacing both booleans, a DID given twice taking its last entry; // the authority may be a member; an empty batch changes nothing. put_all( &s, &ta, &m, &[ ("did:plc:bbbb", false, false), (alice.as_str(), false, false), ("did:plc:bbbb", true, true), ], ) .await; put_all(&s, &ta, &m, &[]).await; let mut all: Vec<&str> = dids.to_vec(); all.push(&alice); all.sort(); let listed = members(&s, &ta, &m).await; assert_eq!( listed .as_array() .unwrap() .iter() .map(|x| x["did"].as_str().unwrap()) .collect::>(), all ); assert_eq!( listed[all.iter().position(|d| *d == "did:plc:bbbb").unwrap()], json!({ "did": "did:plc:bbbb", "read": true, "write": true }) ); // Pages: the cursor is the last member's DID, on the last page too, and absent from an empty one. let page = |limit: &'static str, cursor: Option| { let s = s.clone(); let (ta, m) = (ta.clone(), m.clone()); async move { let mut p = vec![("space", m.as_str()), ("limit", limit)]; if let Some(c) = &cursor { p.push(("cursor", c.as_str())); } query(&s, LIST, Some(&ta), &p).await } }; let mut cursor = None; let mut seen = Vec::new(); loop { let got = page("4", cursor.clone()).await.unwrap(); let dids: Vec = got["members"] .as_array() .unwrap() .iter() .map(|x| x["did"].as_str().unwrap().to_string()) .collect(); if dids.is_empty() { assert!(got.get("cursor").is_none(), "{got}"); break; } assert_eq!(got["cursor"], json!(dids.last().unwrap())); seen.extend(dids); cursor = got["cursor"].as_str().map(str::to_string); } assert_eq!(seen, all); assert_eq!( page("100", Some("did:zzz:z".into())).await.unwrap(), json!({ "members": [] }) ); assert_eq!( page("100", Some("did:a:a".into())).await.unwrap()["members"], listed ); // An empty cursor is as none; any other must be a DID. assert_eq!( page("100", Some(String::new())).await.unwrap()["members"], listed ); for bad in ["zzzz", "a", "did:plc:", "did:PLC:abc"] { assert_eq!( page("100", Some(bad.into())).await, err_of("InvalidCursor"), "{bad}" ); } assert_eq!(page("1000", None).await.unwrap()["members"], listed); assert_eq!( query(&s, LIST, Some(&ta), &[("space", &m)]).await.unwrap()["members"], listed ); for bad in ["0", "1001", "x"] { assert_eq!(page(bad, None).await, err_of("InvalidRequest"), "{bad}"); } // removeMembers: a listed DID given twice, and one not listed. remove( &s, &ta, &m, &["did:plc:aaaa", "did:plc:never", "did:plc:aaaa"], ) .await; remove(&s, &ta, &m, &[]).await; all.retain(|d| *d != "did:plc:aaaa"); let listed = members(&s, &ta, &m).await; assert_eq!( listed .as_array() .unwrap() .iter() .map(|x| x["did"].as_str().unwrap()) .collect::>(), all ); let _ = std::fs::remove_dir_all(&dir); } /// What this part changes of the writer set, and what it leaves. #[tokio::test] async fn the_writer_set() { let plc = plc().await; let dir = scratch("spaces-writers"); let s = open(&dir, &plc); let (alice, ta) = create(&s, "alice").await; let (bob, _) = create(&s, "bob").await; let (carol, dave) = ("did:plc:carol", "did:plc:dave"); let m = create_space( &s, &ta, "m", json!({ "$type": MEMBER, "publicWrite": true }), ) .await; for (i, did) in [&alice, &bob, carol, dave].into_iter().enumerate() { assert!(track(&s, &alice, &m, did, i as u8)); } let mut want = vec![ alice.clone(), bob.clone(), carol.to_string(), dave.to_string(), ]; want.sort(); assert_eq!(writers(&s, &alice, &m), want); // removeWriter: in it or not, the authority's own DID too. for did in [&bob, &alice, &"did:plc:never".to_string()] { assert_eq!( call( &s, REMOVE_WRITER, Some(&ta), json!({ "space": m, "repo": did }) ) .await, Ok(Json::Null) ); } want.retain(|d| *d != bob && *d != alice); assert_eq!(writers(&s, &alice, &m), want); // Tracked again by its next write. assert!(track(&s, &alice, &m, &bob, 9)); // putMembers with write: true leaves it; with write: false takes it // out; removeMembers takes out a member, and leaves a DID not listed. put(&s, &ta, &m, &bob, true, true).await; assert!(writers(&s, &alice, &m).contains(&bob)); put(&s, &ta, &m, &bob, true, false).await; assert!(!writers(&s, &alice, &m).contains(&bob)); put(&s, &ta, &m, carol, true, true).await; remove(&s, &ta, &m, &[carol, dave]).await; assert_eq!(writers(&s, &alice, &m), [dave]); call( &s, REMOVE_WRITER, Some(&ta), json!({ "space": m, "repo": dave }), ) .await .unwrap(); assert!(writers(&s, &alice, &m).is_empty()); // updateSpace leaves it, a migration too. assert!(track(&s, &alice, &m, carol, 3)); call( &s, UPDATE, Some(&ta), json!({ "space": m, "policy": { "$type": PERSONAL } }), ) .await .unwrap(); assert_eq!(writers(&s, &alice, &m), [carol]); // deleteSpace empties it; created again, it is empty. call(&s, DELETE, Some(&ta), json!({ "space": m })) .await .unwrap(); create_space(&s, &ta, "m", json!({ "$type": PERSONAL })).await; assert!(writers(&s, &alice, &m).is_empty()); let _ = std::fs::remove_dir_all(&dir); } /// An operation of a commit, as `listRepoOps` lists it: its path, and /// the CID of the record it left (None: it deleted one). type Op = (String, Option); fn put_op(collection: &str, rkey: &str, record: Json) -> Op { let cid = pds_repo::make_record(data::from_json(&record).unwrap()).cid; (format!("{collection}/{rkey}"), Some(data::cid_string(&cid))) } fn del_op(collection: &str, rkey: &str) -> Op { (format!("{collection}/{rkey}"), None) } /// The records each change writes and deletes in the authority's space /// repo, each change one commit, which `on_commit` hears of. #[tokio::test] async fn publishing() { let plc = plc().await; let dir = scratch("spaces-publishing"); let s = open(&dir, &plc); let (alice, ta) = create(&s, "alice").await; let (bob, _) = create(&s, "bob").await; let heard = Arc::new(std::sync::Mutex::new(Vec::::new())); let h = heard.clone(); s.space_hooks .on_commit(Box::new(move |_, c| h.lock().unwrap().push(c.clone()))); // Each commit heard since last asked: its space, and its operations. let commits = || { let heard = std::mem::take(&mut *heard.lock().unwrap()); let (s, ta, alice) = (s.clone(), ta.clone(), alice.clone()); async move { let mut out = Vec::new(); for c in heard { assert_eq!(c.repo, alice); let got = query( &s, "com.atproto.space.listRepoOps", Some(&ta), &[("space", &c.space), ("repo", &alice), ("limit", "1000")], ) .await .unwrap(); let ops: Vec = got["ops"] .as_array() .unwrap() .iter() .filter(|o| o["rev"] == json!(c.rev)) .map(|o| { ( format!( "{}/{}", o["collection"].as_str().unwrap(), o["rkey"].as_str().unwrap() ), o["cid"].as_str().map(str::to_string), ) }) .collect(); out.push((c.space, ops)); } out } }; let records = |space: &str| { let a = s.account(&alice).unwrap(); let st = crate::read(&a.store); st.space_values(space) }; let web = "did:web:localhost%3A2583"; let record = |read: bool, write: bool| json!({ "$type": MEMBER_RECORD, "read": read, "write": write }); let policy = |p: Json| json!({ "$type": POLICY_RECORD, "policy": p }); // createSpace writes the policy record if it publishes it; nothing otherwise. let quiet = create_space(&s, &ta, "quiet", json!({ "$type": MEMBER })).await; put(&s, &ta, &quiet, &bob, true, true).await; remove(&s, &ta, &quiet, &[bob.as_str()]).await; call( &s, UPDATE, Some(&ta), json!({ "space": quiet, "policy": { "$type": PERSONAL } }), ) .await .unwrap(); assert_eq!(commits().await, []); let p = json!({ "$type": MEMBER, "publishPolicy": true, "publishMembers": true }); let m = create_space(&s, &ta, "m", p.clone()).await; let stored = policy_of(&s, &ta, &m).await; assert_eq!( commits().await, [( m.clone(), vec![put_op(POLICY_RECORD, "self", policy(stored.clone()))] )] ); // putMembers writes each given DID's record, once however often it is // given, in one commit, even one already so; keyed with a did:web's // port after a `:`. An empty batch makes no commit. put(&s, &ta, &m, &bob, true, false).await; put_all( &s, &ta, &m, &[ (bob.as_str(), false, false), (web, false, true), (bob.as_str(), true, false), ], ) .await; put_all(&s, &ta, &m, &[]).await; let mut batch = vec![ put_op(MEMBER_RECORD, &bob, record(true, false)), put_op(MEMBER_RECORD, "did:web:localhost:2583", record(false, true)), ]; batch.sort(); assert_eq!( commits().await, [ ( m.clone(), vec![put_op(MEMBER_RECORD, &bob, record(true, false))] ), (m.clone(), batch) ] ); // removeMembers deletes each removed member's record, in one commit; // one that removes no member makes none. remove(&s, &ta, &m, &[web, "did:plc:never", web]).await; remove(&s, &ta, &m, &["did:plc:never"]).await; assert_eq!( commits().await, [( m.clone(), vec![del_op(MEMBER_RECORD, "did:web:localhost:2583")] )] ); // updateSpace: the policy record, a new version even unchanged. call(&s, UPDATE, Some(&ta), json!({ "space": m, "policy": p })) .await .unwrap(); assert_eq!( commits().await, [( m.clone(), vec![put_op(POLICY_RECORD, "self", policy(stored.clone()))] )] ); // Members no longer published: each record deleted, in the same commit as the policy. put(&s, &ta, &m, web, true, true).await; commits().await; let p2 = json!({ "$type": MEMBER, "publishPolicy": true }); call(&s, UPDATE, Some(&ta), json!({ "space": m, "policy": p2 })) .await .unwrap(); let stored2 = policy_of(&s, &ta, &m).await; let mut rkeys = [bob.clone(), "did:web:localhost:2583".to_string()]; rkeys.sort(); let mut want = vec![put_op(POLICY_RECORD, "self", policy(stored2))]; want.extend(rkeys.iter().map(|k| del_op(MEMBER_RECORD, k))); assert_eq!(commits().await, [(m.clone(), want)]); // ... and published again: a record for each member. call( &s, UPDATE, Some(&ta), json!({ "space": m, "policy": { "$type": MEMBER, "publishMembers": true } }), ) .await .unwrap(); let mut want = vec![del_op(POLICY_RECORD, "self")]; want.push(put_op(MEMBER_RECORD, &bob, record(true, false))); want.push(put_op( MEMBER_RECORD, "did:web:localhost:2583", record(true, true), )); assert_eq!(commits().await, [(m.clone(), want)]); // An update that writes and deletes nothing makes no commit. call( &s, UPDATE, Some(&ta), json!({ "space": m, "policy": { "$type": MEMBER, "publishMembers": true } }), ) .await .unwrap(); assert_eq!(commits().await, []); // A migration away from memberspace deletes the members' records. let managed = json!({ "$type": MANAGED, "managingApp": "did:plc:appappappappappappappapp#forum", "publishPolicy": true }); call( &s, UPDATE, Some(&ta), json!({ "space": m, "policy": managed }), ) .await .unwrap(); let stored3 = policy_of(&s, &ta, &m).await; let want = vec![ put_op(POLICY_RECORD, "self", policy(stored3.clone())), del_op(MEMBER_RECORD, &bob), del_op(MEMBER_RECORD, "did:web:localhost:2583"), ]; assert_eq!(commits().await, [(m.clone(), want)]); assert_eq!( records(&m), Some(BTreeMap::from([( format!("{POLICY_RECORD}/self"), policy(stored3) )])) ); // importSpaceMeta writes nothing; deleteSpace drops the repo, and so it stays after a restart. let archive = export(&s, &ta, &m).await.unwrap(); import(&s, &ta, &archive).await.unwrap(); assert_eq!(commits().await, []); call(&s, DELETE, Some(&ta), json!({ "space": m })) .await .unwrap(); assert_eq!(commits().await, []); assert_eq!(records(&m), None); drop(s); let s = open(&dir, &plc); let a = s.account(&alice).unwrap(); assert!(crate::read(&a.store).spaces.get(&m).is_none()); assert!(crate::read(&a.store).spaces.get(&quiet).is_none()); let _ = std::fs::remove_dir_all(&dir); } fn v(j: Json) -> V { data::from_json(&j).unwrap() } fn star_of(meta: Json, pairs: &[(&str, V)]) -> Vec { let pairs: Vec<(Vec, Vec)> = pairs .iter() .map(|(k, x)| (k.as_bytes().to_vec(), data::encode(x))) .collect(); star::write( &v(meta), pairs.iter().map(|(k, x)| (k.as_slice(), x.as_slice())), ) } fn writer_v(rev: &str, bytes: &[u8], space_rev: &str) -> V { V::Map(vec![ ("data".into(), V::Bytes(bytes.to_vec())), ("repoRev".into(), V::Str(rev.into())), ("spaceRev".into(), V::Str(space_rev.into())), ]) } /// exportSpaceMeta's archive, read as the spec writes it; importSpaceMeta /// of it answered back byte for byte; and each fault refused, in order. #[tokio::test] async fn meta_archives() { let plc = plc().await; let dir = scratch("spaces-archives"); let s = open(&dir, &plc); let (alice, ta) = create(&s, "alice").await; let (bob, tb) = create(&s, "bob").await; let m = create_space( &s, &ta, "m", json!({ "$type": MEMBER, "allowedApps": ["https://a.example/c"] }), ) .await; let web = "did:web:localhost%3A2583"; put(&s, &ta, &m, &bob, true, false).await; put(&s, &ta, &m, web, false, true).await; put(&s, &ta, &m, "did:web:localhost", true, true).await; assert!(track(&s, &alice, &m, &bob, 7) && track(&s, &alice, &m, "did:plc:zed", 8)); let bytes = export(&s, &ta, &m).await.unwrap(); let a = star::read(&bytes, &star::REPO_LIMITS).unwrap(); assert_eq!( data::to_json(&a.meta), json!({ "$type": "atproto-space-meta", "ver": 1, "space": m }) ); let keys: Vec = a .pairs .iter() .map(|(k, _)| String::from_utf8(k.to_vec()).unwrap()) .collect(); let mut member_keys = vec![ format!("{MEMBER_RECORD}/{bob}"), format!("{MEMBER_RECORD}/did:web:localhost:2583"), format!("{MEMBER_RECORD}/did:web:localhost"), ]; member_keys.sort(); let mut want = vec!["policy".to_string()]; want.extend(member_keys); let mut writer_keys = vec![format!("writer/{bob}"), "writer/did:plc:zed".to_string()]; writer_keys.sort(); want.extend(writer_keys); assert_eq!(keys, want); let value = |k: &str| { data::to_json( &data::decode(a.pairs[keys.iter().position(|x| x == k).unwrap()].1).unwrap(), ) }; assert_eq!(value("policy"), policy_of(&s, &ta, &m).await); assert_eq!( value(&format!("{MEMBER_RECORD}/did:web:localhost:2583")), json!({ "$type": MEMBER_RECORD, "read": false, "write": true }) ); assert_eq!( data::decode( a.pairs[keys .iter() .position(|x| *x == format!("writer/{bob}")) .unwrap()] .1 ) .unwrap(), writer_v(TID, &[7; 32], TID2) ); // A personalspace's archive: its policy and writers alone. let p = create_space(&s, &ta, "p", json!({ "$type": PERSONAL })).await; let pa = export(&s, &ta, &p).await.unwrap(); assert_eq!( pa, star_of( json!({ "$type": "atproto-space-meta", "ver": 1, "space": p }), &[("policy", v(json!({ "$type": PERSONAL })))] ) ); // Imported, deleted or not, it is the space again, exported byte for byte. call(&s, DELETE, Some(&ta), json!({ "space": m })) .await .unwrap(); import(&s, &ta, &bytes).await.unwrap(); assert_eq!(export(&s, &ta, &m).await.unwrap(), bytes); let mut want_writers = [bob.clone(), "did:plc:zed".to_string()]; want_writers.sort(); assert_eq!(writers(&s, &alice, &m), want_writers); // It replaces whatever the server holds, all at once. put(&s, &ta, &m, "did:plc:extra", true, true).await; assert!(track(&s, &alice, &m, "did:plc:extra", 1)); import(&s, &ta, &bytes).await.unwrap(); assert_eq!(export(&s, &ta, &m).await.unwrap(), bytes); // A space never created here, with fields to drop. let fresh = sp(&alice, "fresh"); let meta = json!({ "$type": "atproto-space-meta", "ver": 1, "space": fresh, "other": "ignored" }); let member = |read: bool| v(json!({ "$type": MEMBER_RECORD, "read": read, "write": false, "x": 1 })); let given = star_of( meta.clone(), &[ ( "policy", v(json!({ "$type": MEMBER, "publicRead": true, "junk": 1 })), ), ( &format!("{MEMBER_RECORD}/did:web:localhost:2583"), member(true), ), ( "writer/did:plc:w", V::Map(vec![ ("repoRev".into(), V::Str(TID.into())), ("data".into(), V::Bytes(vec![1, 2])), ("spaceRev".into(), V::Str(TID2.into())), ("more".into(), V::Int(1)), ]), ), ], ); import(&s, &ta, &given).await.unwrap(); assert_eq!( policy_of(&s, &ta, &fresh).await, json!({ "$type": MEMBER, "publicRead": true, "publicWrite": false, "publishPolicy": false, "publishMembers": false }) ); assert_eq!( members(&s, &ta, &fresh).await, json!([{ "did": web, "read": true, "write": false }]) ); assert_eq!(writers(&s, &alice, &fresh), ["did:plc:w"]); // The faults, each refused, and each leaving nothing. let target = sp(&alice, "refused"); let meta = json!({ "$type": "atproto-space-meta", "ver": 1, "space": target }); let ms = v(json!({ "$type": MEMBER })); let w = writer_v(TID, &[0; 32], TID2); let mk = |did: &str| format!("{MEMBER_RECORD}/{did}"); let ok_member = v(json!({ "$type": MEMBER_RECORD, "read": true, "write": true })); let with_meta = |m: Json| star_of(m, &[("policy", ms.clone())]); let mut bad_star = star_of(meta.clone(), &[("policy", ms.clone())]); bad_star.push(0); let mut long_key = String::from("writer/did:plc:"); long_key.push_str(&"a".repeat(4096)); for (why, archive, want) in [ ("no bytes", Vec::new(), "InvalidSpaceMeta"), ("no magic", b"not an archive".to_vec(), "InvalidSpaceMeta"), ("bytes after its end", bad_star, "InvalidSpaceMeta"), ( "a key past the limit", star_of( meta.clone(), &[("policy", ms.clone()), (&long_key, w.clone())], ), "InvalidSpaceMeta", ), ( "another $type", with_meta(json!({ "$type": "atproto-space-repo", "ver": 1, "space": target })), "InvalidSpaceMeta", ), ( "ver 2", with_meta(json!({ "$type": "atproto-space-meta", "ver": 2, "space": target })), "InvalidSpaceMeta", ), ( "ver \"1\"", with_meta(json!({ "$type": "atproto-space-meta", "ver": "1", "space": target })), "InvalidSpaceMeta", ), ( "no space", with_meta(json!({ "$type": "atproto-space-meta", "ver": 1 })), "InvalidSpaceMeta", ), ( "a space that is no space-ref", with_meta( json!({ "$type": "atproto-space-meta", "ver": 1, "space": format!("at://{alice}/space/{T}") }), ), "InvalidSpaceMeta", ), ("no pairs", star_of(meta.clone(), &[]), "InvalidSpaceMeta"), ( "no policy", star_of(meta.clone(), &[(&mk(&bob), ok_member.clone())]), "InvalidSpaceMeta", ), ( "the policy not first", star_of( meta.clone(), &[(&mk(&bob), ok_member.clone()), ("policy", ms.clone())], ), "InvalidSpaceMeta", ), ( "the policy twice", star_of( meta.clone(), &[("policy", ms.clone()), ("policy", ms.clone())], ), "InvalidSpaceMeta", ), ( "state after the writers", star_of( meta.clone(), &[ ("policy", ms.clone()), ("writer/did:plc:a", w.clone()), (&mk(&bob), ok_member.clone()), ], ), "InvalidSpaceMeta", ), ( "members out of order", star_of( meta.clone(), &[ ("policy", ms.clone()), (&mk("did:plc:b"), ok_member.clone()), (&mk("did:plc:a"), ok_member.clone()), ], ), "InvalidSpaceMeta", ), ( "a member repeated", star_of( meta.clone(), &[ ("policy", ms.clone()), (&mk("did:plc:a"), ok_member.clone()), (&mk("did:plc:a"), ok_member.clone()), ], ), "InvalidSpaceMeta", ), ( "writers out of order", star_of( meta.clone(), &[ ("policy", ms.clone()), ("writer/did:plc:b", w.clone()), ("writer/did:plc:a", w.clone()), ], ), "InvalidSpaceMeta", ), ( "a writer that is no DID", star_of( meta.clone(), &[("policy", ms.clone()), ("writer/bob", w.clone())], ), "InvalidSpaceMeta", ), ( "a writer with no data", star_of( meta.clone(), &[ ("policy", ms.clone()), ( "writer/did:plc:a", v(json!({ "repoRev": TID, "spaceRev": TID2 })), ), ], ), "InvalidSpaceMeta", ), ( "a writer whose rev is no TID", star_of( meta.clone(), &[ ("policy", ms.clone()), ("writer/did:plc:a", writer_v("x", &[0; 32], TID2)), ], ), "InvalidSpaceMeta", ), ( "a writer that is not DRISL", star_of( meta.clone(), &[ ("policy", ms.clone()), ("writer/did:plc:a", V::Str("x".into())), ], ), "InvalidSpaceMeta", ), ( "a writer whose repoRev is named rev", star_of( meta.clone(), &[ ("policy", ms.clone()), ( "writer/did:plc:a", V::Map(vec![ ("rev".into(), V::Str(TID.into())), ("data".into(), V::Bytes(vec![0; 32])), ("spaceRev".into(), V::Str(TID2.into())), ]), ), ], ), "InvalidSpaceMeta", ), ( "a policy that is no map", star_of(meta.clone(), &[("policy", v(json!([1])))]), "InvalidSpaceMeta", ), ( "a policy that is no DRISL", { let m = v(meta.clone()); star::write( &m, [(b"policy".as_slice(), [0xffu8].as_slice())].into_iter(), ) }, "InvalidSpaceMeta", ), ( "policy state that is no map, under an unsupported policy", star_of( meta.clone(), &[ ("policy", v(json!({ "$type": "com.example.policy" }))), (&mk("bob"), V::Int(1)), ], ), "InvalidSpaceMeta", ), ( "another's space, and no policy", star_of( json!({ "$type": "atproto-space-meta", "ver": 1, "space": sp(&bob, "x") }), &[("writer/did:plc:a", w.clone())], ), "InvalidSpaceMeta", ), // Ownership, after the archive's shape, before its policy. ( "another's space", star_of( json!({ "$type": "atproto-space-meta", "ver": 1, "space": sp(&bob, "x") }), &[("policy", v(json!({ "$type": "com.example.policy" })))], ), "NotAuthorized", ), ( "an unsupported policy", star_of( meta.clone(), &[("policy", v(json!({ "$type": "com.example.policy" })))], ), "UnsupportedPolicy", ), ( "a policy its lexicon refuses", star_of( meta.clone(), &[("policy", v(json!({ "$type": MEMBER, "publicRead": 1 })))], ), "InvalidSpaceMeta", ), ( "a policy with no $type", star_of( meta.clone(), &[("policy", v(json!({ "publicRead": true })))], ), "InvalidSpaceMeta", ), ( "a bad managingApp", star_of( meta.clone(), &[( "policy", v(json!({ "$type": MANAGED, "managingApp": "app" })), )], ), "InvalidRequest", ), ( "a managingApp with no fragment, and a member", star_of( meta.clone(), &[ ( "policy", v( json!({ "$type": MANAGED, "managingApp": "did:plc:appappappappappappappapp" }), ), ), (&mk(&bob), ok_member.clone()), ], ), "InvalidRequest", ), ( "an unsupported policy, and a member keyed by no DID", star_of( meta.clone(), &[ ("policy", v(json!({ "$type": "com.example.policy" }))), (&mk("bob"), v(json!({ "a": 1 }))), ], ), "UnsupportedPolicy", ), // The policy state, last. ( "members of a personalspace", star_of( meta.clone(), &[ ("policy", v(json!({ "$type": PERSONAL }))), (&mk(&bob), ok_member.clone()), ], ), "InvalidSpaceMeta", ), ( "state it does not know", star_of( meta.clone(), &[ ("policy", ms.clone()), ("com.example.state/x", ok_member.clone()), ], ), "InvalidSpaceMeta", ), ( "a member keyed by no DID", star_of( meta.clone(), &[("policy", ms.clone()), (&mk("bob"), ok_member.clone())], ), "InvalidSpaceMeta", ), ( "a member keyed with a %3A", star_of( meta.clone(), &[("policy", ms.clone()), (&mk(web), ok_member.clone())], ), "InvalidSpaceMeta", ), ( "a member with no $type", star_of( meta.clone(), &[ ("policy", ms.clone()), (&mk(&bob), v(json!({ "read": true, "write": true }))), ], ), "InvalidSpaceMeta", ), ( "a member with no write", star_of( meta.clone(), &[ ("policy", ms.clone()), ( &mk(&bob), v(json!({ "$type": MEMBER_RECORD, "read": true })), ), ], ), "InvalidSpaceMeta", ), ] { assert_eq!(import(&s, &ta, &archive).await, err_of(want), "{why}"); } assert_eq!( query(&s, GET, Some(&ta), &[("space", &target)]).await, err_of("SpaceNotFound") ); // The token first, then the body's type; an app-password session may not import. let good = star_of(meta.clone(), &[("policy", ms.clone())]); assert_eq!( import_as(&s, None, Some("application/json"), b"{}").await, err_of("AuthMissing") ); assert_eq!( import_as(&s, Some("abc.def.ghi"), Some(crate::STAR_TYPE), &good).await, err_of("InvalidToken") ); let app = app_password_session(&s, "alice", &ta).await; assert_eq!(import(&s, &app, &good).await, err_of("InvalidToken")); // Another Content-Type, or none, before the body is read: even an empty one. for ctype in [ Some("application/json"), Some("application/octet-stream"), None, ] { assert_eq!( import_as(&s, Some(&ta), ctype, &good).await, err_of("InvalidRequest"), "{ctype:?}" ); assert_eq!( import_as(&s, Some(&ta), ctype, b"").await, err_of("InvalidRequest"), "{ctype:?}" ); } assert_eq!(import(&s, &tb, &good).await, err_of("NotAuthorized")); assert_eq!( query(&s, GET, Some(&ta), &[("space", &target)]).await, err_of("SpaceNotFound") ); import_as(&s, Some(&ta), Some("Application/VND.dasl.STAR; x=y"), &good) .await .unwrap(); assert_eq!( export(&s, &ta, &target).await.unwrap(), star_of(meta, &[("policy", v(policy_of(&s, &ta, &target).await))]) ); let _ = std::fs::remove_dir_all(&dir); } /// What takedown and deactivation answer, by method and session. #[test] fn takedown_and_deactivation() { use Kind::*; use Session::*; use Status::*; let name = |r: Result<(), XrpcError>| r.err().map(|e| (e.status, e.name)); for kind in [Manage, Import, Read, Export] { assert_eq!(name(admit(kind, Password, Active)), None, "{kind:?}"); } let deactivated = Some((401, "AccountDeactivated")); let taken_down = Some((401, "AccountTakedown")); let invalid = Some((400, "InvalidToken")); for (kind, session, status, want) in [ (Manage, Password, Deactivated, deactivated), (Manage, AppPassword, Deactivated, deactivated), (Manage, Password, TakenDown, taken_down), (Import, Password, Deactivated, None), (Import, Password, TakenDown, taken_down), (Import, AppPassword, Active, invalid), (Read, Password, Deactivated, None), (Read, AppPassword, TakenDown, None), (Export, Password, Deactivated, None), (Export, Password, TakenDown, None), // A taken-down account's own session: exportSpaceMeta alone takes it. (Export, Takendown, TakenDown, None), (Read, Takendown, TakenDown, invalid), (Manage, Takendown, TakenDown, invalid), (Import, Takendown, TakenDown, invalid), ] { assert_eq!( name(admit(kind, session, status)), want, "{kind:?} {session:?} {status:?}" ); } } #[test] fn member_record_keys() { for (did, rkey) in [ ("did:web:localhost%3A2583", "did:web:localhost:2583"), ("did:plc:abc", "did:plc:abc"), ("did:web:example.com", "did:web:example.com"), ] { assert_eq!(member_rkey(did), rkey); assert_eq!(member_did(rkey).as_deref(), Some(did)); } for bad in ["bob", "did:web:a%3A1", "did:web:", "did:plc:a b"] { assert_eq!(member_did(bad), None, "{bad}"); } } /// A `managingApp`'s forms (`spec/SPACES-POLICIES.md`, "Policies"). #[test] fn managing_app_forms() { let plc = "did:plc:abcdefghijklmnopqrstuvwx"; for ok in [ format!("{plc}#forum"), "did:web:app.example#svc".into(), "did:web:localhost%3A2583#x".into(), format!("{plc}#a/b?c:@!$&'()*+,;=-._~%41"), ] { assert!(service_ref(&ok), "{ok}"); } for bad in [ plc.to_string(), "did:".into(), "did:key:zQ3shokFTS3brHcDQrn82RUDfCZESWL1ZdCEJwekUDPQiYBme#x".into(), "did:example:abc#x".into(), "did:plc:abc#x".into(), "did:plc:abcdefghijklmnopqrstuvw1#x".into(), "did:plc:ABCDEFGHIJKLMNOPQRSTUVWX#x".into(), format!("{plc}#"), format!("{plc}#a#b"), format!("{plc}#a b"), format!("{plc}#%4"), format!("{plc}#%4g"), "did:web:app.example:path#x".into(), "did:web:app.example%3A443#x".into(), "web:app.example#x".into(), ] { assert!(!service_ref(&bad), "{bad}"); } } /// A checkpoint's spaces: each live one's archive, as `exportSpaceMeta` /// writes it with its writers taken out marked removed, restores the /// same. One a checkpoint could not have kept, a writer's repo rev as /// `rev` or a `managingApp` no `createSpace` takes, is refused. #[test] fn a_checkpoints_spaces_round_trip() { let did = "did:plc:aaaaaaaaaaaaaaaaaaaaaaaa"; let writer = "did:plc:bbbbbbbbbbbbbbbbbbbbbbbb"; let (m, g) = (sp(did, "m"), sp(did, "g")); let meta = |uri: &str| json!({ "$type": META_TYPE, "ver": 1, "space": uri }); let policy = v( json!({ "$type": MEMBER, "publicRead": false, "publicWrite": false, "publishPolicy": false, "publishMembers": false }), ); let (member_key, writer_key) = ( format!("{MEMBER_RECORD}/{writer}"), format!("{WRITER}{writer}"), ); let member = v(json!({ "$type": MEMBER_RECORD, "read": true, "write": false })); let archive = |w: V| { star_of( meta(&m), &[ ("policy", policy.clone()), (&member_key, member.clone()), (&writer_key, w), ], ) }; let V::Map(mut removed) = writer_v(TID, &[3; 32], TID2) else { panic!("a writer that is no map") }; removed.push(("removed".into(), V::Bool(true))); let kept = archive(V::Map(removed)); let managed = |app: &str| { star_of( meta(&g), &[( "policy", v(json!({ "$type": MANAGED, "managingApp": app, "publishPolicy": false })), )], ) }; let mut a = Authority::default(); a.restore(did, &m, Some(&kept)).unwrap(); a.restore(did, &g, Some(&managed("did:web:app.example#x"))) .unwrap(); assert_eq!( a.live(&m).unwrap().writers.get(writer), Some(&Writer { rev: TID.into(), data: vec![3; 32], space_rev: TID2.into(), removed: true, }) ); let saved: BTreeMap>> = a .saved() .map(|(uri, bytes)| (uri.to_string(), bytes)) .collect(); assert_eq!(saved[&m].as_deref(), Some(kept.as_slice())); let mut b = Authority::default(); for (uri, bytes) in &saved { b.restore(did, uri, bytes.as_deref()).unwrap(); } assert_eq!(b, a); let rev_named = archive(V::Map(vec![ ("rev".into(), V::Str(TID.into())), ("data".into(), V::Bytes(vec![3; 32])), ("spaceRev".into(), V::Str(TID2.into())), ])); for (uri, bad) in [(&m, rev_named), (&g, managed("did:"))] { assert!(Authority::default().restore(did, uri, Some(&bad)).is_err()); } } }