typewire 0.0.3

Derive-based cross-language type bridging with compile-time schema embedding and multi-target codegen
Documentation 
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

use std::path::PathBuf;

use clap::{Parser, ValueEnum};
use object::{Object, ObjectSection};
use typewire_schema::coded::SECTION_NAME;

#[derive(Parser)]
#[command(name = "typewire", about = "Generate bindings from compiled Typewire schemas")]
struct Cli {
  /// Path to the compiled binary (WASM, ELF, or Mach-O)
  binary: PathBuf,

  /// Target language for binding generation
  #[arg(short, long, default_value = "typescript")]
  lang: Lang,

  /// Output file (stdout if omitted)
  #[arg(short, long)]
  output: Option<PathBuf>,

  /// Keep the `typewire_schemas` section in the binary after extraction
  #[arg(long)]
  no_strip: bool,
}

#[derive(Clone, ValueEnum)]
enum Lang {
  Typescript,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
  let cli = Cli::parse();
  let data = std::fs::read(&cli.binary)?;
  let obj = object::File::parse(&*data)?;
  let section = obj
    .section_by_name(SECTION_NAME)
    .ok_or_else(|| format!("no {SECTION_NAME} section found in {}", cli.binary.display()))?;
  let schema_bytes = section.data()?;

  let schemas = typewire_schema::decode::parse_section(schema_bytes)?;

  let output = match cli.lang {
    Lang::Typescript => typewire_schema::typescript::generate(&schemas),
  };

  match cli.output {
    Some(path) => std::fs::write(&path, &output)?,
    None => print!("{output}"),
  }

  if !cli.no_strip {
    if obj.format() == object::BinaryFormat::Wasm {
      let mut module = walrus::Module::from_buffer(&data)?;
      let ids: Vec<_> =
        module.customs.iter().filter(|(_, s)| s.name() == SECTION_NAME).map(|(id, _)| id).collect();
      for id in ids {
        module.customs.delete(id);
      }
      let stripped = module.emit_wasm();
      // Write to a temporary file then rename for crash-safe replacement.
      let tmp = cli.binary.with_extension("typewire-tmp");
      std::fs::write(&tmp, stripped)?;
      std::fs::rename(&tmp, &cli.binary)?;
    } else {
      eprintln!(
        "warning: stripping is only supported for WASM binaries, skipping for {} (use --no-strip to silence)",
        cli.binary.display()
      );
    }
  }

  Ok(())
}