CLI initial concept

cli/Cargo.toml

@@ -7,3 +7,4 @@ edition = "2021"
 
 [dependencies]
 clap = { version = "4", features = ["derive"]}
+color-eyre = "0.6"

cli/src/main.rs

@@ -1,12 +1,15 @@
-use std::path::PathBuf;
+use std::{io::Write, path::PathBuf};
 
 use clap::Parser;
+use color_eyre::Result;
+
+mod path;
 
 #[derive(Parser, Debug)]
 struct Args {
     /// Defines where your TS bindings will be saved by setting TS_RS_EXPORT_DIR
-    #[arg(long, short)]
-    output_directory: Option<PathBuf>,
+    #[arg(long, short, default_value = "./bindings")]
+    output_directory: PathBuf,
 
     /// Disables warnings caused by using serde attributes that ts-rs cannot process
     #[arg(long)]
@@ -19,6 +22,9 @@ struct Args {
     /// Formats the generated TypeScript files
     #[arg(long)]
     format: bool,
+
+    #[arg(long = "index")]
+    generate_index_ts: bool,
 }
 
 macro_rules! feature {
@@ -33,26 +39,56 @@ macro_rules! feature {
     };
 }
 
-fn main() {
+fn main() -> Result<()> {
+    color_eyre::install()?;
+
     let args = Args::parse();
 
     let mut cargo_invocation = std::process::Command::new("cargo");
 
+    let metadata_path = args.output_directory.join("ts_rs.meta");
+    if metadata_path.exists() {
+        std::fs::remove_file(&metadata_path)?;
+    }
+
     cargo_invocation
         .arg("test")
         .arg("export_bindings_")
         .arg("--features")
-        .arg("ts-rs/export");
-
-    if let Some(ref output_directory) = args.output_directory {
-        cargo_invocation.env("TS_RS_EXPORT_DIR", output_directory);
-    }
+        .arg("ts-rs/export")
+        .env("TS_RS_EXPORT_DIR", path::absolute(&args.output_directory)?);
 
     feature!(cargo_invocation, args, {
         no_warnings => "no-serde-warnings",
         esm_imports => "import-esm",
         format => "format",
     });
 
-    cargo_invocation.spawn().unwrap().wait().unwrap();
+    cargo_invocation.spawn()?.wait()?;
+
+    if args.generate_index_ts {
+        let metadata = std::fs::read_to_string(&metadata_path)?
+            .lines()
+            .map(ToOwned::to_owned)
+            .collect::<std::collections::HashSet<_>>();
+
+        let index_path = args.output_directory.join("index.ts");
+
+        if index_path.exists() {
+            std::fs::remove_file(&index_path)?;
+        }
+
+        let mut index = std::fs::OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(index_path)?;
+
+        for file in metadata.iter() {
+            index.write_fmt(format_args!("export * from {file:?};\n"))?;
+        }
+    }
+
+    std::fs::remove_file(&metadata_path)?;
+
+    Ok(())
 }

ts-rs/src/export.rs

@@ -135,14 +135,27 @@ pub(crate) fn export_to<T: TS + ?Sized + 'static, P: AsRef<Path>>(
     if let Some(parent) = path.as_ref().parent() {
         std::fs::create_dir_all(parent)?;
     }
+
     let lock = FILE_LOCK.lock().unwrap();
     {
         // Manually write to file & call `sync_data`. Otherwise, calling `fs::read(path)`
         // immediately after `T::export()` might result in an empty file.
         use std::io::Write;
-        let mut file = File::create(path)?;
+        let mut file = File::create(&path)?;
         file.write_all(buffer.as_bytes())?;
         file.sync_data()?;
+
+        let bytes = path::absolute(path.as_ref())?
+            .to_string_lossy()
+            .bytes()
+            .chain([b'\n'])
+            .collect::<Box<[_]>>();
+        std::fs::OpenOptions::new()
+            .read(true)
+            .append(true)
+            .create(true)
+            .open(default_out_dir().join("ts_rs.meta"))?
+            .write_all(&bytes)?;
     }
 
     drop(lock);