feat(pay): add forward-compatible enum handling

crates/yttrium/Cargo.toml

@@ -333,10 +333,16 @@ aws-config = { version = "1.1.7", features = ["behavior-version-latest"], option
 aws-sdk-cloudwatch = { version = "1.91.0", optional = true }
 
 # Pay
-progenitor = { workspace = true }
 progenitor-client = { workspace = true, optional = true }
 urlencoding = "2.1"
 
+[build-dependencies]
+progenitor = { workspace = true }
+serde_json = { workspace = true }
+prettyplease = "0.2"
+syn = "2.0"
+openapiv3 = "2.0"
+
 [dev-dependencies]
 pay-api = { path = "../pay-api" }
 

crates/yttrium/build.rs

@@ -0,0 +1,62 @@
+use std::{env, fs, path::PathBuf};
+
+fn main() {
+    println!("cargo:rerun-if-changed=src/pay/openapi.json");
+
+    // Only generate pay API if the pay feature is enabled
+    if env::var("CARGO_FEATURE_PAY").is_ok() {
+        generate_pay_api();
+    }
+}
+
+fn generate_pay_api() {
+    let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
+    let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
+    let spec_path = manifest_dir.join("src/pay/openapi.json");
+
+    // Read and preprocess the OpenAPI spec as JSON
+    let spec_content =
+        fs::read_to_string(&spec_path).expect("Failed to read openapi.json");
+    let mut spec: serde_json::Value = serde_json::from_str(&spec_content)
+        .expect("Failed to parse openapi.json");
+
+    // Remove enum constraints from specific schemas to make them
+    // forward-compatible (unknown values won't fail deserialization)
+    remove_enum_constraint(&mut spec, "PaymentStatus");
+    remove_enum_constraint(&mut spec, "CollectDataFieldType");
+
+    // Write the preprocessed spec
+    let preprocessed_path = out_dir.join("pay_openapi_preprocessed.json");
+    fs::write(&preprocessed_path, serde_json::to_string_pretty(&spec).unwrap())
+        .expect("Failed to write preprocessed spec");
+
+    // Parse preprocessed JSON as OpenAPI spec
+    let file = fs::File::open(&preprocessed_path).unwrap();
+    let spec: openapiv3::OpenAPI =
+        serde_json::from_reader(file).expect("Failed to parse as OpenAPI");
+
+    // Generate progenitor code with Builder interface and Separate tags
+    let mut settings = progenitor::GenerationSettings::default();
+    settings.with_interface(progenitor::InterfaceStyle::Builder);
+    settings.with_tag(progenitor::TagStyle::Separate);
+    settings.with_derive("PartialEq".to_string());
+    let mut generator = progenitor::Generator::new(&settings);
+    let tokens = generator
+        .generate_tokens(&spec)
+        .expect("Failed to generate progenitor tokens");
+    let ast = syn::parse2(tokens).expect("Failed to parse generated tokens");
+    let content = prettyplease::unparse(&ast);
+
+    let codegen_path = out_dir.join("pay_codegen.rs");
+    fs::write(&codegen_path, content).expect("Failed to write generated code");
+}
+
+fn remove_enum_constraint(spec: &mut serde_json::Value, schema_name: &str) {
+    if let Some(schema) =
+        spec.pointer_mut(&format!("/components/schemas/{}", schema_name))
+    {
+        if let Some(obj) = schema.as_object_mut() {
+            obj.remove("enum");
+        }
+    }
+}

crates/yttrium/src/pay/e2e_tests.rs

@@ -363,7 +363,8 @@ async fn e2e_payment_happy_path() {
                             CollectDataFieldType::Date => {
                                 "1990-01-15".to_string()
                             }
-                            CollectDataFieldType::Text => {
+                            CollectDataFieldType::Text
+                            | CollectDataFieldType::Unknown { .. } => {
                                 "test-value".to_string()
                             }
                             CollectDataFieldType::Checkbox => {

crates/yttrium/src/pay/mod.rs

@@ -1,12 +1,10 @@
-progenitor::generate_api!(
-    spec = "src/pay/openapi.json",
-    interface = Builder,
-    tags = Separate,
-    derives = [PartialEq],
-);
+// Progenitor generates elided lifetimes that trigger this lint
+#![allow(mismatched_lifetime_syntaxes)]
+include!(concat!(env!("OUT_DIR"), "/pay_codegen.rs"));
 
 mod error_reporting;
 mod observability;
+mod serde_enums;
 
 #[cfg(any(feature = "uniffi", feature = "wasm"))]
 pub mod json;
@@ -307,27 +305,26 @@
     pub client_id: Option<String>,
 }
 
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, PartialEq)]
 #[cfg_attr(feature = "uniffi", derive(uniffi::Enum))]
-#[serde(rename_all = "snake_case")]
 pub enum PaymentStatus {
     RequiresAction,
     Processing,
     Succeeded,
     Failed,
     Expired,
+    Unknown { value: String },
 }
 
 impl From<types::PaymentStatus> for PaymentStatus {
     fn from(s: types::PaymentStatus) -> Self {
-        match s {
-            types::PaymentStatus::RequiresAction => {
-                PaymentStatus::RequiresAction
-            }
-            types::PaymentStatus::Processing => PaymentStatus::Processing,
-            types::PaymentStatus::Succeeded => PaymentStatus::Succeeded,
-            types::PaymentStatus::Failed => PaymentStatus::Failed,
-            types::PaymentStatus::Expired => PaymentStatus::Expired,
+        match s.as_str() {
+            "requires_action" => PaymentStatus::RequiresAction,
+            "processing" => PaymentStatus::Processing,
+            "succeeded" => PaymentStatus::Succeeded,
+            "failed" => PaymentStatus::Failed,
+            "expired" => PaymentStatus::Expired,
+            other => PaymentStatus::Unknown { value: other.to_string() },
         }
     }
 }
@@ -389,23 +386,22 @@
     }
 }
 
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, PartialEq)]
 #[cfg_attr(feature = "uniffi", derive(uniffi::Enum))]
