flarer 0.1.0

Rust client and CLI for Cloudflare's Browser Rendering REST API (content, screenshot, PDF, snapshot, markdown, scrape, JSON extraction, links, crawl).
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

//! Step-by-step interactive JSON schema builder.

use inquire::{Confirm, MultiSelect, Select, Text};
use serde_json::{Map, Value, json};
use strum::VariantNames;

use crate::ResponseFormat;
use crate::error::FlarerError;

/// JSON Schema primitive types offered to the user.
#[derive(Debug, Clone, Copy, strum::Display, strum::EnumString, strum::VariantNames)]
#[strum(serialize_all = "lowercase")]
pub enum JsonType {
    /// Object.
    Object,
    /// Array.
    Array,
    /// String.
    String,
    /// Number.
    Number,
    /// Boolean.
    Boolean,
    /// Null.
    Null,
}

#[derive(Debug, Clone)]
struct Item {
    name: String,
    type_: String,
}

fn cfg<E: std::fmt::Display>(e: E) -> FlarerError {
    FlarerError::Config(e.to_string())
}

fn properties_builder() -> crate::Result<Vec<String>> {
    let mut names: Vec<String> = Vec::new();
    println!(
        "Define one or more top-level properties. e.g. for an e-commerce page \
         you might want a `products` array."
    );
    let first = Text::new("First property name:")
        .with_help_message("e.g. products")
        .prompt()
        .map_err(cfg)?;
    names.push(first);

    loop {
        let more = Confirm::new("Add another top-level property?")
            .with_default(false)
            .prompt()
            .map_err(cfg)?;
        if !more {
            break;
        }
        let next = Text::new("Property name:").prompt().map_err(cfg)?;
        names.push(next);
    }
    Ok(names)
}

type PropertyDef = (String, Vec<Item>, Vec<String>);

fn items_builder(names: Vec<String>) -> crate::Result<Vec<PropertyDef>> {
    let mut results = Vec::new();
    for name in names {
        loop {
            let mut items: Vec<Item> = Vec::new();
            println!(
                "Defining fields for `{name}`. After each field choose whether to add another."
            );
            loop {
                let item_name = Text::new("Field name:").prompt().map_err(cfg)?;
                let item_type = Select::new("Field type:", JsonType::VARIANTS.to_vec())
                    .prompt()
                    .map_err(cfg)?;
                items.push(Item {
                    name: item_name,
                    type_: item_type.to_string(),
                });
                let more = Confirm::new("Add another field?")
                    .with_default(false)
                    .prompt()
                    .map_err(cfg)?;
                if !more {
                    break;
                }
            }
            let required = MultiSelect::new(
                "Select required fields:",
                items.iter().map(|i| i.name.clone()).collect(),
            )
            .prompt()
            .map_err(cfg)?;
            let confirm = Confirm::new(&format!(
                "Confirm fields for `{name}`: {:?} (required: {:?})",
                items, required
            ))
            .with_default(true)
            .prompt()
            .map_err(cfg)?;
            if confirm {
                results.push((name.clone(), items, required));
                break;
            }
        }
    }
    Ok(results)
}

fn assemble(values: Vec<PropertyDef>) -> Value {
    let mut root = Map::new();
    for (name, items, required) in values {
        let mut props = Map::new();
        for it in items {
            props.insert(it.name, json!({ "type": it.type_ }));
        }
        root.insert(
            name,
            json!({
                "type": "array",
                "items": {
                    "type": "object",
                    "properties": Value::Object(props),
                    "required": required,
                }
            }),
        );
    }
    json!({
        "type": "object",
        "properties": Value::Object(root),
    })
}

/// Public entry point: walk the user through assembling a JSON schema and
/// return a typed [`ResponseFormat`].
pub async fn build_response_format_interactive() -> crate::Result<ResponseFormat> {
    let names = properties_builder()?;
    let items = items_builder(names)?;
    Ok(ResponseFormat::json_schema(assemble(items)))
}