feat(adapters): from_jsonschema single-endpoint adapter + shared forwarding core
- src/adapters/forward.rs: shared HTTP forwarding core (extracted from old from_openapi) — HttpServiceConfig/HttpAuthScheme, build_request with capabilities-based credential injection (no env vars), forward + forward_stream (SSE projection), parse_sse_frames - src/adapters/from_jsonschema.rs: FromJsonSchema OperationAdapter (ADR-066) — one registration per call, FromJsonSchema provenance (leaf, Internal default), Sub -> HandlerKind::Stream (text/event-stream) - adapted to alkcall 0.1.1: OperationType::Sub, alkcall::client adapter traits Verified: cargo test (106 lib tests), clippy -D warnings, fmt.
This commit is contained in:
@@ -0,0 +1,442 @@
|
||||
//! Shared HTTP forwarding core for the HTTP-backed adapters
|
||||
//! (`from_openapi`, `from_jsonschema`): request construction
|
||||
//! (path templates, query split, body, credential injection), the
|
||||
//! reqwest forwarding handlers (`forward` / `forward_stream`), and the
|
||||
//! SSE frame parser for streaming (SSE → `ResponseEnvelope`) handlers
|
||||
//! (ADR-049).
|
||||
//!
|
||||
//! The forwarding handler is the no-env-vars credential injection point
|
||||
//! (ADR-014): it reads `OperationContext.capabilities`, never
|
||||
//! `std::env::var`. Imported error codes are `HTTP_<status>` to avoid
|
||||
//! collision with the protocol-level codes (ADR-023).
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::sync::Arc;
|
||||
|
||||
use alkcall::protocol::wire::{CallError, ResponseEnvelope};
|
||||
use alkcall::registry::context::OperationContext;
|
||||
use alkcall::registry::registration::ResponseStream;
|
||||
use alkcall::registry::spec::OperationType;
|
||||
use futures::stream;
|
||||
use futures::StreamExt;
|
||||
use reqwest::header::{HeaderMap, HeaderName, HeaderValue, ACCEPT, AUTHORIZATION, CONTENT_TYPE};
|
||||
use reqwest::Method;
|
||||
use serde_json::Value;
|
||||
use url::Url;
|
||||
|
||||
use crate::client::SharedHttpClient;
|
||||
|
||||
#[derive(Clone)]
|
||||
pub enum HttpAuthScheme {
|
||||
Bearer,
|
||||
ApiKey { header_name: String },
|
||||
Basic,
|
||||
}
|
||||
|
||||
pub struct HttpServiceConfig {
|
||||
pub namespace: String,
|
||||
pub base_url: String,
|
||||
pub auth: Option<HttpAuthScheme>,
|
||||
pub default_headers: HashMap<String, String>,
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub(crate) fn build_request(
|
||||
base_url: &str,
|
||||
path_template: &str,
|
||||
method: &str,
|
||||
auth_scheme: &Option<HttpAuthScheme>,
|
||||
default_headers: &HashMap<String, String>,
|
||||
namespace: &str,
|
||||
input: &Value,
|
||||
context: &OperationContext,
|
||||
) -> Result<(Method, Url, Option<Value>, HeaderMap), CallError> {
|
||||
let input_obj = input.as_object();
|
||||
|
||||
let mut url_path = path_template.to_string();
|
||||
let mut query_params: Vec<(String, String)> = Vec::new();
|
||||
let mut body: Option<Value> = None;
|
||||
|
||||
if let Some(obj) = input_obj {
|
||||
for (key, value) in obj {
|
||||
let placeholder = format!("{{{key}}}");
|
||||
if url_path.contains(&placeholder) {
|
||||
let rendered = value_to_path_segment(value);
|
||||
url_path = url_path.replace(&placeholder, &rendered);
|
||||
} else if key == "body" {
|
||||
body = Some(value.clone());
|
||||
} else {
|
||||
query_params.push((key.clone(), value_to_query(value)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let base = Url::parse(base_url)
|
||||
.map_err(|e| CallError::internal(format!("invalid base_url `{base_url}`: {e}")))?;
|
||||
let mut url = base
|
||||
.join(url_path.trim_start_matches('/'))
|
||||
.map_err(|e| CallError::internal(format!("invalid path `{url_path}`: {e}")))?;
|
||||
if !query_params.is_empty() {
|
||||
let mut pairs = url.query_pairs_mut();
|
||||
for (k, v) in &query_params {
|
||||
pairs.append_pair(k, v);
|
||||
}
|
||||
}
|
||||
|
||||
let mut headers = HeaderMap::new();
|
||||
for (k, v) in default_headers {
|
||||
if let (Ok(name), Ok(value)) = (
|
||||
HeaderName::try_from(k.as_str()),
|
||||
HeaderValue::try_from(v.as_str()),
|
||||
) {
|
||||
headers.insert(name, value);
|
||||
}
|
||||
}
|
||||
|
||||
if body.is_some() {
|
||||
headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
|
||||
}
|
||||
|
||||
if let Some(scheme) = auth_scheme {
|
||||
if let Some(secret) = context.capabilities.get(namespace) {
|
||||
let credential = secret.expose_secret().clone();
|
||||
match scheme {
|
||||
HttpAuthScheme::Bearer => {
|
||||
let header_value = format!("Bearer {credential}");
|
||||
if let Ok(value) = HeaderValue::try_from(header_value) {
|
||||
headers.insert(AUTHORIZATION, value);
|
||||
}
|
||||
}
|
||||
HttpAuthScheme::ApiKey { header_name } => {
|
||||
if let (Ok(name), Ok(value)) = (
|
||||
HeaderName::try_from(header_name.as_str()),
|
||||
HeaderValue::try_from(credential.as_str()),
|
||||
) {
|
||||
headers.insert(name, value);
|
||||
}
|
||||
}
|
||||
HttpAuthScheme::Basic => {
|
||||
let header_value = format!("Basic {credential}");
|
||||
if let Ok(value) = HeaderValue::try_from(header_value) {
|
||||
headers.insert(AUTHORIZATION, value);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let http_method = Method::from_bytes(method.as_bytes())
|
||||
.map_err(|_| CallError::internal(format!("invalid HTTP method `{method}`")))?;
|
||||
Ok((http_method, url, body, headers))
|
||||
}
|
||||
|
||||
pub(crate) fn value_to_path_segment(value: &Value) -> String {
|
||||
match value {
|
||||
Value::String(s) => s.clone(),
|
||||
Value::Number(n) => n.to_string(),
|
||||
Value::Bool(b) => b.to_string(),
|
||||
Value::Null => String::new(),
|
||||
other => other.to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn value_to_query(value: &Value) -> String {
|
||||
match value {
|
||||
Value::String(s) => s.clone(),
|
||||
Value::Number(n) => n.to_string(),
|
||||
Value::Bool(b) => b.to_string(),
|
||||
Value::Null => String::new(),
|
||||
other => other.to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub(crate) async fn forward(
|
||||
http_client: &Arc<SharedHttpClient>,
|
||||
base_url: &str,
|
||||
path_template: &str,
|
||||
method: &str,
|
||||
auth_scheme: &Option<HttpAuthScheme>,
|
||||
default_headers: &HashMap<String, String>,
|
||||
namespace: &str,
|
||||
error_status_codes: &[(u16, String)],
|
||||
op_type: OperationType,
|
||||
input: Value,
|
||||
context: OperationContext,
|
||||
) -> ResponseEnvelope {
|
||||
let request_id = context.request_id.clone();
|
||||
|
||||
let (http_method, url, body, headers) = match build_request(
|
||||
base_url,
|
||||
path_template,
|
||||
method,
|
||||
auth_scheme,
|
||||
default_headers,
|
||||
namespace,
|
||||
&input,
|
||||
&context,
|
||||
) {
|
||||
Ok(parts) => parts,
|
||||
Err(err) => return ResponseEnvelope::error(request_id, err),
|
||||
};
|
||||
|
||||
let http_client = http_client.client();
|
||||
|
||||
let request_builder = http_client
|
||||
.request(http_method, url.as_str())
|
||||
.headers(headers);
|
||||
|
||||
let request_builder = if op_type == OperationType::Sub {
|
||||
request_builder.header(ACCEPT, "text/event-stream")
|
||||
} else {
|
||||
request_builder.header(ACCEPT, "*/*")
|
||||
};
|
||||
|
||||
let request_builder = match body.as_ref() {
|
||||
Some(b) => {
|
||||
let serialized = serde_json::to_string(b).unwrap_or_else(|_| String::from("null"));
|
||||
request_builder.body(serialized)
|
||||
}
|
||||
None => request_builder,
|
||||
};
|
||||
|
||||
let response: reqwest::Response = match request_builder.send().await {
|
||||
Ok(r) => r,
|
||||
Err(err) => {
|
||||
return ResponseEnvelope::error(
|
||||
request_id,
|
||||
CallError::internal(format!("HTTP request failed: {err}")),
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
let status = response.status();
|
||||
|
||||
if !status.is_success() {
|
||||
let code = error_status_codes
|
||||
.iter()
|
||||
.find(|(s, _)| *s == status.as_u16())
|
||||
.map(|(_, code)| code.clone())
|
||||
.unwrap_or_else(|| format!("HTTP_{}", status.as_u16()));
|
||||
let message = format!(
|
||||
"HTTP {}: {}",
|
||||
status.as_u16(),
|
||||
status.canonical_reason().unwrap_or("")
|
||||
);
|
||||
return ResponseEnvelope::error(request_id, CallError::new(code, message, false));
|
||||
}
|
||||
|
||||
let content_type = response
|
||||
.headers()
|
||||
.get(reqwest::header::CONTENT_TYPE)
|
||||
.and_then(|v: &reqwest::header::HeaderValue| v.to_str().ok())
|
||||
.unwrap_or("")
|
||||
.to_string();
|
||||
|
||||
if content_type.contains("application/json") {
|
||||
match response.json::<Value>().await {
|
||||
Ok(v) => ResponseEnvelope::ok(request_id, v),
|
||||
Err(err) => ResponseEnvelope::error(
|
||||
request_id,
|
||||
CallError::internal(format!("failed to decode JSON body: {err}")),
|
||||
),
|
||||
}
|
||||
} else if content_type.starts_with("text/") {
|
||||
match response.text().await {
|
||||
Ok(t) => ResponseEnvelope::ok(request_id, Value::String(t)),
|
||||
Err(err) => ResponseEnvelope::error(
|
||||
request_id,
|
||||
CallError::internal(format!("failed to decode text body: {err}")),
|
||||
),
|
||||
}
|
||||
} else {
|
||||
match response.bytes().await {
|
||||
Ok(b) => {
|
||||
let arr: Vec<Value> = b.iter().map(|byte| Value::Number((*byte).into())).collect();
|
||||
ResponseEnvelope::ok(request_id, Value::Array(arr))
|
||||
}
|
||||
Err(err) => ResponseEnvelope::error(
|
||||
request_id,
|
||||
CallError::internal(format!("failed to read body: {err}")),
|
||||
),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub(crate) fn forward_stream(
|
||||
http_client: &Arc<SharedHttpClient>,
|
||||
base_url: &str,
|
||||
path_template: &str,
|
||||
method: &str,
|
||||
auth_scheme: &Option<HttpAuthScheme>,
|
||||
default_headers: &HashMap<String, String>,
|
||||
namespace: &str,
|
||||
error_status_codes: &[(u16, String)],
|
||||
input: Value,
|
||||
context: OperationContext,
|
||||
) -> ResponseStream {
|
||||
let request_id = context.request_id.clone();
|
||||
|
||||
let (http_method, url, body, headers) = match build_request(
|
||||
base_url,
|
||||
path_template,
|
||||
method,
|
||||
auth_scheme,
|
||||
default_headers,
|
||||
namespace,
|
||||
&input,
|
||||
&context,
|
||||
) {
|
||||
Ok(parts) => parts,
|
||||
Err(err) => {
|
||||
return Box::pin(stream::once(async move {
|
||||
ResponseEnvelope::error(request_id, err)
|
||||
}));
|
||||
}
|
||||
};
|
||||
|
||||
let http_client = Arc::clone(http_client);
|
||||
let error_status_codes = error_status_codes.to_vec();
|
||||
|
||||
let request_id_stream = request_id.clone();
|
||||
let error_status_codes_stream = error_status_codes.clone();
|
||||
|
||||
let init = async move {
|
||||
let request_builder = http_client
|
||||
.client()
|
||||
.request(http_method, url.as_str())
|
||||
.headers(headers)
|
||||
.header(ACCEPT, "text/event-stream");
|
||||
let request_builder = match body.as_ref() {
|
||||
Some(b) => {
|
||||
let serialized = serde_json::to_string(b).unwrap_or_else(|_| String::from("null"));
|
||||
request_builder.body(serialized)
|
||||
}
|
||||
None => request_builder,
|
||||
};
|
||||
request_builder.send().await
|
||||
};
|
||||
|
||||
let sse = stream::once(init).flat_map(move |result| {
|
||||
let request_id = request_id_stream.clone();
|
||||
let error_status_codes = error_status_codes_stream.clone();
|
||||
match result {
|
||||
Err(err) => Box::pin(stream::once(async move {
|
||||
ResponseEnvelope::error(
|
||||
request_id,
|
||||
CallError::internal(format!("HTTP request failed: {err}")),
|
||||
)
|
||||
})) as ResponseStream,
|
||||
Ok(response) => {
|
||||
let status = response.status();
|
||||
if !status.is_success() {
|
||||
let code = error_status_codes
|
||||
.iter()
|
||||
.find(|(s, _)| *s == status.as_u16())
|
||||
.map(|(_, c)| c.clone())
|
||||
.unwrap_or_else(|| format!("HTTP_{}", status.as_u16()));
|
||||
let message = format!(
|
||||
"HTTP {}: {}",
|
||||
status.as_u16(),
|
||||
status.canonical_reason().unwrap_or("")
|
||||
);
|
||||
Box::pin(stream::once(async move {
|
||||
ResponseEnvelope::error(request_id, CallError::new(code, message, false))
|
||||
})) as ResponseStream
|
||||
} else {
|
||||
let request_id_inner = request_id.clone();
|
||||
Box::pin(
|
||||
stream::unfold(
|
||||
(response.bytes_stream(), String::new()),
|
||||
move |(mut bytes, mut buffer)| {
|
||||
let request_id = request_id_inner.clone();
|
||||
async move {
|
||||
match bytes.next().await {
|
||||
Some(Ok(chunk)) => {
|
||||
buffer.push_str(&String::from_utf8_lossy(&chunk));
|
||||
let (events, remaining) = parse_sse_frames(&buffer);
|
||||
let envelopes: Vec<ResponseEnvelope> = events
|
||||
.into_iter()
|
||||
.map(|e| {
|
||||
let parsed = if e.data.trim().is_empty() {
|
||||
Value::Null
|
||||
} else {
|
||||
serde_json::from_str(&e.data).unwrap_or(
|
||||
Value::String(e.data.clone()),
|
||||
)
|
||||
};
|
||||
ResponseEnvelope::ok(&request_id, parsed)
|
||||
})
|
||||
.collect();
|
||||
Some((envelopes, (bytes, remaining)))
|
||||
}
|
||||
Some(Err(err)) => {
|
||||
let error = CallError::internal(format!(
|
||||
"SSE stream error: {err}"
|
||||
));
|
||||
Some((
|
||||
vec![ResponseEnvelope::error(request_id, error)],
|
||||
(bytes, buffer),
|
||||
))
|
||||
}
|
||||
None => None,
|
||||
}
|
||||
}
|
||||
},
|
||||
)
|
||||
.flat_map(stream::iter),
|
||||
) as ResponseStream
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
Box::pin(sse)
|
||||
}
|
||||
|
||||
pub(crate) struct SseEvent {
|
||||
pub(crate) data: String,
|
||||
}
|
||||
|
||||
pub(crate) fn parse_sse_frames(buffer: &str) -> (Vec<SseEvent>, String) {
|
||||
let mut events = Vec::new();
|
||||
let text = if let Some(stripped) = buffer.strip_prefix('\u{feff}') {
|
||||
stripped
|
||||
} else {
|
||||
buffer
|
||||
};
|
||||
let lines: Vec<&str> = text.split('\n').collect();
|
||||
let mut data_buffer: Vec<String> = Vec::new();
|
||||
let mut remaining = String::new();
|
||||
|
||||
for (i, line) in lines.iter().enumerate() {
|
||||
if i == lines.len() - 1 {
|
||||
remaining = line.to_string();
|
||||
break;
|
||||
}
|
||||
let line = line.strip_suffix('\r').unwrap_or(line);
|
||||
if line.is_empty() {
|
||||
if !data_buffer.is_empty() {
|
||||
events.push(SseEvent {
|
||||
data: data_buffer.join("\n"),
|
||||
});
|
||||
}
|
||||
data_buffer.clear();
|
||||
continue;
|
||||
}
|
||||
if line.starts_with(':') {
|
||||
continue;
|
||||
}
|
||||
if let Some((field, value)) = line.split_once(':') {
|
||||
let value = value.strip_prefix(' ').unwrap_or(value);
|
||||
if field == "data" {
|
||||
data_buffer.push(value.to_string());
|
||||
}
|
||||
} else if line == "data" {
|
||||
data_buffer.push(String::new());
|
||||
}
|
||||
}
|
||||
|
||||
(events, remaining)
|
||||
}
|
||||
Reference in New Issue
Block a user