juniper 0.14.2

GraphQL server library
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

#![allow(missing_docs)]

use crate::{
    executor::Context,
    tests::model::{Character, Database, Droid, Episode, Human},
};

impl Context for Database {}

graphql_interface!(<'a> &'a dyn Character: Database as "Character" |&self| {
    description: "A character in the Star Wars Trilogy"

    field id() -> &str as "The id of the character" {
        self.id()
    }

    field name() -> Option<&str> as "The name of the character" {
        Some(self.name())
    }

    field friends(&executor) -> Vec<&dyn Character>
    as "The friends of the character" {
        executor.context().get_friends(self.as_character())
    }

    field appears_in() -> &[Episode] as "Which movies they appear in" {
        self.appears_in()
    }

    instance_resolvers: |&context| {
        &dyn Human => context.get_human(&self.id()),
        &dyn Droid => context.get_droid(&self.id()),
    }
});

#[crate::object_internal(
    Context = Database,
    Scalar = crate::DefaultScalarValue,
    interfaces = [&dyn Character],
)]
/// A humanoid creature in the Star Wars universe.
impl<'a> &'a dyn Human {
    /// The id of the human
    fn id(&self) -> &str {
        self.id()
    }

    /// The name of the human
    fn name(&self) -> Option<&str> {
        Some(self.name())
    }

    /// The friends of the human
    fn friends(&self, ctx: &Database) -> Vec<&dyn Character> {
        ctx.get_friends(self.as_character())
    }

    /// Which movies they appear in
    fn appears_in(&self) -> &[Episode] {
        self.appears_in()
    }

    /// The home planet of the human
    fn home_planet(&self) -> &Option<String> {
        self.home_planet()
    }
}

#[crate::object_internal(
    Context = Database,
    Scalar = crate::DefaultScalarValue,
    interfaces = [&dyn Character],
)]
/// A mechanical creature in the Star Wars universe.
impl<'a> &'a dyn Droid {
    /// The id of the droid
    fn id(&self) -> &str {
        self.id()
    }

    /// The name of the droid
    fn name(&self) -> Option<&str> {
        Some(self.name())
    }

    /// The friends of the droid
    fn friends(&self, ctx: &Database) -> Vec<&dyn Character> {
        ctx.get_friends(self.as_character())
    }

    /// Which movies they appear in
    fn appears_in(&self) -> &[Episode] {
        self.appears_in()
    }

    /// The primary function of the droid
    fn primary_function(&self) -> &Option<String> {
        self.primary_function()
    }
}

pub struct Query;

#[crate::object_internal(
    Context = Database,
    Scalar = crate::DefaultScalarValue,
)]
/// The root query object of the schema
impl Query {
    #[graphql(arguments(id(description = "id of the human")))]
    fn human(database: &Database, id: String) -> Option<&dyn Human> {
        database.get_human(&id)
    }

    #[graphql(arguments(id(description = "id of the droid")))]
    fn droid(database: &Database, id: String) -> Option<&dyn Droid> {
        database.get_droid(&id)
    }

    #[graphql(arguments(episode(
        description = "If omitted, returns the hero of the whole saga. If provided, returns the hero of that particular episode"
    )))]
    fn hero(database: &Database, episode: Option<Episode>) -> Option<&dyn Character> {
        Some(database.get_hero(episode).as_character())
    }
}