evix-protocol 1.0.0

Daemon and worker protocol types for evix
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

use evix::{Config, Derivation, Diff, Event, Filter};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum Request {
  Eval {
    config: Config,
  },
  Watch {
    config: Config,
  },
  Query {
    config: Config,
    #[serde(default)]
    filter: Filter,
  },
  Diff {
    config: Config,
  },
}

impl Request {
  pub fn eval(config: &Config) -> Self {
    Self::Eval {
      config: config.clone(),
    }
  }

  pub fn watch(config: &Config) -> Self {
    Self::Watch {
      config: config.clone(),
    }
  }

  pub fn query(config: &Config, filter: &Filter) -> Self {
    Self::Query {
      config: config.clone(),
      filter: filter.clone(),
    }
  }

  pub fn diff(config: &Config) -> Self {
    Self::Diff {
      config: config.clone(),
    }
  }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum Response {
  Event { event: Event },
  Diff { diff: Diff },
  Done,
  Error { message: String },
}

impl Response {
  pub fn event(event: &Event) -> Self {
    Self::Event {
      event: event.clone(),
    }
  }

  pub fn derivation_event(derivation: &Derivation) -> Self {
    Self::Event {
      event: Event::Derivation(derivation.clone()),
    }
  }

  pub fn diff(diff: &Diff) -> Self {
    Self::Diff { diff: diff.clone() }
  }

  pub fn error(message: impl Into<String>) -> Self {
    Self::Error {
      message: message.into(),
    }
  }
}