eql_core 0.1.8

EVM Query Language core components
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

use crate::common::{
    entity::Entity,
    types::{Expression, Field, GetExpression},
};
use std::error::Error;

#[derive(Debug)]
pub enum SemanticError {
    InvalidField { field: Field, enetity: Entity },
}

impl std::fmt::Display for SemanticError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            SemanticError::InvalidField { field, enetity } => {
                write!(f, "Invalid field `{}` for entity `{}`", field, enetity)
            }
        }
    }
}

impl Error for SemanticError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        None
    }
}

pub struct SemanticAnalyzer<'a> {
    expressions: &'a Vec<Expression>,
}

impl<'a> SemanticAnalyzer<'a> {
    pub fn new(expressions: &'a Vec<Expression>) -> Self {
        SemanticAnalyzer { expressions }
    }

    // TODO: fields should only contain fields that are valid for the entity
    pub fn analyze(&self) -> Result<(), Box<dyn Error>> {
        for expression in self.expressions {
            match expression {
                Expression::Get(get_expr) => {
                    self.analyze_get_expr(get_expr)?;
                }
            }
        }

        Ok(())
    }

    fn analyze_get_expr(&self, get_expr: &GetExpression) -> Result<(), Box<dyn Error>> {
        for field in &get_expr.fields {
            match field {
                Field::Block(_) => {
                    if get_expr.entity != Entity::Block {
                        return Err(Box::new(SemanticError::InvalidField {
                            field: field.clone(),
                            enetity: get_expr.entity.clone(),
                        }));
                    }
                }
                Field::Account(_) => {
                    if get_expr.entity != Entity::Account {
                        return Err(Box::new(SemanticError::InvalidField {
                            field: field.clone(),
                            enetity: get_expr.entity.clone(),
                        }));
                    }
                }
                Field::Transaction(_) => {
                    if get_expr.entity != Entity::Transaction {
                        return Err(Box::new(SemanticError::InvalidField {
                            field: field.clone(),
                            enetity: get_expr.entity.clone(),
                        }));
                    }
                }
            }
        }

        Ok(())
    }
}

#[cfg(test)]
mod test {
    use crate::common::{
        chain::Chain,
        entity::Entity,
        types::{BlockField, Expression, Field, GetExpression},
    };

    #[test]
    fn test_analyze_get_expression_with_wrong_fields() {
        let expressions = vec![Expression::Get(GetExpression {
            entity: Entity::Account,
            entity_id: "0x1234567890123456789012345678901234567890"
                .try_into()
                .unwrap(),
            chain: Chain::Ethereum,
            fields: vec![Field::Block(BlockField::Number)],
            // The query doesn't matter for this test
            query: String::from(""),
        })];
        let analyzer = super::SemanticAnalyzer::new(&expressions);
        match analyzer.analyze() {
            Ok(_) => panic!("Expected an error"),
            Err(error) => {
                assert_eq!(
                    error.to_string(),
                    "Invalid field `number` for entity `account`"
                );
            }
        }
    }
}