vvv_engine/capabilities/
discovery.rs1use serde::{Deserialize, Serialize};
3
4#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
5#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6pub struct DiscoveryQuery {}
7#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
8#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
9pub struct Discovery {
10 #[serde(default)]
11 pub schemas_available: bool,
12 pub validation_available: bool,
13 pub validation_defaults: crate::ValidationBudget,
14 pub schema: u32,
15 pub languages: Vec<crate::LanguageId>,
16 pub commands: Vec<Capability>,
17 pub page_defaults: crate::PageBudget,
18 pub page_maximum: crate::PageBudget,
19 pub work_defaults: crate::WorkBudget,
20 pub work_maximum: crate::WorkBudget,
21 pub query_retention: crate::QueryLimits,
22 pub plan_retention: crate::PlanLimits,
23 pub context_defaults: crate::ContextBudget,
24 pub context_maximum: crate::ContextBudget,
25 pub min_output_bytes: usize,
26 pub max_output_bytes: usize,
27}
28#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
29#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
30pub struct Capability {
31 #[cfg(feature = "schema")]
32 #[serde(default, skip_serializing_if = "Option::is_none")]
33 pub schemas: Option<crate::SchemaReferences>,
34 pub command: String,
35 pub read_only: bool,
37 pub parameters: Vec<String>,
38}
39impl DiscoveryQuery {
40 pub fn execute(self, engine: &crate::Engine) -> Discovery {
41 Discovery {
42 schema: crate::protocol::SCHEMA,
43 validation_available: crate::ValidatePlanQuery::available(engine),
44 validation_defaults: crate::ValidationBudget::default(),
45 languages: engine.language_ids(),
46 schemas_available: cfg!(feature = "schema"),
47 commands: crate::Command::ALL
48 .iter()
49 .map(|&command| Capability {
50 command: command.as_str().into(),
51 read_only: command.is_read_only(),
52 parameters: command.parameters().iter().map(|p| (*p).into()).collect(),
53 #[cfg(feature = "schema")]
54 schemas: Some(crate::SchemaReferences::for_command(command)),
55 })
56 .collect(),
57 page_defaults: crate::PageBudget::default(),
58 page_maximum: crate::PageBudget::MAXIMUM,
59 work_defaults: crate::WorkBudget::default(),
60 work_maximum: crate::WorkBudget::MAXIMUM,
61 query_retention: crate::QueryLimits::default(),
62 plan_retention: crate::PlanLimits::default(),
63 context_defaults: crate::ContextBudget::default(),
64 context_maximum: crate::ContextBudget::MAXIMUM,
65 min_output_bytes: crate::ContextBudget::MIN_BYTES,
66 max_output_bytes: crate::ContextBudget::MAX_BYTES,
67 }
68 }
69}
70impl crate::report::Document {
71 pub(crate) fn discovery(reply: &Discovery) -> Self {
72 use crate::protocol::display::{Line, Role};
73 let mut doc = Self::new();
74 doc.body([Line::single(Role::Strong, "Available commands")]);
75 for capability in &reply.commands {
76 doc.body([Line::single(Role::Plain, &capability.command).and(
77 Role::Dim,
78 if capability.read_only {
79 " (read-only)"
80 } else {
81 " (can write)"
82 },
83 )]);
84 }
85 doc
86 }
87}