firecrawl 2.4.1

Official Rust SDK for Firecrawl API v2.
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

use serde::Deserialize;
use serde_json::Value;

/// Handles metadata fields that the API may return as either a string or an array of strings.
/// Arrays are joined with ", ".
pub(crate) fn deserialize_string_or_array<'de, D>(
    deserializer: D,
) -> Result<Option<String>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    match Option::<Value>::deserialize(deserializer)? {
        None | Some(Value::Null) => Ok(None),
        Some(Value::String(s)) => Ok(Some(s)),
        Some(Value::Array(arr)) => {
            let strings: Vec<String> = arr
                .into_iter()
                .map(|v| match v {
                    Value::String(s) => s,
                    other => other.to_string(),
                })
                .collect();
            if strings.is_empty() {
                Ok(None)
            } else {
                Ok(Some(strings.join(", ")))
            }
        }
        Some(other) => Ok(Some(other.to_string())),
    }
}

#[cfg(test)]
mod tests {
    use serde::Deserialize;
    use serde_json::json;

    #[derive(Deserialize)]
    struct Helper {
        #[serde(default, deserialize_with = "super::deserialize_string_or_array")]
        field: Option<String>,
    }

    #[test]
    fn test_string_value() {
        let h: Helper = serde_json::from_value(json!({"field": "hello"})).unwrap();
        assert_eq!(h.field, Some("hello".to_string()));
    }

    #[test]
    fn test_array_value() {
        let h: Helper = serde_json::from_value(json!({"field": ["index", "follow"]})).unwrap();
        assert_eq!(h.field, Some("index, follow".to_string()));
    }

    #[test]
    fn test_null_value() {
        let h: Helper = serde_json::from_value(json!({"field": null})).unwrap();
        assert_eq!(h.field, None);
    }

    #[test]
    fn test_missing_field() {
        let h: Helper = serde_json::from_value(json!({})).unwrap();
        assert_eq!(h.field, None);
    }

    #[test]
    fn test_empty_array() {
        let h: Helper = serde_json::from_value(json!({"field": []})).unwrap();
        assert_eq!(h.field, None);
    }

    #[test]
    fn test_single_element_array() {
        let h: Helper = serde_json::from_value(json!({"field": ["noindex"]})).unwrap();
        assert_eq!(h.field, Some("noindex".to_string()));
    }

    #[test]
    fn test_serialization_roundtrip() {
        let h: Helper = serde_json::from_value(json!({"field": "index, follow"})).unwrap();
        assert_eq!(h.field, Some("index, follow".to_string()));
    }
}