feat: rule validator (#202)

Author: AnkitKmrGupta

Cargo.lock

@@ -95,6 +95,7 @@ rand = "0.8.5"
 tower-http = { version = "0.6.2", features = ["trace"] }
 bytes = "1.10.1"
 strum = { version = "0.26.2", features = ["derive"] }
+regex = "1.10"
 # -------------------------------------
 
 [dev-dependencies]

Cargo.toml

@@ -85,8 +85,8 @@ mobile_payment = { type = "enum", values = "direct_carrier_billing" }
 payment_method = { type = "enum", values = "card, card_redirect, pay_later, wallet, bank_redirect, bank_transfer, crypto, bank_debit, reward, real_time_payment, upi, voucher, gift_card, open_banking, mobile_payment" }
 card_type = { type = "enum", values = "debit, credit" }
 card = { type = "enum", values = "debit, credit" }
-payment_card_bin = { type = "udf" }
-issuer_name = { type = "str_value" }
+payment_card_bin = { type = "udf", exact_length = 6, regex = "^[0-9]{6}$" } 
+issuer_name = { type = "str_value", min_length = 1 }
 payment_card_type = { type = "enum", values = "CREDIT, DEBIT" }
 mandate_acceptance_type = { type = "enum", values = "online, offline" }
 mandate_type = { type = "enum", values = "single_use, multi_use" }
@@ -97,12 +97,13 @@ authentication_type = { type = "enum", values = "three_ds, no_three_ds" }
 capture_methods = { type = "enum", values = "automatic, manual, manual_multiple, scheduled, sequential_automatic" }
 setup_future_usage = { type = "enum", values = "on_session, off_session" }
 payment_card_network = { type = "enum", values = "visa, mastercard, american_express, jcb, diners_club, discover, cartes_bancaires, union_pay, interac, rupay, maestro" }
-amount = { type = "integer" }
+amount = { type = "integer", min = 0 }
 login_date = { type = "str_value" }
 currency = { type = "enum", values = "AED, AFN, ALL, AMD, ANG, AOA, ARS, AUD, AWG, AZN, BAM, BBD, BDT, BGN, BHD, BIF, BMD, BND, BOB, BRL, BSD, BTN, BWP, BYN, BZD, CAD, CDF, CHF, CLF, CLP, CNY, COP, CRC, CUC, CUP, CVE, CZK, DJF, DKK, DOP, DZD, EGP, ERN, ETB, EUR, FJD, FKP, GBP, GEL, GHS, GIP, GMD, GNF, GTQ, GYD, HKD, HNL, HRK, HTG, HUF, IDR, ILS, INR, IQD, IRR, ISK, JMD, JOD, JPY, KES, KGS, KHR, KMF, KPW, KRW, KWD, KYD, KZT, LAK, LBP, LKR, LRD, LSL, LYD, MAD, MDL, MGA, MKD, MMK, MNT, MOP, MRU, MUR, MVR, MWK, MXN, MYR, MZN, NAD, NGN, NIO, NOK, NPR, NZD, OMR, PAB, PEN, PGK, PHP, PKR, PLN, PYG, QAR, RON, RSD, RUB, RWF, SAR, SBD, SCR, SDG, SEK, SGD, SHP, SLE, SLL, SOS, SRD, SSP, STD, STN, SVC, SYP, SZL, THB, TJS, TMT, TND, TOP, TRY, TTD, TWD, TZS, UAH, UGX, USD, UYU, UZS, VES, VND, VUV, WST, XAF, XCD, XOF, XPF, YER, ZAR, ZMW, ZWL" }
 payment_card_issuer_country = { type = "enum", values = "AF, AX, AL, DZ, AS, AD, AO, AI, AQ, AG, AR, AM, AW, AU, AT, AZ, BS, BH, BD, BB, BY, BE, BZ, BJ, BM, BT, BO, BQ, BA, BW, BV, BR, IO, BN, BG, BF, BI, KH, CM, CA, CV, KY, CF, TD, CL, CN, CX, CC, CO, KM, CG, CD, CK, CR, CI, HR, CU, CW, CY, CZ, DK, DJ, DM, DO, EC, EG, SV, GQ, ER, EE, ET, FK, FO, FJ, FI, FR, GF, PF, TF, GA, GM, GE, DE, GH, GI, GR, GL, GD, GP, GU, GT, GG, GN, GW, GY, HT, HM, VA, HN, HK, HU, IS, IN, ID, IR, IQ, IE, IM, IL, IT, JM, JP, JE, JO, KZ, KE, KI, KP, KR, KW, KG, LA, LV, LB, LS, LR, LY, LI, LT, LU, MO, MK, MG, MW, MY, MV, ML, MT, MH, MQ, MR, MU, YT, MX, FM, MD, MC, MN, ME, MS, MA, MZ, MM, NA, NR, NP, NL, NC, NZ, NI, NE, NG, NU, NF, MP, NO, OM, PK, PW, PS, PA, PG, PY, PE, PH, PN, PL, PT, PR, QA, RE, RO, RU, RW, BL, SH, KN, LC, MF, PM, VC, WS, SM, ST, SA, SN, RS, SC, SL, SG, SX, SK, SI, SB, SO, ZA, GS, SS, ES, LK, SD, SR, SJ, SZ, SE, CH, SY, TW, TJ, TZ, TH, TL, TG, TK, TO, TT, TN, TR, TM, TC, TV, UG, UA, AE, GB, UM, UY, UZ, VU, VE, VN, VG, VI, WF, EH, YE, ZM, ZW, US" }
-card_bin = { type = "str_value" }
-extended_card_bin = { type = "str_value" }
+
+card_bin = { type = "str_value", exact_length = 6, regex = "^[0-9]{6}$" }
+extended_card_bin = { type = "str_value", exact_length = 8, regex = "^[0-9]{8}$" }
 capture_method = { type = "enum", values = "automatic, manual" }
 new_customer = { type = "udf" }
 udf1 = { type = "str_value" }

config/development.toml

@@ -43,6 +43,30 @@ pub enum EuclidErrors {
 
     #[error("Invalid Sr Dimension Configuration")]
     InvalidSrDimensionConfig(String),
+
+    #[error("Field validation failed: {0}")]
+    FieldValidationFailed(String),
+}
+
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct ValidationErrorDetails {
+    pub field: String,
+    pub error_type: String,
+    pub message: String,
+}
+
+impl ValidationErrorDetails {
+    pub fn new(
+        field: impl Into<String>,
+        error_type: impl Into<String>,
+        message: impl Into<String>,
+    ) -> Self {
+        Self {
+            field: field.into(),
+            error_type: error_type.into(),
+            message: message.into(),
+        }
+    }
 }
 
 impl axum::response::IntoResponse for EuclidErrors {
@@ -195,15 +219,25 @@ impl axum::response::IntoResponse for EuclidErrors {
             )
                 .into_response(),
 
-                EuclidErrors::InvalidSrDimensionConfig(msg) => (
-                    hyper::StatusCode::BAD_REQUEST,
-                    axum::Json(ApiErrorResponse::new(
-                        error_codes::TE_04,
-                        msg,
-                        None,
-                    )),
-                )
-                    .into_response(),
+            EuclidErrors::InvalidSrDimensionConfig(msg) => (
+                hyper::StatusCode::BAD_REQUEST,
+                axum::Json(ApiErrorResponse::new(
+                    error_codes::TE_04,
+                    msg,
+                    None,
+                )),
+            )
+                .into_response(),
+
+            EuclidErrors::FieldValidationFailed(msg) => (
+                hyper::StatusCode::BAD_REQUEST,
+                axum::Json(ApiErrorResponse::new(
+                    error_codes::TE_04,
+                    format!("Field validation failed: {}", msg),
+                    None,
+                )),
+            )
+                .into_response(),
         }
     }
 }

