oas3-gen 0.12.0

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

use std::collections::BTreeMap;

use proc_macro2::TokenStream;
use quote::{format_ident, quote};

use crate::{
  generator::ast::RustType,
  reserved::{header_const_name, regex_const_name},
};

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) struct RegexKey {
  owner_type: String,
  owner_variant: Option<String>,
  field: String,
}

impl RegexKey {
  pub fn for_struct(type_name: &str, field_name: &str) -> Self {
    Self {
      owner_type: type_name.to_string(),
      owner_variant: None,
      field: field_name.to_string(),
    }
  }

  #[allow(dead_code)]
  pub fn for_variant(type_name: &str, variant_name: &str, field_name: &str) -> Self {
    Self {
      owner_type: type_name.to_string(),
      owner_variant: Some(variant_name.to_string()),
      field: field_name.to_string(),
    }
  }

  pub fn parts(&self) -> Vec<&str> {
    let mut parts = vec![self.owner_type.as_str()];
    if let Some(variant) = &self.owner_variant {
      parts.push(variant.as_str());
    }
    parts.push(self.field.as_str());
    parts
  }
}

pub(crate) fn generate_regex_constants(types: &[&RustType]) -> (TokenStream, BTreeMap<RegexKey, String>) {
  let mut const_defs: BTreeMap<String, String> = BTreeMap::new();
  let mut lookup: BTreeMap<RegexKey, String> = BTreeMap::new();
  let mut pattern_to_const: BTreeMap<String, String> = BTreeMap::new();

  for rust_type in types {
    match rust_type {
      RustType::Struct(def) => {
        for field in &def.fields {
          let Some(pattern) = &field.regex_validation else {
            continue;
          };
          let key = RegexKey::for_struct(&def.name, &field.name);
          let pattern_key = pattern.clone();
          let const_name = if let Some(existing) = pattern_to_const.get(&pattern_key) {
            existing.clone()
          } else {
            let name = regex_const_name(&key.parts());
            pattern_to_const.insert(pattern_key.clone(), name.clone());
            const_defs.insert(name.clone(), pattern_key);
            name
          };
          lookup.insert(key, const_name);
        }
      }
      RustType::Enum(_) | RustType::TypeAlias(_) | RustType::DiscriminatedEnum(_) => {}
    }
  }

  if const_defs.is_empty() {
    return (quote! {}, lookup);
  }

  let regex_defs: Vec<TokenStream> = const_defs
    .into_iter()
    .map(|(name, pattern)| {
      let ident = format_ident!("{}", name);
      quote! {
        static #ident: std::sync::LazyLock<regex::Regex> =
          std::sync::LazyLock::new(|| regex::Regex::new(#pattern).expect("invalid regex"));
      }
    })
    .collect();

  (quote! { #(#regex_defs)* }, lookup)
}

pub(crate) fn generate_header_constants(headers: &[&String]) -> TokenStream {
  if headers.is_empty() {
    return quote! {};
  }

  let const_tokens: Vec<TokenStream> = headers
    .iter()
    .map(|header| {
      let const_name = header_const_name(header);
      let ident = format_ident!("{}", const_name);
      quote! {
        pub const #ident: http::HeaderName = http::HeaderName::from_static(#header);
      }
    })
    .collect();

  quote! { #(#const_tokens)* }
}