feat(gRPC): build gRPC client interface to initiate communication with recovery-decider service

config/development.toml

@@ -1145,6 +1145,14 @@ host = "localhost"
 port = 8000
 service = "dynamo"
 
+[grpc_client.recovery_decider_client]
+host = "127.0.0.1"
+port = 8000
+
+[grpc_client.trainer_client]
+host = "0.0.0.0"
+port = 50051
+
 [theme.storage]
 file_storage_backend = "file_system" # Theme storage backend to be used
 

crates/common_utils/Cargo.toml

@@ -43,6 +43,7 @@ nutype = { version = "0.4.3", features = ["serde"] }
 once_cell = "1.21.3"
 openssl = {version = "0.10.72", optional = true}
 phonenumber = "0.3.7"
+prost-types = { version = "0.13" }
 quick-xml = { version = "0.31.0", features = ["serialize"] }
 rand = "0.8.5"
 regex = "1.11.1"

crates/common_utils/src/custom_serde.rs

@@ -1,4 +1,6 @@
 //! Custom serialization/deserialization implementations.
+/// Serde helpers for `prost_types::Timestamp` and `Option<prost_types::Timestamp>`.
+pub mod prost_timestamp;
 
 /// Use the well-known ISO 8601 format when serializing and deserializing an
 /// [`PrimitiveDateTime`][PrimitiveDateTime].

crates/common_utils/src/custom_serde/prost_timestamp.rs

@@ -0,0 +1,80 @@
+use prost_types::Timestamp;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+/// A wrapper around `prost_types::Timestamp` to enable custom Serde implementations.
+#[derive(Debug, Clone, PartialEq)]
+pub struct SerializableTimestamp(pub Timestamp);
+
+impl From<Timestamp> for SerializableTimestamp {
+    fn from(ts: Timestamp) -> Self {
+        Self(ts)
+    }
+}
+
+impl From<SerializableTimestamp> for Timestamp {
+    fn from(sts: SerializableTimestamp) -> Self {
+        sts.0
+    }
+}
+
+// Helper struct for serializing/deserializing the fields of Timestamp
+#[derive(Serialize, Deserialize)]
+struct TimestampFields {
+    seconds: i64,
+    nanos: i32,
+}
+
+impl Serialize for SerializableTimestamp {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let fields = TimestampFields {
+            seconds: self.0.seconds,
+            nanos: self.0.nanos,
+        };
+        fields.serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for SerializableTimestamp {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let fields = TimestampFields::deserialize(deserializer)?;
+        Ok(Self(Timestamp {
+            seconds: fields.seconds,
+            nanos: fields.nanos,
+        }))
+    }
+}
+
+/// Serde module for `Option<SerializableTimestamp>`.
+pub mod optional_prost_timestamp {
+    use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+    use super::SerializableTimestamp;
+
+    /// Serializes `Option<SerializableTimestamp>`.
+    pub fn serialize<S>(
+        option_timestamp: &Option<SerializableTimestamp>,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match option_timestamp {
+            Some(timestamp) => timestamp.serialize(serializer), // Directly use SerializableTimestamp's Serialize impl
+            None => serializer.serialize_none(),
+        }
+    }
+
+    /// Deserializes `Option<SerializableTimestamp>`.
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<SerializableTimestamp>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Option::<SerializableTimestamp>::deserialize(deserializer) // Directly use SerializableTimestamp's Deserialize impl
+    }
+}

crates/common_utils/src/lib.rs

