feat(router): add endpoint for listing connector features

crates/api_models/src/feature_matrix.rs

@@ -0,0 +1,43 @@
+use serde::{Deserialize, Serialize};
+use utoipa::ToSchema;
+
+use crate::enums;
+
+#[derive(Default, Debug, Deserialize, Serialize, Clone, ToSchema)]
+pub struct FeatureMatrixRequest {
+    // List of connectors for which the feature matrix is requested
+    pub connectors: Option<Vec<enums::Connector>>,
+}
+
+#[cfg(feature = "v1")]
+#[derive(Clone, Debug, Serialize)]
+pub struct SupportedPaymentMethod {
+    pub payment_method: enums::PaymentMethodType,
+    pub availability_status: enums::PaymentMethodStage,
+    pub supports_mandates: bool,
+}
+
+#[cfg(feature = "v1")]
+#[derive(Clone, Debug, ToSchema, Serialize)]
+pub struct SupportedPaymentMethodTypes {
+    pub payment_method_type: enums::PaymentMethod,
+    pub payment_methods: Vec<SupportedPaymentMethod>,
+}
+
+#[cfg(feature = "v1")]
+#[derive(Clone, Debug, ToSchema, Serialize)]
+pub struct FeatureMatrixResponse {
+    pub connector: enums::Connector,
+    pub payment_method_types: Vec<SupportedPaymentMethodTypes>,
+}
+
+#[derive(Clone, Debug, serde::Serialize, ToSchema)]
+pub struct FeatureMatrixListResponse {
+    /// The number of connectors included in the list
+    pub size: usize,
+    // The list of payments response objects
+    pub data: Vec<FeatureMatrixResponse>,
+}
+
+impl common_utils::events::ApiEventMetric for FeatureMatrixListResponse {}
+impl common_utils::events::ApiEventMetric for FeatureMatrixRequest {}

crates/api_models/src/lib.rs

@@ -16,6 +16,7 @@ pub mod ephemeral_key;
 #[cfg(feature = "errors")]
 pub mod errors;
 pub mod events;
+pub mod feature_matrix;
 pub mod files;
 pub mod gsm;
 pub mod health_check;

crates/common_enums/src/enums.rs

@@ -1643,6 +1643,33 @@ pub enum PaymentMethod {
     MobilePayment,
 }
 
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    Default,
+    Eq,
+    Hash,
+    PartialEq,
+    serde::Deserialize,
+    serde::Serialize,
+    strum::Display,
+    strum::VariantNames,
+    strum::EnumIter,
+    strum::EnumString,
+    ToSchema,
+)]
+#[strum(serialize_all = "snake_case")]
+pub enum PaymentMethodStage {
+    /// Payment Method available in production
+    #[default]
+    Live,
+    /// Payment Method available in sandbox
+    Beta,
+    /// Payment Method not available
+    Upcoming,
+}
+
 /// The type of the payment that differentiates between normal and various types of mandate payments. Use 'setup_mandate' in case of zero auth flow.
 #[derive(
     Clone,

crates/hyperswitch_connectors/src/connectors/bambora.rs

@@ -38,8 +38,9 @@ use hyperswitch_interfaces::{
     errors,
     events::connector_api_logs::ConnectorEvent,
     types::{
-        self, PaymentsAuthorizeType, PaymentsCaptureType, PaymentsCompleteAuthorizeType,
-        PaymentsSyncType, PaymentsVoidType, Response,
+        self, PaymentMethodDetails, PaymentMethodTypeMetadata, PaymentsAuthorizeType,
+        PaymentsCaptureType, PaymentsCompleteAuthorizeType, PaymentsSyncType, PaymentsVoidType,
+        Response, SupportedPaymentMethods,
     },
     webhooks,
 };
@@ -119,6 +120,27 @@ impl ConnectorCommon for Bambora {
         )])
     }
 
