feat(payment-methods): Add volatile payment method id support in proxy v2

api-reference/v2/openapi_spec_v2.json

@@ -27169,7 +27169,8 @@
         "type": "string",
         "enum": [
           "tokenization_id",
-          "payment_method_id"
+          "payment_method_id",
+          "volatile_payment_method_id"
         ]
       },
       "Tokenization": {

crates/api_models/src/payment_methods.rs

@@ -108,7 +108,7 @@ pub struct PaymentMethodCreate {
     pub payment_method_type: api_enums::PaymentMethod,
 
     /// This is a sub-category of payment method.
-    #[schema(value_type = PaymentMethodType,example = "google_pay")]
+    #[schema(value_type = PaymentMethodType,example = "credit")]
     pub payment_method_subtype: api_enums::PaymentMethodType,
 
     /// You can specify up to 50 keys, with key names up to 40 characters long and values up to 500 characters long. Metadata is useful for storing additional, structured information on an object.

crates/api_models/src/proxy.rs

@@ -52,6 +52,7 @@ pub struct ProxyRequest {
 pub enum TokenType {
     TokenizationId,
     PaymentMethodId,
+    VolatilePaymentMethodId,
 }
 
 #[derive(Debug, ToSchema, Clone, Deserialize, Serialize)]

crates/router/src/core/payment_methods.rs

@@ -40,6 +40,8 @@ use error_stack::{report, ResultExt};
 use futures::TryStreamExt;
 #[cfg(feature = "v1")]
 use hyperswitch_domain_models::api::{GenericLinks, GenericLinksData};
+#[cfg(feature = "v2")]
+use hyperswitch_domain_models::behaviour::Conversion;
 use hyperswitch_domain_models::{
     payments::{payment_attempt::PaymentAttempt, PaymentIntent, VaultData},
     router_data_v2::flow_common_types::VaultConnectorFlowData,

crates/router/src/core/proxy/utils.rs

@@ -1,11 +1,12 @@
 use api_models::{payment_methods::PaymentMethodId, proxy as proxy_api_models};
 use common_utils::{
-    ext_traits::{Encode, OptionExt},
+    crypto::{DecodeMessage, GcmAes256},
+    ext_traits::{BytesExt, Encode, OptionExt},
     id_type,
 };
 use error_stack::ResultExt;
-use hyperswitch_domain_models::payment_methods;
-use masking::Mask;
+use hyperswitch_domain_models::{behaviour::Conversion, payment_methods};
+use masking::{Mask, PeekInterface};
 use serde_json::Value;
 use x509_parser::nom::{
     bytes::complete::{tag, take_while1},
@@ -26,6 +27,7 @@ use crate::{
 pub struct ProxyRequestWrapper(pub proxy_api_models::ProxyRequest);
 pub enum ProxyRecord {
     PaymentMethodRecord(Box<domain::PaymentMethod>),
+    VolatilePaymentMethodRecord(Box<domain::PaymentMethod>),
     TokenizationRecord(Box<domain::Tokenization>),
 }
 
@@ -75,6 +77,60 @@ impl ProxyRequestWrapper {
                     tokenization_record,
                 )))
             }
+            proxy_api_models::TokenType::VolatilePaymentMethodId => {
+                let pm_id = token.as_str();
+                let encryption_key = key_store.key.get_inner();
+
+                let redis_conn = state
+                    .store
+                    .get_redis_conn()
+                    .change_context(errors::ApiErrorResponse::InternalServerError)
+                    .attach_printable("Failed to get redis connection")?;
+
+                let response = redis_conn.get_key::<bytes::Bytes>(&pm_id.into()).await;
+
+                let payment_method_record = match response {
+                    Ok(resp) => {
+                        let decrypted_payload = GcmAes256
+                            .decode_message(
+                                encryption_key.peek().as_ref(),
+                                masking::Secret::new(resp.into()),
+                            )
+                            .change_context(errors::ApiErrorResponse::InternalServerError)
+                            .attach_printable("Failed to decode redis temp locker data")?;
+
+                        let payment_method = bytes::Bytes::from(decrypted_payload)
+                            .parse_struct::<diesel_models::PaymentMethod>("PaymentMethod")
+                            .change_context(errors::ApiErrorResponse::InternalServerError)
+                            .attach_printable(
+                                "Error getting PaymentMethod from tokenize response",
+                            )?;
+
+                        let keymanager_state = &state.into();
+
+                        let domain_payment_method = domain::PaymentMethod::convert_back(
+                            keymanager_state,
+                            payment_method,
+                            key_store.key.get_inner(),
+                            key_store.merchant_id.clone().into(),
+                        )
+                        .await
+                        .change_context(errors::StorageError::EncryptionError)
+                        .change_context(errors::ApiErrorResponse::InternalServerError)?;
+
+                        Ok(domain_payment_method)
+                    }
+                    Err(err) => {
+                        Err(err).change_context(errors::ApiErrorResponse::UnprocessableEntity {
+                            message: "Token is invalid or expired".into(),
+                        })
+                    }
+                }?;
+
+                Ok(ProxyRecord::VolatilePaymentMethodRecord(Box::new(
+                    payment_method_record,
+                )))
+            }
         }
     }
 
@@ -108,19 +164,31 @@ impl ProxyRecord {
             Self::TokenizationRecord(tokenization_record) => Ok(
                 payment_methods::VaultId::generate(tokenization_record.locker_id.clone()),
             ),
+            Self::VolatilePaymentMethodRecord(payment_method) => payment_method
+                .locker_id
+                .clone()
+                .get_required_value("vault_id")
+                .change_context(errors::ApiErrorResponse::InternalServerError)
+                .attach_printable("Locker id not present in Volatile Payment Method Entry"),
         }
     }
 
