use base64::engine::general_purpose::URL_SAFE_NO_PAD;
use base64::Engine as _;
pub const HEADER_PREFIX: &str = "x-encore-meta-ctx-";
pub const ATTRIBUTE_PREFIX: &str = "encore-ctx-";
pub const MAX_FIELD_SIZE: usize = 4096;
pub const MAX_FIELDS_SIZE: usize = 8192;
const MAX_NAME_LEN: usize = 63;
pub fn encode(json: &[u8]) -> String {
URL_SAFE_NO_PAD.encode(json)
}
pub fn decode(encoded: &str) -> Result<Vec<u8>, DecodeError> {
URL_SAFE_NO_PAD
.decode(encoded.trim())
.map_err(|e| DecodeError(e.to_string()))
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DecodeError(String);
impl std::fmt::Display for DecodeError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "invalid request context field value: {}", self.0)
}
}
impl std::error::Error for DecodeError {}
pub fn valid_name(name: &str) -> bool {
let bytes = name.as_bytes();
let (Some(first), Some(last)) = (bytes.first(), bytes.last()) else {
return false;
};
bytes.len() <= MAX_NAME_LEN
&& first.is_ascii_lowercase()
&& (last.is_ascii_lowercase() || last.is_ascii_digit())
&& bytes
.iter()
.all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || *b == b'-')
}
pub fn header_name(name: &str) -> String {
format!("{HEADER_PREFIX}{name}")
}
pub fn field_of(header: &str) -> Option<&str> {
header.strip_prefix(HEADER_PREFIX)
}
pub fn is_field_header(header: &str) -> bool {
header.starts_with(HEADER_PREFIX)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_value_round_trips_without_padding_in_url_safe_characters() {
let json = "{\"name\":\"Åsa\",\"tags\":[\"a?b\"]}".as_bytes();
let encoded = encode(json);
assert!(!encoded.contains('='), "{encoded}");
assert!(
encoded
.bytes()
.all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_'),
"{encoded}"
);
assert_eq!(decode(&encoded).unwrap(), json);
assert!(decode("not base64!").is_err());
}
#[test]
fn names_are_kebab_case() {
for name in ["user", "tenant-id", "plan2", "a", "feature-flags-v2"] {
assert!(valid_name(name), "{name}");
}
let long = "a".repeat(64);
for name in [
"",
"User",
"tenant_id",
"2fa",
"-user",
"user-",
"user.id",
"üser",
long.as_str(),
] {
assert!(!valid_name(name), "{name}");
}
}
#[test]
fn the_propagation_check_has_the_same_prefixes() {
use encore_telemetry::propagation;
assert_eq!(propagation::CONTEXT_HEADER_PREFIX, HEADER_PREFIX);
assert_eq!(propagation::CONTEXT_ATTRIBUTE_PREFIX, ATTRIBUTE_PREFIX);
}
#[test]
fn a_field_has_a_header_of_its_own() {
assert_eq!(header_name("user"), "x-encore-meta-ctx-user");
assert_eq!(field_of("x-encore-meta-ctx-user"), Some("user"));
assert_eq!(field_of("x-encore-meta-caller"), None);
assert!(is_field_header("x-encore-meta-ctx-tenant"));
assert!(!is_field_header("x-encore-meta-authdata"));
}
}