use std::collections::BTreeMap;
use serde::{Deserialize, Serialize};
use serde_json::{Map, Value};
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum CustomFieldType {
#[default]
Text,
Textarea,
Password,
Email,
Select,
Checkbox,
}
impl CustomFieldType {
pub fn as_wire(self) -> &'static str {
match self {
Self::Text => "text",
Self::Textarea => "textarea",
Self::Password => "password",
Self::Email => "email",
Self::Select => "select",
Self::Checkbox => "checkbox",
}
}
pub fn from_wire(raw: Option<&Value>) -> Self {
match raw.and_then(Value::as_str) {
Some("textarea") => Self::Textarea,
Some("password") => Self::Password,
Some("email") => Self::Email,
Some("select") => Self::Select,
Some("checkbox") => Self::Checkbox,
_ => Self::Text,
}
}
pub fn is_text_like(self) -> bool {
!matches!(self, Self::Select | Self::Checkbox)
}
}
pub const ALL_CUSTOM_FIELD_TYPES: &[CustomFieldType] = &[
CustomFieldType::Text,
CustomFieldType::Textarea,
CustomFieldType::Password,
CustomFieldType::Email,
CustomFieldType::Select,
CustomFieldType::Checkbox,
];
pub const CUSTOM_FIELDS_MAX: usize = 20;
pub const CUSTOM_FIELD_CONDITIONS_MAX: usize = 10;
pub const CHECKBOX_CHECKED: &str = "true";
pub const CHECKBOX_UNCHECKED: &str = "false";
pub fn is_checkbox_checked(value: Option<&str>) -> bool {
value.is_some_and(|v| v.trim().eq_ignore_ascii_case(CHECKBOX_CHECKED))
}
pub fn is_valid_custom_field_key(key: &str) -> bool {
let mut chars = key.chars();
let Some(first) = chars.next() else {
return false;
};
if !first.is_ascii_alphabetic() {
return false;
}
if key.len() > 40 {
return false;
}
chars.all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-')
}
pub type CustomFieldTranslations = BTreeMap<String, String>;
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct CustomFieldOption {
pub value: String,
pub label: String,
pub label_translations: CustomFieldTranslations,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum CustomFieldConditionSource {
#[default]
Metadata,
Currency,
Amount,
}
impl CustomFieldConditionSource {
pub fn as_wire(self) -> &'static str {
match self {
Self::Metadata => "metadata",
Self::Currency => "currency",
Self::Amount => "amount",
}
}
pub fn from_wire(raw: Option<&Value>) -> Self {
match raw.and_then(Value::as_str) {
Some("currency") => Self::Currency,
Some("amount") => Self::Amount,
_ => Self::Metadata,
}
}
pub fn operators(self) -> &'static [CustomFieldOperator] {
use CustomFieldOperator as Op;
match self {
Self::Metadata => ALL_CUSTOM_FIELD_OPERATORS,
Self::Currency => &[Op::Equals, Op::NotEquals, Op::In, Op::NotIn],
Self::Amount => &[Op::Equals, Op::NotEquals, Op::Gt, Op::Gte, Op::Lt, Op::Lte],
}
}
pub fn default_operator(self) -> CustomFieldOperator {
self.operators()
.first()
.copied()
.unwrap_or(CustomFieldOperator::Equals)
}
}
pub const ALL_CUSTOM_FIELD_CONDITION_SOURCES: &[CustomFieldConditionSource] = &[
CustomFieldConditionSource::Metadata,
CustomFieldConditionSource::Currency,
CustomFieldConditionSource::Amount,
];
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum CustomFieldOperator {
#[default]
Equals,
NotEquals,
Contains,
NotContains,
StartsWith,
EndsWith,
In,
NotIn,
Exists,
NotExists,
Gt,
Gte,
Lt,
Lte,
}
impl CustomFieldOperator {
pub fn as_wire(self) -> &'static str {
match self {
Self::Equals => "equals",
Self::NotEquals => "not_equals",
Self::Contains => "contains",
Self::NotContains => "not_contains",
Self::StartsWith => "starts_with",
Self::EndsWith => "ends_with",
Self::In => "in",
Self::NotIn => "not_in",
Self::Exists => "exists",
Self::NotExists => "not_exists",
Self::Gt => "gt",
Self::Gte => "gte",
Self::Lt => "lt",
Self::Lte => "lte",
}
}
pub fn from_wire_str(raw: &str) -> Option<Self> {
ALL_CUSTOM_FIELD_OPERATORS
.iter()
.copied()
.find(|op| op.as_wire() == raw)
}
pub fn takes_value(self) -> bool {
!matches!(self, Self::Exists | Self::NotExists)
}
}
pub const ALL_CUSTOM_FIELD_OPERATORS: &[CustomFieldOperator] = &[
CustomFieldOperator::Equals,
CustomFieldOperator::NotEquals,
CustomFieldOperator::Contains,
CustomFieldOperator::NotContains,
CustomFieldOperator::StartsWith,
CustomFieldOperator::EndsWith,
CustomFieldOperator::In,
CustomFieldOperator::NotIn,
CustomFieldOperator::Exists,
CustomFieldOperator::NotExists,
CustomFieldOperator::Gt,
CustomFieldOperator::Gte,
CustomFieldOperator::Lt,
CustomFieldOperator::Lte,
];
pub const CUSTOM_FIELD_VALUELESS_OPERATORS: &[CustomFieldOperator] =
&[CustomFieldOperator::Exists, CustomFieldOperator::NotExists];
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct CustomFieldCondition {
pub id: String,
pub source: CustomFieldConditionSource,
pub key: String,
pub operator: CustomFieldOperator,
pub value: String,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum CustomFieldMatch {
#[default]
All,
Any,
}
impl CustomFieldMatch {
pub fn as_wire(self) -> &'static str {
match self {
Self::All => "all",
Self::Any => "any",
}
}
pub fn from_wire(raw: Option<&Value>) -> Self {
match raw.and_then(Value::as_str) {
Some("any") => Self::Any,
_ => Self::All,
}
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum CustomFieldVisibilityMode {
#[default]
Always,
Match,
}
impl CustomFieldVisibilityMode {
pub fn as_wire(self) -> &'static str {
match self {
Self::Always => "always",
Self::Match => "match",
}
}
pub fn from_wire(raw: Option<&Value>) -> Self {
match raw.and_then(Value::as_str) {
Some("match") => Self::Match,
_ => Self::Always,
}
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(default)]
pub struct CustomFieldVisibility {
pub mode: CustomFieldVisibilityMode,
#[serde(rename = "match")]
pub match_: CustomFieldMatch,
pub conditions: Vec<CustomFieldCondition>,
}
pub fn default_custom_field_visibility() -> CustomFieldVisibility {
CustomFieldVisibility::default()
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct CheckoutCustomField {
pub id: String,
pub key: String,
#[serde(rename = "type")]
pub field_type: CustomFieldType,
pub label: String,
pub label_translations: CustomFieldTranslations,
pub placeholder: String,
pub placeholder_translations: CustomFieldTranslations,
pub help_text: String,
pub help_text_translations: CustomFieldTranslations,
pub required: bool,
pub enabled: bool,
pub min_length: Option<i64>,
pub max_length: Option<i64>,
pub default_value: String,
pub options: Vec<CustomFieldOption>,
pub visibility: CustomFieldVisibility,
}
impl CheckoutCustomField {
pub fn new(key: impl Into<String>) -> Self {
let key = key.into();
Self {
id: format!("field-{key}"),
label: key.clone(),
key,
field_type: CustomFieldType::Text,
enabled: true,
..Default::default()
}
}
}
fn parse_translations(raw: Option<&Value>) -> CustomFieldTranslations {
let mut out = CustomFieldTranslations::new();
let Some(obj) = raw.and_then(Value::as_object) else {
return out;
};
for (k, v) in obj {
if let Some(s) = v.as_str()
&& !s.is_empty()
{
out.insert(k.clone(), s.to_string());
}
}
out
}
fn parse_bounded_int(raw: Option<&Value>) -> Option<i64> {
let n = match raw {
Some(Value::Number(n)) => n.as_f64()?,
Some(Value::String(s)) => s.trim().parse::<f64>().ok()?,
_ => return None,
};
if n.fract() != 0.0 || n < 0.0 {
return None;
}
Some((n as i64).min(5000))
}
fn parse_bool(raw: Option<&Value>, default: bool) -> bool {
raw.and_then(Value::as_bool).unwrap_or(default)
}
fn str_or_empty(obj: &Map<String, Value>, key: &str) -> String {
obj.get(key)
.and_then(Value::as_str)
.unwrap_or_default()
.to_string()
}
fn normalize_condition(raw: &Value, index: usize) -> Option<CustomFieldCondition> {
let obj = raw.as_object()?;
let source = CustomFieldConditionSource::from_wire(obj.get("source"));
let allowed = source.operators();
let operator = obj
.get("operator")
.and_then(Value::as_str)
.and_then(CustomFieldOperator::from_wire_str)
.filter(|op| allowed.contains(op))
.unwrap_or_else(|| source.default_operator());
let value = match obj.get("value") {
Some(Value::String(s)) => s.clone(),
Some(Value::Number(n)) => n.to_string(),
Some(Value::Bool(b)) => b.to_string(),
_ => String::new(),
};
Some(CustomFieldCondition {
id: match obj.get("id").and_then(Value::as_str) {
Some(id) if !id.is_empty() => id.to_string(),
_ => format!("cond-{index}"),
},
source,
key: match source {
CustomFieldConditionSource::Metadata => obj
.get("key")
.and_then(Value::as_str)
.unwrap_or_default()
.trim()
.to_string(),
_ => String::new(),
},
operator,
value,
})
}
fn normalize_visibility(raw: Option<&Value>) -> CustomFieldVisibility {
let Some(obj) = raw.and_then(Value::as_object) else {
return default_custom_field_visibility();
};
let conditions = obj
.get("conditions")
.and_then(Value::as_array)
.map(|rows| {
rows.iter()
.take(CUSTOM_FIELD_CONDITIONS_MAX)
.enumerate()
.filter_map(|(i, row)| normalize_condition(row, i))
.collect()
})
.unwrap_or_default();
CustomFieldVisibility {
mode: CustomFieldVisibilityMode::from_wire(obj.get("mode")),
match_: CustomFieldMatch::from_wire(obj.get("match")),
conditions,
}
}
fn normalize_custom_field(raw: &Value, index: usize) -> Option<CheckoutCustomField> {
let obj = raw.as_object()?;
let key = obj
.get("key")
.and_then(Value::as_str)
.unwrap_or_default()
.trim()
.to_string();
if !is_valid_custom_field_key(&key) {
return None;
}
let field_type = CustomFieldType::from_wire(obj.get("type"));
let options = if field_type == CustomFieldType::Select {
obj.get("options")
.and_then(Value::as_array)
.map(|rows| {
rows.iter()
.filter_map(Value::as_object)
.map(|o| {
let value = o.get("value").and_then(Value::as_str).unwrap_or_default();
CustomFieldOption {
value: value.to_string(),
label: match o.get("label").and_then(Value::as_str) {
Some(l) if !l.is_empty() => l.to_string(),
_ => value.to_string(),
},
label_translations: parse_translations(o.get("labelTranslations")),
}
})
.filter(|o| !o.value.is_empty())
.collect()
})
.unwrap_or_default()
} else {
Vec::new()
};
let text_like = field_type.is_text_like();
let min_length = text_like
.then(|| parse_bounded_int(obj.get("minLength")))
.flatten();
let max_length = text_like
.then(|| parse_bounded_int(obj.get("maxLength")))
.flatten();
let raw_default = str_or_empty(obj, "defaultValue");
let default_value = if field_type == CustomFieldType::Checkbox {
if is_checkbox_checked(Some(&raw_default)) {
CHECKBOX_CHECKED.to_string()
} else {
CHECKBOX_UNCHECKED.to_string()
}
} else {
raw_default
};
Some(CheckoutCustomField {
id: match obj.get("id").and_then(Value::as_str) {
Some(id) if !id.is_empty() => id.to_string(),
_ => format!("field-{index}"),
},
label: match obj.get("label").and_then(Value::as_str) {
Some(l) if !l.is_empty() => l.to_string(),
_ => key.clone(),
},
key,
field_type,
label_translations: parse_translations(obj.get("labelTranslations")),
placeholder: str_or_empty(obj, "placeholder"),
placeholder_translations: parse_translations(obj.get("placeholderTranslations")),
help_text: str_or_empty(obj, "helpText"),
help_text_translations: parse_translations(obj.get("helpTextTranslations")),
required: parse_bool(obj.get("required"), false),
enabled: parse_bool(obj.get("enabled"), true),
min_length,
max_length: match (min_length, max_length) {
(Some(min), Some(max)) if max < min => None,
_ => max_length,
},
default_value,
options,
visibility: normalize_visibility(obj.get("visibility")),
})
}
pub fn parse_custom_fields_loose(raw: &Value) -> Option<Vec<CheckoutCustomField>> {
let rows = raw.as_array()?;
let mut seen: Vec<String> = Vec::new();
let mut out: Vec<CheckoutCustomField> = Vec::new();
for (i, row) in rows.iter().enumerate() {
if out.len() >= CUSTOM_FIELDS_MAX {
break;
}
let Some(field) = normalize_custom_field(row, i) else {
continue;
};
if seen.iter().any(|k| k == &field.key) {
continue;
}
seen.push(field.key.clone());
out.push(field);
}
Some(out)
}
pub fn decode_custom_fields(raw: Option<&str>) -> Option<Vec<CheckoutCustomField>> {
let parsed: Value = serde_json::from_str(raw?).ok()?;
parse_custom_fields_loose(&parsed)
}
fn non_empty_translations(map: &CustomFieldTranslations) -> Option<Map<String, Value>> {
let kept: Map<String, Value> = map
.iter()
.filter(|(_, v)| !v.trim().is_empty())
.map(|(k, v)| (k.clone(), Value::String(v.clone())))
.collect();
(!kept.is_empty()).then_some(kept)
}
fn encode_visibility(v: &CustomFieldVisibility) -> Value {
let conditions: Vec<Value> = v
.conditions
.iter()
.map(|c| {
let mut row = Map::new();
row.insert("id".into(), Value::String(c.id.clone()));
row.insert("source".into(), Value::String(c.source.as_wire().into()));
if c.source == CustomFieldConditionSource::Metadata && !c.key.is_empty() {
row.insert("key".into(), Value::String(c.key.clone()));
}
row.insert(
"operator".into(),
Value::String(c.operator.as_wire().into()),
);
if c.operator.takes_value() && !c.value.is_empty() {
row.insert("value".into(), Value::String(c.value.clone()));
}
Value::Object(row)
})
.collect();
let mut out = Map::new();
out.insert("mode".into(), Value::String(v.mode.as_wire().into()));
out.insert("match".into(), Value::String(v.match_.as_wire().into()));
out.insert("conditions".into(), Value::Array(conditions));
Value::Object(out)
}
pub fn custom_fields_to_value(fields: &[CheckoutCustomField]) -> Value {
let rows: Vec<Value> = fields
.iter()
.map(|f| {
let mut row = Map::new();
row.insert("id".into(), Value::String(f.id.clone()));
row.insert("key".into(), Value::String(f.key.clone()));
row.insert("type".into(), Value::String(f.field_type.as_wire().into()));
row.insert("label".into(), Value::String(f.label.clone()));
if let Some(m) = non_empty_translations(&f.label_translations) {
row.insert("labelTranslations".into(), Value::Object(m));
}
if !f.placeholder.is_empty() {
row.insert("placeholder".into(), Value::String(f.placeholder.clone()));
}
if let Some(m) = non_empty_translations(&f.placeholder_translations) {
row.insert("placeholderTranslations".into(), Value::Object(m));
}
if !f.help_text.is_empty() {
row.insert("helpText".into(), Value::String(f.help_text.clone()));
}
if let Some(m) = non_empty_translations(&f.help_text_translations) {
row.insert("helpTextTranslations".into(), Value::Object(m));
}
if f.required {
row.insert("required".into(), Value::Bool(true));
}
if !f.enabled {
row.insert("enabled".into(), Value::Bool(false));
}
if f.field_type.is_text_like() {
if let Some(min) = f.min_length {
row.insert("minLength".into(), Value::from(min));
}
if let Some(max) = f.max_length {
row.insert("maxLength".into(), Value::from(max));
}
}
if f.field_type == CustomFieldType::Checkbox {
if is_checkbox_checked(Some(&f.default_value)) {
row.insert(
"defaultValue".into(),
Value::String(CHECKBOX_CHECKED.into()),
);
}
} else if !f.default_value.is_empty() {
row.insert(
"defaultValue".into(),
Value::String(f.default_value.clone()),
);
}
if f.field_type == CustomFieldType::Select {
let options: Vec<Value> = f
.options
.iter()
.map(|o| {
let mut row = Map::new();
row.insert("value".into(), Value::String(o.value.clone()));
row.insert("label".into(), Value::String(o.label.clone()));
row.insert(
"labelTranslations".into(),
Value::Object(
o.label_translations
.iter()
.map(|(k, v)| (k.clone(), Value::String(v.clone())))
.collect(),
),
);
Value::Object(row)
})
.collect();
row.insert("options".into(), Value::Array(options));
}
if f.visibility.mode == CustomFieldVisibilityMode::Match {
row.insert("visibility".into(), encode_visibility(&f.visibility));
}
Value::Object(row)
})
.collect();
Value::Array(rows)
}
pub fn encode_custom_fields(fields: &[CheckoutCustomField]) -> String {
serde_json::to_string(&custom_fields_to_value(fields)).unwrap_or_else(|_| "[]".to_string())
}
#[derive(Debug, Clone, Default)]
pub struct CustomFieldContext {
pub amount: i64,
pub currency: String,
pub metadata: BTreeMap<String, String>,
}
pub fn custom_field_context_from_metadata(raw: &Value) -> BTreeMap<String, String> {
let mut out = BTreeMap::new();
let Some(obj) = raw.as_object() else {
return out;
};
for (key, value) in obj {
if let Some(flat) = flatten_metadata_value(value) {
out.insert(key.clone(), flat);
}
}
out
}
fn flatten_metadata_value(value: &Value) -> Option<String> {
match value {
Value::String(s) => Some(s.clone()),
Value::Number(n) => Some(n.to_string()),
Value::Bool(b) => Some(b.to_string()),
Value::Null => None,
Value::Array(items) => Some(
items
.iter()
.filter_map(flatten_metadata_value)
.collect::<Vec<_>>()
.join(","),
),
Value::Object(_) => serde_json::to_string(value).ok(),
}
}
fn norm(value: &str) -> String {
value.trim().to_lowercase()
}
fn numeric(value: &str) -> Option<f64> {
let trimmed = value.trim();
if trimmed.is_empty() {
return None;
}
let n: f64 = trimmed.parse().ok()?;
n.is_finite().then_some(n)
}
fn split_list(value: &str) -> Vec<String> {
value
.split(',')
.map(norm)
.filter(|part| !part.is_empty())
.collect()
}
fn operand_for(condition: &CustomFieldCondition, ctx: &CustomFieldContext) -> Option<String> {
match condition.source {
CustomFieldConditionSource::Currency => Some(ctx.currency.clone()),
CustomFieldConditionSource::Amount => Some(ctx.amount.to_string()),
CustomFieldConditionSource::Metadata => ctx.metadata.get(&condition.key).cloned(),
}
}
pub fn evaluate_custom_field_condition(
condition: &CustomFieldCondition,
ctx: &CustomFieldContext,
) -> bool {
use CustomFieldOperator as Op;
let raw = operand_for(condition, ctx);
let actual = raw.clone().unwrap_or_default();
let expected = &condition.value;
match condition.operator {
Op::Exists => raw.is_some_and(|v| !v.trim().is_empty()),
Op::NotExists => raw.is_none_or(|v| v.trim().is_empty()),
Op::Equals => norm(&actual) == norm(expected),
Op::NotEquals => norm(&actual) != norm(expected),
Op::Contains => norm(&actual).contains(&norm(expected)),
Op::NotContains => !norm(&actual).contains(&norm(expected)),
Op::StartsWith => norm(&actual).starts_with(&norm(expected)),
Op::EndsWith => norm(&actual).ends_with(&norm(expected)),
Op::In => split_list(expected).contains(&norm(&actual)),
Op::NotIn => !split_list(expected).contains(&norm(&actual)),
Op::Gt | Op::Gte | Op::Lt | Op::Lte => {
let (Some(a), Some(b)) = (numeric(&actual), numeric(expected)) else {
return false;
};
match condition.operator {
Op::Gt => a > b,
Op::Gte => a >= b,
Op::Lt => a < b,
_ => a <= b,
}
}
}
}
pub fn evaluate_custom_field_visibility(
field: &CheckoutCustomField,
ctx: &CustomFieldContext,
) -> bool {
let v = &field.visibility;
if v.mode != CustomFieldVisibilityMode::Match || v.conditions.is_empty() {
return true;
}
match v.match_ {
CustomFieldMatch::Any => v
.conditions
.iter()
.any(|c| evaluate_custom_field_condition(c, ctx)),
CustomFieldMatch::All => v
.conditions
.iter()
.all(|c| evaluate_custom_field_condition(c, ctx)),
}
}
pub fn visible_custom_fields<'a>(
fields: &'a [CheckoutCustomField],
ctx: &CustomFieldContext,
) -> Vec<&'a CheckoutCustomField> {
fields
.iter()
.filter(|f| f.enabled && evaluate_custom_field_visibility(f, ctx))
.collect()
}
fn translation_for(map: &CustomFieldTranslations, locale: Option<&str>) -> Option<String> {
let locale = locale?;
let own = |k: &str| map.get(k).filter(|v| !v.is_empty()).cloned();
if let Some(exact) = own(locale) {
return Some(exact);
}
let base = locale.split('-').next().unwrap_or_default();
(!base.is_empty() && base != locale).then(|| own(base))?
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CustomFieldTextPart {
Label,
Placeholder,
HelpText,
}
pub fn custom_field_text(
field: &CheckoutCustomField,
part: CustomFieldTextPart,
locale: Option<&str>,
) -> String {
let (map, fallback) = match part {
CustomFieldTextPart::Label => (&field.label_translations, &field.label),
CustomFieldTextPart::Placeholder => (&field.placeholder_translations, &field.placeholder),
CustomFieldTextPart::HelpText => (&field.help_text_translations, &field.help_text),
};
if let Some(translated) = translation_for(map, locale) {
return translated;
}
if !fallback.is_empty() {
return fallback.clone();
}
match part {
CustomFieldTextPart::Label => field.key.clone(),
_ => String::new(),
}
}
pub fn custom_field_option_label(option: &CustomFieldOption, locale: Option<&str>) -> String {
translation_for(&option.label_translations, locale).unwrap_or_else(|| {
if option.label.is_empty() {
option.value.clone()
} else {
option.label.clone()
}
})
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
fn ctx(amount: i64, currency: &str, metadata: &[(&str, &str)]) -> CustomFieldContext {
CustomFieldContext {
amount,
currency: currency.to_string(),
metadata: metadata
.iter()
.map(|(k, v)| ((*k).to_string(), (*v).to_string()))
.collect(),
}
}
fn condition(source: &str, key: &str, operator: &str, value: &str) -> CustomFieldCondition {
CustomFieldCondition {
id: "c1".into(),
source: CustomFieldConditionSource::from_wire(Some(&json!(source))),
key: key.into(),
operator: CustomFieldOperator::from_wire_str(operator).unwrap(),
value: value.into(),
}
}
#[test]
fn key_grammar_matches_the_documented_pattern() {
assert!(is_valid_custom_field_key("account_login"));
assert!(is_valid_custom_field_key("A"));
assert!(is_valid_custom_field_key("a-b_9"));
assert!(!is_valid_custom_field_key(""), "empty");
assert!(
!is_valid_custom_field_key("9lives"),
"must start with a letter"
);
assert!(!is_valid_custom_field_key("_x"), "must start with a letter");
assert!(!is_valid_custom_field_key("has space"));
assert!(!is_valid_custom_field_key(&"a".repeat(41)), "40 chars max");
assert!(is_valid_custom_field_key(&"a".repeat(40)));
}
#[test]
fn decode_drops_rows_without_a_usable_key_and_dedupes() {
let decoded = parse_custom_fields_loose(&json!([
{"key": "login"},
{"key": "login", "label": "Duplicate"},
{"key": "9bad"},
{"no": "key"},
{"key": "password"}
]))
.unwrap();
let keys: Vec<&str> = decoded.iter().map(|f| f.key.as_str()).collect();
assert_eq!(keys, ["login", "password"]);
}
#[test]
fn decode_defaults_label_to_the_key_and_enables_by_default() {
let decoded = parse_custom_fields_loose(&json!([{"key": "login"}])).unwrap();
assert_eq!(decoded[0].label, "login");
assert!(decoded[0].enabled);
assert!(!decoded[0].required);
assert_eq!(decoded[0].field_type, CustomFieldType::Text);
assert_eq!(
decoded[0].visibility.mode,
CustomFieldVisibilityMode::Always
);
}
#[test]
fn decode_degrades_an_unknown_type_to_text() {
let decoded = parse_custom_fields_loose(&json!([{"key": "x", "type": "colour"}])).unwrap();
assert_eq!(decoded[0].field_type, CustomFieldType::Text);
}
#[test]
fn decode_drops_length_bounds_from_choice_controls() {
let decoded = parse_custom_fields_loose(&json!([
{"key": "terms", "type": "checkbox", "minLength": 2, "maxLength": 10},
{"key": "plan", "type": "select", "minLength": 2, "options": [{"value": "pro"}]},
{"key": "note", "type": "text", "minLength": 2, "maxLength": 10}
]))
.unwrap();
assert_eq!(decoded[0].min_length, None);
assert_eq!(decoded[1].min_length, None);
assert_eq!(decoded[2].min_length, Some(2));
assert_eq!(decoded[2].max_length, Some(10));
}
#[test]
fn decode_drops_an_inverted_max_bound() {
let decoded =
parse_custom_fields_loose(&json!([{"key": "x", "minLength": 10, "maxLength": 2}]))
.unwrap();
assert_eq!(decoded[0].min_length, Some(10));
assert_eq!(decoded[0].max_length, None);
}
#[test]
fn decode_normalizes_a_checkbox_default_to_one_of_two_states() {
let decoded = parse_custom_fields_loose(&json!([
{"key": "a", "type": "checkbox", "defaultValue": " True "},
{"key": "b", "type": "checkbox", "defaultValue": "whatever"},
{"key": "c", "type": "checkbox"}
]))
.unwrap();
assert_eq!(decoded[0].default_value, CHECKBOX_CHECKED);
assert_eq!(decoded[1].default_value, CHECKBOX_UNCHECKED);
assert_eq!(decoded[2].default_value, CHECKBOX_UNCHECKED);
}
#[test]
fn decode_keeps_select_options_and_drops_valueless_ones() {
let decoded = parse_custom_fields_loose(&json!([{
"key": "plan",
"type": "select",
"options": [
{"value": "pro", "label": "Pro", "labelTranslations": {"de": "Profi", "fr": ""}},
{"value": "", "label": "ignored"},
{"value": "basic"}
]
}]))
.unwrap();
let options = &decoded[0].options;
assert_eq!(options.len(), 2);
assert_eq!(options[0].label_translations.get("de").unwrap(), "Profi");
assert!(!options[0].label_translations.contains_key("fr"));
assert_eq!(options[1].label, "basic");
}
#[test]
fn decode_falls_back_an_operator_the_source_does_not_allow() {
let decoded = parse_custom_fields_loose(&json!([{
"key": "x",
"visibility": {
"mode": "match",
"match": "any",
"conditions": [{"source": "amount", "operator": "contains", "value": "5"}]
}
}]))
.unwrap();
let c = &decoded[0].visibility.conditions[0];
assert_eq!(c.source, CustomFieldConditionSource::Amount);
assert_eq!(c.operator, CustomFieldOperator::Equals);
assert_eq!(decoded[0].visibility.mode, CustomFieldVisibilityMode::Match);
}
#[test]
fn decode_drops_a_key_from_a_non_metadata_condition() {
let decoded = parse_custom_fields_loose(&json!([{
"key": "x",
"visibility": {"mode": "match", "conditions": [
{"source": "currency", "key": "stale", "operator": "equals", "value": "EUR"}
]}
}]))
.unwrap();
assert_eq!(decoded[0].visibility.conditions[0].key, "");
}
#[test]
fn decode_caps_conditions_and_fields() {
let conditions: Vec<Value> = (0..25)
.map(|i| json!({"source": "metadata", "key": format!("k{i}"), "operator": "exists"}))
.collect();
let fields: Vec<Value> = (0..30)
.map(|i| json!({"key": format!("field{i}"), "visibility": {"mode": "match", "conditions": conditions}}))
.collect();
let decoded = parse_custom_fields_loose(&Value::Array(fields)).unwrap();
assert_eq!(decoded.len(), CUSTOM_FIELDS_MAX);
assert_eq!(
decoded[0].visibility.conditions.len(),
CUSTOM_FIELD_CONDITIONS_MAX
);
}
#[test]
fn decode_custom_fields_tolerates_malformed_json() {
assert!(decode_custom_fields(None).is_none());
assert!(decode_custom_fields(Some("not json")).is_none());
assert!(decode_custom_fields(Some("{}")).is_none());
assert_eq!(decode_custom_fields(Some("[]")).unwrap().len(), 0);
}
#[test]
fn encode_omits_visibility_for_an_unconditional_field() {
let field = CheckoutCustomField::new("login");
let encoded = encode_custom_fields(std::slice::from_ref(&field));
assert!(!encoded.contains("visibility"), "{encoded}");
assert!(!encoded.contains("required"), "{encoded}");
assert!(!encoded.contains("enabled"), "{encoded}");
}
#[test]
fn encode_round_trips_a_conditional_field() {
let mut field = CheckoutCustomField::new("login");
field.field_type = CustomFieldType::Email;
field.required = true;
field.min_length = Some(3);
field.max_length = Some(64);
field
.label_translations
.insert("de".into(), "Anmeldung".into());
field.visibility = CustomFieldVisibility {
mode: CustomFieldVisibilityMode::Match,
match_: CustomFieldMatch::Any,
conditions: vec![
condition("metadata", "product", "equals", "spotify"),
condition("amount", "", "gte", "1000"),
],
};
let round_tripped =
decode_custom_fields(Some(&encode_custom_fields(std::slice::from_ref(&field))))
.unwrap();
assert_eq!(round_tripped[0], field);
}
#[test]
fn encode_persists_only_a_ticked_checkbox_default() {
let mut ticked = CheckoutCustomField::new("terms");
ticked.field_type = CustomFieldType::Checkbox;
ticked.default_value = CHECKBOX_CHECKED.into();
let mut unticked = CheckoutCustomField::new("news");
unticked.field_type = CustomFieldType::Checkbox;
unticked.default_value = CHECKBOX_UNCHECKED.into();
let encoded: Value =
serde_json::from_str(&encode_custom_fields(&[ticked, unticked])).unwrap();
assert_eq!(encoded[0]["defaultValue"], CHECKBOX_CHECKED);
assert!(encoded[1].get("defaultValue").is_none(), "{encoded}");
}
#[test]
fn encode_drops_the_operand_of_a_valueless_operator() {
let mut field = CheckoutCustomField::new("x");
field.visibility = CustomFieldVisibility {
mode: CustomFieldVisibilityMode::Match,
match_: CustomFieldMatch::All,
conditions: vec![CustomFieldCondition {
value: "stale".into(),
..condition("metadata", "product", "exists", "stale")
}],
};
let encoded: Value =
serde_json::from_str(&encode_custom_fields(std::slice::from_ref(&field))).unwrap();
let cond = &encoded[0]["visibility"]["conditions"][0];
assert_eq!(cond["operator"], "exists");
assert!(cond.get("value").is_none(), "{cond}");
}
#[test]
fn string_operators_are_case_and_whitespace_insensitive() {
let c = ctx(1000, "EUR", &[("product", " Windows ")]);
assert!(evaluate_custom_field_condition(
&condition("metadata", "product", "equals", "windows"),
&c
));
assert!(evaluate_custom_field_condition(
&condition("metadata", "product", "contains", "WIND"),
&c
));
assert!(evaluate_custom_field_condition(
&condition("metadata", "product", "starts_with", "win"),
&c
));
assert!(evaluate_custom_field_condition(
&condition("metadata", "product", "ends_with", "OWS"),
&c
));
assert!(!evaluate_custom_field_condition(
&condition("metadata", "product", "not_contains", "wind"),
&c
));
}
#[test]
fn list_operators_split_on_commas() {
let c = ctx(1000, "EUR", &[("plan", "pro")]);
assert!(evaluate_custom_field_condition(
&condition("metadata", "plan", "in", "basic, PRO ,team"),
&c
));
assert!(evaluate_custom_field_condition(
&condition("metadata", "plan", "not_in", "basic,team"),
&c
));
}
#[test]
fn exists_treats_a_blank_value_as_missing() {
let c = ctx(1000, "EUR", &[("blank", " "), ("set", "x")]);
assert!(evaluate_custom_field_condition(
&condition("metadata", "set", "exists", ""),
&c
));
assert!(!evaluate_custom_field_condition(
&condition("metadata", "blank", "exists", ""),
&c
));
assert!(evaluate_custom_field_condition(
&condition("metadata", "absent", "not_exists", ""),
&c
));
}
#[test]
fn a_missing_metadata_key_reads_as_empty_for_value_operators() {
let c = ctx(1000, "EUR", &[]);
assert!(evaluate_custom_field_condition(
&condition("metadata", "absent", "equals", ""),
&c
));
assert!(!evaluate_custom_field_condition(
&condition("metadata", "absent", "equals", "x"),
&c
));
}
#[test]
fn numeric_operators_compare_the_amount() {
let c = ctx(2500, "EUR", &[]);
assert!(evaluate_custom_field_condition(
&condition("amount", "", "gte", "2500"),
&c
));
assert!(evaluate_custom_field_condition(
&condition("amount", "", "lt", "2501"),
&c
));
assert!(!evaluate_custom_field_condition(
&condition("amount", "", "gt", "2500"),
&c
));
}
#[test]
fn numeric_operators_refuse_a_non_numeric_operand() {
let c = ctx(1000, "EUR", &[("qty", "many")]);
assert!(!evaluate_custom_field_condition(
&condition("metadata", "qty", "gte", "0"),
&c
));
assert!(!evaluate_custom_field_condition(
&condition("metadata", "qty", "lt", "notanumber"),
&c
));
}
#[test]
fn numeric_operators_reject_radix_literals_and_infinities() {
let c = ctx(1000, "EUR", &[("hex", "0x10"), ("inf", "inf")]);
assert!(!evaluate_custom_field_condition(
&condition("metadata", "hex", "gte", "5"),
&c
));
assert!(!evaluate_custom_field_condition(
&condition("metadata", "inf", "gt", "5"),
&c
));
}
#[test]
fn visibility_fails_open_for_always_and_for_an_empty_match_rule() {
let c = ctx(1000, "EUR", &[]);
let always = CheckoutCustomField::new("a");
assert!(evaluate_custom_field_visibility(&always, &c));
let mut empty_rule = CheckoutCustomField::new("b");
empty_rule.visibility.mode = CustomFieldVisibilityMode::Match;
assert!(
evaluate_custom_field_visibility(&empty_rule, &c),
"a half-authored rule must not swallow the field"
);
}
#[test]
fn visibility_combines_conditions_with_all_and_any() {
let c = ctx(5000, "EUR", &[("product", "spotify")]);
let mut field = CheckoutCustomField::new("login");
field.visibility.mode = CustomFieldVisibilityMode::Match;
field.visibility.conditions = vec![
condition("metadata", "product", "equals", "spotify"),
condition("amount", "", "gt", "9000"),
];
field.visibility.match_ = CustomFieldMatch::All;
assert!(!evaluate_custom_field_visibility(&field, &c));
field.visibility.match_ = CustomFieldMatch::Any;
assert!(evaluate_custom_field_visibility(&field, &c));
}
#[test]
fn visible_custom_fields_drops_disabled_and_non_matching_fields() {
let c = ctx(1000, "EUR", &[("product", "windows")]);
let shown = CheckoutCustomField::new("shown");
let mut disabled = CheckoutCustomField::new("disabled");
disabled.enabled = false;
let mut hidden = CheckoutCustomField::new("hidden");
hidden.visibility.mode = CustomFieldVisibilityMode::Match;
hidden.visibility.conditions = vec![condition("metadata", "product", "equals", "spotify")];
let fields = vec![shown, disabled, hidden];
let visible = visible_custom_fields(&fields, &c);
assert_eq!(visible.len(), 1);
assert_eq!(visible[0].key, "shown");
}
#[test]
fn metadata_flattening_joins_arrays_and_drops_nulls() {
let flat = custom_field_context_from_metadata(&json!({
"s": "text",
"n": 42,
"b": true,
"list": ["a", 1, null, "b"],
"obj": {"k": "v"},
"nothing": null
}));
assert_eq!(flat.get("s").unwrap(), "text");
assert_eq!(flat.get("n").unwrap(), "42");
assert_eq!(flat.get("b").unwrap(), "true");
assert_eq!(flat.get("list").unwrap(), "a,1,b");
assert_eq!(flat.get("obj").unwrap(), r#"{"k":"v"}"#);
assert!(!flat.contains_key("nothing"));
}
#[test]
fn metadata_flattening_ignores_a_non_object() {
assert!(custom_field_context_from_metadata(&json!("nope")).is_empty());
assert!(custom_field_context_from_metadata(&json!([1, 2])).is_empty());
}
#[test]
fn text_resolves_exact_locale_then_base_then_default_then_key() {
let mut field = CheckoutCustomField::new("login");
field.label = "Login".into();
field.label_translations.insert("de".into(), "Konto".into());
field
.label_translations
.insert("de-AT".into(), "Zugang".into());
fn label(field: &CheckoutCustomField, locale: Option<&str>) -> String {
custom_field_text(field, CustomFieldTextPart::Label, locale)
}
assert_eq!(label(&field, Some("de-AT")), "Zugang");
assert_eq!(
label(&field, Some("de-CH")),
"Konto",
"falls back to the base language"
);
assert_eq!(label(&field, Some("fr")), "Login");
assert_eq!(label(&field, None), "Login");
field.label = String::new();
field.label_translations.clear();
assert_eq!(label(&field, Some("fr")), "login");
assert_eq!(
custom_field_text(&field, CustomFieldTextPart::Placeholder, Some("fr")),
""
);
}
#[test]
fn option_label_falls_back_to_the_label_then_the_value() {
let mut option = CustomFieldOption {
value: "pro".into(),
label: "Pro".into(),
label_translations: CustomFieldTranslations::new(),
};
option
.label_translations
.insert("de".into(), "Profi".into());
assert_eq!(custom_field_option_label(&option, Some("de-AT")), "Profi");
assert_eq!(custom_field_option_label(&option, Some("fr")), "Pro");
option.label = String::new();
assert_eq!(custom_field_option_label(&option, None), "pro");
}
#[test]
fn operators_by_source_stay_narrower_than_the_full_set() {
assert_eq!(
CustomFieldConditionSource::Metadata.operators().len(),
ALL_CUSTOM_FIELD_OPERATORS.len()
);
assert_eq!(
CustomFieldConditionSource::Currency.default_operator(),
CustomFieldOperator::Equals
);
assert!(
!CustomFieldConditionSource::Currency
.operators()
.contains(&CustomFieldOperator::Contains),
"a 3-letter closed set has no use for substring matching"
);
assert!(
!CustomFieldConditionSource::Amount
.operators()
.contains(&CustomFieldOperator::StartsWith)
);
for op in CUSTOM_FIELD_VALUELESS_OPERATORS {
assert!(!op.takes_value());
}
assert!(CustomFieldOperator::Equals.takes_value());
}
#[test]
fn type_helpers_agree_on_which_types_are_text_like() {
for t in ALL_CUSTOM_FIELD_TYPES {
let expected = !matches!(t, CustomFieldType::Select | CustomFieldType::Checkbox);
assert_eq!(t.is_text_like(), expected, "{}", t.as_wire());
assert_eq!(
CustomFieldType::from_wire(Some(&json!(t.as_wire()))),
*t,
"{}",
t.as_wire()
);
}
}
#[test]
fn checkbox_checked_is_tolerant_of_case_and_padding() {
assert!(is_checkbox_checked(Some("true")));
assert!(is_checkbox_checked(Some(" True ")));
assert!(!is_checkbox_checked(Some("false")));
assert!(!is_checkbox_checked(Some("")));
assert!(!is_checkbox_checked(None));
}
}