+    fn get_supported_payment_methods(&self) -> Option<SupportedPaymentMethods> {
+        let mut supported_payment_methods = SupportedPaymentMethods::new();
+        let mut card_payment_method = PaymentMethodTypeMetadata::new();
+        card_payment_method.insert(
+            enums::PaymentMethodType::Credit,
+            PaymentMethodDetails {
+                availability_status: enums::PaymentMethodStage::Live,
+                supports_mandates: false,
+            },
+        );
+        card_payment_method.insert(
+            enums::PaymentMethodType::Debit,
+            PaymentMethodDetails {
+                availability_status: enums::PaymentMethodStage::Live,
+                supports_mandates: false,
+            },
+        );
+        supported_payment_methods.insert(enums::PaymentMethod::Card, card_payment_method);
+        Some(supported_payment_methods)
+    }
+
     fn build_error_response(
         &self,
         res: Response,

crates/hyperswitch_connectors/src/connectors/deutschebank.rs

@@ -39,7 +39,9 @@ use hyperswitch_interfaces::{
     configs::Connectors,
     errors,
     events::connector_api_logs::ConnectorEvent,
-    types::{self, Response},
+    types::{
+        self, PaymentMethodDetails, PaymentMethodTypeMetadata, Response, SupportedPaymentMethods,
+    },
     webhooks,
 };
 use masking::{ExposeInterface, Mask, Secret};
@@ -135,6 +137,21 @@ impl ConnectorCommon for Deutschebank {
         connectors.deutschebank.base_url.as_ref()
     }
 
+    fn get_supported_payment_methods(&self) -> Option<SupportedPaymentMethods> {
+        let mut supported_payment_methods = SupportedPaymentMethods::new();
+        let mut bank_debit_payment_method = PaymentMethodTypeMetadata::new();
+        bank_debit_payment_method.insert(
+            enums::PaymentMethodType::Sepa,
+            PaymentMethodDetails {
+                availability_status: enums::PaymentMethodStage::Live,
+                supports_mandates: true,
+            },
+        );
+        supported_payment_methods
+            .insert(enums::PaymentMethod::BankDebit, bank_debit_payment_method);
+        Some(supported_payment_methods)
+    }
+
     fn get_auth_header(
         &self,
         auth_type: &ConnectorAuthType,

crates/hyperswitch_interfaces/src/api.rs

@@ -16,7 +16,11 @@ pub mod payouts;
 pub mod payouts_v2;
 pub mod refunds;
 pub mod refunds_v2;
-use common_enums::enums::{CallConnectorAction, CaptureMethod, PaymentAction, PaymentMethodType};
+
+use common_enums::{
+    enums::{CallConnectorAction, CaptureMethod, PaymentAction, PaymentMethodType},
+    PaymentMethod, PaymentMethodStage,
+};
 use common_utils::{
     errors::CustomResult,
     request::{Method, Request, RequestContent},
@@ -42,8 +46,12 @@ use serde_json::json;
 pub use self::payouts::*;
 pub use self::{payments::*, refunds::*};
 use crate::{
-    configs::Connectors, connector_integration_v2::ConnectorIntegrationV2, consts, errors,
-    events::connector_api_logs::ConnectorEvent, metrics, types,
+    configs::Connectors,
+    connector_integration_v2::ConnectorIntegrationV2,
+    consts, errors,
+    events::connector_api_logs::ConnectorEvent,
+    metrics,
+    types::{self, SupportedPaymentMethods},
 };
 
 /// type BoxedConnectorIntegration
@@ -257,6 +265,11 @@ pub trait ConnectorCommon {
     /// The base URL for interacting with the connector's API.
     fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str;
 
+    /// Details related to payment method supported by the connector
+    fn get_supported_payment_methods(&self) -> Option<SupportedPaymentMethods> {
+        None
+    }
+
     /// common error response for a connector if it is same in all case
     fn build_error_response(
         &self,
@@ -340,6 +353,63 @@ pub trait ConnectorVerifyWebhookSourceV2:
 
 /// trait ConnectorValidation
 pub trait ConnectorValidation: ConnectorCommon {
+    /// fn validate_payment_method
+    fn validate_payment_method(
+        &self,
+        payment_method_type: &Option<PaymentMethodType>,
+        payment_method: &PaymentMethod,
+        is_mandate_payment: bool,
+        test_mode: bool,
+    ) -> CustomResult<(), errors::ConnectorError> {
+        match self.get_supported_payment_methods() {
+            Some(supported_payment_methods) => {
+                // Check if the payment method exists
+                let payment_method_information = supported_payment_methods
+                    .get(payment_method)
+                    .ok_or_else(|| errors::ConnectorError::NotSupported {
+                        message: payment_method.to_string(),
+                        connector: self.id(),
+                    })?;
+
+                match payment_method_type {
+                    Some(pmt) => {
+                        // Check if the payment method type exists
+                        let payment_method_type_information =
+                            payment_method_information.get(pmt).ok_or_else(|| {
+                                errors::ConnectorError::NotSupported {
+                                    message: format!("{:?}, {:?}", pmt, payment_method),
+                                    connector: self.id(),
+                                }
+                            })?;
+                        // Validate the payment method type based on its availability and mandate support
+                        match (
+                            test_mode,
+                            is_mandate_payment,
+                            payment_method_type_information.availability_status.clone(),
+                            payment_method_type_information.supports_mandates,
+                        ) {
+                            // Test mode mandate payment
+                            (true, true, PaymentMethodStage::Live | PaymentMethodStage::Beta, true) |
+                            // Test mode payment
+                            (true, false, PaymentMethodStage::Live | PaymentMethodStage::Beta, _) |
+                            // Live mode mandate payment
+                            (false, true, PaymentMethodStage::Live, true) |
+                            // Live mode payment
+                            (false, false, PaymentMethodStage::Live, _) => Ok(()),
+                            // If none of the cases match, return an unsupported error
+                            _ => Err(errors::ConnectorError::NotSupported {
+                                message: format!("{:?}, {:?}", payment_method_type, payment_method),
+                                connector: self.id(),
+                            }.into()),
+                        }
+                    }
+                    None => Ok(()),
+                }
+            }
+            None => Ok(()),
+        }
+    }
+
     /// fn validate_capture_method
     fn validate_capture_method(
         &self,

crates/hyperswitch_interfaces/src/types.rs

@@ -1,4 +1,7 @@
 //! Types interface
+use std::collections::HashMap;
+
+use common_enums::{PaymentMethod, PaymentMethodStage, PaymentMethodType};
 use hyperswitch_domain_models::{
     router_data::AccessToken,
     router_flow_types::{
@@ -185,3 +188,19 @@ pub type RetrieveFileType =
 /// Type alias for `ConnectorIntegration<Defend, DefendDisputeRequestData, DefendDisputeResponse>`
 pub type DefendDisputeType =
     dyn ConnectorIntegration<Defend, DefendDisputeRequestData, DefendDisputeResponse>;
+
+/// Represents details of a payment method.
+#[derive(Debug, Clone)]
+pub struct PaymentMethodDetails {
+    /// The availability status of the payment method based on the environment (e.g., live, beta, upcoming).
+    pub availability_status: PaymentMethodStage,
+
+    /// Indicates whether mandates are supported by this payment method.
+    pub supports_mandates: bool,
+}
+
+/// list of payment method types and metadata related to them
+pub type PaymentMethodTypeMetadata = HashMap<PaymentMethodType, PaymentMethodDetails>;
+
+/// list of payment methods, payment method types and metadata related to them
+pub type SupportedPaymentMethods = HashMap<PaymentMethod, PaymentMethodTypeMetadata>;

crates/router/src/core/payments/flows/authorize_flow.rs

@@ -317,9 +317,21 @@ impl Feature<api::Authorize, types::PaymentsAuthorizeData> for types::PaymentsAu
                     )
                     .to_payment_failed_response()?;
 
-                if crate::connector::utils::PaymentsAuthorizeRequestData::is_customer_initiated_mandate_payment(
+                let is_customer_initiated_mandate_payment = crate::connector::utils::PaymentsAuthorizeRequestData::is_customer_initiated_mandate_payment(
                     &self.request,
-                ) {
+                );
+
+                connector
+                    .connector
+                    .validate_payment_method(
+                        &self.request.payment_method_type,
+                        &self.payment_method,
+                        is_customer_initiated_mandate_payment,
+                        self.test_mode.unwrap_or(false),
+                    )
+                    .to_payment_failed_response()?;
+
+                if is_customer_initiated_mandate_payment {
                     connector
                         .connector
                         .validate_mandate_payment(

crates/router/src/lib.rs

@@ -183,7 +183,8 @@ pub fn mk_app(
                 .service(routes::ConnectorOnboarding::server(state.clone()))
                 .service(routes::Verify::server(state.clone()))
                 .service(routes::Analytics::server(state.clone()))
-                .service(routes::WebhookEvents::server(state.clone()));
+                .service(routes::WebhookEvents::server(state.clone()))
+                .service(routes::FeatureMatrix::server(state.clone()));
         }
     }
 

crates/router/src/routes.rs

@@ -17,6 +17,7 @@ pub mod disputes;
 #[cfg(feature = "dummy_connector")]
 pub mod dummy_connector;
 pub mod ephemeral_key;
+pub mod feature_matrix;
 pub mod files;
 #[cfg(feature = "frm")]
 pub mod fraud_check;
@@ -64,9 +65,9 @@ pub use self::app::DummyConnector;
 pub use self::app::Recon;
 pub use self::app::{
     ApiKeys, AppState, ApplePayCertificatesMigration, Cache, Cards, Configs, ConnectorOnboarding,
-    Customers, Disputes, EphemeralKey, Files, Forex, Gsm, Health, Mandates, MerchantAccount,
-    MerchantConnectorAccount, PaymentLink, PaymentMethods, Payments, Poll, Profile, ProfileNew,
-    Refunds, SessionState, User, Webhooks,
+    Customers, Disputes, EphemeralKey, FeatureMatrix, Files, Forex, Gsm, Health, Mandates,
+    MerchantAccount, MerchantConnectorAccount, PaymentLink, PaymentMethods, Payments, Poll,
+    Profile, ProfileNew, Refunds, SessionState, User, Webhooks,
 };
 #[cfg(feature = "olap")]
 pub use self::app::{Blocklist, Organization, Routing, Verify, WebhookEvents};

crates/router/src/routes/app.rs

@@ -68,6 +68,8 @@ use crate::analytics::AnalyticsProvider;
 use crate::errors::RouterResult;
 #[cfg(feature = "v1")]
 use crate::routes::cards_info::card_iin_info;
+#[cfg(all(feature = "olap", feature = "v1"))]
+use crate::routes::feature_matrix;
 #[cfg(all(feature = "frm", feature = "oltp"))]
 use crate::routes::fraud_check as frm_routes;
 #[cfg(all(feature = "recon", feature = "olap"))]
@@ -2144,3 +2146,18 @@ impl WebhookEvents {
             )
     }
 }
+
+#[cfg(feature = "olap")]
+pub struct FeatureMatrix;
+
+#[cfg(all(feature = "olap", feature = "v1"))]
+impl FeatureMatrix {
+    pub fn server(state: AppState) -> Scope {
+        web::scope("/feature_matrix")
+            .app_data(web::Data::new(state))
+            .service(
+                web::resource("")
+                    .route(web::get().to(feature_matrix::fetch_connector_feature_matrix)),
+            )
+    }
+}