Initial commit

Author: timfish

Diff for: .gitignore

@@ -0,0 +1,5 @@
+/target
+node_modules/
+tests/.tmp*
+Cargo.lock
+yarn.lock

Diff for: Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "bincode-typescript"
+license = "MIT"
+version = "0.1.0"
+authors = ["Tim Fish <[email protected]>"]
+edition = "2018"
+repository = "https://github.com/timfish/bincode-typescript"
+description = "Generates TypeScript serialisation and deserialisation code from Rust structs and enums"
+readme = "README.md"
+
+[lib]
+name = "bincode_typescript"
+path = "src/lib.rs"
+
+[[bin]]
+name = "bincode-typescript"
+path = "src/bin.rs"
+
+
+[dependencies]
+syn = { version = "1.0", features = ["full", "extra-traits", "visit"] }
+askama = "0.8"
+
+[dev-dependencies]
+serde = { version = "1", features = ["derive"] }
+bincode = "1.3"
+tempfile = "3"

Diff for: README.md

@@ -0,0 +1,85 @@
+# bincode-typescript
+
+Generates TypeScript serialisation and deserialisation code from Rust structs
+and enums
+
+## Goals
+
+- Generate TypeScript code directly from Rust source
+- Work from `build.rs`
+- Avoid Object Orientated TypeScript for better tree-shaking and optimisation
+- TypeScript for enums/structs should be ergonomic and high performance
+  - Use `const enum` for Unit enums and respect discriminant values!
+  - Use `TypedArray`s for `Vec<{integer,float}>` for greater performance
+
+## Status
+
+I'm pretty new to Rust and I've just hacked around until the tests pass 🤷‍♂️
+
+There is much room for improvement and PRs are welcome!
+
+## Current Issues & Limitations
+
+- All values must be owned
+- Generic structs/enums will almost certainly panic
+- All types must be in a single file
+- Serde attributes are not currently respected
+- `Vec<T>` are always converted to `Uint8Array/Int8Array/etc` whenever possible
+  and this might not be particularly ergonomic from TypeScript.
+
+## Example via `build.rs`
+
+There is currently a single `bool` option to enable support for node.js
+`Buffer`, so if you are running in the browser you probably don't want this enabled.
+
+```rust
+bincode_typescript::from_file("./src/types.rs", "./ts/types.ts", false);
+```
+
+## Example via CLI
+
+There is currently a single option (`--support-buffer`) to enable support for node.js
+`Buffer`.
+
+```shell
+./bincode-typescript --support-buffer ./src/types.rs > ./ts/types.ts
+```
+
+## Tests
+
+Before running the tests, ensure that you have all the node.js dependencies
+installed by running `yarn` or `npm i`.
+
+The tests check serialisation and deserialisation from generated TypeScript by
+round-tripping encoded data via stdio and asserting the expected values.
+
+## Prior Art
+
+This builds on (ie. much TypeScript stolen from) the following projects.
+
+_The stated pros and cons are just personal opinion!_
+
+### [`ts-rust-bridge`](https://github.com/twop/ts-rust-bridge)
+
+### Pros:
+
+- Function based TypeScript API
+- Great ergonomics for enums with combination of `type` + `interface` + `module`
+
+### Cons:
+
+- Generates both Rust and TypeScript from a DSL. (**I want Rust to be the source
+  of truth**).
+- Does not use `const enum` for Unit enums
+
+### [`serde-reflection/serde-generate`](https://github.com/novifinancial/serde-reflection/pull/59)
+
+### Pros:
+
+- Uses `serde` so no messing around parsing Rust
+
+### Cons:
+
+- All types have to be run through the registry after build so wont work from `build.rs`
+- TypeScript classes wrap every type and use inheritance (ie. no `const enum`)
+- Runtime TypeScript is separate

Diff for: package.json

