feat(payouts): add payout types in euclid crate (#3862)

Co-authored-by: Kashif <[email protected]>

crates/common_enums/src/enums.rs

@@ -2057,12 +2057,15 @@ pub enum PayoutStatus {
     Debug,
     Default,
     Eq,
+    Hash,
     PartialEq,
-    ToSchema,
     serde::Deserialize,
     serde::Serialize,
     strum::Display,
+    strum::EnumVariantNames,
+    strum::EnumIter,
     strum::EnumString,
+    ToSchema,
 )]
 #[router_derive::diesel_enum(storage_type = "db_enum")]
 #[serde(rename_all = "snake_case")]

crates/euclid/Cargo.toml

@@ -23,10 +23,12 @@ common_enums = { version = "0.1.0", path = "../common_enums" }
 euclid_macros = { version = "0.1.0", path = "../euclid_macros" }
 
 [features]
+default = []
 ast_parser = ["dep:nom"]
 valued_jit = []
 connector_choice_mca_id = []
 dummy_connector = []
+payouts = []
 
 [dev-dependencies]
 criterion = "0.5"

crates/euclid/src/enums.rs

@@ -34,6 +34,12 @@ collect_variants!(CaptureMethod);
 collect_variants!(Currency);
 collect_variants!(Country);
 collect_variants!(SetupFutureUsage);
+#[cfg(feature = "payouts")]
+collect_variants!(PayoutType);
+#[cfg(feature = "payouts")]
+collect_variants!(PayoutBankTransferType);
+#[cfg(feature = "payouts")]
+collect_variants!(PayoutWalletType);
 
 #[derive(
     Clone,
@@ -94,3 +100,67 @@ pub enum MandateType {
     SingleUse,
     MultiUse,
 }
+
+#[cfg(feature = "payouts")]
+#[derive(
+    Clone,
+    Debug,
+    Hash,
+    PartialEq,
+    Eq,
+    strum::Display,
+    strum::EnumVariantNames,
+    strum::EnumIter,
+    strum::EnumString,
+    serde::Serialize,
+    serde::Deserialize,
+)]
+#[serde(rename_all = "snake_case")]
+#[strum(serialize_all = "snake_case")]
+pub enum PayoutBankTransferType {
+    Ach,
+    Bacs,
+    Sepa,
+}
+
+#[cfg(feature = "payouts")]
+#[derive(
+    Clone,
+    Debug,
+    Hash,
+    PartialEq,
+    Eq,
+    strum::Display,
+    strum::EnumVariantNames,
+    strum::EnumIter,
+    strum::EnumString,
+    serde::Serialize,
+    serde::Deserialize,
+)]
+#[serde(rename_all = "snake_case")]
+#[strum(serialize_all = "snake_case")]
+pub enum PayoutWalletType {
+    Paypal,
+}
+
+#[cfg(feature = "payouts")]
+#[derive(
+    Clone,
+    Debug,
+    Hash,
+    PartialEq,
+    Eq,
+    strum::Display,
+    strum::EnumVariantNames,
+    strum::EnumIter,
+    strum::EnumString,
+    serde::Serialize,
+    serde::Deserialize,
+)]
+#[serde(rename_all = "snake_case")]
+#[strum(serialize_all = "snake_case")]
+pub enum PayoutType {
+    Card,
+    BankTransfer,
+    Wallet,
+}

crates/euclid/src/frontend/dir.rs

@@ -667,6 +667,101 @@ impl DirValue {
     }
 }
 