-#[serde(rename_all = "snake_case")]
 pub enum CollectDataFieldType {
     Text,
     Date,
     Checkbox,
+    Unknown { value: String },
 }
 
 impl From<types::CollectDataFieldType> for CollectDataFieldType {
     fn from(t: types::CollectDataFieldType) -> Self {
-        match t {
-            types::CollectDataFieldType::Text => CollectDataFieldType::Text,
-            types::CollectDataFieldType::Date => CollectDataFieldType::Date,
-            types::CollectDataFieldType::Checkbox => {
-                CollectDataFieldType::Checkbox
-            }
+        match t.as_str() {
+            "text" => CollectDataFieldType::Text,
+            "date" => CollectDataFieldType::Date,
+            "checkbox" => CollectDataFieldType::Checkbox,
+            other => CollectDataFieldType::Unknown { value: other.to_string() },
         }
     }
 }
@@ -2402,4 +2398,48 @@
             result
         );
     }
+
+    #[test]
+    fn test_payment_status_forward_compatible() {
+        assert_eq!(
+            PaymentStatus::from(types::PaymentStatus::from(
+                "succeeded".to_string()
+            )),
+            PaymentStatus::Succeeded
+        );
+        assert_eq!(
+            PaymentStatus::from(types::PaymentStatus::from(
+                "processing".to_string()
+            )),
+            PaymentStatus::Processing
+        );
+        assert_eq!(
+            PaymentStatus::from(types::PaymentStatus::from(
+                "new_future_status".to_string()
+            )),
+            PaymentStatus::Unknown { value: "new_future_status".to_string() }
+        );
+    }
+
+    #[test]
+    fn test_collect_data_field_type_forward_compatible() {
+        assert_eq!(
+            CollectDataFieldType::from(types::CollectDataFieldType::from(
+                "text".to_string()
+            )),
+            CollectDataFieldType::Text
+        );
+        assert_eq!(
+            CollectDataFieldType::from(types::CollectDataFieldType::from(
+                "date".to_string()
+            )),
+            CollectDataFieldType::Date
+        );
+        assert_eq!(
+            CollectDataFieldType::from(types::CollectDataFieldType::from(
+                "future_type".to_string()
+            )),
+            CollectDataFieldType::Unknown { value: "future_type".to_string() }
+        );
+    }
 }

crates/yttrium/src/pay/serde_enums.rs

