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

use crate::model::__InputValue;
use crate::registry;
use async_graphql_derive::{Enum, Object};

#[Enum(
    internal,
    desc = "A Directive can be adjacent to many parts of the GraphQL language, a __DirectiveLocation describes one such possible adjacencies."
)]
#[allow(non_camel_case_types)]
pub enum __DirectiveLocation {
    #[item(desc = "Location adjacent to a query operation.")]
    QUERY,

    #[item(desc = "Location adjacent to a mutation operation.")]
    MUTATION,

    #[item(desc = "Location adjacent to a subscription operation.")]
    SUBSCRIPTION,

    #[item(desc = "Location adjacent to a field.")]
    FIELD,

    #[item(desc = "Location adjacent to a fragment definition.")]
    FRAGMENT_DEFINITION,

    #[item(desc = "Location adjacent to a fragment spread.")]
    FRAGMENT_SPREAD,

    #[item(desc = "Location adjacent to an inline fragment.")]
    INLINE_FRAGMENT,

    #[item(desc = "Location adjacent to a variable definition.")]
    VARIABLE_DEFINITION,

    #[item(desc = "Location adjacent to a schema definition.")]
    SCHEMA,

    #[item(desc = "Location adjacent to a scalar definition.")]
    SCALAR,

    #[item(desc = "Location adjacent to an object type definition.")]
    OBJECT,

    #[item(desc = "Location adjacent to a field definition.")]
    FIELD_DEFINITION,

    #[item(desc = "Location adjacent to an argument definition.")]
    ARGUMENT_DEFINITION,

    #[item(desc = "Location adjacent to an interface definition.")]
    INTERFACE,

    #[item(desc = "Location adjacent to a union definition.")]
    UNION,

    #[item(desc = "Location adjacent to an enum definition.")]
    ENUM,

    #[item(desc = "Location adjacent to an enum value definition.")]
    ENUM_VALUE,

    #[item(desc = "Location adjacent to an input object type definition.")]
    INPUT_OBJECT,

    #[item(desc = "Location adjacent to an input object field definition.")]
    INPUT_FIELD_DEFINITION,
}

pub struct __Directive<'a> {
    pub registry: &'a registry::Registry,
    pub directive: &'a registry::Directive,
}

#[Object(
    internal,
    desc = r#"A Directive provides a way to describe alternate runtime execution and type validation behavior in a GraphQL document.

In some cases, you need to provide options to alter GraphQL's execution behavior in ways field arguments will not suffice, such as conditionally including or skipping a field. Directives provide this by describing additional information to the executor."#
)]
impl<'a> __Directive<'a> {
    #[field]
    async fn name(&self) -> String {
        self.directive.name.to_string()
    }

    #[field]
    async fn description(&self) -> Option<String> {
        self.directive.description.map(|s| s.to_string())
    }

    #[field]
    async fn locations(&self) -> &Vec<__DirectiveLocation> {
        &self.directive.locations
    }

    #[field]
    async fn args(&self) -> Vec<__InputValue<'a>> {
        self.directive
            .args
            .values()
            .map(|input_value| __InputValue {
                registry: self.registry,
                input_value,
            })
            .collect()
    }
}