mant-protocol 0.11.0

Transport-neutral query contracts and projections for ManT
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

//! Generates discoverable JSON Schemas from the authoritative Rust contracts.

use std::collections::BTreeMap;

use schemars::{JsonSchema, Schema, generate::SchemaSettings};

use crate::{
    DoctorReport, DocumentCatalog, QueryBundle, QueryExcerpt, QueryOutline, QueryRequest,
    QuerySearch, ScopeQueryRequest, ScopeQueryResponse, TldrCacheUpdate,
};

/// Generate the read-only installation health report schema.
#[must_use]
pub fn doctor_report_json_schema() -> Schema {
    serialize_schema::<DoctorReport>()
}

/// Generate the explicit tldr cache update result schema.
#[must_use]
pub fn tldr_cache_update_json_schema() -> Schema {
    serialize_schema::<TldrCacheUpdate>()
}

/// Generate the local document-catalog JSON representation.
#[must_use]
pub fn document_catalog_json_schema() -> Schema {
    serialize_schema::<DocumentCatalog>()
}

/// Generate the JSON representation accepted when deserializing a request.
#[must_use]
pub fn query_request_json_schema() -> Schema {
    deserialize_schema::<QueryRequest>()
}

/// Generate the complete-query JSON representation emitted by `mant`.
#[must_use]
pub fn query_bundle_json_schema() -> Schema {
    serialize_schema::<QueryBundle>()
}

/// Generate the outline JSON representation emitted by `mant`.
#[must_use]
pub fn query_outline_json_schema() -> Schema {
    serialize_schema::<QueryOutline>()
}

/// Generate the selected-excerpt JSON representation emitted by `mant`.
#[must_use]
pub fn query_excerpt_json_schema() -> Schema {
    serialize_schema::<QueryExcerpt>()
}

/// Generate the independent semantic-evidence response representation.
#[must_use]
pub fn query_explanation_json_schema() -> Schema {
    serialize_schema::<crate::QueryExplanation>()
}

/// Generate the structure-aware search result emitted by `mant`.
#[must_use]
pub fn query_search_json_schema() -> Schema {
    serialize_schema::<QuerySearch>()
}

/// Generate the bounded multi-document request representation.
#[must_use]
pub fn scope_query_request_json_schema() -> Schema {
    deserialize_schema::<ScopeQueryRequest>()
}

/// Generate the bounded multi-document result representation.
#[must_use]
pub fn scope_query_response_json_schema() -> Schema {
    serialize_schema::<ScopeQueryResponse>()
}

/// Generate every public request and query-response contract in stable order.
#[must_use]
pub fn query_json_schema_catalog() -> BTreeMap<&'static str, Schema> {
    BTreeMap::from([
        ("catalog", document_catalog_json_schema()),
        ("doctor", doctor_report_json_schema()),
        ("excerpt", query_excerpt_json_schema()),
        ("explanation", query_explanation_json_schema()),
        ("outline", query_outline_json_schema()),
        ("query", query_bundle_json_schema()),
        ("request", query_request_json_schema()),
        ("search", query_search_json_schema()),
        ("scope-query", scope_query_response_json_schema()),
        ("scope-request", scope_query_request_json_schema()),
        ("tldr-update", tldr_cache_update_json_schema()),
    ])
}

fn deserialize_schema<T: JsonSchema>() -> Schema {
    SchemaSettings::draft2020_12()
        .for_deserialize()
        .into_generator()
        .into_root_schema_for::<T>()
}

fn serialize_schema<T: JsonSchema>() -> Schema {
    SchemaSettings::draft2020_12()
        .for_serialize()
        .into_generator()
        .into_root_schema_for::<T>()
}