feat(interface): add authoring macros and codecs
Add the wip-interface facade and proc-macro implementation for typed interface descriptors, DTO value codecs, validated dispatch, metadata extraction, and span-aware compile failures.
This commit is contained in:
@@ -0,0 +1,661 @@
|
||||
//! Public authoring API for Web Interface Protocol (WIP) interfaces.
|
||||
//!
|
||||
//! Add `wip-interface` to an application and import it under the short name
|
||||
//! used by the attribute examples:
|
||||
//!
|
||||
//! ```
|
||||
//! use wip_interface as wip;
|
||||
//!
|
||||
//! #[derive(Debug, PartialEq, wip::WipType)]
|
||||
//! struct Greeting {
|
||||
//! /// Text shown to the recipient.
|
||||
//! message: String,
|
||||
//! }
|
||||
//!
|
||||
//! #[wip::interface]
|
||||
//! pub trait Greeter {
|
||||
//! /// Builds a greeting.
|
||||
//! ///
|
||||
//! /// # Returns
|
||||
//! /// The generated greeting.
|
||||
//! fn greet(&self, /// Person to greet.
|
||||
//! name: String) -> wip::OperationResult<Greeting>;
|
||||
//! }
|
||||
//! ```
|
||||
//!
|
||||
//! The attribute and derive are re-exported by this facade; applications do
|
||||
//! not depend on the implementation-only `wip-interface-macros` crate.
|
||||
//!
|
||||
//! # Rust to protocol type mapping
|
||||
//!
|
||||
//! | Rust type | Protocol type/value |
|
||||
//! | --- | --- |
|
||||
//! | `()` as an operation result | no return declaration / no value |
|
||||
//! | `bool` | `Boolean` |
|
||||
//! | signed and unsigned integer primitives | JavaScript-lossless `Integer` |
|
||||
//! | `f32`, `f64` | finite `Number` |
|
||||
//! | `String` | `String` |
|
||||
//! | [`Bytes`] | `Bytes` |
|
||||
//! | [`wip_protocol::JsonValue`] | `Json` |
|
||||
//! | [`Entry<K, V>`] | `Entry<K, V>` |
|
||||
//! | `Vec<T>` | `List<T>` |
|
||||
//! | a named-field struct deriving [`WipType`] | named record |
|
||||
//! | an all-unit enum deriving [`WipType`] | named enum |
|
||||
//! | an all-newtype enum deriving [`WipType`] | named tagged union |
|
||||
//!
|
||||
//! `Option<T>` is supported only directly as a record field or operation
|
||||
//! parameter. It means omission, not a null value. A domain failure belongs in
|
||||
//! an application return enum/union and is returned as `Ok(value)`.
|
||||
//! [`HostError`] is reserved for host/runtime failure, so the required
|
||||
//! [`OperationResult`] convention keeps those two failure classes distinct.
|
||||
|
||||
#![deny(missing_docs)]
|
||||
|
||||
use std::error::Error;
|
||||
use std::fmt::{self, Display, Formatter};
|
||||
|
||||
pub use wip_interface_macros::{WipType, interface};
|
||||
pub use wip_protocol;
|
||||
pub use wip_protocol::{
|
||||
Documentation, EnumDeclaration, EnumVariantDeclaration, FieldDeclaration, InterfaceDescriptor,
|
||||
JsonMember, JsonValue, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER, NamedValue, OperationDeclaration,
|
||||
ParameterDeclaration, RecordDeclaration, ReturnDeclaration, TypeDeclaration, TypeExpr,
|
||||
UnionDeclaration, UnionVariantDeclaration, ValidationError, Value,
|
||||
};
|
||||
|
||||
/// Converts one Rust application type to and from its protocol representation.
|
||||
///
|
||||
/// Implementations must describe the same shape accepted by [`WipType::decode`]
|
||||
/// and produced by [`WipType::encode`]. Prefer deriving this trait for named
|
||||
/// DTOs. Its declaration-collection method exists for generated interface code
|
||||
/// and normally should not be called by applications.
|
||||
pub trait WipType: Sized {
|
||||
/// Returns the protocol type expression for this Rust type.
|
||||
fn type_expr() -> TypeExpr;
|
||||
|
||||
/// Adds named declarations reachable from this type to `declarations`.
|
||||
///
|
||||
/// Implementations must be cycle-safe and preserve declaration order.
|
||||
fn collect_declarations(declarations: &mut Vec<TypeDeclaration>);
|
||||
|
||||
/// Encodes this value into the transport-independent protocol value model.
|
||||
fn encode(self) -> Result<Value, CodecError>;
|
||||
|
||||
/// Decodes a previously validated protocol value.
|
||||
fn decode(value: Value) -> Result<Self, CodecError>;
|
||||
}
|
||||
|
||||
/// Static metadata implemented by every companion generated by
|
||||
/// [`interface`].
|
||||
pub trait InterfaceDefinition {
|
||||
/// Builds the interface descriptor solely from its trait declaration.
|
||||
fn descriptor() -> InterfaceDescriptor;
|
||||
}
|
||||
|
||||
/// Result convention required for generated interface operations.
|
||||
///
|
||||
/// `Ok(T)` is an application result, including domain-failure union cases.
|
||||
/// `Err(HostError)` means the host or runtime could not perform the operation.
|
||||
pub type OperationResult<T> = Result<T, HostError>;
|
||||
|
||||
/// A host/runtime failure, kept separate from the operation's application
|
||||
/// return type.
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct HostError {
|
||||
message: String,
|
||||
}
|
||||
|
||||
impl HostError {
|
||||
/// Creates a host failure with a human-readable diagnostic.
|
||||
#[must_use]
|
||||
pub fn new(message: impl Into<String>) -> Self {
|
||||
Self {
|
||||
message: message.into(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the diagnostic message.
|
||||
#[must_use]
|
||||
pub fn message(&self) -> &str {
|
||||
&self.message
|
||||
}
|
||||
}
|
||||
|
||||
impl Display for HostError {
|
||||
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
|
||||
formatter.write_str(&self.message)
|
||||
}
|
||||
}
|
||||
|
||||
impl Error for HostError {}
|
||||
|
||||
/// A failure while converting between a Rust value and a protocol [`Value`].
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct CodecError {
|
||||
path: Vec<String>,
|
||||
message: String,
|
||||
}
|
||||
|
||||
impl CodecError {
|
||||
/// Creates a codec failure at the current value.
|
||||
#[must_use]
|
||||
pub fn new(message: impl Into<String>) -> Self {
|
||||
Self {
|
||||
path: Vec::new(),
|
||||
message: message.into(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Creates a structural-kind mismatch diagnostic.
|
||||
#[must_use]
|
||||
pub fn expected(expected: &str, actual: &Value) -> Self {
|
||||
Self::new(format!("expected {expected}, found {:?}", actual.kind()))
|
||||
}
|
||||
|
||||
/// Prepends a field, variant, or collection position to the error path.
|
||||
#[must_use]
|
||||
pub fn at(mut self, segment: impl Into<String>) -> Self {
|
||||
self.path.insert(0, segment.into());
|
||||
self
|
||||
}
|
||||
|
||||
/// Returns the path from the decoded root to the failing value.
|
||||
#[must_use]
|
||||
pub fn path(&self) -> &[String] {
|
||||
&self.path
|
||||
}
|
||||
|
||||
/// Returns the human-readable reason for the failure.
|
||||
#[must_use]
|
||||
pub fn message(&self) -> &str {
|
||||
&self.message
|
||||
}
|
||||
}
|
||||
|
||||
impl Display for CodecError {
|
||||
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
|
||||
if self.path.is_empty() {
|
||||
write!(formatter, "WIP codec error: {}", self.message)
|
||||
} else {
|
||||
write!(
|
||||
formatter,
|
||||
"WIP codec error at {}: {}",
|
||||
self.path.join("."),
|
||||
self.message
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Error for CodecError {}
|
||||
|
||||
/// A failure produced by macro-generated typed operation dispatch.
|
||||
#[derive(Debug)]
|
||||
pub enum DispatchError {
|
||||
/// The requested operation is not declared by this interface.
|
||||
UnknownOperation(String),
|
||||
/// Protocol validation rejected the named arguments.
|
||||
InvalidArguments(wip_protocol::ValidationError),
|
||||
/// A validated value could not be decoded to its Rust type.
|
||||
Decode(CodecError),
|
||||
/// The implementation reported a host/runtime failure.
|
||||
Host(HostError),
|
||||
/// The Rust result could not be encoded.
|
||||
Encode(CodecError),
|
||||
/// The encoded result did not match the generated declaration.
|
||||
InvalidResult(wip_protocol::ValidationError),
|
||||
}
|
||||
|
||||
impl Display for DispatchError {
|
||||
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
Self::UnknownOperation(operation) => {
|
||||
write!(formatter, "unknown operation `{operation}`")
|
||||
}
|
||||
Self::InvalidArguments(error) => write!(formatter, "invalid arguments: {error}"),
|
||||
Self::Decode(error) => write!(formatter, "argument decoding failed: {error}"),
|
||||
Self::Host(error) => write!(formatter, "host operation failed: {error}"),
|
||||
Self::Encode(error) => write!(formatter, "result encoding failed: {error}"),
|
||||
Self::InvalidResult(error) => write!(formatter, "invalid operation result: {error}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Error for DispatchError {
|
||||
fn source(&self) -> Option<&(dyn Error + 'static)> {
|
||||
match self {
|
||||
Self::UnknownOperation(_) => None,
|
||||
Self::InvalidArguments(error) | Self::InvalidResult(error) => Some(error),
|
||||
Self::Decode(error) | Self::Encode(error) => Some(error),
|
||||
Self::Host(error) => Some(error),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// An explicitly byte-oriented sequence.
|
||||
///
|
||||
/// Use this wrapper when the protocol type must be `Bytes`; `Vec<T>` always
|
||||
/// denotes a protocol list, including `Vec<u8>`.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Default)]
|
||||
pub struct Bytes(pub Vec<u8>);
|
||||
|
||||
impl From<Vec<u8>> for Bytes {
|
||||
fn from(value: Vec<u8>) -> Self {
|
||||
Self(value)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<Bytes> for Vec<u8> {
|
||||
fn from(value: Bytes) -> Self {
|
||||
value.0
|
||||
}
|
||||
}
|
||||
|
||||
/// A typed protocol key/value entry.
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct Entry<K, V> {
|
||||
/// Entry key.
|
||||
pub key: K,
|
||||
/// Entry value.
|
||||
pub value: V,
|
||||
}
|
||||
|
||||
impl WipType for bool {
|
||||
fn type_expr() -> TypeExpr {
|
||||
TypeExpr::Boolean
|
||||
}
|
||||
|
||||
fn collect_declarations(_: &mut Vec<TypeDeclaration>) {}
|
||||
|
||||
fn encode(self) -> Result<Value, CodecError> {
|
||||
Ok(Value::Boolean(self))
|
||||
}
|
||||
|
||||
fn decode(value: Value) -> Result<Self, CodecError> {
|
||||
match value {
|
||||
Value::Boolean(value) => Ok(value),
|
||||
other => Err(CodecError::expected("boolean", &other)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! integer_codec {
|
||||
($($ty:ty),+ $(,)?) => {
|
||||
$(
|
||||
impl WipType for $ty {
|
||||
fn type_expr() -> TypeExpr {
|
||||
TypeExpr::Integer
|
||||
}
|
||||
|
||||
fn collect_declarations(_: &mut Vec<TypeDeclaration>) {}
|
||||
|
||||
fn encode(self) -> Result<Value, CodecError> {
|
||||
let value = i64::try_from(self).map_err(|_| {
|
||||
CodecError::new("integer is outside the protocol i64 range")
|
||||
})?;
|
||||
ensure_safe_integer(value)?;
|
||||
Ok(Value::Integer(value))
|
||||
}
|
||||
|
||||
fn decode(value: Value) -> Result<Self, CodecError> {
|
||||
let Value::Integer(value) = value else {
|
||||
return Err(CodecError::expected("integer", &value));
|
||||
};
|
||||
ensure_safe_integer(value)?;
|
||||
Self::try_from(value).map_err(|_| {
|
||||
CodecError::new(concat!("integer does not fit Rust `", stringify!($ty), "`"))
|
||||
})
|
||||
}
|
||||
}
|
||||
)+
|
||||
};
|
||||
}
|
||||
|
||||
integer_codec!(
|
||||
i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize
|
||||
);
|
||||
|
||||
fn ensure_safe_integer(value: i64) -> Result<(), CodecError> {
|
||||
if (MIN_SAFE_INTEGER..=MAX_SAFE_INTEGER).contains(&value) {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(CodecError::new(format!(
|
||||
"integer {value} is outside the JavaScript-lossless protocol range"
|
||||
)))
|
||||
}
|
||||
}
|
||||
|
||||
impl WipType for f64 {
|
||||
fn type_expr() -> TypeExpr {
|
||||
TypeExpr::Number
|
||||
}
|
||||
|
||||
fn collect_declarations(_: &mut Vec<TypeDeclaration>) {}
|
||||
|
||||
fn encode(self) -> Result<Value, CodecError> {
|
||||
ensure_finite(self)?;
|
||||
Ok(Value::Number(self))
|
||||
}
|
||||
|
||||
fn decode(value: Value) -> Result<Self, CodecError> {
|
||||
match value {
|
||||
Value::Number(value) => {
|
||||
ensure_finite(value)?;
|
||||
Ok(value)
|
||||
}
|
||||
other => Err(CodecError::expected("number", &other)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl WipType for f32 {
|
||||
fn type_expr() -> TypeExpr {
|
||||
TypeExpr::Number
|
||||
}
|
||||
|
||||
fn collect_declarations(_: &mut Vec<TypeDeclaration>) {}
|
||||
|
||||
fn encode(self) -> Result<Value, CodecError> {
|
||||
let value = f64::from(self);
|
||||
ensure_finite(value)?;
|
||||
Ok(Value::Number(value))
|
||||
}
|
||||
|
||||
fn decode(value: Value) -> Result<Self, CodecError> {
|
||||
let value = f64::decode(value)?;
|
||||
let narrowed = value as Self;
|
||||
if narrowed.is_finite() {
|
||||
Ok(narrowed)
|
||||
} else {
|
||||
Err(CodecError::new("number does not fit finite Rust `f32`"))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn ensure_finite(value: f64) -> Result<(), CodecError> {
|
||||
if value.is_finite() {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(CodecError::new("protocol numbers must be finite"))
|
||||
}
|
||||
}
|
||||
|
||||
impl WipType for String {
|
||||
fn type_expr() -> TypeExpr {
|
||||
TypeExpr::String
|
||||
}
|
||||
|
||||
fn collect_declarations(_: &mut Vec<TypeDeclaration>) {}
|
||||
|
||||
fn encode(self) -> Result<Value, CodecError> {
|
||||
Ok(Value::String(self))
|
||||
}
|
||||
|
||||
fn decode(value: Value) -> Result<Self, CodecError> {
|
||||
match value {
|
||||
Value::String(value) => Ok(value),
|
||||
other => Err(CodecError::expected("string", &other)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl WipType for Bytes {
|
||||
fn type_expr() -> TypeExpr {
|
||||
TypeExpr::Bytes
|
||||
}
|
||||
|
||||
fn collect_declarations(_: &mut Vec<TypeDeclaration>) {}
|
||||
|
||||
fn encode(self) -> Result<Value, CodecError> {
|
||||
Ok(Value::Bytes(self.0))
|
||||
}
|
||||
|
||||
fn decode(value: Value) -> Result<Self, CodecError> {
|
||||
match value {
|
||||
Value::Bytes(value) => Ok(Self(value)),
|
||||
other => Err(CodecError::expected("bytes", &other)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl WipType for JsonValue {
|
||||
fn type_expr() -> TypeExpr {
|
||||
TypeExpr::Json
|
||||
}
|
||||
|
||||
fn collect_declarations(_: &mut Vec<TypeDeclaration>) {}
|
||||
|
||||
fn encode(self) -> Result<Value, CodecError> {
|
||||
validate_json(&self)?;
|
||||
Ok(Value::Json(self))
|
||||
}
|
||||
|
||||
fn decode(value: Value) -> Result<Self, CodecError> {
|
||||
match value {
|
||||
Value::Json(value) => {
|
||||
validate_json(&value)?;
|
||||
Ok(value)
|
||||
}
|
||||
other => Err(CodecError::expected("json", &other)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn validate_json(value: &JsonValue) -> Result<(), CodecError> {
|
||||
match value {
|
||||
JsonValue::Integer(value) => ensure_safe_integer(*value),
|
||||
JsonValue::Number(value) => ensure_finite(*value),
|
||||
JsonValue::Array(values) => {
|
||||
for (index, value) in values.iter().enumerate() {
|
||||
validate_json(value).map_err(|error| error.at(index.to_string()))?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
JsonValue::Object(members) => {
|
||||
let mut names = std::collections::HashSet::new();
|
||||
for member in members {
|
||||
if !names.insert(member.name.as_str()) {
|
||||
return Err(CodecError::new(format!(
|
||||
"duplicate JSON member `{}`",
|
||||
member.name
|
||||
))
|
||||
.at(member.name.clone()));
|
||||
}
|
||||
validate_json(&member.value).map_err(|error| error.at(member.name.clone()))?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
JsonValue::Null | JsonValue::Boolean(_) | JsonValue::String(_) => Ok(()),
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: WipType> WipType for Vec<T> {
|
||||
fn type_expr() -> TypeExpr {
|
||||
TypeExpr::List(Box::new(T::type_expr()))
|
||||
}
|
||||
|
||||
fn collect_declarations(declarations: &mut Vec<TypeDeclaration>) {
|
||||
T::collect_declarations(declarations);
|
||||
}
|
||||
|
||||
fn encode(self) -> Result<Value, CodecError> {
|
||||
self.into_iter()
|
||||
.enumerate()
|
||||
.map(|(index, value)| value.encode().map_err(|error| error.at(index.to_string())))
|
||||
.collect::<Result<Vec<_>, _>>()
|
||||
.map(Value::List)
|
||||
}
|
||||
|
||||
fn decode(value: Value) -> Result<Self, CodecError> {
|
||||
let Value::List(values) = value else {
|
||||
return Err(CodecError::expected("list", &value));
|
||||
};
|
||||
values
|
||||
.into_iter()
|
||||
.enumerate()
|
||||
.map(|(index, value)| T::decode(value).map_err(|error| error.at(index.to_string())))
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
|
||||
impl<K: WipType, V: WipType> WipType for Entry<K, V> {
|
||||
fn type_expr() -> TypeExpr {
|
||||
TypeExpr::Entry {
|
||||
key: Box::new(K::type_expr()),
|
||||
value: Box::new(V::type_expr()),
|
||||
}
|
||||
}
|
||||
|
||||
fn collect_declarations(declarations: &mut Vec<TypeDeclaration>) {
|
||||
K::collect_declarations(declarations);
|
||||
V::collect_declarations(declarations);
|
||||
}
|
||||
|
||||
fn encode(self) -> Result<Value, CodecError> {
|
||||
Ok(Value::Entry {
|
||||
key: Box::new(self.key.encode().map_err(|error| error.at("key"))?),
|
||||
value: Box::new(self.value.encode().map_err(|error| error.at("value"))?),
|
||||
})
|
||||
}
|
||||
|
||||
fn decode(value: Value) -> Result<Self, CodecError> {
|
||||
let Value::Entry { key, value } = value else {
|
||||
return Err(CodecError::expected("entry", &value));
|
||||
};
|
||||
Ok(Self {
|
||||
key: K::decode(*key).map_err(|error| error.at("key"))?,
|
||||
value: V::decode(*value).map_err(|error| error.at("value"))?,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Implementation details used by code emitted from the facade's macros.
|
||||
///
|
||||
/// These APIs are public only because macro expansions execute in the
|
||||
/// application crate. They are excluded from normal generated documentation
|
||||
/// and are not intended for direct use.
|
||||
#[doc(hidden)]
|
||||
pub mod __private {
|
||||
use std::collections::HashSet;
|
||||
|
||||
use wip_protocol::{
|
||||
InterfaceDescriptor, NamedValue, ObjectId, OperationCall, OperationTarget, TypeDeclaration,
|
||||
ValidationError, Value,
|
||||
};
|
||||
|
||||
use crate::{CodecError, Documentation, WipType};
|
||||
|
||||
/// Builds optional descriptor documentation from generated string literals.
|
||||
pub fn documentation(summary: &str, details: Option<&str>) -> Option<Documentation> {
|
||||
if summary.is_empty() && details.is_none() {
|
||||
None
|
||||
} else {
|
||||
Some(Documentation {
|
||||
summary: summary.into(),
|
||||
details: details.map(str::to_owned),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Registers one declaration and reports whether its dependencies should
|
||||
/// be traversed. Identical declarations are deduplicated; a conflicting
|
||||
/// declaration with the same name is retained for protocol validation.
|
||||
pub fn register_declaration(
|
||||
declarations: &mut Vec<TypeDeclaration>,
|
||||
declaration: TypeDeclaration,
|
||||
) -> bool {
|
||||
if declarations.iter().any(|existing| existing == &declaration) {
|
||||
false
|
||||
} else {
|
||||
declarations.push(declaration);
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
/// Validates named arguments against one generated operation declaration.
|
||||
pub fn validate_arguments(
|
||||
descriptor: &InterfaceDescriptor,
|
||||
operation: &str,
|
||||
arguments: &[NamedValue],
|
||||
) -> Result<(), ValidationError> {
|
||||
descriptor.validate_call(&OperationCall {
|
||||
target: OperationTarget {
|
||||
object: ObjectId("<typed-dispatch>".into()),
|
||||
interface: descriptor.name.clone(),
|
||||
operation: operation.into(),
|
||||
},
|
||||
arguments: arguments.to_vec(),
|
||||
})
|
||||
}
|
||||
|
||||
/// Builds a codec error for a generated structural mismatch.
|
||||
pub fn decode_type_mismatch(expected: &str, actual: Value) -> CodecError {
|
||||
CodecError::expected(expected, &actual)
|
||||
}
|
||||
|
||||
/// Builds a codec error for an unknown generated enum or union variant.
|
||||
pub fn decode_unknown_variant(type_name: &str, variant: String) -> CodecError {
|
||||
CodecError::new(format!(
|
||||
"unknown variant `{variant}` for WIP type `{type_name}`"
|
||||
))
|
||||
.at(variant)
|
||||
}
|
||||
|
||||
/// Decoder for a protocol record or operation's named argument collection.
|
||||
pub struct RecordDecoder {
|
||||
fields: Vec<NamedValue>,
|
||||
seen: HashSet<String>,
|
||||
}
|
||||
|
||||
impl RecordDecoder {
|
||||
/// Starts decoding record fields or named operation arguments and
|
||||
/// rejects duplicate names.
|
||||
pub fn new(fields: Vec<NamedValue>) -> Result<Self, CodecError> {
|
||||
let mut seen = HashSet::new();
|
||||
for field in &fields {
|
||||
if !seen.insert(field.name.clone()) {
|
||||
return Err(CodecError::new(format!("duplicate field `{}`", field.name))
|
||||
.at(field.name.clone()));
|
||||
}
|
||||
}
|
||||
Ok(Self { fields, seen })
|
||||
}
|
||||
|
||||
/// Decodes a required field.
|
||||
pub fn required<T: WipType>(&mut self, name: &str) -> Result<T, CodecError> {
|
||||
let value = self.take(name).ok_or_else(|| {
|
||||
CodecError::new(format!("missing required field `{name}`")).at(name)
|
||||
})?;
|
||||
T::decode(value).map_err(|error| error.at(name))
|
||||
}
|
||||
|
||||
/// Decodes an optional field, where absence maps to `None`.
|
||||
pub fn optional<T: WipType>(&mut self, name: &str) -> Result<Option<T>, CodecError> {
|
||||
self.take(name)
|
||||
.map(T::decode)
|
||||
.transpose()
|
||||
.map_err(|error| error.at(name))
|
||||
}
|
||||
|
||||
/// Rejects any fields that were not consumed by generated code.
|
||||
pub fn finish(self) -> Result<(), CodecError> {
|
||||
if let Some(field) = self.fields.first() {
|
||||
Err(CodecError::new(format!("unknown field `{}`", field.name))
|
||||
.at(field.name.clone()))
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn take(&mut self, name: &str) -> Option<Value> {
|
||||
let index = self.fields.iter().position(|field| field.name == name)?;
|
||||
Some(self.fields.remove(index).value)
|
||||
}
|
||||
|
||||
/// Returns the set of names supplied to this decoder.
|
||||
#[allow(dead_code)]
|
||||
pub fn supplied_names(&self) -> &HashSet<String> {
|
||||
&self.seen
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user