@@ -44,6 +44,7 @@ pub mod date_time {
     use std::{marker::PhantomData, num::NonZeroU8};
 
     use masking::{Deserialize, Serialize};
+    use prost_types::Timestamp;
     use time::{
         format_description::{
             well_known::iso8601::{Config, EncodedConfig, Iso8601, TimePrecision},
@@ -203,6 +204,28 @@ pub mod date_time {
             f.write_str(&output)
         }
     }
+
+    /// Converts a `time::PrimitiveDateTime` to a `prost_types::Timestamp`.
+    /// Assumes UTC for the conversion.
+    pub fn convert_to_prost_timestamp(dt: PrimitiveDateTime) -> Timestamp {
+        let odt = dt.assume_utc();
+        Timestamp {
+            seconds: odt.unix_timestamp(),
+            // This conversion is safe as nanoseconds (0..999_999_999) always fit within an i32.
+            #[allow(clippy::as_conversions)]
+            nanos: odt.nanosecond() as i32,
+        }
+    }
+
+    /// Converts a `prost_types::Timestamp` to an `Option<time::PrimitiveDateTime>`.
+    /// Returns `None` if the timestamp is out of range for `OffsetDateTime`.
+    pub fn convert_from_prost_timestamp(ts: &Timestamp) -> Option<PrimitiveDateTime> {
+        OffsetDateTime::from_unix_timestamp_nanos(
+            i128::from(ts.seconds) * 1_000_000_000 + i128::from(ts.nanos),
+        )
+        .ok()
+        .map(|odt| PrimitiveDateTime::new(odt.date(), odt.time()))
+    }
 }
 
 /// Generate a nanoid with the given prefix and length

crates/external_services/Cargo.toml

@@ -13,6 +13,17 @@ email = ["dep:aws-config"]
 aws_s3 = ["dep:aws-config", "dep:aws-sdk-s3"]
 hashicorp-vault = ["dep:vaultrs"]
 v1 = ["hyperswitch_interfaces/v1", "common_utils/v1"]
+v2 = [
+    "dep:prost",
+    "dep:prost-types",
+    "dep:tonic",
+    "dep:tonic-build",
+    "dep:router_env",
+    "tokio/macros",
+    "tokio/rt-multi-thread",
+    "dep:hyper-util",
+    "dep:http-body-util"
+    ]
 dynamic_routing = [
     "dep:prost",
     "dep:tonic",
@@ -47,6 +58,7 @@ serde = { version = "1.0.219", features = ["derive"] }
 thiserror = "1.0.69"
 vaultrs = { version = "0.7.4", optional = true }
 prost = { version = "0.13", optional = true }
+prost-types = { version = "0.13" , optional = true}
 tokio = "1.45.1"
 tonic = { version = "0.12.3", optional = true }
 tonic-reflection = { version = "0.12.3", optional = true }

crates/external_services/build.rs

@@ -1,29 +1,60 @@
 #[allow(clippy::expect_used)]
 fn main() -> Result<(), Box<dyn std::error::Error>> {
+    #[cfg(any(feature = "dynamic_routing", feature = "v2"))]
+    compile_protos()?;
+
+    Ok(())
+}
+
+#[cfg(any(feature = "dynamic_routing", feature = "v2"))]
+fn compile_protos() -> Result<(), Box<dyn std::error::Error>> {
+    let mut proto_files_to_compile = Vec::new();
+    let proto_base_path = router_env::workspace_path().join("proto");
+
     #[cfg(feature = "dynamic_routing")]
     {
         // Get the directory of the current crate
+        proto_files_to_compile.push(proto_base_path.join("success_rate.proto"));
+        proto_files_to_compile.push(proto_base_path.join("contract_routing.proto"));
+        proto_files_to_compile.push(proto_base_path.join("elimination_rate.proto"));
+        proto_files_to_compile.push(proto_base_path.join("health_check.proto"));
+    }
+
+    #[cfg(feature = "v2")]
+    {
+        proto_files_to_compile.push(proto_base_path.join("recovery_decider.proto"));
+        proto_files_to_compile.push(proto_base_path.join("trainer_client.proto"));
+    }
+
+    if !proto_files_to_compile.is_empty() {
+        // Ensure proto files are unique in case a file is needed by multiple features
+        proto_files_to_compile.sort();
+        proto_files_to_compile.dedup();
 
-        let proto_path = router_env::workspace_path().join("proto");
-        let success_rate_proto_file = proto_path.join("success_rate.proto");
-        let contract_routing_proto_file = proto_path.join("contract_routing.proto");
-        let elimination_proto_file = proto_path.join("elimination_rate.proto");
-        let health_check_proto_file = proto_path.join("health_check.proto");
         let out_dir = std::path::PathBuf::from(std::env::var("OUT_DIR")?);
 
         // Compile the .proto file
         tonic_build::configure()
             .out_dir(out_dir)
-            .compile(
-                &[
-                    success_rate_proto_file,
-                    health_check_proto_file,
-                    elimination_proto_file,
-                    contract_routing_proto_file,
-                ],
-                &[proto_path],
+            .compile_well_known_types(true)
+            .extern_path(".google.protobuf.Timestamp", "::prost_types::Timestamp")
+            .type_attribute(
+                "trainer.TriggerTrainingRequest",
+                "#[derive(masking::Deserialize, masking::Serialize)]",
+            )
+            .type_attribute(
+                "trainer.TriggerTrainingResponse",
+                "#[derive(serde::Serialize)]",
+            )
+            .type_attribute(
+                "trainer.GetTrainingJobStatusResponse",
+                "#[derive(serde::Serialize)]",
+            )
+            .type_attribute(
+                "google.protobuf.Timestamp",
+                "#[derive(serde::Serialize, serde::Deserialize)]",
             )
-            .expect("Failed to compile proto files");
+            .compile(&proto_files_to_compile, &[proto_base_path])?;
     }
     Ok(())
 }