268 lines
9.0 KiB
Rust
268 lines
9.0 KiB
Rust
use std::collections::BTreeMap;
|
|
|
|
use crank_core::Target;
|
|
use crank_schema::{SchemaError, SchemaKind};
|
|
use serde_json::Value;
|
|
|
|
use crate::{PreparedRequest, RuntimeError, RuntimeOperation};
|
|
|
|
/// Validates the imported `content_type`/`body` pair before mapping. The
|
|
/// public schema exposes the union of supported body shapes, while this check
|
|
/// binds the selected media type to its corresponding branch.
|
|
pub(crate) fn validate_selected_body_variant(
|
|
operation: &RuntimeOperation,
|
|
input: &Value,
|
|
) -> Result<(), RuntimeError> {
|
|
let Target::Rest(target) = &operation.target;
|
|
let Some(contract) = &target.request_contract else {
|
|
return Ok(());
|
|
};
|
|
let Some(input) = input.as_object() else {
|
|
return Ok(());
|
|
};
|
|
let body_field = contract.body_field.as_str();
|
|
let Some(selector_field) = contract.selector_field.as_deref() else {
|
|
if contract.body_required && !input.contains_key(body_field) {
|
|
return Err(RuntimeError::InputSchema(SchemaError::missing_field(
|
|
format!("$.{body_field}"),
|
|
)));
|
|
}
|
|
return Ok(());
|
|
};
|
|
match (input.get(selector_field), input.get(body_field)) {
|
|
(None, None) if !contract.body_required => Ok(()),
|
|
(_, None) => Err(RuntimeError::InputSchema(SchemaError::missing_field(
|
|
format!("$.{body_field}"),
|
|
))),
|
|
(None, Some(_)) => Err(RuntimeError::InputSchema(SchemaError::missing_field(
|
|
format!("$.{selector_field}"),
|
|
))),
|
|
(Some(selector), Some(_)) => {
|
|
let Some(selector) = selector.as_str() else {
|
|
return Err(RuntimeError::InputSchema(SchemaError::invalid_type(
|
|
format!("$.{selector_field}"),
|
|
"enum",
|
|
"non-string",
|
|
)));
|
|
};
|
|
let Some(descriptor) = contract
|
|
.variants
|
|
.iter()
|
|
.find(|variant| variant.media_type == selector)
|
|
else {
|
|
return Err(RuntimeError::InputSchema(SchemaError::invalid_enum_value(
|
|
format!("$.{selector_field}"),
|
|
contract
|
|
.variants
|
|
.iter()
|
|
.map(|variant| variant.media_type.clone())
|
|
.collect(),
|
|
selector,
|
|
)));
|
|
};
|
|
let selected_schema = if operation.input_schema.kind == SchemaKind::Oneof {
|
|
operation
|
|
.input_schema
|
|
.variants
|
|
.get(descriptor.schema_variant)
|
|
.ok_or(RuntimeError::InvalidExecutionRequest)?
|
|
} else if descriptor.schema_variant == 0 {
|
|
&operation.input_schema
|
|
} else {
|
|
return Err(RuntimeError::InvalidExecutionRequest);
|
|
};
|
|
selected_schema
|
|
.validate_shape(&Value::Object(input.clone()))
|
|
.map_err(RuntimeError::InputSchema)
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PreparedRequest {
|
|
pub fn from_mapping_output(mapped: &Value, target: &Target) -> Result<Self, RuntimeError> {
|
|
let request =
|
|
mapped
|
|
.get("request")
|
|
.ok_or_else(|| RuntimeError::InvalidPreparedRequest {
|
|
field: "request".to_owned(),
|
|
reason: "mapped input must contain request root".to_owned(),
|
|
})?;
|
|
|
|
let mut headers = read_string_map(request.get("headers"), "request.headers")?;
|
|
for (index, (name, value)) in read_string_map(request.get("cookies"), "request.cookies")?
|
|
.into_iter()
|
|
.enumerate()
|
|
{
|
|
headers.insert(
|
|
format!("x-crank-internal-cookie-{index}"),
|
|
format!("{name}\t{value}"),
|
|
);
|
|
}
|
|
let typed_body_contract =
|
|
matches!(target, Target::Rest(target) if target.request_contract.is_some());
|
|
let body = if typed_body_contract {
|
|
request.get("body").cloned()
|
|
} else {
|
|
request.get("body").and_then(non_empty_legacy_body).cloned()
|
|
};
|
|
let body_content_type = match request.get("body_content_type") {
|
|
Some(Value::String(value)) => Some(value.clone()),
|
|
Some(_) => {
|
|
return Err(RuntimeError::InvalidPreparedRequest {
|
|
field: "request.body_content_type".to_owned(),
|
|
reason: "must be a string".to_owned(),
|
|
});
|
|
}
|
|
None => None,
|
|
};
|
|
Ok(Self {
|
|
path_params: read_string_map(request.get("path"), "request.path")?,
|
|
query_params: read_string_map(request.get("query"), "request.query")?,
|
|
headers,
|
|
trusted_header_names: Default::default(),
|
|
body,
|
|
body_content_type,
|
|
timeout_ms: 0,
|
|
})
|
|
}
|
|
}
|
|
|
|
pub(crate) fn adapter_prepared_request(
|
|
operation: &RuntimeOperation,
|
|
prepared_request: &PreparedRequest,
|
|
timeout_ms: u64,
|
|
) -> PreparedRequest {
|
|
let static_headers = match &operation.target {
|
|
Target::Rest(target) => &target.static_headers,
|
|
};
|
|
|
|
let mut prepared_request = prepared_request.clone();
|
|
prepared_request.headers = merge_headers(
|
|
static_headers,
|
|
&operation.execution_config.headers,
|
|
&prepared_request.headers,
|
|
);
|
|
prepared_request.timeout_ms = timeout_ms;
|
|
prepared_request
|
|
}
|
|
|
|
fn merge_headers(
|
|
static_headers: &BTreeMap<String, String>,
|
|
execution_headers: &BTreeMap<String, String>,
|
|
request_headers: &BTreeMap<String, String>,
|
|
) -> BTreeMap<String, String> {
|
|
let mut headers = static_headers.clone();
|
|
headers.extend(execution_headers.clone());
|
|
headers.extend(request_headers.clone());
|
|
headers
|
|
}
|
|
|
|
fn read_string_map(
|
|
value: Option<&Value>,
|
|
field_name: &str,
|
|
) -> Result<BTreeMap<String, String>, RuntimeError> {
|
|
let Some(value) = value else {
|
|
return Ok(BTreeMap::new());
|
|
};
|
|
|
|
let Some(object) = value.as_object() else {
|
|
return Err(RuntimeError::InvalidPreparedRequest {
|
|
field: field_name.to_owned(),
|
|
reason: "must be an object".to_owned(),
|
|
});
|
|
};
|
|
|
|
object
|
|
.iter()
|
|
.map(|(key, value)| stringify_value(value).map(|value| (key.clone(), value)))
|
|
.collect::<Result<BTreeMap<_, _>, _>>()
|
|
.map_err(|reason| RuntimeError::InvalidPreparedRequest {
|
|
field: field_name.to_owned(),
|
|
reason,
|
|
})
|
|
}
|
|
|
|
fn stringify_value(value: &Value) -> Result<String, String> {
|
|
match value {
|
|
Value::Null => Ok("null".to_owned()),
|
|
Value::Bool(value) => Ok(value.to_string()),
|
|
Value::Number(value) => Ok(value.to_string()),
|
|
Value::String(value) => Ok(value.clone()),
|
|
Value::Array(_) | Value::Object(_) => {
|
|
Err("request path/query/headers accept only scalar values".to_owned())
|
|
}
|
|
}
|
|
}
|
|
|
|
fn non_empty_legacy_body(value: &Value) -> Option<&Value> {
|
|
match value {
|
|
Value::Null => None,
|
|
Value::Object(object) if object.is_empty() => None,
|
|
_ => Some(value),
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use std::collections::BTreeMap;
|
|
|
|
use crank_core::{
|
|
HttpMethod, RestRequestContract, RestRequestContractVersion, RestRequestDescriptor,
|
|
RestTarget, Target,
|
|
};
|
|
use serde_json::json;
|
|
|
|
use crate::PreparedRequest;
|
|
|
|
#[test]
|
|
fn legacy_empty_and_null_bodies_remain_absent() {
|
|
let target = legacy_target();
|
|
for body in [json!(null), json!({})] {
|
|
let mapped = json!({"request": {"body": body}});
|
|
assert_eq!(
|
|
PreparedRequest::from_mapping_output(&mapped, &target)
|
|
.unwrap()
|
|
.body,
|
|
None
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn typed_contract_preserves_explicit_empty_and_null_bodies() {
|
|
let mut target = legacy_target();
|
|
let Target::Rest(rest) = &mut target;
|
|
rest.request_contract = Some(RestRequestContract {
|
|
version: RestRequestContractVersion::V1,
|
|
body_field: "body".to_owned(),
|
|
selector_field: None,
|
|
body_required: true,
|
|
variants: vec![RestRequestDescriptor {
|
|
media_type: "application/json".to_owned(),
|
|
schema_variant: 0,
|
|
}],
|
|
});
|
|
for body in [json!(null), json!({})] {
|
|
let mapped = json!({"request": {"body": body}});
|
|
assert_eq!(
|
|
PreparedRequest::from_mapping_output(&mapped, &target)
|
|
.unwrap()
|
|
.body,
|
|
Some(body)
|
|
);
|
|
}
|
|
}
|
|
|
|
fn legacy_target() -> Target {
|
|
Target::Rest(RestTarget {
|
|
base_url: "https://example.invalid".to_owned(),
|
|
method: HttpMethod::Post,
|
|
path_template: "/".to_owned(),
|
|
static_headers: BTreeMap::new(),
|
|
request_contract: None,
|
|
response_contract: Vec::new(),
|
|
multipart_field_mime_types: BTreeMap::new(),
|
|
})
|
|
}
|
|
}
|