statsig-rs 0.5.1

Unofficial crate to interact with statsig.io
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use std::collections::HashMap;

use serde::{Deserialize, Serialize};

#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct EvalResult {
    pub pass: bool,
    pub config_value: Option<serde_json::Value>,
    pub fetch_from_server: bool,
    pub id: String,
    pub secondary_exposures: Vec<HashMap<String, String>>,
    // pub undelegated_secondary_exposures: Option<Vec<HashMap<String, String>>>,
    // pub config_delegate: Option<String>,
    // pub explicit_parameters: Option<HashMap<String, bool>>,
}

impl Default for EvalResult {
    fn default() -> Self {
        Self::fail()
    }
}

impl EvalResult {
    pub fn pass() -> Self {
        Self::new(true, false)
    }

    pub fn fail() -> Self {
        Self::new(false, false)
    }

    pub fn fetch_from_server() -> Self {
        Self::new(false, true)
    }

    fn new(pass: bool, fetch_from_server: bool) -> Self {
        Self {
            pass,
            fetch_from_server,
            config_value: None,
            id: "default".to_string(),
            secondary_exposures: vec![],
        }
    }
}

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct ConfigData {
    pub dynamic_configs: Option<Vec<ConfigSpec>>,
    pub feature_gates: Option<Vec<ConfigSpec>>,
    pub layer_configs: Option<Vec<ConfigSpec>>,
    pub has_updates: bool,
    pub time: Option<u64>,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConfigSpec {
    pub name: String,
    pub r#type: ConfigSpecType,
    pub salt: String,
    pub enabled: bool,
    pub rules: Option<Vec<ConfigRule>>,
    pub default_value: serde_json::Value,
    pub id_type: Option<String>,
    // pub explicit_parameters: Option<Vec<String>>,
}

#[derive(Debug, Clone, Copy, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum ConfigSpecType {
    DynamicConfig,
    FeatureGate,
    #[serde(other)]
    Unknown,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConfigRule {
    pub name: String,
    pub id: String,
    pub salt: String,
    pub pass_percentage: f64,
    pub conditions: Vec<ConfigCondition>,
    pub return_value: serde_json::Value, // json.RawMessage
    pub id_type: String,
    // pub config_delegate: String,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConfigCondition {
    pub r#type: ConditionType,
    pub operator: Option<OperatorType>,
    pub field: Option<String>,
    pub target_value: Option<serde_json::Value>,
    pub additional_values: Option<HashMap<String, String>>,
    pub id_type: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum ConditionType {
    Public,
    FailGate,
    PassGate,
    IpBased,
    UaBased,
    UserField,
    EnvironmentField,
    CurrentTime,
    UserBucket,
    UnitId,
    #[serde(other)]
    Unknown,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum OperatorType {
    Gt,
    Gte,
    Lt,
    Lte,
    VersionGt,
    VersionGte,
    VersionLt,
    VersionLte,
    VersionEq,
    VersionNeq,
    Any,
    None,
    AnyCaseSensitive,
    NoneCaseSensitive,
    StrStartsWithAny,
    StrEndsWithAny,
    StrContainsAny,
    StrContainsNone,
    StrMatches,
    Eq,
    Neq,
    Before,
    After,
    On,
    InSegmentList,
    NotInSegmentList,
    #[serde(other)]
    Unknown,
}