#avro #code-generation #serde

bin+lib rsgen-avro

Command line and library for generating Rust types from Avro schemas

10 releases (5 breaking)

0.6.4 Mar 15, 2020
0.6.3 Jan 13, 2020
0.6.0 Dec 12, 2019
0.5.0 Jun 11, 2019
0.1.0 Oct 28, 2018

#144 in Encoding

Download history 280/week @ 2020-06-03 382/week @ 2020-06-10 292/week @ 2020-06-17 354/week @ 2020-06-24 244/week @ 2020-07-01 279/week @ 2020-07-08 307/week @ 2020-07-15 387/week @ 2020-07-22 218/week @ 2020-07-29 274/week @ 2020-08-05 424/week @ 2020-08-12 402/week @ 2020-08-19 293/week @ 2020-08-26 240/week @ 2020-09-02 183/week @ 2020-09-09 129/week @ 2020-09-16

1,370 downloads per month

MIT license

64KB
1.5K SLoC

rsgen-avro

Crates.io Docs MIT licensed

A command line tool and library for generating serde-compatible Rust types from Avro schemas. The avro-rs crate provides a way to read and write Avro data with such types.

Command line usage

Install with:

cargo install rsgen-avro

Available options:

Usage:
  rsgen-avro [options] <schema-file-or-dir> <output-file>
  rsgen-avro (-h | --help)
  rsgen-avro (-V | --version)

Options:
  --fmt          Run rustfmt on the resulting <output-file>
  --nullable     Replace null fields with their default value
                 when deserializing.
  --precision=P  Precision for f32/f64 default values
                 that aren't round numbers [default: 3].
  -V, --version  Show version.
  -h, --help     Show this screen.

Library usage

As a libray, the basic usage is:

use rsgen_avro::{Source, Generator};

let raw_schema = r#"
{
    "type": "record",
    "name": "test",
    "fields": [
        {"name": "a", "type": "long", "default": 42},
        {"name": "b", "type": "string"}
    ]
}
"#;

let source = Source::SchemaStr(&raw_schema);

let mut out = std::io::stdout();

let g = Generator::new().unwrap();
g.gen(&source, &mut out).unwrap();

This will generate the following output:

use serde::{Deserialize, Serialize};

#[serde(default)]
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
pub struct Test {
    pub a: i64,
    pub b: String,
}

impl Default for Test {
    fn default() -> Test {
        Test {
            a: 42,
            b: String::default(),
        }
    }
}

Various Schema sources can be used with Generator's .gen(..) method:

pub enum Source<'a> {
    Schema(&'a avro_rs::Schema), // from `avro-rs` crate
    SchemaStr(&'a str),
    FilePath(&'a std::path::Path),
    DirPath(&'a std::path::Path),
}

Note also that the Generator can be customized with a builder:

let g = Generator::builder().precision(2).build().unwrap();

Limitations

  • Avro schema namespace fields are ignored, therefore names from a single schema must no clash.
  • Only union of the form ["null", "some-type"] are supported and treated as Option<_>.

Dependencies

~8MB
~171K SLoC