-    fn get_customer_id(&self) -> RouterResult<id_type::GlobalCustomerId> {
+    fn get_customer_id(&self) -> RouterResult<Option<id_type::GlobalCustomerId>> {
         match self {
-            Self::PaymentMethodRecord(payment_method) => payment_method
-                .customer_id
-                .clone()
-                .get_required_value("customer_id")
-                .change_context(errors::ApiErrorResponse::InternalServerError)
-                .attach_printable("Customer id not present in Payment Method Entry"),
+            Self::PaymentMethodRecord(payment_method) => {
+                let customer_id = payment_method
+                    .customer_id
+                    .clone()
+                    .get_required_value("customer_id")
+                    .change_context(errors::ApiErrorResponse::InternalServerError)
+                    .attach_printable("Customer id not present in Payment Method Entry")?;
+                Ok(Some(customer_id))
+            }
             Self::TokenizationRecord(tokenization_record) => {
-                Ok(tokenization_record.customer_id.clone())
+                Ok(Some(tokenization_record.customer_id.clone()))
+            }
+            Self::VolatilePaymentMethodRecord(payment_method) => {
+                Ok(payment_method.customer_id.clone())
             }
         }
     }
@@ -132,11 +200,16 @@ impl ProxyRecord {
     ) -> RouterResult<Value> {
         match self {
             Self::PaymentMethodRecord(_) => {
+                let customer_id = self
+                    .get_customer_id()?
+                    .get_required_value("customer_id")
+                    .change_context(errors::ApiErrorResponse::InternalServerError)
+                    .attach_printable("Locker id not present in Payment Method Entry")?;
                 let vault_resp = vault::retrieve_payment_method_from_vault_internal(
                     state,
                     &platform,
                     &self.get_vault_id()?,
-                    &self.get_customer_id()?,
+                    &customer_id,
                 )
                 .await
                 .change_context(errors::ApiErrorResponse::InternalServerError)
@@ -149,8 +222,13 @@ impl ProxyRecord {
                     .attach_printable("Failed to serialize vault data")?)
             }
             Self::TokenizationRecord(_) => {
+                let customer_id = self
+                    .get_customer_id()?
+                    .get_required_value("customer_id")
+                    .change_context(errors::ApiErrorResponse::InternalServerError)
+                    .attach_printable("Locker id not present in Tokenization Record")?;
                 let vault_request = pm_types::VaultRetrieveRequest {
-                    entity_id: self.get_customer_id()?,
+                    entity_id: customer_id,
                     vault_id: self.get_vault_id()?,
                 };
 
@@ -161,6 +239,53 @@ impl ProxyRecord {
 
                 Ok(vault_data.get("data").cloned().unwrap_or(Value::Null))
             }
+            Self::VolatilePaymentMethodRecord(_) => {
+                //retrieve from redis
+                let vault_id = self.get_vault_id()?;
+                let key_store = platform.get_processor().get_key_store();
+                let encryption_key = key_store.key.get_inner();
+
+                let redis_conn = state
+                    .store
+                    .get_redis_conn()
+                    .change_context(errors::ApiErrorResponse::InternalServerError)
+                    .attach_printable("Failed to get redis connection")?;
+
+                let response = redis_conn
+                    .get_key::<bytes::Bytes>(&vault_id.get_string_repr().into())
+                    .await;
+
+                match response {
+                    Ok(resp) => {
+                        let decrypted_payload = GcmAes256
+                            .decode_message(
+                                encryption_key.peek().as_ref(),
+                                masking::Secret::new(resp.into()),
+                            )
+                            .change_context(errors::ApiErrorResponse::InternalServerError)
+                            .attach_printable("Failed to decode redis temp locker data")?;
+
+                        let vault_data = bytes::Bytes::from(decrypted_payload)
+                            .parse_struct::<domain::PaymentMethodVaultingData>(
+                                "PaymentMethodVaultingData",
+                            )
+                            .change_context(errors::ApiErrorResponse::InternalServerError)
+                            .attach_printable(
+                                "Error getting PaymentMethodVaultingData from tokenize response",
+                            )?;
+
+                        Ok(vault_data
+                            .encode_to_value()
+                            .change_context(errors::ApiErrorResponse::InternalServerError)
+                            .attach_printable("Failed to serialize vault data")?)
+                    }
+                    Err(err) => {
+                        Err(err).change_context(errors::ApiErrorResponse::UnprocessableEntity {
+                            message: "Token is invalid or expired".into(),
+                        })
+                    }
+                }
+            }
         }
     }
 }