@@ -0,0 +1,13 @@
+{
+  "name": "bincode-typescript",
+  "version": "0.1.0",
+  "main": "index.js",
+  "author": "Tim Fish <[email protected]>",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^12.12.2",
+    "ts-node": "^9.0.0",
+    "typescript": "^4.0.3",
+    "get-stdin": "^8.0.0"
+  }
+}

Diff for: src/bin.rs

@@ -0,0 +1,16 @@
+use bincode_typescript::from_string;
+use std::{
+    error::Error,
+    fs::{self},
+};
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let args: Vec<String> = std::env::args().collect();
+    let support_buffer = args.contains(&"--support-buffer".to_string());
+    let input = args.last().expect("Could not find input file name");
+
+    let rust = fs::read_to_string(input)?;
+    println!("{}", from_string(&rust, support_buffer)?);
+
+    Ok(())
+}

Diff for: src/enums.rs

@@ -0,0 +1,115 @@
+use crate::types::RustType;
+use askama::Template;
+use syn::{Expr, Fields, ItemEnum, Lit};
+
+#[derive(Clone, Debug)]
+pub enum EnumVariantDeclaration {
+    Unit {
+        ident: String,
+        value: String,
+    },
+    Unnamed {
+        ident: String,
+        types: Vec<RustType>,
+    },
+    Named {
+        ident: String,
+        types: Vec<(String, RustType)>,
+    },
+}
+
+impl EnumVariantDeclaration {
+    pub fn ident(&self) -> String {
+        match self {
+            EnumVariantDeclaration::Unit { ident, .. } => ident.to_string(),
+            EnumVariantDeclaration::Unnamed { ident, .. } => ident.to_string(),
+            EnumVariantDeclaration::Named { ident, .. } => ident.to_string(),
+        }
+    }
+
+    pub fn value(&self) -> String {
+        match self {
+            EnumVariantDeclaration::Unit { value, .. } => value.to_string(),
+            _ => panic!("should not happen"),
+        }
+    }
+
+    pub fn first_type(&self) -> RustType {
+        match self {
+            EnumVariantDeclaration::Unnamed { types, .. } => types[0].clone(),
+            _ => panic!("should not happen"),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Template)]
+#[template(path = "enum.ts.j2", escape = "txt")]
+pub struct EnumDeclaration {
+    ident: String,
+    variants: Vec<EnumVariantDeclaration>,
+}
+
+impl EnumDeclaration {
+    pub fn new(ident: String) -> Self {
+        EnumDeclaration {
+            ident,
+            variants: Default::default(),
+        }
+    }
+
+    pub fn is_unit(&self) -> bool {
+        self.variants
+            .iter()
+            .all(|v| matches!(v, EnumVariantDeclaration::Unit { .. }))
+    }
+}
+
+impl From<ItemEnum> for EnumDeclaration {
+    fn from(node: ItemEnum) -> Self {
+        let mut e = EnumDeclaration::new(node.ident.to_string());
+
+        for (i, variant) in node.variants.into_iter().enumerate() {
+            match variant.fields {
+                Fields::Unit => {
+                    let value = if let Some(discriminant) = variant.discriminant {
+                        if let Expr::Lit(lit) = discriminant.1 {
+                            if let Lit::Int(val) = lit.lit {
+                                Some(val.to_string())
+                            } else {
+                                None
+                            }
+                        } else {
+                            None
+                        }
+                    } else {
+                        None
+                    };
+
+                    e.variants.push(EnumVariantDeclaration::Unit {
+                        ident: variant.ident.to_string(),
+                        value: value.unwrap_or_else(|| i.to_string()),
+                    })
+                }
+                Fields::Named(fields) => e.variants.push(EnumVariantDeclaration::Named {
+                    ident: variant.ident.to_string(),
+                    types: fields
+                        .named
+                        .into_iter()
+                        .map(|v| {
+                            (
+                                v.ident.expect("Should have an ident").to_string(),
+                                v.ty.into(),
+                            )
+                        })
+                        .collect(),
+                }),
+                Fields::Unnamed(fields) => e.variants.push(EnumVariantDeclaration::Unnamed {
+                    ident: variant.ident.to_string(),
+                    types: fields.unnamed.into_iter().map(|v| v.ty.into()).collect(),
+                }),
+            }
+        }
+
+        e
+    }
+}

Diff for: src/lib.rs

@@ -0,0 +1,74 @@
+use askama::Template;
+use enums::EnumDeclaration;
+use std::{
+    error::Error,
+    fs::{self},
+    path::Path,
+};
+use structs::StructDeclaration;
+use syn::{
+    visit::{self, Visit},
+    ItemEnum, ItemStruct,
+};
+
+mod enums;
+mod structs;
+mod types;
+
+const NAME: &str = env!("CARGO_PKG_NAME");
+const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+#[derive(Clone, Debug, Template)]
+#[template(path = "module.ts.j2", escape = "txt")]
+struct CodeVisitor {
+    pub pkg_name: String,
+    pub pkg_version: String,
+    support_buffer: bool,
+    pub structs: Vec<StructDeclaration>,
+    pub enums: Vec<EnumDeclaration>,
+}
+
+impl CodeVisitor {
+    pub fn new(support_buffer: bool) -> Self {
+        CodeVisitor {
+            pkg_name: NAME.to_string(),
+            pkg_version: VERSION.to_string(),
+            support_buffer,
+            structs: Default::default(),
+            enums: Default::default(),
+        }
+    }
+}
+
+impl<'ast> Visit<'ast> for CodeVisitor {
+    fn visit_item_struct(&mut self, node: &'ast ItemStruct) {
+        self.structs.push(node.clone().into());
+        visit::visit_item_struct(self, node);
+    }
+
+    fn visit_item_enum(&mut self, node: &'ast ItemEnum) {
+        self.enums.push(node.clone().into());
+        visit::visit_item_enum(self, node);
+    }
+}
+
+pub fn from_string(input: &str, support_buffer: bool) -> Result<String, Box<dyn Error>> {
+    let ast = syn::parse_file(input)?;
+    let mut enum_visit = CodeVisitor::new(support_buffer);
+    enum_visit.visit_file(&ast);
+
+    Ok(enum_visit.render()?)
+}
+
+pub fn from_file<P1: AsRef<Path>, P2: AsRef<Path>>(
+    input: P1,
+    output: P2,
+    support_buffer: bool,
+) -> Result<(), Box<dyn Error>> {
+    fs::create_dir_all(&output.as_ref().parent().unwrap())?;
+    let rust = fs::read_to_string(input)?;
+    let typescript = from_string(&rust, support_buffer)?;
+    fs::write(output, typescript)?;
+
+    Ok(())
+}

Diff for: src/structs.rs

@@ -0,0 +1,36 @@
+use crate::types::RustType;
+use askama::Template;
+use syn::ItemStruct;
+
+#[derive(Clone, Debug, Template)]
+#[template(path = "struct.ts.j2", escape = "txt")]
+pub struct StructDeclaration {
+    ident: String,
+    fields: Vec<(Option<String>, RustType)>,
+}
+
+impl StructDeclaration {
+    pub fn new(ident: String) -> Self {
+        StructDeclaration {
+            ident,
+            fields: Default::default(),
+        }
+    }
+
+    pub fn is_tuple(&self) -> bool {
+        self.fields.iter().all(|(id, _)| id.is_none())
+    }
+}
+
+impl From<ItemStruct> for StructDeclaration {
+    fn from(node: ItemStruct) -> Self {
+        let mut e = StructDeclaration::new(node.ident.to_string());
+
+        for field in node.fields.into_iter() {
+            e.fields
+                .push((field.ident.map(|i| i.to_string()), field.ty.into()))
+        }
+
+        e
+    }
+}