🥮 mooncakes.io

    marianoguerra/atproto/data does not have a README file

    DecodeError

    source
    pub(all) suberror DecodeError {
      DecodeError(path~ : String, reason~ : String)
    } derive(Eq, 
    Debug    )

    impl Show for DecodeError

    DecodeError::describe_error

    source
    fn DecodeError::describe_error(self : DecodeError) -> String

    DecodeError::path

    source
    fn DecodeError::path(self : DecodeError) -> String

    DecodeError::reason

    source
    fn DecodeError::reason(self : DecodeError) -> String

    BlobRef

    source
    pub(all) enum BlobRef {
      Typed(cid~ : 
    Cid    , mime_type~ : String, size~ : Int64)
      Legacy(cid~ : 
    Cid    , mime_type~ : String)
    } derive(Eq, 
    Debug    )

    A reference to a blob, in whichever of the two encodings it arrived in.

    BlobRef::cid

    source

    BlobRef::from_lex

    source
    fn BlobRef::from_lex(value : LexValue, path? : String) -> BlobRef raise DecodeError

    Accepts both encodings.

    The typed form's ref is a cid-link, so by the time this sees it the JSON codec has already turned {"$link": ...} into a Link. The legacy form's cid is a plain string, and has to be parsed here.

    BlobRef::is_legacy

    source
    fn BlobRef::is_legacy(self : BlobRef) -> Bool

    BlobRef::mime_type

    source
    fn BlobRef::mime_type(self : BlobRef) -> String

    BlobRef::size

    source
    fn BlobRef::size(self : BlobRef) -> Int64?

    None for a legacy ref, which does not carry one.

    Note what this is not: a guarantee. The size is what the server recorded when the blob was uploaded, and nothing re-checks it.

    BlobRef::to_lex

    source
    fn BlobRef::to_lex(self : BlobRef) -> LexValue

    Encodes back into whichever form it came from.

    A legacy ref is NOT upgraded on the way out. Rewriting it into the typed form would change the record's bytes and therefore its CID, turning a read-modify-write into a different record.

    LexValue

    source
    pub(all) enum LexValue {
      Null
      Bool(Bool)
      Int(Int64)
      Str(String)
      Bytes(Bytes)
      Link(
    Cid    )
      Arr(Array[LexValue])
      Obj(Map[String, LexValue])
    } derive(Eq, 
    Debug    )

    A value in the atproto data model.

    LexValue::as_array

    source
    fn LexValue::as_array(self : LexValue) -> Array[LexValue]?

    LexValue::as_bool

    source
    fn LexValue::as_bool(self : LexValue) -> Bool?

    LexValue::as_bytes

    source
    fn LexValue::as_bytes(self : LexValue) -> Bytes?

    LexValue::as_int

    source
    fn LexValue::as_int(self : LexValue) -> Int64?

    LexValue::as_object

    source
    fn LexValue::as_object(self : LexValue) -> Map[String, LexValue]?

    LexValue::as_string

    source
    fn LexValue::as_string(self : LexValue) -> String?

    LexValue::get

    source
    fn LexValue::get(self : LexValue, key : String) -> LexValue?

    One field of an object, or None if this is not an object or has no such field. The two cases are deliberately not distinguished: a caller reaching for a field on a non-object has already gone wrong somewhere else.

    LexValue::kind

    source
    fn LexValue::kind(self : LexValue) -> String

    The kind name, for error messages. Matches the Lexicon spelling of each type, so a mismatch reads in the same vocabulary the schema uses.

    LexValue::parse

    source
    fn LexValue::parse(text : String) -> LexValue raise DecodeError

    Parses JSON into the data model, decoding $link and $bytes on the way.

    This and stringify are the only doors between JSON and everything above, which is what keeps Json out of the library's public API.

    LexValue::stringify

    source
    fn LexValue::stringify(self : LexValue) -> String

    LexValue::type_tag

    source
    fn LexValue::type_tag(self : LexValue) -> String?

    The $type discriminator, if this is a tagged object.

    Every record and every open-union member carries one, and it is what dispatch is done on -- never the shape of the object, which is how TypeScript does it and how rsky's untagged unions go wrong.

    Nullable

    source
    pub(all) enum Nullable[T] {
      Absent
      Null
      Value(T)
    } derive(Eq, 
    Debug    )

    Nullable::is_absent

    source
    fn[T] Nullable::is_absent(self : Nullable[T]) -> Bool

    Nullable::is_null

    source
    fn[T] Nullable::is_null(self : Nullable[T]) -> Bool

    Nullable::value

    source
    fn[T] Nullable::value(self : Nullable[T]) -> T?

    The value, if there is one. Both empty cases collapse here, which is fine for a reader -- it is the WRITER that needs all three.

    base64_decode

    source
    fn base64_decode(text : String) -> Bytes?

    None if the text is not base64. A lone trailing character is not: base64 has no encoding that produces one, so a 4n+1 length means truncation.

    base64_encode

    source
    fn base64_encode(bytes : Bytes) -> String

    expect_array

    source
    fn[T] expect_array(value : LexValue, path : String, parse : (LexValue, String) -> T raise DecodeError) -> Array[T] raise DecodeError

    An array, every element decoded by parse. All-or-nothing, for the same reason take_array is: a half-decoded list round-trips as a shorter list.

    expect_bool

    source
    fn expect_bool(value : LexValue, path : String) -> Bool raise DecodeError

    expect_bytes

    source
    fn expect_bytes(value : LexValue, path : String) -> Bytes raise DecodeError

    expect_format

    source
    fn[T] expect_format(value : LexValue, path : String, parse : (String) -> T raise 
    SyntaxError    ) -> T raise DecodeError

    A string in one of the eleven Lexicon formats.

    expect_int

    source
    fn expect_int(value : LexValue, path : String) -> Int64 raise DecodeError

    fn expect_link(value : LexValue, path : String) -> 
    Cid     raise DecodeError

    expect_string

    source
    fn expect_string(value : LexValue, path : String) -> String raise DecodeError

    field_path

    source
    fn field_path(prefix : String, field : String) -> String

    Dotted for fields, bracketed for indices: feed[0].post.author.did. Empty at the root, where the path prefix is dropped rather than shown as a leading dot.

    fields_of

    source
    fn fields_of(fields : Map[String, LexValue]) -> Map[String, LexValue]

    A working copy of an object's fields, for a decoder to consume.

    index_path

    source
    fn index_path(prefix : String, index : Int) -> String

    merge_extra

    source
    fn merge_extra(out : Map[String, LexValue], extra : Map[String, LexValue]) -> LexValue

    Writes back the fields the type did not model, and returns the finished object. Modelled fields win a collision -- extra should not contain one, and if it does the typed value is the one the caller set.

    object_fields

    source
    fn object_fields(value : LexValue, path? : String) -> Map[String, LexValue] raise DecodeError

    The object's fields, or a decode error naming what arrived instead.

    put_array

    source
    fn[T] put_array(out : Map[String, LexValue], key : String, value : Array[T]?, encode : (T) -> LexValue) -> Unit

    put_bool

    source
    fn put_bool(out : Map[String, LexValue], key : String, value : Bool?) -> Unit

    put_int

    source
    fn put_int(out : Map[String, LexValue], key : String, value : Int64?) -> Unit

    put_lex

    source
    fn put_lex(out : Map[String, LexValue], key : String, value : LexValue?) -> Unit

    put_nullable

    source
    fn[T] put_nullable(out : Map[String, LexValue], key : String, value : Nullable[T], encode : (T) -> LexValue) -> Unit

    Writes a nullable field. Absent writes nothing; Null writes an explicit null, which is the whole point -- this is the one place in the library where emitting a null is correct rather than a bug.

    put_object

    source
    fn[T] put_object(out : Map[String, LexValue], key : String, value : T?, encode : (T) -> LexValue) -> Unit

    put_string

    source
    fn put_string(out : Map[String, LexValue], key : String, value : String?) -> Unit

    put_string_array

    source
    fn put_string_array(out : Map[String, LexValue], key : String, value : Array[String]?) -> Unit

    require_array

    source
    fn[T] require_array(rest : Map[String, LexValue], key : String, path? : String, parse : (LexValue, String) -> T raise DecodeError) -> Array[T] raise DecodeError

    require_bool

    source
    fn require_bool(rest : Map[String, LexValue], key : String, path? : String) -> Bool raise DecodeError

    require_bytes

    source
    fn require_bytes(rest : Map[String, LexValue], key : String, path? : String) -> Bytes raise DecodeError

    require_format

    source
    fn[T] require_format(rest : Map[String, LexValue], key : String, path? : String, parse : (String) -> T raise 
    SyntaxError    ) -> T raise DecodeError

    require_int

    source
    fn require_int(rest : Map[String, LexValue], key : String, path? : String) -> Int64 raise DecodeError

    require_lex

    source
    fn require_lex(rest : Map[String, LexValue], key : String, path? : String) -> LexValue raise DecodeError

    fn require_link(rest : Map[String, LexValue], key : String, path? : String) -> 
    Cid     raise DecodeError

    require_object

    source
    fn[T] require_object(rest : Map[String, LexValue], key : String, path? : String, parse : (LexValue, String) -> T raise DecodeError) -> T raise DecodeError

    require_string

    source
    fn require_string(rest : Map[String, LexValue], key : String, path? : String) -> String raise DecodeError

    tagged

    source
    fn tagged(value : LexValue, type_ : String) -> LexValue

    Adds a $type to an object, for a value being encoded as a union member.

    The UNION owns the tag, not the member: com.atproto.repo.strongRef is a bare {uri, cid} on its own and only carries a $type where a union needs to tell it from its siblings. Tagging the member type instead -- which is what rsky does, inconsistently -- puts a $type on values that should not have one.

    A non-object is returned unchanged; there is nowhere to put a tag, and a union whose members are not objects could not be dispatched anyway.

    take_array

    source
    fn[T] take_array(rest : Map[String, LexValue], key : String, path? : String, parse : (LexValue, String) -> T raise DecodeError) -> Array[T]? raise DecodeError

    An array, every element decoded by parse.

    All-or-nothing on purpose: a half-decoded list would round-trip as a shorter list, which is silent data loss.

    take_bool

    source
    fn take_bool(rest : Map[String, LexValue], key : String) -> Bool?

    take_bytes

    source
    fn take_bytes(rest : Map[String, LexValue], key : String) -> Bytes?

    take_format

    source
    fn[T] take_format(rest : Map[String, LexValue], key : String, path? : String, parse : (String) -> T raise 
    SyntaxError    ) -> T? raise DecodeError

    A string field whose Lexicon declares a format, parsed into the matching type -- which is what stops a Did and a Handle from being the same thing at 214 and 28 call sites respectively.

    Absent gives None; present but malformed RAISES rather than answering None. A format failure is a server sending something it should not, and quietly dropping the field would turn that into a mysterious missing value.

    take_int

    source
    fn take_int(rest : Map[String, LexValue], key : String) -> Int64?

    take_lex

    source
    fn take_lex(rest : Map[String, LexValue], key : String) -> LexValue?

    fn take_link(rest : Map[String, LexValue], key : String) -> 
    Cid    ?

    take_nullable

    source
    fn[T] take_nullable(rest : Map[String, LexValue], key : String, path? : String, parse : (LexValue, String) -> T raise DecodeError) -> Nullable[T] raise DecodeError

    Reads a nullable field, consuming it. Absent when the key is not there, Null when it is there and null.

    take_object

    source
    fn[T] take_object(rest : Map[String, LexValue], key : String, path? : String, parse : (LexValue, String) -> T raise DecodeError) -> T? raise DecodeError

    A nested object, decoded by parse. Absent gives None; present and malformed raises, because a sub-object that fails to decode is a schema mismatch rather than an absent value.

    take_string

    source
    fn take_string(rest : Map[String, LexValue], key : String) -> String?

    take_string_array

    source
    fn take_string_array(rest : Map[String, LexValue], key : String, path? : String) -> Array[String]? raise DecodeError

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io