liminal-sdk 0.20.20

Application-facing SDK traits for liminal messaging clients
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

//! The one substitution the seat's `flow` and a line's stages share.
//!
//! `{"$prev": "<JSON pointer>"}` and `{"$item": "<JSON pointer>"}` objects are filled from
//! the previous reply and a fan-out's element (SDK-017 R4; NET-031 R1, R5).

use alloc::format;
use alloc::string::String;

use serde_json::{Map, Value};

/// The key naming a pointer into the previous reply.
pub const PREV: &str = "$prev";

/// The key naming a pointer into a fan-out's element.
pub const ITEM: &str = "$item";

/// `input` with every `{"$prev": pointer}` object replaced from `prev`.
///
/// # Errors
/// The pointer that names nothing in `prev`, or a `$prev` with no previous reply.
pub fn fill(input: &Value, prev: Option<&Value>) -> Result<Value, String> {
    fill_with(input, prev, None)
}

/// `input` with every `{"$prev": pointer}` object replaced from `prev` and every
/// `{"$item": pointer}` object from `item`.
///
/// # Errors
/// The pointer that names nothing, a `$prev` with no previous reply, or an `$item` outside
/// a fan-out.
pub fn fill_with(
    input: &Value,
    prev: Option<&Value>,
    item: Option<&Value>,
) -> Result<Value, String> {
    match input {
        Value::Object(object) => {
            if let Some(pointer) = sole(object, PREV) {
                let prev = prev.ok_or_else(|| format!("{PREV} {pointer:?} in the first step"))?;
                return prev.pointer(pointer).cloned().ok_or_else(|| {
                    format!("{PREV} {pointer:?} names nothing in the previous reply")
                });
            }
            if let Some(pointer) = sole(object, ITEM) {
                let item = item.ok_or_else(|| format!("{ITEM} {pointer:?} outside a fan-out"))?;
                return item
                    .pointer(pointer)
                    .cloned()
                    .ok_or_else(|| format!("{ITEM} {pointer:?} names nothing in the element"));
            }
            let mut filled = Map::with_capacity(object.len());
            for (key, value) in object {
                filled.insert(key.clone(), fill_with(value, prev, item)?);
            }
            Ok(Value::Object(filled))
        }
        Value::Array(items) => items
            .iter()
            .map(|value| fill_with(value, prev, item))
            .collect::<Result<_, _>>()
            .map(Value::Array),
        other => Ok(other.clone()),
    }
}

/// Whether `input` names `$prev` anywhere, so a first stage that does is refused before it
/// is kept (NET-031 R1).
#[must_use]
pub fn names_prev(input: &Value) -> bool {
    match input {
        Value::Object(object) => sole(object, PREV).is_some() || object.values().any(names_prev),
        Value::Array(items) => items.iter().any(names_prev),
        _ => false,
    }
}

/// The pointer of an object whose one member is `key` with a string value.
fn sole<'a>(object: &'a Map<String, Value>, key: &str) -> Option<&'a str> {
    match (object.len(), object.get(key)) {
        (1, Some(Value::String(pointer))) => Some(pointer),
        _ => None,
    }
}

#[cfg(test)]
#[path = "prev_tests.rs"]
mod tests;