1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
//! This library aims to facilitate the workflow between Rust and TypeScript data
//! structures by auto-generating ! TypeScript classes and respective serialization
//! layouts used for Borsh (de)serialization. Check out
//! [`borsh-js`](https://github.com/near/borsh-js) and
//! [`borsh-rs`](https://docs.rs/borsh/0.9.1/borsh/index.html) for more details.
//!
//! By default the library provides a derivable trait `BorshSchema` without any
//! associated methods and constants. It's an empty trait that is essentially a
//! flag for the schema parser that works the following way:
//!
//! 1) the parser traverses all `.rs` files in the provided input directory
//!
//! 2) data structures (`struct`s and `enum`s) annotated with
//! `#[derive(BorshSchema, ...)]` are parsed into an intermediate data
//! structure
//!
//! 3) the intermediate data structure is used to generate output files
//! containing TypeScript classes and serialization schemas
//!
//! The parser itself is only available through the `full` feature flag,
//! because it uses parsing libraries incompatible with `wasm` or `bpf`
//! targets.
pub use agsol_borsh_schema_derive::*;
/// Intermediate data structures used for generating
/// schema an TypeScript class layouts.
#[cfg(feature = "full")]
mod layout;
#[cfg(all(test, feature = "full"))]
mod test;
#[cfg(feature = "full")]
mod utils;
#[cfg(feature = "full")]
pub use utils::*;
/// An empty trait that serves as a flag for the schema parser.
///
/// It has an `alias` attribute that can be used to annotate `struct` and
/// `enum` fields to explicitly indicate the type of that field. This is needed
/// because the parser reads the file as a raw string, therefore it has no way
/// of knowing the underlying type of a type alias.
///
/// # Example
/// ```rust
/// use agsol_borsh_schema::BorshSchema;
/// use std::collections::BTreeMap;
///
/// type SomeAlias = [u8; 32];
///
/// #[derive(BorshSchema)]
/// struct Foo {
/// foo: Option<u64>,
/// bar: BTreeMap<u8, Bar>,
/// #[alias([u8; 32])]
/// baz: SomeAlias,
/// }
///
/// #[derive(BorshSchema)]
/// enum Bar {
/// A,
/// B,
/// C(u64),
/// D {
/// foo: i32,
/// bar: String,
/// },
/// }
/// ```
///
/// In the above example you may notice that `Foo`'s `bar` field doesn't need
/// an alias because `Bar` implements `BorshSchema` itself, however, the parser
/// doesn't know that `SomeAlias` is actually a byte array without the `alias`
/// attribute. If the `alias` attribute is omitted, the generated TypeScript
/// code will contain `SomeAlias` instead of `Uint8Array`.
pub trait BorshSchema {}