use serde::{Deserialize, Serialize, de::Error as _};
use super::ProtocolError;
pub const EXECUTION_TARGET_CAPABILITY_PROFILE: &str = "lenso.execution-target-capability-profile@1";
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd, Serialize)]
pub enum ExecutionTargetCapability {
#[serde(rename = "request")]
Request,
#[serde(rename = "stream")]
Stream,
#[serde(rename = "event")]
Event,
#[serde(rename = "websocket")]
WebSocket,
#[serde(rename = "host-imports")]
HostImports,
#[serde(rename = "native-process")]
NativeProcess,
#[serde(rename = "wasm-component")]
WasmComponent,
#[serde(rename = "remote")]
Remote,
#[serde(rename = "browser")]
Browser,
#[serde(rename = "workers")]
Workers,
}
impl ExecutionTargetCapability {
pub const ALL: [Self; 10] = [
Self::Browser,
Self::Event,
Self::HostImports,
Self::NativeProcess,
Self::Remote,
Self::Request,
Self::Stream,
Self::WasmComponent,
Self::WebSocket,
Self::Workers,
];
#[must_use]
pub const fn as_str(self) -> &'static str {
match self {
Self::Request => "request",
Self::Stream => "stream",
Self::Event => "event",
Self::WebSocket => "websocket",
Self::HostImports => "host-imports",
Self::NativeProcess => "native-process",
Self::WasmComponent => "wasm-component",
Self::Remote => "remote",
Self::Browser => "browser",
Self::Workers => "workers",
}
}
#[must_use]
pub fn from_name(value: &str) -> Option<Self> {
match value {
"request" => Some(Self::Request),
"stream" => Some(Self::Stream),
"event" => Some(Self::Event),
"websocket" => Some(Self::WebSocket),
"host-imports" => Some(Self::HostImports),
"native-process" => Some(Self::NativeProcess),
"wasm-component" => Some(Self::WasmComponent),
"remote" => Some(Self::Remote),
"browser" => Some(Self::Browser),
"workers" => Some(Self::Workers),
_ => None,
}
}
}
impl<'de> Deserialize<'de> for ExecutionTargetCapability {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let value = String::deserialize(deserializer)?;
Self::from_name(&value)
.ok_or_else(|| D::Error::custom("unknown execution target capability"))
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ExecutionTargetCapabilityProfile {
pub profile: String,
pub target_profile: String,
pub capabilities: Vec<ExecutionTargetCapability>,
}
impl ExecutionTargetCapabilityProfile {
pub fn validate(&self) -> Result<(), ProtocolError> {
if self.profile != EXECUTION_TARGET_CAPABILITY_PROFILE {
return Err(ProtocolError::new(
"unsupported execution target capability profile",
));
}
validate_target_profile(&self.target_profile)?;
if self
.capabilities
.windows(2)
.any(|pair| pair[0].as_str() >= pair[1].as_str())
{
return Err(ProtocolError::new(
"capabilities must be strictly canonical-sorted and unique",
));
}
Ok(())
}
#[must_use]
pub fn supports(&self, capability: ExecutionTargetCapability) -> bool {
self.validate().is_ok() && self.capabilities.contains(&capability)
}
#[must_use]
pub fn supports_named(&self, capability: &str) -> bool {
ExecutionTargetCapability::from_name(capability).is_some_and(|known| self.supports(known))
}
#[must_use]
pub fn missing_capabilities<'a>(
&self,
required: impl IntoIterator<Item = &'a str>,
) -> Vec<String> {
required
.into_iter()
.filter(|capability| !self.supports_named(capability))
.map(ToOwned::to_owned)
.collect()
}
}
fn validate_target_profile(value: &str) -> Result<(), ProtocolError> {
if value.is_empty()
|| value.len() > 128
|| !value
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'_' | b'-' | b'@'))
{
return Err(ProtocolError::new(
"target_profile must be a 1..=128 byte portable token",
));
}
Ok(())
}