#[derive(Clone, PartialEq, Eq)]
pub struct SecretKey(String);
impl SecretKey {
pub fn new(key: impl Into<String>) -> Self {
Self(key.into())
}
#[must_use]
pub fn as_str(&self) -> &str {
&self.0
}
#[must_use]
pub fn into_string(self) -> String {
self.0
}
}
impl From<String> for SecretKey {
fn from(key: String) -> Self {
Self(key)
}
}
impl From<&str> for SecretKey {
fn from(key: &str) -> Self {
Self(key.to_string())
}
}
impl std::fmt::Debug for SecretKey {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("SecretKey(<redacted>)")
}
}
#[derive(Clone, PartialEq, Eq)]
pub struct PublishableKey(String);
impl PublishableKey {
pub fn new(key: impl Into<String>) -> crate::core::error::Result<Self> {
let key = key.into();
if !key.starts_with("pk_") {
return Err(crate::core::error::DelopayError::Config(
"a publishable key must start with `pk_` — a secret key must never reach a \
buyer-side client"
.to_string(),
));
}
Ok(Self(key))
}
#[must_use]
pub fn as_str(&self) -> &str {
&self.0
}
#[must_use]
pub fn into_string(self) -> String {
self.0
}
}
impl std::str::FromStr for PublishableKey {
type Err = crate::core::error::DelopayError;
fn from_str(key: &str) -> Result<Self, Self::Err> {
Self::new(key)
}
}
impl TryFrom<String> for PublishableKey {
type Error = crate::core::error::DelopayError;
fn try_from(key: String) -> Result<Self, Self::Error> {
Self::new(key)
}
}
impl TryFrom<&str> for PublishableKey {
type Error = crate::core::error::DelopayError;
fn try_from(key: &str) -> Result<Self, Self::Error> {
Self::new(key)
}
}
impl std::fmt::Debug for PublishableKey {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("PublishableKey(<redacted>)")
}
}
#[derive(Clone, PartialEq, Eq)]
pub struct ClientSecret(String);
impl ClientSecret {
pub fn new(secret: impl Into<String>) -> Self {
Self(secret.into())
}
#[must_use]
pub fn as_str(&self) -> &str {
&self.0
}
#[must_use]
pub fn into_string(self) -> String {
self.0
}
}
impl From<String> for ClientSecret {
fn from(secret: String) -> Self {
Self(secret)
}
}
impl From<&str> for ClientSecret {
fn from(secret: &str) -> Self {
Self(secret.to_string())
}
}
impl std::fmt::Debug for ClientSecret {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("ClientSecret(<redacted>)")
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::core::error::DelopayError;
#[test]
fn publishable_key_rejects_a_secret_key() {
for secret in ["prd_live_abc", "snd_test_abc"] {
match PublishableKey::new(secret).unwrap_err() {
DelopayError::Config(msg) => assert!(msg.contains("pk_"), "unexpected: {msg}"),
other => panic!("expected Config, got {other:?}"),
}
}
}
#[test]
fn publishable_key_accepts_both_environments() {
assert_eq!(
PublishableKey::new("pk_prd_abc").unwrap().as_str(),
"pk_prd_abc"
);
assert_eq!(
PublishableKey::new("pk_snd_abc").unwrap().as_str(),
"pk_snd_abc"
);
}
#[test]
fn publishable_key_parses_from_str() {
let parsed: PublishableKey = "pk_snd_abc".parse().unwrap();
assert_eq!(parsed.as_str(), "pk_snd_abc");
assert!("snd_abc".parse::<PublishableKey>().is_err());
}
#[test]
fn credentials_redact_in_debug() {
assert_eq!(
format!("{:?}", SecretKey::new("prd_supersecret")),
"SecretKey(<redacted>)"
);
assert_eq!(
format!("{:?}", PublishableKey::new("pk_snd_abc").unwrap()),
"PublishableKey(<redacted>)"
);
assert_eq!(
format!("{:?}", ClientSecret::new("pay_123_secret_xyz")),
"ClientSecret(<redacted>)"
);
}
#[test]
fn debug_of_a_credential_never_contains_its_value() {
let rendered = format!(
"{:?} {:?} {:?}",
SecretKey::new("prd_supersecret"),
PublishableKey::new("pk_snd_visible").unwrap(),
ClientSecret::new("cs_visible")
);
assert!(!rendered.contains("supersecret"));
assert!(!rendered.contains("visible"));
}
}