Skip to main content

vvv_engine/capabilities/
discovery.rs

1//! Capabilities exposed by this build, available without scanning the workspace.
2use 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    /// Whether this command is always read-only, including every supported option.
36    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}