castle_macro 0.20.2

Castle Macro, macros to make your life easier
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

use castle_api::types::{Input, Primitive, State, Directive};

#[test]
fn can_derive_struct() {
    #[castle_macro::castle(Input)]
    struct Foo {
        bar: i32,
        bar2: usize,
        bar3: String
    }

    let converted: Foo = Foo::try_from(&Input::Map([
        ("bar".into(), Input::Primitive(Primitive::Number(1u32.into()))),
        ("bar2".into(), Input::Primitive(Primitive::Number(2u32.into()))),
        ("bar3".into(), Input::Primitive(Primitive::String("hello".into()))),
    ].into())).unwrap();

    assert_eq!(converted.bar, 1);
    assert_eq!(converted.bar2, 2);
    assert_eq!(converted.bar3, "hello".to_string());
}



// #[test]
// fn can_impl_resolve() {
//     struct Root {
//         foo: String
//     }

//     #[castle_macro::castle(Type)]
//     impl Root {
//         async fn first_name(a: String) -> Result<(), anyhow::Error> {
//             unimplemented!()
//         }
//     }
// }

#[test]
fn testing_user_match() {
    struct User;
    struct Profile;

    #[castle_macro::castle(Type)]
    impl Profile {
        fn name(&self, _ctx: &State) -> String {
            "hello".to_string()
        }
    }

    #[castle_macro::castle(Type)]
    impl User {

        async fn first_name(&self, _ctx: &State) -> Result<String, anyhow::Error> {
            unimplemented!()
        }

        fn profile(&self, _ctx: &State, _arg: String) -> Profile {
            unimplemented!()
        }
    }
}



#[test]
fn testing_directives() {

    #[castle_macro::castle(Directive @authenticated(limit: u32))]
    struct Authenticated;

    impl Directive for Authenticated {

    }

    struct Root;
    // directives need a identifier or name
    // directives can take args and must match the specification within the
    // SchemaItem trait
    // full eg directive #[directive(type: value)]
    #[castle_macro::castle(Type)]
    impl Root {
        #[directives("@authenticated(a: 1) @sorted(a: 1)")]
        fn me(&self, _ctx: &State) -> String {
            unimplemented!()
        }
    }
}


#[test]
fn testing_structs_in_type() {

    #[castle_macro::castle(Type)]
    struct Root {
        a: u32,
    }
}