oas3-gen 0.5.1

A rust type generator for OpenAPI v3.1.x specification.
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use std::path::PathBuf;

use clap::Parser;

use crate::generator::{code_generator::Visibility, orchestrator::Orchestrator};

mod generator;
mod reserved;

/// OpenAPI to Rust code generator
///
/// Generates Rust type definitions from OpenAPI 3.x specifications with validation,
/// serde serialization, and comprehensive documentation.
#[derive(Parser, Debug)]
#[command(name = "openapi-gen")]
#[command(author, version, about, long_about = None)]
struct Cli {
  /// Path to the OpenAPI JSON specification file
  #[arg(short, long, value_name = "FILE")]
  input: PathBuf,

  /// Path where the generated Rust code will be written
  #[arg(short, long, value_name = "FILE")]
  output: PathBuf,

  /// Visibility level for generated types
  #[arg(long, value_name = "VISIBILITY", default_value = "public")]
  visibility: String,

  /// Enable verbose output with detailed progress information
  #[arg(short, long, default_value_t = false)]
  verbose: bool,

  /// Suppress non-essential output (errors only)
  #[arg(short, long, default_value_t = false)]
  quiet: bool,
}

macro_rules! log_info {
  ($cli:expr, $($arg:tt)*) => {
    if !$cli.quiet {
      println!($($arg)*);
    }
  };
}

macro_rules! log_verbose {
  ($cli:expr, $($arg:tt)*) => {
    if $cli.verbose && !$cli.quiet {
      println!($($arg)*);
    }
  };
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
  let cli = Cli::parse();

  // Parse visibility argument
  let visibility = Visibility::parse(&cli.visibility).unwrap_or(Visibility::Public);

  // Load and parse OpenAPI specification
  log_info!(cli, "Loading OpenAPI spec from: {}", cli.input.display());
  let file_content = tokio::fs::read_to_string(&cli.input).await?;
  let spec = oas3::from_json(file_content)?;

  // Create orchestrator and generate code
  log_info!(cli, "Generating Rust types...");
  let orchestrator = Orchestrator::new(spec, visibility)?;
  let (code, stats) = orchestrator.generate_with_header(&cli.input.display().to_string())?;

  // Report statistics
  log_verbose!(cli, "  Types generated: {}", stats.types_generated);
  log_verbose!(cli, "  Operations converted: {}", stats.operations_converted);

  if stats.cycles_detected > 0 {
    log_info!(cli, "  Found {} cycles", stats.cycles_detected);
    for (i, cycle) in stats.cycle_details.iter().enumerate() {
      log_verbose!(cli, "    Cycle {}: {}", i + 1, cycle.join(" -> "));
    }
  } else {
    log_verbose!(cli, "  No cycles detected");
  }

  // Report warnings
  if !stats.warnings.is_empty() {
    log_verbose!(cli, "");
    for warning in &stats.warnings {
      eprintln!("Warning: {}", warning);
    }
  }

  // Write output file
  log_info!(cli, "\nWriting to: {}", cli.output.display());
  if let Some(parent) = cli.output.parent() {
    tokio::fs::create_dir_all(parent).await?;
  }
  tokio::fs::write(&cli.output, code).await?;

  // Report success
  log_info!(cli, "\n✓ Successfully generated Rust types!");
  log_info!(cli, "  Input:  {}", cli.input.display());
  log_info!(cli, "  Output: {}", cli.output.display());
  log_info!(cli, "  Types:  {}", stats.types_generated);

  if stats.cycles_detected > 0 {
    log_info!(cli, "  Cycles: {}", stats.cycles_detected);
  }

  Ok(())
}