burrtype 0.3.0

Exports your types to other languages, currently supporting TypeScript.

Install

Add to your Cargo.toml

[dependencies]
burrtype = { version = "0.2", features = ["typescript"] }

Usage

Preparing your types

Decorate your types with the Burr derive macro.

use burrtype::prelude::*;

#[derive(Burr)]
pub struct Foo(u64);

#[derive(Burr)]
pub struct Bar(Foo);

Use the optional #[burr(mod)] attribute to assign your type to a module automatically.

use burrtype::prelude::*;

#[derive(Burr)]
// `Foo` will be automatically included in the specified module if not explicitly included during export
#[burr(mod = "common/types")]
pub struct Foo(u64);

Exporting your types

In your build.rs or another binary, we can create an exporter and optionally configure it. The exporter and its components behave as builder patterns.

Burrxporter::new()

Add your types using modules to organize them. This module tree typically translates to the file structure being produced - with one file per module - but language constraits, features, or options can change this behavior.

    .with_mod(BurrMod::new("bar")
        .with_type::<Bar>()
    )

Resolve type dependencies, which exports types your types depend on. They will be added to either the type's chosen module or the given default module. This step is unnecessary if you explicitly include all types needed to describe your data.

    .resolve_exports("common")

Export to one or more targets.

    // outputs ./ts/common.ts and ./ts/bar.ts
    .export("ts", TypeScript::new())?
    // bundles all exported types into a single file
    .export("out/bundled.ts", TypeScript::new().with_file_map(ModFileMap::Inline))?

See these concepts in action in the example.

3rd-party types

For types that don't derive Burr, such as those from third-party crates, use an attribute to treat fields as another type:

#[derive(serde::Serialize, serde::Deserialize, Debug)]
pub struct PhantomType(pub u64);

#[derive(Burr)]
pub struct Foo {
    #[burr(type = u64)]
    pub foo: PhantomType,
}

Alternatively, you can register a 3rd-party type as a string name representing that type in the target language.

    .export("api", TypeScript::new()
        .with_type_name::<rust_decimal::Decimal>("number")
    )?

Desired features going forward

• Replace panics with errors

• tests

• Rust target

  • Support the same set of common features as TypeScript
  • Generic types?