use std::time::Duration; use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD}; use crank_core::{CachedHeader, CachedResponse, HttpMethod, Target}; use serde_json::{Value, json}; use sha2::{Digest, Sha256}; use crate::{AdapterResponse, PreparedRequest, RuntimeOperation, RuntimeRequestContext}; pub(crate) fn response_cache_ttl( operation: &RuntimeOperation, request_context: Option<&RuntimeRequestContext>, ) -> Option { let is_cacheable_protocol = matches!(&operation.target, Target::Rest(target) if target.method == HttpMethod::Get); if !is_cacheable_protocol { return None; } if let Some(policy) = request_context.and_then(RuntimeRequestContext::resource_response_cache) { if policy.ttl_ms == 0 { return None; } return Some(Duration::from_millis(policy.ttl_ms)); } let policy = operation.execution_config.response_cache.as_ref()?; if operation.execution_config.auth_profile_ref.is_some() || policy.ttl_ms == 0 { return None; } Some(Duration::from_millis(policy.ttl_ms)) } pub(crate) fn response_cache_key( operation: &RuntimeOperation, prepared_request: &PreparedRequest, request_context: Option<&RuntimeRequestContext>, ) -> Option { let _ = response_cache_ttl(operation, request_context)?; let scope = request_context?.response_cache_scope()?; let fingerprint_hash = prepared_request_fingerprint(prepared_request)?; let auth_scope = operation .execution_config .auth_profile_ref .as_ref() .map(|id| id.as_str()) .unwrap_or("none"); let resource_scope = request_context.and_then(RuntimeRequestContext::resource_response_cache); if resource_scope.is_none() { return Some(format!( "crank:response:workspace:{}:agent:{}:operation:{}:version:{}:request:{}", scope.workspace_key, scope.agent_key, operation.operation_id.as_str(), operation.operation_version, fingerprint_hash )); } let resource_fingerprint = resource_scope.and_then(|resource| resource_cache_identity(resource, auth_scope)); let resource_key = resource_fingerprint.unwrap_or_default(); Some(format!( "crank:response:workspace:{}:agent:{}:operation:{}:version:{}:resource:{}:request:{}", scope.workspace_key, scope.agent_key, operation.operation_id.as_str(), operation.operation_version, resource_key, fingerprint_hash )) } fn prepared_request_fingerprint(prepared_request: &PreparedRequest) -> Option { let fingerprint = json!({ "path_params": prepared_request.path_params, "query_params": prepared_request.query_params, "headers": prepared_request.headers, "body": prepared_request.body, }); let bytes = serde_json::to_vec(&fingerprint).ok()?; Some(URL_SAFE_NO_PAD.encode(Sha256::digest(bytes))) } fn resource_cache_identity( resource: &crate::request_context::ResourceResponseCache, auth_scope: &str, ) -> Option { let identity = serde_json::to_vec(&json!({ "resource_id": resource.resource_id, "version": resource.version, "auth_profile": auth_scope, })) .ok()?; Some(URL_SAFE_NO_PAD.encode(Sha256::digest(identity))) } pub(crate) fn cached_response_from_adapter( adapter_response: &AdapterResponse, ) -> Option { let body = serde_json::to_vec(&adapter_response.body).ok()?; Some(CachedResponse { status: adapter_response.status_code, headers: adapter_response .headers .iter() .map(|(name, value)| CachedHeader { name: name.clone(), value: value.clone(), }) .collect(), body, data: serde_json::to_vec(&adapter_response.data).ok()?, }) } pub(crate) fn adapter_response_from_cached( cached_response: CachedResponse, ) -> Result { let body: Value = serde_json::from_slice(&cached_response.body).map_err(|error| error.to_string())?; let data: Value = serde_json::from_slice(&cached_response.data).map_err(|error| error.to_string())?; Ok(AdapterResponse { status_code: cached_response.status, headers: cached_response .headers .into_iter() .map(|header| (header.name, header.value)) .collect(), body, data, }) } #[cfg(test)] mod tests { use std::collections::BTreeMap; use super::*; #[test] fn resource_cache_identity_separates_resource_version_and_auth_scope_without_disclosing_values() { let base = crate::request_context::ResourceResponseCache { resource_id: "resource-a".to_owned(), version: 1, ttl_ms: 30_000, max_bytes: 1024, }; let base_key = resource_cache_identity(&base, "auth-a").unwrap(); assert_ne!(base_key, resource_cache_identity(&base, "auth-b").unwrap()); assert_ne!( base_key, resource_cache_identity( &crate::request_context::ResourceResponseCache { version: 2, ..base.clone() }, "auth-a" ) .unwrap() ); assert_ne!( base_key, resource_cache_identity( &crate::request_context::ResourceResponseCache { resource_id: "resource-b".to_owned(), ..base }, "auth-a" ) .unwrap() ); assert!(!base_key.contains("resource-a")); assert!(!base_key.contains("auth-a")); } #[test] fn prepared_request_fingerprint_separates_canonical_parameter_values_without_disclosure() { let first = PreparedRequest { path_params: BTreeMap::from([("order_id".to_owned(), "order-a".to_owned())]), ..PreparedRequest::default() }; let second = PreparedRequest { path_params: BTreeMap::from([("order_id".to_owned(), "order-b".to_owned())]), ..PreparedRequest::default() }; let first_key = prepared_request_fingerprint(&first).unwrap(); let second_key = prepared_request_fingerprint(&second).unwrap(); assert_ne!(first_key, second_key); assert!(!first_key.contains("order-a")); } }