+#[cfg(feature = "payouts")]
+#[derive(
+    Debug,
+    Clone,
+    Hash,
+    PartialEq,
+    Eq,
+    serde::Serialize,
+    strum::Display,
+    strum::EnumIter,
+    strum::EnumVariantNames,
+    strum::EnumString,
+    strum::EnumMessage,
+    strum::EnumProperty,
+)]
+pub enum PayoutDirKeyKind {
+    #[strum(
+        serialize = "country",
+        serialize = "business_country",
+        detailed_message = "Country of the business unit",
+        props(Category = "Merchant")
+    )]
+    #[serde(rename = "business_country", alias = "country")]
+    BusinessCountry,
+
+    #[strum(
+        serialize = "billing_country",
+        detailed_message = "Country of the billing address of the customer",
+        props(Category = "Customer")
+    )]
+    #[serde(rename = "billing_country")]
+    BillingCountry,
+
+    #[strum(
+        serialize = "business_label",
+        detailed_message = "Identifier for business unit",
+        props(Category = "Merchant")
+    )]
+    #[serde(rename = "business_label")]
+    BusinessLabel,
+
+    #[strum(
+        serialize = "amount",
+        detailed_message = "Value of the transaction",
+        props(Category = "Order details")
+    )]
+    #[serde(rename = "amount")]
+    PayoutAmount,
+
+    #[strum(
+        serialize = "payment_method",
+        detailed_message = "Different modes of payout - eg. cards, wallets, banks",
+        props(Category = "Payout Methods")
+    )]
+    #[serde(rename = "payment_method")]
+    PayoutType,
+
+    #[strum(
+        serialize = "wallet",
+        detailed_message = "Supported types of Wallets for payouts",
+        props(Category = "Payout Methods Type")
+    )]
+    #[serde(rename = "wallet")]
+    WalletType,
+
+    #[strum(
+        serialize = "bank_transfer",
+        detailed_message = "Supported types of Bank transfer types for payouts",
+        props(Category = "Payout Methods Type")
+    )]
+    #[serde(rename = "bank_transfer")]
+    BankTransferType,
+}
+
+#[cfg(feature = "payouts")]
+#[derive(
+    Debug, Clone, Hash, PartialEq, Eq, serde::Serialize, strum::Display, strum::EnumVariantNames,
+)]
+pub enum PayoutDirValue {
+    #[serde(rename = "business_country", alias = "country")]
+    BusinessCountry(enums::Country),
+    #[serde(rename = "billing_country")]
+    BillingCountry(enums::Country),
+    #[serde(rename = "business_label")]
+    BusinessLabel(types::StrValue),
+    #[serde(rename = "amount")]
+    PayoutAmount(types::NumValue),
+    #[serde(rename = "payment_method")]
+    PayoutType(common_enums::PayoutType),
+    #[serde(rename = "wallet")]
+    WalletType(enums::PayoutWalletType),
+    #[serde(rename = "bank_transfer")]
+    BankTransferType(enums::PayoutBankTransferType),
+}
+
 #[derive(Debug, Clone)]
 pub enum DirComparisonLogic {
     NegativeConjunction,

crates/euclid/src/frontend/dir/enums.rs

@@ -6,6 +6,8 @@ pub use crate::enums::{
     Country as BillingCountry, Currency as PaymentCurrency, MandateAcceptanceType, MandateType,
     PaymentMethod, PaymentType, RoutableConnectors, SetupFutureUsage,
 };
+#[cfg(feature = "payouts")]
+pub use crate::enums::{PayoutBankTransferType, PayoutType, PayoutWalletType};
 
 #[derive(
     Clone,

crates/euclid_wasm/Cargo.toml

@@ -11,14 +11,14 @@ crate-type = ["cdylib"]
 
 [features]
 default = ["connector_choice_bcompat", "payouts", "connector_choice_mca_id"]
-release = ["connector_choice_bcompat", "connector_choice_mca_id"]
+release = ["connector_choice_bcompat", "connector_choice_mca_id", "payouts"]
 connector_choice_bcompat = ["api_models/connector_choice_bcompat"]
 connector_choice_mca_id = ["api_models/connector_choice_mca_id", "euclid/connector_choice_mca_id", "kgraph_utils/connector_choice_mca_id"]
 dummy_connector = ["kgraph_utils/dummy_connector", "connector_configs/dummy_connector"]
 production = ["connector_configs/production"]
 development = ["connector_configs/development"]
 sandbox = ["connector_configs/sandbox"]
-payouts = ["api_models/payouts"]
+payouts = ["api_models/payouts", "euclid/payouts"]
 
 [dependencies]
 api_models = { version = "0.1.0", path = "../api_models", package = "api_models" }

crates/euclid_wasm/src/lib.rs

@@ -256,12 +256,13 @@ pub fn get_variant_values(key: &str) -> Result<JsValue, JsValue> {
         dir::DirKeyKind::CardRedirectType => dir_enums::CardRedirectType::VARIANTS,
         dir::DirKeyKind::GiftCardType => dir_enums::GiftCardType::VARIANTS,
         dir::DirKeyKind::VoucherType => dir_enums::VoucherType::VARIANTS,
+        dir::DirKeyKind::BankDebitType => dir_enums::BankDebitType::VARIANTS,
+
         dir::DirKeyKind::PaymentAmount
         | dir::DirKeyKind::Connector
         | dir::DirKeyKind::CardBin
         | dir::DirKeyKind::BusinessLabel
         | dir::DirKeyKind::MetaData => Err("Key does not have variants".to_string())?,
-        dir::DirKeyKind::BankDebitType => dir_enums::BankDebitType::VARIANTS,
     };
 
     Ok(serde_wasm_bindgen::to_value(variants)?)
@@ -335,3 +336,52 @@ pub fn get_response_payload(input: JsValue) -> JsResult {
     let result = ConnectorApiIntegrationPayload::get_transformed_response_payload(input);
     Ok(serde_wasm_bindgen::to_value(&result)?)
 }
+
+#[cfg(feature = "payouts")]
+#[wasm_bindgen(js_name = getAllPayoutKeys)]
+pub fn get_all_payout_keys() -> JsResult {
+    let keys: Vec<&'static str> = dir::PayoutDirKeyKind::VARIANTS.to_vec();
+    Ok(serde_wasm_bindgen::to_value(&keys)?)
+}
+
+#[cfg(feature = "payouts")]
+#[wasm_bindgen(js_name = getPayoutVariantValues)]
+pub fn get_payout_variant_values(key: &str) -> Result<JsValue, JsValue> {
+    let key =
+        dir::PayoutDirKeyKind::from_str(key).map_err(|_| "Invalid key received".to_string())?;
+
+    let variants: &[&str] = match key {
+        dir::PayoutDirKeyKind::BusinessCountry => dir_enums::BusinessCountry::VARIANTS,
+        dir::PayoutDirKeyKind::BillingCountry => dir_enums::BillingCountry::VARIANTS,
+        dir::PayoutDirKeyKind::PayoutType => dir_enums::PayoutType::VARIANTS,
+        dir::PayoutDirKeyKind::WalletType => dir_enums::PayoutWalletType::VARIANTS,
+        dir::PayoutDirKeyKind::BankTransferType => dir_enums::PayoutBankTransferType::VARIANTS,
+
+        dir::PayoutDirKeyKind::PayoutAmount | dir::PayoutDirKeyKind::BusinessLabel => {
+            Err("Key does not have variants".to_string())?
+        }
+    };
+
+    Ok(serde_wasm_bindgen::to_value(variants)?)
+}
+
+#[cfg(feature = "payouts")]
+#[wasm_bindgen(js_name = getPayoutDescriptionCategory)]
+pub fn get_payout_description_category() -> JsResult {
+    let keys = dir::PayoutDirKeyKind::VARIANTS.to_vec();
+    let mut category: HashMap<Option<&str>, Vec<types::PayoutDetails<'_>>> = HashMap::new();
+    for key in keys {
+        let dir_key =
+            dir::PayoutDirKeyKind::from_str(key).map_err(|_| "Invalid key received".to_string())?;
+        let details = types::PayoutDetails {
+            description: dir_key.get_detailed_message(),
+            kind: dir_key.clone(),
+        };
+        category
+            .entry(dir_key.get_str("Category"))
+            .and_modify(|val| val.push(details.clone()))
+            .or_insert(vec![details]);
+    }
+
+    Ok(serde_wasm_bindgen::to_value(&category)?)
+}

crates/euclid_wasm/src/types.rs

@@ -1,8 +1,17 @@
 use euclid::frontend::dir::DirKeyKind;
+#[cfg(feature = "payouts")]
+use euclid::frontend::dir::PayoutDirKeyKind;
 use serde::Serialize;
 
 #[derive(Serialize, Clone)]
 pub struct Details<'a> {
     pub description: Option<&'a str>,
     pub kind: DirKeyKind,
 }
