oag-core 0.20.6

OpenAPI 3.2 parser, IR, and transforms for oag
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
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

use super::types::NormalizedName;

/// A resolved schema in the IR.
#[derive(Debug, Clone)]
pub enum IrSchema {
    Object(IrObjectSchema),
    Enum(IrEnumSchema),
    Alias(IrAliasSchema),
    Union(IrUnionSchema),
}

impl IrSchema {
    pub fn name(&self) -> &NormalizedName {
        match self {
            IrSchema::Object(o) => &o.name,
            IrSchema::Enum(e) => &e.name,
            IrSchema::Alias(a) => &a.name,
            IrSchema::Union(u) => &u.name,
        }
    }
}

/// An object schema with typed fields.
#[derive(Debug, Clone)]
pub struct IrObjectSchema {
    pub name: NormalizedName,
    pub description: Option<String>,
    pub fields: Vec<IrField>,
    pub additional_properties: Option<IrType>,
}

/// A field on an object schema.
#[derive(Debug, Clone)]
pub struct IrField {
    pub name: NormalizedName,
    pub original_name: String,
    pub field_type: IrType,
    pub required: bool,
    pub description: Option<String>,
    pub read_only: bool,
    pub write_only: bool,
    /// The literal default value (from `const`, a single-value `enum`, or a
    /// scalar `default`), carried as a literal `IrType` so packs can render it
    /// via the existing type-map literal templates. `None` when the property has
    /// no default. Required-ness is unaffected by this value.
    pub default_repr: Option<IrType>,
}

/// A single variant value in an enum schema.
#[derive(Debug, Clone)]
pub enum IrEnumVariant {
    String(String),
    Integer(i64),
}

/// An enum schema (string or integer variants).
#[derive(Debug, Clone)]
pub struct IrEnumSchema {
    pub name: NormalizedName,
    pub description: Option<String>,
    pub variants: Vec<IrEnumVariant>,
}

/// A type alias (e.g., `type Foo = string`).
#[derive(Debug, Clone)]
pub struct IrAliasSchema {
    pub name: NormalizedName,
    pub description: Option<String>,
    pub target: IrType,
}

/// A union type (oneOf / anyOf).
#[derive(Debug, Clone)]
pub struct IrUnionSchema {
    pub name: NormalizedName,
    pub description: Option<String>,
    pub variants: Vec<IrType>,
    pub discriminator: Option<IrDiscriminator>,
}

/// Discriminator for union types.
#[derive(Debug, Clone)]
pub struct IrDiscriminator {
    pub property_name: String,
    pub mapping: Vec<(String, String)>,
}

/// A resolved type reference.
#[derive(Debug, Clone, PartialEq)]
pub enum IrType {
    String,
    StringLiteral(String),
    Number,
    Integer,
    Boolean,
    Null,
    Array(Box<IrType>),
    Object(Vec<(String, IrType, bool)>), // inline object: (name, type, required)
    Map(Box<IrType>),                    // Record<string, T>
    Ref(String),                         // reference to a named schema (PascalCase)
    IntegerLiteral(i64),
    Union(Vec<IrType>),
    Intersection(Vec<IrType>),
    Any,
    Void,
    DateTime,
    Binary,
}