cartel-pg 0.20.0

Async PostgreSQL driver for the dope runtime
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

use std::{any::TypeId, marker::PhantomData};

use crate::schema::{self, desc};

mod proof;
pub(super) use proof::Proof;

#[doc(hidden)]
pub struct End;

#[doc(hidden)]
pub struct Cons<Head, Tail>(PhantomData<(Head, Tail)>);

#[doc(hidden)]
pub struct Empty;

#[doc(hidden)]
pub struct Item<Head, Tail>(PhantomData<(Head, Tail)>);

impl Proof for End {}
impl Proof for Empty {}

impl<Head, Tail> Proof for Item<Head, Tail> {}
impl<Head, Tail> Proof for Cons<Head, Tail> {}

#[doc(hidden)]
pub trait List: Proof {
    fn matches(groups: &[&[schema::QueryMeta<'_>]]) -> bool;

    fn contains<Q: schema::TypedQuery>() -> bool;

    fn validate(group: u32, input: desc::Input<'_>) -> Result<(), crate::Error>;
}

#[doc(hidden)]
pub trait Items: Proof {
    fn matches(queries: &[schema::QueryMeta<'_>]) -> bool;

    fn contains<Q: schema::TypedQuery>() -> bool;

    fn validate(query: u32, input: desc::Input<'_>) -> Result<(), crate::Error>;
}

impl List for End {
    fn matches(groups: &[&[schema::QueryMeta<'_>]]) -> bool {
        matches!(groups, [])
    }

    fn contains<Q: schema::TypedQuery>() -> bool {
        false
    }

    fn validate(_group: u32, _input: desc::Input<'_>) -> Result<(), crate::Error> {
        Err(crate::Error::QueryMetadata)
    }
}

impl Items for Empty {
    fn matches(queries: &[schema::QueryMeta<'_>]) -> bool {
        matches!(queries, [])
    }

    fn contains<Q: schema::TypedQuery>() -> bool {
        false
    }

    fn validate(_query: u32, _input: desc::Input<'_>) -> Result<(), crate::Error> {
        Err(crate::Error::QueryMetadata)
    }
}

impl<Head, Tail> Items for Item<Head, Tail>
where
    Head: schema::TypedQuery,
    Tail: Items,
{
    fn matches(queries: &[schema::QueryMeta<'_>]) -> bool {
        let Some((head, tail)) = queries.split_first() else {
            return false;
        };
        head.matches::<Head>() && Tail::matches(tail)
    }

    fn contains<Q: schema::TypedQuery>() -> bool {
        TypeId::of::<Head>() == TypeId::of::<Q>() || Tail::contains::<Q>()
    }

    fn validate(query: u32, input: desc::Input<'_>) -> Result<(), crate::Error> {
        if query == 0 {
            desc::Types::query::<Head>(input.payload, input.registry)
        } else {
            Tail::validate(query - 1, input)
        }
    }
}

impl<Head, Tail> List for Cons<Head, Tail>
where
    Head: schema::QueryGroup,
    Tail: List,
{
    fn matches(groups: &[&[schema::QueryMeta<'_>]]) -> bool {
        let Some((head, tail)) = groups.split_first() else {
            return false;
        };
        *head == Head::QUERIES && Head::Items::matches(head) && Tail::matches(tail)
    }

    fn contains<Q: schema::TypedQuery>() -> bool {
        Head::Items::contains::<Q>() || Tail::contains::<Q>()
    }

    fn validate(group: u32, input: desc::Input<'_>) -> Result<(), crate::Error> {
        if group == 0 {
            Head::Items::validate(input.cursor.query(), input)
        } else {
            Tail::validate(group - 1, input)
        }
    }
}