feat(core): Move RouterData to crate hyperswitch_domain_models

connector-template/mod.rs

@@ -7,7 +7,7 @@ use masking::ExposeInterface;
 use crate::{
     events::connector_api_logs::ConnectorEvent,
     configs::settings,
-    utils::{self, BytesExt},
+    utils::BytesExt,
     core::{
         errors::{self, CustomResult},
     },

connector-template/transformers.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 use masking::Secret;
-use crate::{connector::utils::{PaymentsAuthorizeRequestData},core::errors,types::{self,api, storage::enums}};
+use crate::{connector::utils::{PaymentsAuthorizeRequestData},core::errors,types::{self, domain, api, storage::enums}};
 
 //TODO: Fill the struct with respective fields
 pub struct {{project-name | downcase | pascal_case}}RouterData<T> {
@@ -53,7 +53,7 @@ impl TryFrom<&{{project-name | downcase | pascal_case}}RouterData<&types::Paymen
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(item: &{{project-name | downcase | pascal_case}}RouterData<&types::PaymentsAuthorizeRouterData>) -> Result<Self,Self::Error> {
         match item.router_data.request.payment_method_data.clone() {
-            api::PaymentMethodData::Card(req_card) => {
+            domain::PaymentMethodData::Card(req_card) => {
                 let card = {{project-name | downcase | pascal_case}}Card {
                     number: req_card.card_number,
                     expiry_month: req_card.card_exp_month,

crates/hyperswitch_domain_models/Cargo.toml

@@ -23,6 +23,7 @@ diesel_models = { version = "0.1.0", path = "../diesel_models", features = ["kv_
 # Third party deps
 async-trait = "0.1.79"
 error-stack = "0.4.1"
+http = "0.2.12"
 serde = { version = "1.0.197", features = ["derive"] }
 serde_json = "1.0.115"
 thiserror = "1.0.58"

crates/hyperswitch_domain_models/src/lib.rs

@@ -1,8 +1,10 @@
 pub mod errors;
 pub mod mandates;
+pub mod payment_address;
 pub mod payments;
 #[cfg(feature = "payouts")]
 pub mod payouts;
+pub mod router_data;
 
 #[cfg(not(feature = "payouts"))]
 pub trait PayoutAttemptInterface {}

crates/hyperswitch_domain_models/src/payment_address.rs

@@ -0,0 +1,82 @@
+use api_models::payments::Address;
+
+#[derive(Clone, Default, Debug)]
+pub struct PaymentAddress {
+    shipping: Option<Address>,
+    billing: Option<Address>,
+    unified_payment_method_billing: Option<Address>,
+    payment_method_billing: Option<Address>,
+}
+
+impl PaymentAddress {
+    pub fn new(
+        shipping: Option<Address>,
+        billing: Option<Address>,
+        payment_method_billing: Option<Address>,
+        should_unify_address: Option<bool>,
+    ) -> Self {
+        // billing -> .billing, this is the billing details passed in the root of payments request
+        // payment_method_billing -> .payment_method_data.billing
+
+        let unified_payment_method_billing = if should_unify_address.unwrap_or(true) {
+            // Merge the billing details field from both `payment.billing` and `payment.payment_method_data.billing`
+            // The unified payment_method_billing will be used as billing address and passed to the connector module
+            // This unification is required in order to provide backwards compatibility
+            // so that if `payment.billing` is passed it should be sent to the connector module
+            // Unify the billing details with `payment_method_data.billing`
+            payment_method_billing
+                .as_ref()
+                .map(|payment_method_billing| {
+                    payment_method_billing
+                        .clone()
+                        .unify_address(billing.as_ref())
+                })
+                .or(billing.clone())
+        } else {
+            payment_method_billing.clone()
+        };
+
+        Self {
+            shipping,
+            billing,
+            unified_payment_method_billing,
+            payment_method_billing,
+        }
+    }
+
+    pub fn get_shipping(&self) -> Option<&Address> {
+        self.shipping.as_ref()
+    }
+
+    pub fn get_payment_method_billing(&self) -> Option<&Address> {
+        self.unified_payment_method_billing.as_ref()
+    }
+
+    /// Unify the billing details from `payment_method_data.[payment_method_data].billing details`.
+    pub fn unify_with_payment_method_data_billing(
+        self,
+        payment_method_data_billing: Option<Address>,
+    ) -> Self {
+        // Unify the billing details with `payment_method_data.billing_details`
+        let unified_payment_method_billing = payment_method_data_billing
+            .map(|payment_method_data_billing| {
+                payment_method_data_billing.unify_address(self.get_payment_method_billing())
+            })
+            .or(self.get_payment_method_billing().cloned());
+
+        Self {
+            shipping: self.shipping,
+            billing: self.billing,
+            unified_payment_method_billing,
+            payment_method_billing: self.payment_method_billing,
+        }
+    }
+
+    pub fn get_request_payment_method_billing(&self) -> Option<&Address> {
+        self.payment_method_billing.as_ref()
+    }
+
+    pub fn get_payment_billing(&self) -> Option<&Address> {
+        self.billing.as_ref()
+    }
+}