haveapi-rust-client 0.30.0

data/runtime/src/runtime/transport.rs

@@ -0,0 +1,152 @@
+use std::fmt;
+
+use crate::runtime::{ClientConfig, Error, PreparedRequest, RawResponse};
+
+mod private {
+    pub trait Sealed {}
+}
+
+pub trait Mode: private::Sealed {}
+
+#[derive(Clone)]
+pub struct AsyncTransport {
+    client: reqwest::Client,
+    max_response_bytes: usize,
+}
+
+impl private::Sealed for AsyncTransport {}
+impl Mode for AsyncTransport {}
+
+impl AsyncTransport {
+    pub fn new(config: &ClientConfig) -> Result<Self, Error> {
+        let client = reqwest::Client::builder()
+            .redirect(reqwest::redirect::Policy::none())
+            .retry(reqwest::retry::never())
+            .timeout(config.timeout)
+            .connect_timeout(config.connect_timeout)
+            .build()
+            .map_err(|_| Error::configuration("could not construct the HTTP client"))?;
+        Ok(Self {
+            client,
+            max_response_bytes: config.max_response_bytes,
+        })
+    }
+
+    pub async fn execute(&self, request: PreparedRequest) -> Result<RawResponse, Error> {
+        let mut builder = self
+            .client
+            .request(request.method.reqwest(), request.url)
+            .headers(request.headers);
+        if let Some(body) = request.body {
+            builder = builder.body(body);
+        }
+        let mut response = builder.send().await.map_err(Error::transport)?;
+        let status = response.status().as_u16();
+        if response
+            .content_length()
+            .is_some_and(|length| length > self.max_response_bytes as u64)
+        {
+            return Err(Error::ResponseTooLarge {
+                limit: self.max_response_bytes,
+            });
+        }
+        let mut body = Vec::new();
+        while let Some(chunk) = response.chunk().await.map_err(Error::transport)? {
+            if chunk.len() > self.max_response_bytes.saturating_sub(body.len()) {
+                return Err(Error::ResponseTooLarge {
+                    limit: self.max_response_bytes,
+                });
+            }
+            body.extend_from_slice(&chunk);
+        }
+        Ok(RawResponse { status, body })
+    }
+}
+
+#[cfg(feature = "blocking")]
+#[derive(Clone)]
+pub struct BlockingTransport {
+    client: reqwest::blocking::Client,
+    max_response_bytes: usize,
+}
+
+#[cfg(feature = "blocking")]
+impl private::Sealed for BlockingTransport {}
+#[cfg(feature = "blocking")]
+impl Mode for BlockingTransport {}
+
+#[cfg(feature = "blocking")]
+impl BlockingTransport {
+    pub fn new(config: &ClientConfig) -> Result<Self, Error> {
+        let client = reqwest::blocking::Client::builder()
+            .redirect(reqwest::redirect::Policy::none())
+            .retry(reqwest::retry::never())
+            .timeout(config.timeout)
+            .connect_timeout(config.connect_timeout)
+            .build()
+            .map_err(|_| Error::configuration("could not construct the blocking HTTP client"))?;
+        Ok(Self {
+            client,
+            max_response_bytes: config.max_response_bytes,
+        })
+    }
+
+    pub fn execute(&self, request: PreparedRequest) -> Result<RawResponse, Error> {
+        use std::io::Read;
+
+        let mut builder = self
+            .client
+            .request(request.method.reqwest(), request.url)
+            .headers(request.headers);
+        if let Some(body) = request.body {
+            builder = builder.body(body);
+        }
+        let mut response = builder.send().map_err(Error::transport)?;
+        let status = response.status().as_u16();
+        if response
+            .content_length()
+            .is_some_and(|length| length > self.max_response_bytes as u64)
+        {
+            return Err(Error::ResponseTooLarge {
+                limit: self.max_response_bytes,
+            });
+        }
+        let mut body = Vec::new();
+        let mut buffer = [0; 8192];
+        loop {
+            let remaining = self.max_response_bytes.saturating_sub(body.len());
+            let to_read = buffer.len().min(remaining.saturating_add(1));
+            let length = response.read(&mut buffer[..to_read]).map_err(|error| {
+                // reqwest wraps body failures in io::Error while preserving its source.
+                let timeout = error.kind() == std::io::ErrorKind::TimedOut
+                    || error
+                        .get_ref()
+                        .and_then(|source| source.downcast_ref::<reqwest::Error>())
+                        .is_some_and(reqwest::Error::is_timeout);
+                Error::Transport { timeout }
+            })?;
+            if length == 0 {
+                break;
+            }
+            if length > remaining {
+                return Err(Error::ResponseTooLarge {
+                    limit: self.max_response_bytes,
+                });
+            }
+            body.extend_from_slice(&buffer[..length]);
+        }
+        Ok(RawResponse { status, body })
+    }
+}
+
+impl fmt::Debug for AsyncTransport {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("AsyncTransport { [REDACTED] }")
+    }
+}
+#[cfg(feature = "blocking")]
+impl fmt::Debug for BlockingTransport {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("BlockingTransport { [REDACTED] }")
+    }
+}

