rototo 0.1.0-alpha.8

Control plane for runtime configuration of your application.
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

use std::sync::Arc;

use super::super::catalog_schema::catalog_schema_uri;
use super::super::index::*;
use super::super::source::SourceDocument;
use super::super::syntax::{ParsedToml, SyntaxIndex, table_location};
use super::fields::json_from_toml_value;

pub(crate) fn project_catalog(
    document: &SourceDocument,
    syntax: &SyntaxIndex,
    id: &str,
) -> CatalogNode {
    let json = syntax.json.get(&document.id).cloned();

    CatalogNode {
        doc: document.id,
        id: id.to_owned(),
        path: document.path.clone(),
        location: document.document_location(),
        json,
        validator: None,
        invalid_message: None,
    }
}

pub(crate) fn compile_catalog_validators(index: &mut SemanticIndex) {
    let resources = catalog_schema_resources(index);
    for catalog in index.catalogs.values_mut() {
        let Some(json) = catalog.json.as_ref() else {
            continue;
        };
        let base_uri = catalog_schema_uri(&catalog.id);
        match jsonschema::options()
            .should_validate_formats(true)
            .with_base_uri(base_uri)
            .with_resources(resources.clone().into_iter())
            .build(json)
        {
            Ok(validator) => {
                catalog.validator = Some(Arc::new(validator));
                catalog.invalid_message = None;
            }
            Err(err) => {
                catalog.validator = None;
                catalog.invalid_message = Some(err.to_string());
            }
        }
    }
}

fn catalog_schema_resources(index: &SemanticIndex) -> Vec<(String, jsonschema::Resource)> {
    let mut resources = Vec::new();
    for catalog in index.catalogs.values() {
        let Some(json) = catalog.json.as_ref() else {
            continue;
        };
        let Ok(resource) = jsonschema::Resource::from_contents(json.clone()) else {
            continue;
        };

        resources.push((catalog_schema_uri(&catalog.id), resource.clone()));
        if let Some(id) = json
            .get("$id")
            .and_then(serde_json::Value::as_str)
            .map(normalize_schema_uri)
            .filter(|id| !id.is_empty())
        {
            resources.push((id, resource));
        }
    }
    resources
}

fn normalize_schema_uri(uri: &str) -> String {
    uri.trim_end_matches('#').to_owned()
}

pub(crate) fn project_catalog_entry(
    document: &SourceDocument,
    toml: &ParsedToml,
    catalog_id: &str,
    key: &str,
) -> CatalogEntryNode {
    let root = toml.root();
    CatalogEntryNode {
        catalog_id: catalog_id.to_owned(),
        key: key.to_owned(),
        location: table_location(document, root),
        value: json_from_toml_value(root),
    }
}