Issue:
Bug: Improve UCS connector configuration format for better type safety and usability



## Problem Statement

The current unified connector service (UCS) configuration uses an array format for specifying connectors that should use UCS only. This approach has several limitations:

### Current Issues

1. **Type Safety**: The current `Vec<String>` approach allows invalid connector names to be specified without compile-time validation
2. **Configuration Verbosity**: Array format in TOML files is more verbose and harder to read/maintain
3. **Runtime Validation**: Invalid connector names are only caught at runtime when the configuration is parsed
4. **Inconsistent Format**: Different from other comma-separated configuration patterns used elsewhere in the codebase

### Current Configuration Format
```toml
[grpc_client.unified_connector_service]
ucs_only_connectors = [
  "razorpay",
  "phonepe", 
  "paytm",
  "cashfree",
]
```

## Proposed Solution

Refactor the configuration to use a comma-separated string format with type-safe parsing:

### Benefits
- **Type Safety**: Use `HashSet<Connector>` with enum validation to prevent invalid connector names
- **Cleaner Configuration**: More concise and readable comma-separated format
- **Better Error Handling**: Custom deserializer with detailed error messages for invalid configurations
- **Consistency**: Aligns with other comma-separated configuration patterns in the codebase
- **Performance**: HashSet provides O(1) lookup time for connector validation

### Proposed Configuration Format
```toml
[grpc_client.unified_connector_service]
ucs_only_connectors = "paytm, phonepe, razorpay, cashfree"
```

## Implementation Requirements

1. **Custom Deserializer**: Implement a generic deserializer for comma-separated strings to typed HashSets
2. **Type Safety**: Use `Connector` enum instead of raw strings
3. **Backward Compatibility**: Ensure existing connector validation logic continues to work
4. **Configuration Updates**: Update all config files to use the new format
5. **Comprehensive Testing**: Add unit tests for the deserializer and configuration parsing

## Acceptance Criteria

- [x] Configuration uses comma-separated string format
- [x] Type-safe parsing with `Connector` enum validation
- [x] Custom deserializer handles edge cases (whitespace, duplicates, empty strings)
- [x] All configuration files updated consistently
- [x] Comprehensive unit tests for the deserializer
- [x] Existing connector validation logic works with new format
- [x] Detailed error messages for invalid configurations

## Labels

- Enhancement
- Configuration
- Type Safety
- Refactoring

Pull request description:
# Refactor: Change UCS connector configuration from array to comma-separated string

## Summary

This PR refactors the unified connector service (UCS) configuration to use a comma-separated string format instead of an array for specifying connectors that should use UCS only. This change improves configuration management and parsing efficiency while maintaining type safety through a custom deserializer.

## Changes

- **Configuration Format Change**: Modified `ucs_only_connectors` from `Vec<String>` to `HashSet<Connector>` with comma-separated string input
- **Custom Deserializer Implementation**: Added a new `utils.rs` module in `external_services` with `deserialize_hashset` function for parsing comma-separated values into typed HashSets
- **Type Safety Enhancement**: Updated connector validation to use `Connector` enum instead of raw strings, preventing invalid connector names
- **Configuration Updates**: Updated all config files (`development.toml`, `config.example.toml`, `deployments/env_specific.toml`) to use the new comma-separated format
- **Dependencies**: Added `common_enums` dependency to `external_services` crate for proper connector enum handling

## Related Issues

Closes #8906 - Improve UCS connector configuration format for better type safety and usability

## Type of Change

- [x] Refactoring
- [ ] Bug fix
- [ ] New feature
- [ ] Breaking change
- [ ] Documentation update

## Testing

- **Configuration Parsing**: Tested comma-separated string parsing with various inputs including whitespace handling
- **Type Validation**: Verified that invalid connector names are properly rejected during deserialization
- **Backward Compatibility**: Ensured existing connector validation logic works with the new enum-based approach
- **Unit Tests**: Added comprehensive test suite for the new deserializer functionality covering:
  - Valid comma-separated inputs
  - Whitespace handling
  - Error handling for invalid values
  - Empty string and single value scenarios
  - Duplicate value handling

## Implementation Details

### Key Files Modified
- `crates/external_services/src/grpc_client/unified_connector_service.rs:119` - Configuration struct update
- `crates/external_services/src/utils.rs` - New deserializer implementation
- `crates/router/src/core/unified_connector_service.rs:57` - Connector validation logic update
- Configuration files in `config/` directory

### New Functionality
The custom deserializer provides:
- Type-safe parsing of comma-separated strings into HashSets
- Comprehensive error handling with detailed error messages
- Generic implementation supporting any type that implements `FromStr + Eq + Hash`
- Proper handling of edge cases (empty strings, whitespace, duplicates)

