#avro #code-generation #serde

bin+lib rsgen-avro

Command line and library for generating Rust types from Avro schemas

42 releases

0.13.0 Sep 3, 2023
0.12.1 Aug 28, 2023
0.11.11 Apr 16, 2023
0.11.9 Mar 23, 2023
0.2.0 Nov 4, 2018

#7 in #avro

Download history 699/week @ 2024-02-26 925/week @ 2024-03-04 607/week @ 2024-03-11 640/week @ 2024-03-18 420/week @ 2024-03-25 493/week @ 2024-04-01 705/week @ 2024-04-08 469/week @ 2024-04-15 774/week @ 2024-04-22 390/week @ 2024-04-29 988/week @ 2024-05-06 1090/week @ 2024-05-13 1410/week @ 2024-05-20 1233/week @ 2024-05-27 1054/week @ 2024-06-03 1004/week @ 2024-06-10

4,713 downloads per month
Used in 2 crates

MIT license

82KB
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.

Available options rsgen-avro --help:

Generate Rust types from Avro schemas

Usage: rsgen-avro [OPTIONS] <GLOB_PATTERN> <OUTPUT_FILE>

Arguments:
  <GLOB_PATTERN>  Glob pattern to select Avro schema files
  <OUTPUT_FILE>   The file where Rust types will be written, '-' for stdout

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
      --chrono-dates     Use chrono::NaiveDateTime for date/timestamps logical types
      --derive-builders  Derive builders for generated record structs
      --derive-schemas   Derive AvroSchema for generated record structs
  -h, --help             Print help
  -V, --version          Print version

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, Eq, 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::gen(source, output) method:

pub enum Source<'a> {
    Schema(&'a rsgen_avro::Schema),    // Avro schema enum re-exported from `apache-avro`
    Schemas(&'a [rsgen_avro::Schema]), // A slice of Avro schema enums
    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 gen = rsgen_avro::Generator::builder()
    .precision(2)
    .build()
    .unwrap();

See GeneratorBuilder documentation for all available options.

Limitations

  • Avro schema namespace fields are ignored, therefore record names within a schema (and across schemas) must not conflict (i.e. must be unique).
  • Rust Option<T> are supported through Avro unions having "null" in their first position only (See #39)

Dependencies

~12–23MB
~344K SLoC