+
+#[cfg(feature = "payouts")]
+#[derive(Serialize, Clone)]
+pub struct PayoutDetails<'a> {
+    pub description: Option<&'a str>,
+    pub kind: PayoutDirKeyKind,
+}

crates/router/src/core/routing.rs

@@ -714,6 +714,7 @@ pub async fn retrieve_linked_routing_config(
     state: AppState,
     merchant_account: domain::MerchantAccount,
     #[cfg(feature = "business_profile_routing")] query_params: RoutingRetrieveLinkQuery,
+    #[cfg(feature = "business_profile_routing")] transaction_type: &enums::TransactionType,
 ) -> RouterResponse<routing_types::LinkedRoutingConfigRetrieveResponse> {
     metrics::ROUTING_RETRIEVE_LINK_CONFIG.add(&metrics::CONTEXT, 1, &[]);
     let db = state.store.as_ref();
@@ -739,16 +740,17 @@ pub async fn retrieve_linked_routing_config(
         let mut active_algorithms = Vec::new();
 
         for business_profile in business_profiles {
-            let routing_ref: routing_types::RoutingAlgorithmRef = business_profile
-                .routing_algorithm
-                .clone()
-                .map(|val| val.parse_value("RoutingAlgorithmRef"))
-                .transpose()
-                .change_context(errors::ApiErrorResponse::InternalServerError)
-                .attach_printable(
-                    "unable to deserialize routing algorithm ref from merchant account",
-                )?
-                .unwrap_or_default();
+            let routing_ref: routing_types::RoutingAlgorithmRef = match transaction_type {
+                enums::TransactionType::Payment => business_profile.routing_algorithm,
+                #[cfg(feature = "payouts")]
+                enums::TransactionType::Payout => business_profile.payout_routing_algorithm,
+            }
+            .clone()
+            .map(|val| val.parse_value("RoutingAlgorithmRef"))
+            .transpose()
+            .change_context(errors::ApiErrorResponse::InternalServerError)
+            .attach_printable("unable to deserialize routing algorithm ref from merchant account")?
+            .unwrap_or_default();
 
             if let Some(algorithm_id) = routing_ref.algorithm_id {
                 let record = db