## Checklist

- [x] Code follows project style guidelines
- [x] Self-review completed
- [x] Configuration changes tested locally
- [x] Unit tests added for new deserializer functionality
- [x] Type safety improvements verified
- [x] All config files updated consistently

Testing:

Patch:
diff --git a/config/config.example.toml b/config/config.example.toml
index d4ce454edfc..5783a70c370 100644
--- a/config/config.example.toml
+++ b/config/config.example.toml
@@ -1159,6 +1159,7 @@ url = "http://localhost:8080"           # Open Router URL
 [grpc_client.unified_connector_service]
 base_url = "http://localhost:8000"      # Unified Connector Service Base URL
 connection_timeout = 10                 # Connection Timeout Duration in Seconds
+ucs_only_connectors = "paytm, phonepe"    # Comma-separated list of connectors that use UCS only
 
 [grpc_client.recovery_decider_client] # Revenue recovery client base url
 base_url = "http://127.0.0.1:8080" #Base URL
diff --git a/config/deployments/env_specific.toml b/config/deployments/env_specific.toml
index 6acf697ac4d..64db7079f40 100644
--- a/config/deployments/env_specific.toml
+++ b/config/deployments/env_specific.toml
@@ -384,6 +384,7 @@ connector_names = "connector_names"     # Comma-separated list of allowed connec
 [grpc_client.unified_connector_service]
 base_url = "http://localhost:8000"      # Unified Connector Service Base URL
 connection_timeout = 10                 # Connection Timeout Duration in Seconds
+ucs_only_connectors = "paytm, phonepe"    # Comma-separated list of connectors that use UCS only
 
 [revenue_recovery.recovery_timestamp] # Timestamp configuration for Revenue Recovery
 initial_timestamp_in_hours = 1        # number of hours added to start time for Decider service of Revenue Recovery
diff --git a/config/deployments/integration_test.toml b/config/deployments/integration_test.toml
index 47c2bc39bc1..a387cd0c164 100644
--- a/config/deployments/integration_test.toml
+++ b/config/deployments/integration_test.toml
@@ -837,3 +837,6 @@ click_to_pay = {connector_list = "adyen, cybersource, trustpay"}
 
 [list_dispute_supported_connectors]
 connector_list = "worldpayvantiv"
+
+[grpc_client.unified_connector_service]
+ucs_only_connectors = "paytm, phonepe"    # Comma-separated list of connectors that use UCS only
diff --git a/config/deployments/production.toml b/config/deployments/production.toml
index 3550b1ec929..a95d88dc632 100644
--- a/config/deployments/production.toml
+++ b/config/deployments/production.toml
@@ -847,3 +847,6 @@ click_to_pay = {connector_list = "adyen, cybersource, trustpay"}
 [revenue_recovery]
 monitoring_threshold_in_seconds = 60
 retry_algorithm_type = "cascading"
+
+[grpc_client.unified_connector_service]
+ucs_only_connectors = "paytm, phonepe"    # Comma-separated list of connectors that use UCS only
diff --git a/config/deployments/sandbox.toml b/config/deployments/sandbox.toml
index 47a64b91b4b..296888abcdd 100644
--- a/config/deployments/sandbox.toml
+++ b/config/deployments/sandbox.toml
@@ -856,3 +856,6 @@ retry_algorithm_type = "cascading"
 
 [list_dispute_supported_connectors]
 connector_list = "worldpayvantiv"
+
+[grpc_client.unified_connector_service]
+ucs_only_connectors = "paytm, phonepe"    # Comma-separated list of connectors that use UCS only
diff --git a/config/development.toml b/config/development.toml
index 7bc0dcc397d..95b2f289621 100644
--- a/config/development.toml
+++ b/config/development.toml
@@ -1268,12 +1268,7 @@ enabled = "true"
 [grpc_client.unified_connector_service]
 base_url = "http://localhost:8000"
 connection_timeout = 10
-ucs_only_connectors = [
-  "razorpay",
-  "phonepe",
-  "paytm",
-  "cashfree",
-]
+ucs_only_connectors = "paytm, phonepe"    # Comma-separated list of connectors that use UCS only
 
 [revenue_recovery]
 monitoring_threshold_in_seconds = 60
