graphql_utils.rs

use crate::api_model::SortOrder;
use graphql_parser::query::parse_query;
use graphql_parser::query::Definition;
use graphql_parser::query::Field;
use graphql_parser::query::OperationDefinition;
use graphql_parser::query::Selection;
use graphql_parser::query::SelectionSet;
use graphql_parser::query::Text;
use graphql_parser::query::Value;
use std::convert::TryFrom;
use warp::http::status::StatusCode;

use crate::error::Error;
use crate::error::Result;
use std::collections::HashMap;

#[derive(Debug)]
pub struct QueryASTNode {
    pub item_type: Option<String>,
    pub arguments: Arguments,
    pub properties: Vec<String>,
    pub edges: HashMap<String, QueryASTNode>,
}

impl QueryASTNode {
    fn new() -> Self {
        QueryASTNode {
            item_type: None,
            arguments: Arguments::new(),
            properties: Vec::new(),
            edges: HashMap::new(),
        }
    }
}

fn parse_query_recursive(selection_set: SelectionSet<String>) -> Result<QueryASTNode> {
    let mut result = QueryASTNode::new();
    for selection in selection_set.items {
        if let Selection::Field(field) = selection {
            if field_is_property(&field) {
                result.properties.push(field.name);
            } else {
                let mut edge_ast_node = parse_query_recursive(field.selection_set)?;
                for (arg_name, arg_value) in field.arguments {
                    edge_ast_node.arguments.add_arg(arg_name, arg_value)?;
                }
                result.edges.insert(field.name, edge_ast_node);
            }
        }
    }
    Ok(result)
}

pub fn parse_graphql_query(query_string: &str) -> Result<QueryASTNode> {
    // TODO Only returns first Query
    // TODO error handling
    let parsed = match parse_query::<String>(query_string) {
        Ok(res) => res,
        Err(err) => {
            return Err(Error {
                code: StatusCode::BAD_REQUEST,
                msg: format!("Invalid GraphQL query {}", err).to_owned(),
            });
        }
    };

    if parsed.definitions.len() > 1 {
        panic!("graphQL only supports queries");
    }