Struct AtUri 

pub struct AtUri { /* private fields */ }

A validated AT-URI.

Format: at://did-or-handle/collection/rkey

Implementations

impl AtUri

pub fn new(s: &str) -> Result<Self, InvalidAtUriError>

Parse and validate an AT-URI string.

pub fn is_valid(s: &str) -> bool

Check whether a string is a valid AT-URI.

pub fn make( authority: &str, collection: Option<&str>, rkey: Option<&str>, ) -> Result<Self, InvalidAtUriError>

Build an AT-URI from individual parts. The collection and rkey are each optional, mirroring the TS AtUri.make(host, coll?, rkey?) constructor. Every part is validated in the same way as the full-string parser — calling make(h, None, Some(r)) (rkey without collection) is an error.

pub fn authority(&self) -> &str

Return the authority (DID or handle).

pub fn collection(&self) -> Option<&str>

Return the collection NSID, if present.

pub fn rkey(&self) -> Option<&str>

Return the record key, if present.

pub fn fragment(&self) -> Option<&str>

Return the fragment, if present.

pub const fn protocol(&self) -> &'static str

The URI protocol — always "at:".

pub fn origin(&self) -> String

The URI origin — at://<authority>. Analogous to URL.origin in browsers (and to the TS AtUri.origin getter).

pub fn set_authority( &mut self, v: impl Into<String>, ) -> Result<(), InvalidAtUriError>

Replace the authority. Validates the new value as a DID or a handle before committing — a failed update leaves the URI unchanged.

pub fn set_collection( &mut self, v: Option<&str>, ) -> Result<(), InvalidAtUriError>

Replace the collection NSID. Pass None to clear both collection and rkey (an rkey without a collection is not a valid AT-URI, so setting collection to None also drops rkey).

pub fn set_rkey(&mut self, v: Option<&str>) -> Result<(), InvalidAtUriError>

Replace the record key. Setting a rkey on a URI with no collection is rejected — the spec requires coll/rkey together.

pub fn set_fragment(&mut self, v: Option<&str>) -> Result<(), InvalidAtUriError>

Replace the fragment. Pass None to clear it. Fragments must start with / per the atproto syntax (they’re JSON Pointer expressions), so a non-None value that doesn’t is rejected.

pub fn resolve(&self, reference: &str) -> Result<Self, InvalidAtUriError>

Resolve a reference relative to this URI.

Handles the two cases the atproto spec actually uses:

• If reference is a full AT-URI (at://…), it’s parsed in isolation and returned.
• If reference starts with #, the fragment is replaced.
• Otherwise, reference is treated as a path applied to this URI’s authority: an empty / single-segment / two-segment reference sets just the collection / collection + rkey.

This is a pragmatic subset of TS’s relative-URI handling — atproto doesn’t use the full RFC 3986 scheme-relative / host- relative escalation ladder, so replicating all of it would be yak-shaving.

Trait Implementations

impl Clone for AtUri

fn clone(&self) -> AtUri

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AtUri

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AtUri

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for AtUri

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromStr for AtUri

type Err = InvalidAtUriError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for AtUri

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for AtUri

fn eq(&self, other: &AtUri) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for AtUri

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl Eq for AtUri

impl StructuralPartialEq for AtUri