#avro #code-generation #serde

bin+lib rsgen-avro

Command line and library for generating Rust types from Avro schemas

28 releases

Uses new Rust 2021

new 0.11.0 Aug 4, 2022
0.10.1 Jul 13, 2022
0.9.9 Jan 5, 2022
0.9.8 Sep 9, 2021
0.2.0 Nov 4, 2018

#124 in Command line utilities

Download history 153/week @ 2022-04-21 374/week @ 2022-04-28 348/week @ 2022-05-05 566/week @ 2022-05-12 253/week @ 2022-05-19 274/week @ 2022-05-26 439/week @ 2022-06-02 218/week @ 2022-06-09 178/week @ 2022-06-16 268/week @ 2022-06-23 263/week @ 2022-06-30 274/week @ 2022-07-07 292/week @ 2022-07-14 354/week @ 2022-07-21 391/week @ 2022-07-28 305/week @ 2022-08-04

1,439 downloads per month

MIT license

72KB
1.5K SLoC

rsgen-avro   latest doc

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

Command line usage

Download the latest release or install with:

cargo install rsgen-avro

Available options:

Usage:
  rsgen-avro [options] <schema-files-glob-pattern> <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].
  --union-deser      Custom deserialization for apache-avro multi-valued union types.
  --derive-builders  Derive builders for generated record structs.
  --derive-schemas   Derive AvroSchema for generated record structs.
  -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:

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

#[inline(always)]
fn default_test_a() -> i64 { 42 }

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

pub enum Source<'a> {
    Schema(&'a rsgen_avro::Schema), // Enum re-exported from `apache-avro`
    SchemaStr(&'a str),             // Schema as a json string
    GlobPattern(&'a str),           // Glob pattern to select schema files
}

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

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

The derive_builders option will use the derive-builder crate to derive builders for the generated structs. The builders will only be derived for those structs that are generated from Avro records.

Limitations

  • Avro schema namespace fields are ignored, therefore names from a single schema must not conflict.

Dependencies

~9MB
~192K SLoC