@@ -0,0 +1,154 @@
+use {
+    super::{CollectDataFieldType, PaymentStatus},
+    serde::{de::Deserializer, ser::Serializer},
+};
+
+impl serde::Serialize for PaymentStatus {
+    fn serialize<S: Serializer>(
+        &self,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        serializer.serialize_str(match self {
+            Self::RequiresAction => "requires_action",
+            Self::Processing => "processing",
+            Self::Succeeded => "succeeded",
+            Self::Failed => "failed",
+            Self::Expired => "expired",
+            Self::Unknown { value } => value,
+        })
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for PaymentStatus {
+    fn deserialize<D: Deserializer<'de>>(
+        deserializer: D,
+    ) -> Result<Self, D::Error> {
+        let s: String = serde::Deserialize::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "requires_action" => Self::RequiresAction,
+            "processing" => Self::Processing,
+            "succeeded" => Self::Succeeded,
+            "failed" => Self::Failed,
+            "expired" => Self::Expired,
+            _ => Self::Unknown { value: s },
+        })
+    }
+}
+
+impl serde::Serialize for CollectDataFieldType {
+    fn serialize<S: Serializer>(
+        &self,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        serializer.serialize_str(match self {
+            Self::Text => "text",
+            Self::Date => "date",
+            Self::Checkbox => "checkbox",
+            Self::Unknown { value } => value,
+        })
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for CollectDataFieldType {
+    fn deserialize<D: Deserializer<'de>>(
+        deserializer: D,
+    ) -> Result<Self, D::Error> {
+        let s: String = serde::Deserialize::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "text" => Self::Text,
+            "date" => Self::Date,
+            "checkbox" => Self::Checkbox,
+            _ => Self::Unknown { value: s },
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn payment_status_serializes_known_variants() {
+        assert_eq!(
+            serde_json::to_string(&PaymentStatus::Succeeded).unwrap(),
+            "\"succeeded\""
+        );
+        assert_eq!(
+            serde_json::to_string(&PaymentStatus::RequiresAction).unwrap(),
+            "\"requires_action\""
+        );
+    }
+
+    #[test]
+    fn payment_status_serializes_unknown_variant() {
+        let status = PaymentStatus::Unknown { value: "new_status".to_string() };
+        assert_eq!(serde_json::to_string(&status).unwrap(), "\"new_status\"");
+    }
+
+    #[test]
+    fn payment_status_deserializes_known_variants() {
+        assert_eq!(
+            serde_json::from_str::<PaymentStatus>("\"succeeded\"").unwrap(),
+            PaymentStatus::Succeeded
+        );
+        assert_eq!(
+            serde_json::from_str::<PaymentStatus>("\"requires_action\"")
+                .unwrap(),
+            PaymentStatus::RequiresAction
+        );
+    }
+
+    #[test]
+    fn payment_status_deserializes_unknown_variant() {
+        assert_eq!(
+            serde_json::from_str::<PaymentStatus>("\"new_status\"").unwrap(),
+            PaymentStatus::Unknown { value: "new_status".to_string() }
+        );
+    }
+
+    #[test]
+    fn payment_status_roundtrip() {
+        for status in [
+            PaymentStatus::RequiresAction,
+            PaymentStatus::Processing,
+            PaymentStatus::Succeeded,
+            PaymentStatus::Failed,
+            PaymentStatus::Expired,
+            PaymentStatus::Unknown { value: "future_status".to_string() },
+        ] {
+            let json = serde_json::to_string(&status).unwrap();
+            let back: PaymentStatus = serde_json::from_str(&json).unwrap();
+            assert_eq!(back, status);
+        }
+    }
+
+    #[test]
+    fn collect_data_field_type_serializes_known_variants() {
+        assert_eq!(
+            serde_json::to_string(&CollectDataFieldType::Text).unwrap(),
+            "\"text\""
+        );
+    }
+
+    #[test]
+    fn collect_data_field_type_serializes_unknown_variant() {
+        let ft =
+            CollectDataFieldType::Unknown { value: "dropdown".to_string() };
+        assert_eq!(serde_json::to_string(&ft).unwrap(), "\"dropdown\"");
+    }
+
+    #[test]
+    fn collect_data_field_type_roundtrip() {
+        for ft in [
+            CollectDataFieldType::Text,
+            CollectDataFieldType::Date,
+            CollectDataFieldType::Checkbox,
+            CollectDataFieldType::Unknown { value: "dropdown".to_string() },
+        ] {
+            let json = serde_json::to_string(&ft).unwrap();
+            let back: CollectDataFieldType =
+                serde_json::from_str(&json).unwrap();
+            assert_eq!(back, ft);
+        }
+    }
+}