diff --git a/crates/external_services/src/grpc_client/unified_connector_service.rs b/crates/external_services/src/grpc_client/unified_connector_service.rs
index 62f681a985c..81bb2dc8988 100644
--- a/crates/external_services/src/grpc_client/unified_connector_service.rs
+++ b/crates/external_services/src/grpc_client/unified_connector_service.rs
@@ -1,5 +1,6 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
+use common_enums::connector_enums::Connector;
 use common_utils::{consts as common_utils_consts, errors::CustomResult, types::Url};
 use error_stack::ResultExt;
 use masking::{PeekInterface, Secret};
@@ -18,6 +19,7 @@ use unified_connector_service_client::payments::{
 use crate::{
     consts,
     grpc_client::{GrpcClientSettings, GrpcHeaders},
+    utils::deserialize_hashset,
 };
 
 /// Unified Connector Service error variants
@@ -123,9 +125,9 @@ pub struct UnifiedConnectorServiceClientConfig {
     /// Contains the connection timeout duration in seconds
     pub connection_timeout: u64,
 
-    /// List of connectors to use with the unified connector service
-    #[serde(default)]
-    pub ucs_only_connectors: Vec<String>,
+    /// Set of external services/connectors available for the unified connector service
+    #[serde(default, deserialize_with = "deserialize_hashset")]
+    pub ucs_only_connectors: HashSet<Connector>,
 }
 
 /// Contains the Connector Auth Type and related authentication data.
diff --git a/crates/external_services/src/lib.rs b/crates/external_services/src/lib.rs
index 7d97b5e99c0..aee7d232bb3 100644
--- a/crates/external_services/src/lib.rs
+++ b/crates/external_services/src/lib.rs
@@ -28,6 +28,9 @@ pub mod managers;
 /// crm module
 pub mod crm;
 
+/// deserializers module_path
+pub mod utils;
+
 #[cfg(feature = "revenue_recovery")]
 /// date_time module
 pub mod date_time {
diff --git a/crates/external_services/src/utils.rs b/crates/external_services/src/utils.rs
new file mode 100644
index 00000000000..16cfc8ea008
--- /dev/null
+++ b/crates/external_services/src/utils.rs
@@ -0,0 +1,178 @@
+//! Custom deserializers for external services configuration
+
+use std::collections::HashSet;
+
+use serde::Deserialize;
+
+/// Parses a comma-separated string into a HashSet of typed values.
+///
+/// # Arguments
+///
+/// * `value` - String or string reference containing comma-separated values
+///
+/// # Returns
+///
+/// * `Ok(HashSet<T>)` - Successfully parsed HashSet
+/// * `Err(String)` - Error message if any value parsing fails
+///
+/// # Type Parameters
+///
+/// * `T` - Target type that implements `FromStr`, `Eq`, and `Hash`
+///
+/// # Examples
+///
+/// ```
+/// use std::collections::HashSet;
+///
+/// let result: Result<HashSet<i32>, String> =
+///     deserialize_hashset_inner("1,2,3");
+/// assert!(result.is_ok());
+///
+/// if let Ok(hashset) = result {
+///     assert!(hashset.contains(&1));
+///     assert!(hashset.contains(&2));
+///     assert!(hashset.contains(&3));
+/// }
+/// ```
+fn deserialize_hashset_inner<T>(value: impl AsRef<str>) -> Result<HashSet<T>, String>
+where
+    T: Eq + std::str::FromStr + std::hash::Hash,
+    <T as std::str::FromStr>::Err: std::fmt::Display,
+{
+    let (values, errors) = value
+        .as_ref()
+        .trim()
+        .split(',')
+        .map(|s| {
+            T::from_str(s.trim()).map_err(|error| {
+                format!(
+                    "Unable to deserialize `{}` as `{}`: {error}",
+                    s.trim(),
+                    std::any::type_name::<T>()
+                )
+            })
+        })
+        .fold(
+            (HashSet::new(), Vec::new()),
+            |(mut values, mut errors), result| match result {
+                Ok(t) => {
+                    values.insert(t);
+                    (values, errors)
+                }
+                Err(error) => {
+                    errors.push(error);
+                    (values, errors)
+                }
+            },
+        );
+    if !errors.is_empty() {
+        Err(format!("Some errors occurred:\n{}", errors.join("\n")))
+    } else {
+        Ok(values)
+    }
+}
+
+/// Serde deserializer function for converting comma-separated strings into typed HashSets.
+///
+/// This function is designed to be used with serde's `#[serde(deserialize_with = "deserialize_hashset")]`
+/// attribute to customize deserialization of HashSet fields.
+///
+/// # Arguments
+///
+/// * `deserializer` - Serde deserializer instance
+///
+/// # Returns
+///
+/// * `Ok(HashSet<T>)` - Successfully deserialized HashSet
+/// * `Err(D::Error)` - Serde deserialization error
+///
+/// # Type Parameters
+///
+/// * `D` - Serde deserializer type
+/// * `T` - Target type that implements `FromStr`, `Eq`, and `Hash`
+pub(crate) fn deserialize_hashset<'a, D, T>(deserializer: D) -> Result<HashSet<T>, D::Error>
+where
+    D: serde::Deserializer<'a>,
+    T: Eq + std::str::FromStr + std::hash::Hash,
+    <T as std::str::FromStr>::Err: std::fmt::Display,
+{
+    use serde::de::Error;
+
+    deserialize_hashset_inner(<String>::deserialize(deserializer)?).map_err(D::Error::custom)
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashSet;
+
+    use super::*;
+
+    #[test]
+    fn test_deserialize_hashset_inner_success() {
+        let result: Result<HashSet<i32>, String> = deserialize_hashset_inner("1,2,3");
+        assert!(result.is_ok());
+
+        if let Ok(hashset) = result {
+            assert_eq!(hashset.len(), 3);
+            assert!(hashset.contains(&1));
+            assert!(hashset.contains(&2));
+            assert!(hashset.contains(&3));
+        }
+    }
+
+    #[test]
+    fn test_deserialize_hashset_inner_with_whitespace() {
+        let result: Result<HashSet<String>, String> = deserialize_hashset_inner(" a , b , c ");
+        assert!(result.is_ok());
+
+        if let Ok(hashset) = result {
+            assert_eq!(hashset.len(), 3);
+            assert!(hashset.contains("a"));
+            assert!(hashset.contains("b"));
+            assert!(hashset.contains("c"));
+        }
+    }
+
+    #[test]
+    fn test_deserialize_hashset_inner_empty_string() {
+        let result: Result<HashSet<String>, String> = deserialize_hashset_inner("");
+        assert!(result.is_ok());
+        if let Ok(hashset) = result {
+            assert_eq!(hashset.len(), 0);
+        }
+    }
+
+    #[test]
+    fn test_deserialize_hashset_inner_single_value() {
+        let result: Result<HashSet<String>, String> = deserialize_hashset_inner("single");
+        assert!(result.is_ok());
+
+        if let Ok(hashset) = result {
+            assert_eq!(hashset.len(), 1);
+            assert!(hashset.contains("single"));
+        }
+    }
+
+    #[test]
+    fn test_deserialize_hashset_inner_invalid_int() {
+        let result: Result<HashSet<i32>, String> = deserialize_hashset_inner("1,invalid,3");
+        assert!(result.is_err());
+
+        if let Err(error) = result {
+            assert!(error.contains("Unable to deserialize `invalid` as `i32`"));
+        }
+    }
+
+    #[test]
+    fn test_deserialize_hashset_inner_duplicates() {
+        let result: Result<HashSet<String>, String> = deserialize_hashset_inner("a,b,a,c,b");
+        assert!(result.is_ok());
+
+        if let Ok(hashset) = result {
+            assert_eq!(hashset.len(), 3); // Duplicates should be removed
+            assert!(hashset.contains("a"));
+            assert!(hashset.contains("b"));
+            assert!(hashset.contains("c"));
+        }
+    }
+}
diff --git a/crates/router/src/core/unified_connector_service.rs b/crates/router/src/core/unified_connector_service.rs
index b14811ea735..2ef6e81eedc 100644
--- a/crates/router/src/core/unified_connector_service.rs
+++ b/crates/router/src/core/unified_connector_service.rs
@@ -1,5 +1,7 @@
+use std::str::FromStr;
+
 use api_models::admin;
-use common_enums::{AttemptStatus, GatewaySystem, PaymentMethodType};
+use common_enums::{connector_enums::Connector, AttemptStatus, GatewaySystem, PaymentMethodType};
 use common_utils::{errors::CustomResult, ext_traits::ValueExt};
 use diesel_models::types::FeatureMetadata;
 use error_stack::ResultExt;
@@ -105,6 +107,9 @@ where
         .get_string_repr();
 
     let connector_name = router_data.connector.clone();
+    let connector_enum = Connector::from_str(&connector_name)
+        .change_context(errors::ApiErrorResponse::IncorrectConnectorNameGiven)?;
+
     let payment_method = router_data.payment_method.to_string();
     let flow_name = get_flow_name::<F>()?;
 
@@ -113,7 +118,7 @@ where
         .grpc_client
         .unified_connector_service
         .as_ref()
-        .is_some_and(|config| config.ucs_only_connectors.contains(&connector_name));
+        .is_some_and(|config| config.ucs_only_connectors.contains(&connector_enum));
 
     if is_ucs_only_connector {
         router_env::logger::info!(