grafbase-sdk 0.23.1

An SDK to implement extensions for the Grafbase Gateway
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use crate::wit;

/// The site where a directive is applied in the GraphQL schema.
pub enum DirectiveSite<'a> {
    /// Directive applied to an object type
    Object(ObjectDirectiveSite<'a>),
    /// Directive applied to a field definition
    FieldDefinition(FieldDefinitionDirectiveSite<'a>),
    /// Directive applied to an interface
    Interface(InterfaceDirectiveSite<'a>),
    /// Directive applied to a union
    Union(UnionDirectiveSite<'a>),
    /// Directive applied to an enum
    Enum(EnumDirectiveSite<'a>),
    /// Directive applied to a scalar
    Scalar(ScalarDirectiveSite<'a>),
}

impl<'a> From<&'a wit::DirectiveSite> for DirectiveSite<'a> {
    fn from(value: &'a wit::DirectiveSite) -> Self {
        match value {
            wit::DirectiveSite::Object(site) => DirectiveSite::Object(site.into()),
            wit::DirectiveSite::FieldDefinition(site) => DirectiveSite::FieldDefinition(site.into()),
            wit::DirectiveSite::Interface(site) => DirectiveSite::Interface(site.into()),
            wit::DirectiveSite::Union(site) => DirectiveSite::Union(site.into()),
            wit::DirectiveSite::Enum(site) => DirectiveSite::Enum(site.into()),
            wit::DirectiveSite::Scalar(site) => DirectiveSite::Scalar(site.into()),
        }
    }
}

/// A directive site for object types
pub struct ObjectDirectiveSite<'a>(&'a wit::ObjectDirectiveSite);

impl<'a> ObjectDirectiveSite<'a> {
    /// The name of the object type
    #[inline]
    pub fn name(&self) -> &'a str {
        &self.0.object_name
    }
}

impl<'a> From<&'a wit::ObjectDirectiveSite> for ObjectDirectiveSite<'a> {
    fn from(value: &'a wit::ObjectDirectiveSite) -> Self {
        Self(value)
    }
}

/// A directive site for field definitions
pub struct FieldDefinitionDirectiveSite<'a>(&'a wit::FieldDefinitionDirectiveSite);

impl<'a> FieldDefinitionDirectiveSite<'a> {
    /// The name of the parent type containing this field
    #[inline]
    pub fn parent_type_name(&self) -> &'a str {
        &self.0.parent_type_name
    }

    /// The name of the field
    #[inline]
    pub fn name(&self) -> &'a str {
        &self.0.field_name
    }
}

impl<'a> From<&'a wit::FieldDefinitionDirectiveSite> for FieldDefinitionDirectiveSite<'a> {
    fn from(value: &'a wit::FieldDefinitionDirectiveSite) -> Self {
        Self(value)
    }
}

/// A directive site for union types
pub struct UnionDirectiveSite<'a>(&'a wit::UnionDirectiveSite);

impl<'a> UnionDirectiveSite<'a> {
    /// The name of the union type
    #[inline]
    pub fn name(&self) -> &'a str {
        &self.0.union_name
    }
}

impl<'a> From<&'a wit::UnionDirectiveSite> for UnionDirectiveSite<'a> {
    fn from(value: &'a wit::UnionDirectiveSite) -> Self {
        Self(value)
    }
}

/// A directive site for interfaces
pub struct InterfaceDirectiveSite<'a>(&'a wit::InterfaceDirectiveSite);

impl<'a> InterfaceDirectiveSite<'a> {
    /// The name of the interface type
    #[inline]
    pub fn name(&self) -> &'a str {
        &self.0.interface_name
    }
}

impl<'a> From<&'a wit::InterfaceDirectiveSite> for InterfaceDirectiveSite<'a> {
    fn from(value: &'a wit::InterfaceDirectiveSite) -> Self {
        Self(value)
    }
}

/// A directive site for scalars
pub struct ScalarDirectiveSite<'a>(&'a wit::ScalarDirectiveSite);

impl<'a> ScalarDirectiveSite<'a> {
    /// The name of the scalar type
    #[inline]
    pub fn name(&self) -> &'a str {
        &self.0.scalar_name
    }
}

impl<'a> From<&'a wit::ScalarDirectiveSite> for ScalarDirectiveSite<'a> {
    fn from(value: &'a wit::ScalarDirectiveSite) -> Self {
        Self(value)
    }
}

/// A directive site for enums
pub struct EnumDirectiveSite<'a>(&'a wit::EnumDirectiveSite);

impl<'a> EnumDirectiveSite<'a> {
    /// The name of the enum type
    #[inline]
    pub fn name(&self) -> &'a str {
        &self.0.enum_name
    }
}

impl<'a> From<&'a wit::EnumDirectiveSite> for EnumDirectiveSite<'a> {
    fn from(value: &'a wit::EnumDirectiveSite) -> Self {
        Self(value)
    }
}