use std::collections::BTreeMap;
use std::fmt;
#[derive(Clone, Default, PartialEq, Eq)]
pub struct Params {
inner: BTreeMap<String, String>,
}
impl Params {
pub fn new() -> Self {
Self::default()
}
pub fn insert(&mut self, key: impl Into<String>, value: impl Into<String>) -> &mut Self {
let key = key.into();
let value = value.into();
if !value.is_empty() {
self.inner.insert(key, value);
}
self
}
pub fn insert_opt(
&mut self,
key: impl Into<String>,
value: Option<impl Into<String>>,
) -> &mut Self {
if let Some(v) = value {
self.insert(key, v);
}
self
}
pub fn get(&self, key: &str) -> Option<&str> {
self.inner.get(key).map(String::as_str)
}
pub fn contains(&self, key: &str) -> bool {
self.inner.contains_key(key)
}
pub fn remove(&mut self, key: &str) -> Option<String> {
self.inner.remove(key)
}
pub fn iter(&self) -> impl Iterator<Item = (&str, &str)> {
self.inner.iter().map(|(k, v)| (k.as_str(), v.as_str()))
}
pub fn len(&self) -> usize {
self.inner.len()
}
pub fn is_empty(&self) -> bool {
self.inner.is_empty()
}
pub fn merge(&mut self, other: Params) -> &mut Self {
self.inner.extend(other.inner);
self
}
pub fn from_urlencoded(input: &str) -> Self {
let mut params = Self::new();
for (k, v) in url::form_urlencoded::parse(input.as_bytes()) {
params.insert(k.into_owned(), v.into_owned());
}
params
}
pub fn sign_payload(&self) -> String {
let mut parts = Vec::with_capacity(self.inner.len());
for (k, v) in &self.inner {
if k == "sign" || k == "sign_type" {
continue;
}
parts.push(format!("{k}={v}"));
}
parts.join("&")
}
pub fn encode(&self) -> String {
let mut ser = url::form_urlencoded::Serializer::new(String::new());
for (k, v) in &self.inner {
ser.append_pair(k, v);
}
ser.finish()
}
pub fn as_pairs(&self) -> Vec<(&str, &str)> {
self.iter().collect()
}
pub fn redacted_encode(&self) -> String {
let mut ser = url::form_urlencoded::Serializer::new(String::new());
for (k, v) in &self.inner {
if is_secret(k) {
ser.append_pair(k, "***");
} else {
ser.append_pair(k, &redacted_value(k, v));
}
}
ser.finish()
}
}
impl fmt::Display for Params {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.redacted_encode())
}
}
fn is_secret(key: &str) -> bool {
matches!(key, "key" | "sign")
}
fn redacted_value(key: &str, value: &str) -> String {
if key.ends_with("_url") {
return redact_url_query(value);
}
value.to_owned()
}
pub(crate) fn redact_url_query(value: &str) -> String {
match url::Url::parse(value) {
Ok(mut url) => {
if url.query().is_some() {
url.set_query(Some("***"));
}
url.to_string()
}
Err(_) => format!("<invalid url: {} bytes>", value.len()),
}
}
impl fmt::Debug for Params {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut map = f.debug_map();
for (k, v) in &self.inner {
if is_secret(k) {
map.entry(k, &"***");
} else {
map.entry(k, &redacted_value(k, v));
}
}
map.finish()
}
}
impl<K, V> FromIterator<(K, V)> for Params
where
K: Into<String>,
V: Into<String>,
{
fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self {
let mut params = Self::new();
for (k, v) in iter {
params.insert(k, v);
}
params
}
}
impl From<BTreeMap<String, String>> for Params {
fn from(inner: BTreeMap<String, String>) -> Self {
let mut params = Self::new();
for (k, v) in inner {
params.insert(k, v);
}
params
}
}
impl From<std::collections::HashMap<String, String>> for Params {
fn from(map: std::collections::HashMap<String, String>) -> Self {
map.into_iter().collect()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn sign_payload_sorts_and_skips() {
let mut p = Params::new();
p.insert("c", "3");
p.insert("a", "1");
p.insert("b", "2");
p.insert("sign", "deadbeef");
p.insert("sign_type", "MD5");
p.insert("empty", "");
assert_eq!(p.sign_payload(), "a=1&b=2&c=3");
}
#[test]
fn debug_and_display_redact_secrets() {
let mut p = Params::new();
p.insert("pid", "1001");
p.insert("key", "super-secret");
p.insert("sign", "deadbeef");
p.insert(
"notify_url",
"https://shop.example/notify?token=callback-secret",
);
for s in [format!("{p:?}"), p.to_string()] {
assert!(!s.contains("super-secret"), "{s}");
assert!(!s.contains("deadbeef"), "{s}");
assert!(!s.contains("callback-secret"), "{s}");
assert!(s.contains("1001"), "{s}");
}
}
#[test]
fn url_redaction_never_echoes_unparseable_input() {
assert_eq!(
redact_url_query("https://shop.example/notify?token=secret"),
"https://shop.example/notify?***"
);
assert_eq!(
redact_url_query("https://shop.example/notify"),
"https://shop.example/notify"
);
let text = redact_url_query("not a url?token=secret");
assert!(!text.contains("secret"), "{text}");
assert_eq!(text, "<invalid url: 22 bytes>");
}
#[test]
fn from_urlencoded() {
let p = Params::from_urlencoded("pid=1001&out_trade_no=ORDER001&money=10.00");
assert_eq!(p.get("pid"), Some("1001"));
assert_eq!(p.get("out_trade_no"), Some("ORDER001"));
assert_eq!(p.get("money"), Some("10.00"));
}
}