nexo-microapp-sdk 0.1.19

Reusable runtime helpers for Phase 11 stdio microapps consuming the nexo-rs daemon (JSON-RPC dispatch loop, BindingContext parsing, typed replies).
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

use serde::{Deserialize, Serialize};

use nexo_tool_meta::marketing::{AssignTarget, RoutingRule, RuleSet, TenantIdRef};

/// Operator-facing YAML schema. Round-trips into `RuleSet` so
/// the YAML stays editable as the canonical source while the
/// dispatcher works with the strongly-typed wire shape.
///
/// Example:
///
/// ```yaml
/// version: 1
/// default_target:
///   kind: round_robin
///   pool:
///     - { id: pedro }
///     - { id: ana }
/// rules:
///   - id: vip-personal
///     name: VIP personal
///     active: true
///     followup_profile: vip
///     conditions:
///       - { kind: person_has_tag, tag: vip }
///     assigns_to:
///       kind: seller
///       id:
///         id: ana
/// ```
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RuleSetYaml {
    pub version: u32,
    pub rules: Vec<RoutingRule>,
    pub default_target: AssignTarget,
}

/// Parse a YAML document into a typed `RuleSet`. Caller passes
/// the active `tenant_id` because the YAML doesn't repeat it
/// (the file path encodes it: `<state>/marketing/<tenant>/rules.yaml`).
pub fn load_rule_set_from_str(
    tenant_id: TenantIdRef,
    yaml: &str,
) -> Result<RuleSet, serde_yaml::Error> {
    let parsed: RuleSetYaml = serde_yaml::from_str(yaml)?;
    Ok(RuleSet {
        tenant_id,
        version: parsed.version,
        rules: parsed.rules,
        default_target: parsed.default_target,
    })
}

#[cfg(test)]
mod tests {
    use super::*;
    use nexo_tool_meta::marketing::{AssignTarget, RulePredicate, SellerId, TenantIdRef};

    const SAMPLE: &str = r#"
version: 1
default_target:
  kind: round_robin
  pool:
    - "pedro"
    - "ana"
rules:
  - id: vip-personal
    name: VIP personal
    active: true
    followup_profile: vip
    conditions:
      - kind: person_has_tag
        tag: vip
    assigns_to:
      kind: seller
      id: "ana"
"#;

    #[test]
    fn parses_sample_yaml() {
        let rs = load_rule_set_from_str(TenantIdRef("acme".into()), SAMPLE).unwrap();
        assert_eq!(rs.tenant_id, TenantIdRef("acme".into()));
        assert_eq!(rs.version, 1);
        assert_eq!(rs.rules.len(), 1);
        assert_eq!(rs.rules[0].id, "vip-personal");
        assert!(matches!(
            rs.rules[0].conditions[0],
            RulePredicate::PersonHasTag { .. }
        ));
        assert!(matches!(
            rs.default_target,
            AssignTarget::RoundRobin { ref pool } if pool == &vec![SellerId("pedro".into()), SellerId("ana".into())]
        ));
    }

    #[test]
    fn empty_rules_ok() {
        let yaml = r#"
version: 1
default_target:
  kind: drop
rules: []
"#;
        let rs = load_rule_set_from_str(TenantIdRef("acme".into()), yaml).unwrap();
        assert!(rs.rules.is_empty());
    }

    #[test]
    fn invalid_predicate_kind_fails() {
        let yaml = r#"
version: 1
default_target:
  kind: drop
rules:
  - id: bad
    name: bad
    active: true
    followup_profile: x
    conditions:
      - kind: nonexistent_predicate
    assigns_to:
      kind: drop
"#;
        let r = load_rule_set_from_str(TenantIdRef("acme".into()), yaml);
        assert!(r.is_err());
    }

    #[test]
    fn round_trip_yaml() {
        let rs1 = load_rule_set_from_str(TenantIdRef("acme".into()), SAMPLE).unwrap();
        let yaml_out = serde_yaml::to_string(&RuleSetYaml {
            version: rs1.version,
            rules: rs1.rules.clone(),
            default_target: rs1.default_target.clone(),
        })
        .unwrap();
        let rs2 = load_rule_set_from_str(TenantIdRef("acme".into()), &yaml_out).unwrap();
        assert_eq!(rs1.rules, rs2.rules);
        assert_eq!(rs1.default_target, rs2.default_target);
    }
}