src/euclid/errors.rs

@@ -9,7 +9,7 @@ use crate::{
         cgraph,
         interpreter::{evaluate_output, InterpreterBackend},
         types::{
-            ActivateRoutingConfigRequest, Context, JsonifiedRoutingAlgorithm,
+            ActivateRoutingConfigRequest, Context, JsonifiedRoutingAlgorithm, KeyDataType,
             RoutingAlgorithmMapperNew, RoutingDictionaryRecord, RoutingEvaluateResponse,
             RoutingRequest, RoutingRule, SrDimensionConfig, StaticRoutingAlgorithm,
             ELIGIBLE_DIMENSIONS,
@@ -145,34 +145,57 @@ pub async fn routing_create(
 
     logger::debug!("Received routing config: {:?}", config);
 
-    if let Err(err) = validate_routing_rule(&config, &state.config.routing_config) {
-        let source = err.get_inner();
+    match validate_routing_rule(&config, &state.config.routing_config) {
+        Ok(validation_result) => {
+            if !validation_result.is_valid {
+                for error in &validation_result.errors {
+                    logger::error!(
+                        field = %error.field,
+                        error_type = %error.error_type,
+                        message = %error.message,
+                        "Field validation error during routing rule creation"
+                    );
+                }
+
+                let error_details: Vec<serde_json::Value> = validation_result
+                    .errors
+                    .iter()
+                    .map(|e| {
+                        serde_json::json!({
+                            "field": e.field,
+                            "error_type": e.error_type,
+                            "message": e.message,
+                        })
+                    })
+                    .collect();
 
-        if let EuclidErrors::FailedToValidateRoutingRule = source {
-            if let Some(validation_messages) = err.downcast_ref::<Vec<String>>() {
-                let detailed_error = validation_messages.join("; ");
-                logger::error!("Routing rule validation failed with errors: {detailed_error}");
+                let detailed_error = validation_result.to_error_message();
 
                 metrics::API_REQUEST_COUNTER
                     .with_label_values(&["routing_create", "failure"])
                     .inc();
                 timer.observe_duration();
+
                 return Err(ContainerError::new_with_status_code_and_payload(
-                    EuclidErrors::FailedToValidateRoutingRule,
+                    EuclidErrors::FieldValidationFailed(detailed_error.clone()),
                     axum::http::StatusCode::BAD_REQUEST,
                     ApiErrorResponse::new(
-                        "INVALID_REQUEST_DATA",
+                        "FIELD_VALIDATION_FAILED",
                         format!("Routing rule validation failed: {}", detailed_error),
-                        None,
+                        Some(serde_json::json!({ "validation_errors": error_details })),
                     ),
                 ));
             }
+            logger::debug!("Routing rule validation passed successfully");
+        }
+        Err(err) => {
+            logger::error!(error = ?err, "Failed to validate routing rule configuration");
+            metrics::API_REQUEST_COUNTER
+                .with_label_values(&["routing_create", "failure"])
+                .inc();
+            timer.observe_duration();
+            return Err(err.into());
         }
-        metrics::API_REQUEST_COUNTER
-            .with_label_values(&["routing_create", "failure"])
-            .inc();
-        timer.observe_duration();
-        return Err(err.into());
     }
 
     let utc_date_time = time::OffsetDateTime::now_utc();
@@ -306,7 +329,7 @@ pub async fn routing_evaluate(
         }
 
         if let Some(key_config) = routing_config.keys.keys.get(key) {
-            if key_config.data_type == "enum" {
+            if key_config.data_type == KeyDataType::Enum {
                 if let Some(Some(ValueType::EnumVariant(value))) = parameters.get(key) {
                     if !is_valid_enum_value(routing_config, key, value) {
                         update_failure_metrics();

src/euclid/handlers/routing_rules.rs

@@ -268,13 +268,105 @@ impl Deref for Context {
     }
 }
 
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum KeyDataType {
+    #[serde(rename = "integer")]
+    Integer,
+    #[serde(rename = "enum")]
+    Enum,
+    #[serde(rename = "udf")]
+    Udf,
+    #[serde(rename = "str_value")]
+    StrValue,
+    #[serde(rename = "global_ref")]
+    GlobalRef,
+}
+
+impl KeyDataType {
+    pub fn as_str(&self) -> &str {
+        match self {
+            KeyDataType::Integer => "integer",
+            KeyDataType::Enum => "enum",
+            KeyDataType::Udf => "udf",
+            KeyDataType::StrValue => "str_value",
+            KeyDataType::GlobalRef => "global_ref",
+        }
+    }
+}
+
 /// Represents a key configuration in the TOML file
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct KeyConfig {
     #[serde(rename = "type")]
-    pub data_type: String,
+    pub data_type: KeyDataType,
     #[serde(default)]
     pub values: Option<String>,
+    #[serde(default)]
+    pub min_value: Option<i64>,
+    #[serde(default)]
+    pub max_value: Option<i64>,
+    #[serde(default)]
+    pub min_length: Option<usize>,
+    #[serde(default)]
+    pub max_length: Option<usize>,
+    #[serde(default)]
+    pub exact_length: Option<usize>,
+    #[serde(default)]
+    pub regex: Option<String>,
+}
+
+impl KeyConfig {
+    pub fn has_validation_constraints(&self) -> bool {
+        self.min_value.is_some()
+            || self.max_value.is_some()
+            || self.min_length.is_some()
+            || self.max_length.is_some()
+            || self.exact_length.is_some()
+            || self.regex.is_some()
+    }
+
+    pub fn build_validation_rules(&self) -> Result<FieldValidationRules, String> {
+        let regex_pattern = match &self.regex {
+            Some(pattern) => Some(
+                regex::Regex::new(pattern)
+                    .map_err(|e| format!("Invalid regex pattern '{}': {}", pattern, e))?,
+            ),
+            None => None,
+        };
+
+        Ok(FieldValidationRules {
+            min_value: self.min_value,
+            max_value: self.max_value,
+            min_length: self.min_length,
+            max_length: self.max_length,
+            exact_length: self.exact_length,
+            regex_pattern,
+        })
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct FieldValidationRules {
+    pub min_value: Option<i64>,
+    pub max_value: Option<i64>,
+    pub min_length: Option<usize>,
+    pub max_length: Option<usize>,
+    pub exact_length: Option<usize>,
+    pub regex_pattern: Option<regex::Regex>,
+}
+
+impl Default for FieldValidationRules {
+    fn default() -> Self {
+        Self {
+            min_value: None,
+            max_value: None,
+            min_length: None,
+            max_length: None,
+            exact_length: None,
+            regex_pattern: None,
+        }
+    }
 }
 
 /// Structure for the [keys] section in the TOML