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

use derive_builder::Builder;
use crate::ToQueryString;
use itertools::Itertools;
use crate::condition::{Condition, ConditionValue};
use rand::random;
use std::collections::HashMap;
use serde::Serialize;

#[derive(Builder, Serialize, Clone)]
pub struct Mutation {
    #[builder(default)]
    pub set: Vec<MutationUnit>,
    #[builder(default)]
    pub delete: Vec<MutationUnit>
}

#[derive(Clone, Serialize)]
pub struct MutationUnit {
    #[serde(flatten)]
    uid: MutationUID,
    #[serde(flatten)]
    predicates: HashMap<String, MutationPredicateValue>,
}

impl MutationUnit {
    pub fn new(uid: MutationUID) -> Self {
        Self {
            uid,
            predicates: Default::default()
        }
    }

    pub fn predicate(mut self, name: &str, value: MutationPredicateValue) -> Self {
        self.predicates.insert(name.to_string(), value);
        self
    }

    pub fn predicate_ref(&mut self, name: &str, value: MutationPredicateValue) {
        self.predicates.insert(name.to_string(), value);
    }
}

#[derive(Clone, Serialize)]
#[serde(untagged)]
pub enum MutationPredicateValue {
    // todo: technically should support arrays
    String(String),
    Number(i64),
    Float(f64),
    Bool(bool),
    Edge(MutationUID),
    Edges(Vec<MutationUID>),
    Null
}

impl MutationPredicateValue {
    pub fn string(value: &str) -> MutationPredicateValue {
        MutationPredicateValue::String(value.to_string())
    }
}

#[derive(Clone, Serialize)]
pub struct MutationUID {
    uid: String
}

impl MutationUID {
    pub fn placeholder() -> MutationUID {
        Self {
            uid: MutationUID::generate_placeholder()
        }
    }

    pub fn variable(name: &str) -> MutationUID {
        Self {
            uid: MutationUID::generate_variable(name)
        }
    }

    pub fn uid(value: &str) -> MutationUID {
        Self {
            uid: value.to_string()
        }
    }

    fn generate_placeholder() -> String {
        format!("_:uid_placeholder_{}", random::<u128>())
    }

    fn generate_variable(name: &str) -> String {
        format!("uid({})", name)
    }
}

#[derive(Clone)]
pub enum MutationType {
    SET
}

#[derive(Clone)]
pub enum MutationLiteral {
    Literal(String),
    String(String)
}

impl ToQueryString for Mutation {
    fn to_query_string(&self) -> String {
        unimplemented!()
    }
}