trustfall_core 0.8.1

The trustfall query engine, empowering you to query everything.
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

//! Errors from parsing Trustfall queries
use async_graphql_parser::Pos;
use async_graphql_value::Value;
use serde::{ser::Error as SerError, Deserialize, Serialize, Serializer};

#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, thiserror::Error)]
pub enum ParseError {
    #[error("Unrecognized directive {0}")]
    UnrecognizedDirective(String, Pos),

    #[error("Directive in unsupported position {0}: {1}")]
    UnsupportedDirectivePosition(String, String, Pos),

    #[error("Directive {0} missing required argument {1}")]
    MissingRequiredDirectiveArgument(String, String, Pos),

    #[error("Directive {0} received unrecognized argument {1}")]
    UnrecognizedDirectiveArgument(String, String, Pos),

    #[error("Directive {0} received duplicated argument {1}")]
    DuplicatedDirectiveArgument(String, String, Pos),

    #[error("Directive {0} received value of inappropriate type for argument {1}")]
    InappropriateTypeForDirectiveArgument(String, String, Pos),

    #[error(
        "Value argument in @filter directive is a string instead of a list. \
        Did you mean to put '@filter(op: \"{0}\", value: [\"{1}\"])' instead?"
    )]
    FilterExpectsListNotString(String, String, Pos),

    #[error("Field {0} received an invalid value for argument {1}: {2}")]
    InvalidFieldArgument(String, String, Value, Pos),

    #[error("Input contains non-inline fragments, this is not supported")]
    DocumentContainsNonInlineFragments(Pos),

    #[error("Input contains multiple operation blocks, this is not supported")]
    MultipleOperationsInDocument(Pos),

    #[error(
        "Input contains multiple root vertices, which is not supported. \
        Please make sure that only a single field inside the outer-most curly braces is expanded."
    )]
    MultipleQueryRoots(Pos),

    #[error("Found {0} instead of a root vertex, which is not supported.")]
    UnsupportedQueryRoot(String, Pos),

    #[error("Found directive {0} applied on or outside the root vertex, which is not supported ")]
    DirectiveNotInsideQueryRoot(String, Pos),

    #[error("Input is not a query operation")]
    DocumentNotAQuery(Pos),

    #[error("Unrecognized filter operator: {0}")]
    UnsupportedFilterOperator(String, Pos),

    #[error("Filter is passed an invalid operand argument '{0}': {1}")]
    InvalidFilterOperandName(String, String, Pos),

    #[error("Unrecognized transform operator: {0}")]
    UnsupportedTransformOperator(String, Pos),

    #[error("Output name \"{0}\" contains invalid characters: {1:?}")]
    InvalidOutputName(String, Vec<char>, Pos),

    #[error("Tag name \"{0}\" contains invalid characters: {1:?}")]
    InvalidTagName(String, Vec<char>, Pos),

    #[serde(skip_deserializing, serialize_with = "fail_serialize_invalid_graphql_error")]
    #[error("{0}")]
    InvalidGraphQL(async_graphql_parser::Error),

    #[error("Unsupported syntax feature found: {0}")]
    UnsupportedSyntax(String, Pos),

    #[error("Nested type coercion found. Please merge the type coercion blocks so that coercion is only performed once.")]
    NestedTypeCoercion(Pos),

    #[error("Properties and edges side-by-side with a coercion (`... on X`) are not supported. Please move them inside the type coercion instead.")]
    TypeCoercionWithSiblingFields(Pos),

    #[error("Directive \"{0}\" is applied more than once, this is not supported.")]
    UnsupportedDuplicatedDirective(String, Pos),

    #[error("Edge {1} specifies a duplicated parameter {0}")]
    DuplicatedEdgeParameter(String, String, Pos),

    #[error(
        "Found GraphQL query variable definition(s). \
    These are not necessary since variables are defined implicitly, \
    and must be removed."
    )]
    VariableDefinitionInQuery(Pos),

    #[error("Unexpected error: {0}")]
    OtherError(String, Pos),
}

fn fail_serialize_invalid_graphql_error<S: Serializer>(
    _: &async_graphql_parser::Error,
    _: S,
) -> Result<S::Ok, S::Error> {
    Err(S::Error::custom("cannot serialize InvalidGraphQL error variant"))
}

impl From<async_graphql_parser::Error> for ParseError {
    fn from(e: async_graphql_parser::Error) -> Self {
        Self::InvalidGraphQL(e)
    }
}