data/runtime/src/runtime/types.rs

@@ -0,0 +1,219 @@
+use std::{collections::BTreeMap, fmt};
+
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde_json::Value;
+
+pub type JsonMap = serde_json::Map<String, Value>;
+pub type ValidationErrors = BTreeMap<String, Vec<String>>;
+
+/// An omitted input, an explicit null, or an explicitly supplied value.
+#[derive(Clone, Default, PartialEq, Eq)]
+pub enum InputValue<T> {
+    #[default]
+    Unset,
+    Null,
+    Value(T),
+}
+
+pub type Input<T> = InputValue<T>;
+
+impl<T> InputValue<T> {
+    pub fn is_unset(&self) -> bool {
+        matches!(self, Self::Unset)
+    }
+}
+
+impl<T> fmt::Debug for InputValue<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            Self::Unset => "Unset",
+            Self::Null => "Null",
+            Self::Value(_) => "Value([REDACTED])",
+        })
+    }
+}
+
+impl<T: Serialize> Serialize for InputValue<T> {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        match self {
+            Self::Unset | Self::Null => serializer.serialize_none(),
+            Self::Value(value) => value.serialize(serializer),
+        }
+    }
+}
+
+impl<'de, T: Deserialize<'de>> Deserialize<'de> for InputValue<T> {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        Ok(match Option::<T>::deserialize(deserializer)? {
+            None => Self::Null,
+            Some(value) => Self::Value(value),
+        })
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Method {
+    Get,
+    Delete,
+    Post,
+    Put,
+    Patch,
+}
+
+impl Method {
+    pub(crate) fn reqwest(self) -> reqwest::Method {
+        match self {
+            Self::Get => reqwest::Method::GET,
+            Self::Delete => reqwest::Method::DELETE,
+            Self::Post => reqwest::Method::POST,
+            Self::Put => reqwest::Method::PUT,
+            Self::Patch => reqwest::Method::PATCH,
+        }
+    }
+
+    pub(crate) fn query(self) -> bool {
+        // The HaveAPI server reads DELETE action input from its JSON body.
+        matches!(self, Self::Get)
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Layout {
+    Object,
+    ObjectList,
+    Hash,
+    HashList,
+}
+
+impl Layout {
+    pub(crate) fn list(self) -> bool {
+        matches!(self, Self::ObjectList | Self::HashList)
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ParameterKind {
+    String,
+    Text,
+    Integer,
+    Float,
+    Boolean,
+    Datetime,
+    Resource,
+    Custom,
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum RequestAuth {
+    Configured,
+    None,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct ParameterSpec {
+    pub name: &'static str,
+    pub kind: ParameterKind,
+    pub required: bool,
+    pub nullable: bool,
+    pub protected: bool,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct InputSpec {
+    pub layout: Layout,
+    pub namespace: Option<&'static str>,
+    pub parameters: &'static [ParameterSpec],
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct OutputSpec {
+    pub layout: Layout,
+    pub namespace: &'static str,
+    pub allow_empty_response: bool,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct ActionSpec {
+    pub name: &'static str,
+    pub method: Method,
+    pub path: &'static str,
+    pub input: Option<InputSpec>,
+    pub output: Option<OutputSpec>,
+    pub meta_namespace: Option<&'static str>,
+    pub global_meta: &'static [ParameterSpec],
+    pub object_meta: &'static [ParameterSpec],
+    pub auth: RequestAuth,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct ApiSpec {
+    pub api_version: &'static str,
+    pub protocol_major: u16,
+    pub schema_sha256: &'static str,
+    pub basic_auth: bool,
+    pub token_header: Option<&'static str>,
+    pub oauth2_header: Option<&'static str>,
+}
+
+#[derive(Default)]
+pub struct RequestParts {
+    pub path_params: BTreeMap<String, String>,
+    pub input: Option<Value>,
+    pub global_meta: Option<JsonMap>,
+    pub object_meta: Option<JsonMap>,
+}
+
+pub struct PreparedRequest {
+    pub method: Method,
+    pub url: url::Url,
+    pub headers: reqwest::header::HeaderMap,
+    pub body: Option<Vec<u8>>,
+}
+
+pub struct RawResponse {
+    pub status: u16,
+    pub body: Vec<u8>,
+}
+pub struct Response<T, M> {
+    pub output: T,
+    pub meta: M,
+    pub http_status: u16,
+}
+
+macro_rules! redacted_debug {
+    ($name:ty, $label:literal) => {
+        impl fmt::Debug for $name {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                f.write_str(concat!($label, " { [REDACTED] }"))
+            }
+        }
+    };
+}
+redacted_debug!(RequestParts, "RequestParts");
+redacted_debug!(PreparedRequest, "PreparedRequest");
+redacted_debug!(RawResponse, "RawResponse");
+
+impl<T, M> fmt::Debug for Response<T, M> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Response")
+            .field("http_status", &self.http_status)
+            .finish_non_exhaustive()
+    }
+}
+
+/// A partial or expanded resource association, without implied network access.
+#[derive(Clone, Default, PartialEq, Serialize, Deserialize)]
+#[serde(transparent)]
+pub struct Association(JsonMap);
+
+impl Association {
+    pub fn as_map(&self) -> &JsonMap {
+        &self.0
+    }
+}
+
+impl From<JsonMap> for Association {
+    fn from(value: JsonMap) -> Self {
+        Self(value)
+    }
+}
+redacted_debug!(Association, "Association");

data/runtime/src/runtime/validation.rs

@@ -0,0 +1,213 @@
+use serde_json::Value;
+
+use crate::runtime::{
+    Association, Error, InputValue, JsonMap, ParameterKind, ParameterSpec, ValidationErrors,
+};
+
+/// Validation must precede Serde conversion, which would turn nonfinite floats into null.
+pub trait Validate {
+    fn validate(&self) -> Result<(), Error>;
+}
+
+impl<T: Validate> Validate for InputValue<T> {
+    fn validate(&self) -> Result<(), Error> {
+        match self {
+            Self::Value(value) => value.validate(),
+            _ => Ok(()),
+        }
+    }
+}
+
+impl<T: Validate> Validate for Vec<T> {
+    fn validate(&self) -> Result<(), Error> {
+        self.iter().try_for_each(Validate::validate)
+    }
+}
+
+impl Validate for f64 {
+    fn validate(&self) -> Result<(), Error> {
+        if self.is_finite() {
+            Ok(())
+        } else {
+            Err(Error::validation("input", "not a valid finite float"))
+        }
+    }
+}
+
+macro_rules! valid_types {
+    ($($ty:ty),*) => { $(impl Validate for $ty { fn validate(&self) -> Result<(), Error> { Ok(()) } })* };
+}
+valid_types!((), String, i64, bool, Value, Association);
+
+pub(crate) fn validate_map(
+    map: &JsonMap,
+    specs: &[ParameterSpec],
+    prefix: &str,
+) -> Result<(), Error> {
+    let mut errors = ValidationErrors::new();
+    for spec in specs {
+        let problem = match map.get(spec.name) {
+            None if spec.required => Some("is required"),
+            None => None,
+            Some(Value::Null) if !spec.nullable || spec.required => Some("cannot be null"),
+            Some(Value::Null) => None,
+            Some(value) => validate_kind(value, spec.kind),
+        };
+        if let Some(message) = problem {
+            errors.insert(format!("{prefix}{}", spec.name), vec![message.to_owned()]);
+        }
+    }
+    for name in map.keys() {
+        if !specs.iter().any(|spec| spec.name == name) {
+            errors.insert(
+                format!("{prefix}{name}"),
+                vec!["is not a described parameter".to_owned()],
+            );
+        }
+    }
+    if errors.is_empty() {
+        Ok(())
+    } else {
+        Err(Error::Validation { errors })
+    }
+}
+
+fn validate_kind(value: &Value, kind: ParameterKind) -> Option<&'static str> {
+    let (valid, message) = match kind {
+        ParameterKind::String | ParameterKind::Text => (value.is_string(), "not a valid string"),
+        ParameterKind::Integer => (value.as_i64().is_some(), "not a valid integer"),
+        ParameterKind::Float => (
+            value.as_f64().is_some_and(f64::is_finite),
+            "not a valid finite float",
+        ),
+        ParameterKind::Boolean => (value.is_boolean(), "not a valid boolean"),
+        ParameterKind::Datetime => (
+            value.as_str().is_some_and(valid_datetime),
+            "not in ISO 8601 format",
+        ),
+        ParameterKind::Resource => (
+            value.as_i64().is_some_and(|id| id >= 0),
+            "not a valid resource ID",
+        ),
+        ParameterKind::Custom => (true, ""),
+    };
+    if valid { None } else { Some(message) }
+}
+
+// Match the documented HaveAPI wire grammar, including date-only values and
+// shortened times. A pure RFC3339 parser would reject supported values.
+fn valid_datetime(value: &str) -> bool {
+    let bytes = value.as_bytes();
+    if bytes.len() < 10 || bytes[4] != b'-' || bytes[7] != b'-' {
+        return false;
+    }
+    let (Some(year), Some(month), Some(day)) = (
+        digits(&bytes[0..4]),
+        digits(&bytes[5..7]),
+        digits(&bytes[8..10]),
+    ) else {
+        return false;
+    };
+    let leap = year.is_multiple_of(4) && (!year.is_multiple_of(100) || year.is_multiple_of(400));
+    let days = match month {
+        1 | 3 | 5 | 7 | 8 | 10 | 12 => 31,
+        4 | 6 | 9 | 11 => 30,
+        2 if leap => 29,
+        2 => 28,
+        _ => return false,
+    };
+    if year == 0 || day == 0 || day > days {
+        return false;
+    }
+    if bytes.len() == 10 {
+        return true;
+    }
+    if bytes.len() < 17 || bytes[10] != b'T' || bytes[13] != b':' {
+        return false;
+    }
+    if !digits(&bytes[11..13]).is_some_and(|hour| hour <= 23)
+        || !digits(&bytes[14..16]).is_some_and(|minute| minute <= 59)
+    {
+        return false;
+    }
+    let mut cursor = 16;
+    if bytes.get(cursor) == Some(&b':') {
+        if bytes.len() < cursor + 3
+            || !digits(&bytes[cursor + 1..cursor + 3]).is_some_and(|second| second <= 59)
+        {
+            return false;
+        }
+        cursor += 3;
+        if bytes.get(cursor) == Some(&b'.') {
+            cursor += 1;
+            let start = cursor;
+            while bytes.get(cursor).is_some_and(u8::is_ascii_digit) {
+                cursor += 1;
+            }
+            if cursor == start {
+                return false;
+            }
+        }
+    }
+    let zone = &bytes[cursor..];
+    if zone == b"Z" {
+        return true;
+    }
+    if !matches!(zone.first(), Some(b'+' | b'-')) {
+        return false;
+    }
+    let (hour, minute) = match zone.len() {
+        5 => (digits(&zone[1..3]), digits(&zone[3..5])),
+        6 if zone[3] == b':' => (digits(&zone[1..3]), digits(&zone[4..6])),
+        _ => return false,
+    };
+    hour.is_some_and(|hour| hour <= 23) && minute.is_some_and(|minute| minute <= 59)
+}
+
+fn digits(bytes: &[u8]) -> Option<u32> {
+    bytes.iter().try_fold(0, |acc, digit| {
+        if digit.is_ascii_digit() {
+            Some(acc * 10 + u32::from(digit - b'0'))
+        } else {
+            None
+        }
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn datetime_grammar_and_calendar() {
+        for value in [
+            "2020-02-29",
+            "2020-01-31T10:20Z",
+            "2020-01-31T10:20+01:30",
+            "2020-01-31T10:20:30.123-0500",
+            "2000-02-29T23:59:59Z",
+        ] {
+            assert!(valid_datetime(value), "{value}");
+        }
+        for value in [
+            "",
+            "2020/01/31",
+            "1900-02-29",
+            "2020-02-30",
+            "0000-01-01",
+            "2020-00-01",
+            "2020-01-00",
+            "2020-01-31T10:20",
+            "2020-01-31T24:00Z",
+            "2020-01-31T10:60Z",
+            "2020-01-31T10:20:60Z",
+            "2020-01-31T10:20:30.Z",
+            "2020-01-31T10:20+2400",
+            "2020-01-31T10:20+0060",
+            "2020-01-31T10:20Zx",
+            "２０２０-01-31",
+        ] {
+            assert!(!valid_datetime(value), "{value}");
+        }
+    }
+}

data/template/Cargo.toml.erb

@@ -0,0 +1,19 @@
+[package]
+name = "<%= config.fetch('crate_name') %>"
+version = "<%= config.fetch('crate_version') %>"
+license = "<%= config.fetch('license') %>"
+edition = "<%= config.fetch('edition') %>"
+rust-version = "<%= config.fetch('rust_version') %>"
+
+[features]
+default = []
+blocking = ["reqwest/blocking"]
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+url = "2.5"
+reqwest = { version = "0.13.5", default-features = false, features = ["json", "rustls"] }
+
+[dev-dependencies]
+tokio = { version = "1", features = ["macros", "rt-multi-thread"] }

data/template/action.rs.erb

@@ -0,0 +1,103 @@
+use crate::runtime;
+
+<% if action[:input] -%>
+#[derive(Default, serde::Serialize)]
+pub struct Input {
+<% action[:input][:parameters].each do |parameter| -%>
+    #[serde(rename = <%= generator.literal(parameter[:name]) %>, skip_serializing_if = "runtime::InputValue::is_unset")]
+    pub <%= parameter[:field] %>: runtime::InputValue<<%= generator.rust_type(parameter) %>>,
+<% end -%>
+}
+impl runtime::Validate for Input {
+    fn validate(&self) -> Result<(), runtime::Error> {
+<% action[:input][:parameters].each do |parameter| -%>
+        runtime::Validate::validate(&self.<%= parameter[:field] %>)?;
+<% end -%>
+        Ok(())
+    }
+}
+<% end -%>
+<% if action[:output] -%>
+#[derive(Default, serde::Deserialize)]
+#[non_exhaustive]
+pub struct Output {
+<% action[:output][:parameters].each do |parameter| -%>
+<% if parameter[:desc]['type'] == 'Resource' -%>
+    #[doc = <%= generator.literal("Association keys: ID=#{parameter[:desc]['value_id']}, label=#{parameter[:desc]['value_label']}") %>]
+<% end -%>
+    #[serde(default, rename = <%= generator.literal(parameter[:name]) %>)]
+    pub <%= parameter[:field] %>: Option<<%= generator.rust_type(parameter, output: true) %>>,
+<% end -%>
+    #[serde(default, rename = <%= generator.literal(schema.dig('description', 'meta', 'namespace')) %>)]
+    pub object_meta: Option<runtime::JsonMap>,
+    #[serde(flatten)]
+    pub extra: runtime::JsonMap,
+}
+<% if action[:auth_provider] == 'token' && %w[complete token next_action].all? { |name| action[:output][:parameters].any? { |parameter| parameter[:name] == name } } -%>
+impl Output {
+    pub fn token_step(&self) -> Result<runtime::TokenStep, runtime::Error> {
+        // Missing complete is inconsistent; force the checked protocol-error path.
+        let complete = match self.complete {
+            Some(value) => value,
+            None => return runtime::TokenStep::from_parts(true, None, None, &[]),
+        };
+        runtime::TokenStep::from_parts(complete, self.token.clone(), self.next_action.clone(), &[<%= action[:resource][:actions].select { |item| item[:desc]['auth'] == false }.map { |item| generator.literal(item[:name]) }.join(',') %>])
+    }
+}
+<% end -%>
+<% end -%>
+#[derive(Default, serde::Deserialize)]
+#[non_exhaustive]
+pub struct Meta {
+<% generator.meta_parameters(action).each do |parameter| -%>
+    #[serde(default, rename = <%= generator.literal(parameter[:name]) %>)]
+    pub <%= parameter[:field] %>: Option<<%= generator.rust_type(parameter, output: true) %>>,
+<% end -%>
+    #[serde(flatten)]
+    pub extra: runtime::JsonMap,
+}
+
+pub static SPEC: runtime::ActionSpec = runtime::ActionSpec {
+    name: <%= generator.literal(action[:path].join('/')) %>,
+    method: runtime::Method::<%= action[:desc].fetch('method').capitalize %>,
+    path: <%= generator.literal(action[:route]) %>,
+<% if action[:input] -%>
+    input: Some(runtime::InputSpec {
+        layout: runtime::Layout::<%= generator.layout(action[:input][:layout]) %>,
+        namespace: <%= generator.option(action[:input][:namespace]) %>,
+        parameters: <%= generator.parameter_specs(action[:input]) %>,
+    }),
+<% else -%>
+    input: None,
+<% end -%>
+<% if action[:output] -%>
+    output: Some(runtime::OutputSpec {
+        layout: runtime::Layout::<%= generator.layout(action[:output][:layout]) %>,
+        namespace: <%= generator.literal(action[:output][:namespace]) %>,
+        allow_empty_response: <%= %w[object hash].include?(action[:output][:layout]) && action[:output][:parameters].empty? %>,
+    }),
+<% else -%>
+    output: None,
+<% end -%>
+    meta_namespace: <%= generator.option(schema.dig('description', 'meta', 'namespace')) %>,
+    global_meta: <%= generator.parameter_specs(action[:global_input]) %>,
+    object_meta: <%= generator.parameter_specs(action[:object_input]) %>,
+    auth: runtime::RequestAuth::<%= action[:auth_provider] == 'token' && action[:desc]['auth'] == false ? 'None' : 'Configured' %>,
+};
+<% if action[:input] && !action[:input][:layout].end_with?('_list') -%>
+impl<'a, C: runtime::Mode> runtime::Request<'a, C, Input, <%= generator.output_type(action) %>, Meta> {
+<% action[:input][:parameters].each do |parameter| -%>
+<% type = generator.rust_type(parameter) -%>
+    pub fn <%= parameter[:field] %>(mut self, value: <%= type == 'String' ? 'impl Into<String>' : type %>) -> Self {
+        self.input_mut().<%= parameter[:field] %> = runtime::InputValue::Value(value<%= type == 'String' ? '.into()' : '' %>);
+        self
+    }
+<% if parameter[:desc]['nullable'] == true -%>
+    pub fn <%= parameter[:field] %>_null(mut self) -> Self {
+        self.input_mut().<%= parameter[:field] %> = runtime::InputValue::Null;
+        self
+    }
+<% end -%>
+<% end -%>
+}
+<% end -%>