feat: ofrep provider

Signed-off-by: Rahul Baradol <[email protected]>

Author: Rahul-Baradol

Cargo.toml

@@ -12,5 +12,6 @@ edition = "2021"
 members = [
     "crates/env-var",
     "crates/flagd",
-    "crates/flipt"
-]
+    "crates/flipt",
+    "crates/ofrep"
+]

crates/ofrep/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "ofrep"
+version = "0.0.1"
+edition = "2024"
+
+[dependencies]
+async-trait = "0.1.88"
+open-feature = "0.2.5"
+reqwest = { version = "0.12", default-features = false, features = ["json", "stream", "rustls-tls"] }
+serde = "1.0.219"
+serde_json = "1.0.140"
+tracing = "0.1.41"
+thiserror = "2.0"
+anyhow = "1.0.98"

crates/ofrep/src/error.rs

@@ -0,0 +1,30 @@
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum OfrepError {
+    #[error("Provider error: {0}")]
+    Provider(String),
+    #[error("Connection error: {0}")]
+    Connection(String),
+    #[error("Invalid configuration: {0}")]
+    Config(String),
+}
+
+// Add implementations for error conversion
+impl From<Box<dyn std::error::Error>> for OfrepError {
+    fn from(error: Box<dyn std::error::Error>) -> Self {
+        OfrepError::Provider(error.to_string())
+    }
+}
+
+impl From<Box<dyn std::error::Error + Send + Sync>> for OfrepError {
+    fn from(error: Box<dyn std::error::Error + Send + Sync>) -> Self {
+        OfrepError::Provider(error.to_string())
+    }
+}
+
+impl From<anyhow::Error> for OfrepError {
+    fn from(error: anyhow::Error) -> Self {
+        OfrepError::Provider(error.to_string())
+    }
+}

crates/ofrep/src/lib.rs

@@ -0,0 +1,107 @@
+mod resolver;
+mod error;
+
+use std::time::Duration;
+use std::sync::Arc;
+use reqwest::header::{HeaderMap};
+use open_feature::provider::{FeatureProvider, ProviderMetadata, ResolutionDetails};
+use open_feature::{
+    EvaluationContext, EvaluationError, StructValue,
+};
+use tracing::debug;
+use tracing::instrument;
+use resolver::Resolver;
+use error::OfrepError;
+
+use async_trait::async_trait;
+
+const DEFAULT_BASE_URL: &str = "http://localhost:8016";
+const DEFAULT_CONNECT_TIMEOUT: Duration = Duration::from_secs(10);
+
+#[derive(Debug, Clone)]
+pub struct OfrepOptions {
+    pub base_url: String,
+    pub headers: HeaderMap,
+    pub connect_timeout: Duration,
+}
+
+impl Default for OfrepOptions {
+    fn default() -> Self {
+        OfrepOptions {
+            base_url: DEFAULT_BASE_URL.to_string(),
+            headers: HeaderMap::new(),
+            connect_timeout: DEFAULT_CONNECT_TIMEOUT,
+        }
+    }
+}
+
+pub struct OfrepProvider {
+    provider: Arc<dyn FeatureProvider + Send + Sync>,
+}
+
+impl OfrepProvider {
+    #[instrument(skip(options))]
+    pub async fn new(options: OfrepOptions) -> Result<Self, OfrepError> {
+        debug!("Initializing OfrepProvider with options: {:?}", options);
+        Ok(Self {
+            provider: Arc::new(Resolver::new(&options))
+        })
+    }
+}
+
+#[async_trait]
+impl FeatureProvider for OfrepProvider {
+    fn metadata(&self) -> &ProviderMetadata {
+        self.provider.metadata()
+    }
+
+    async fn resolve_bool_value(
+        &self,
+        flag_key: &str,
+        context: &EvaluationContext,
+    ) -> Result<ResolutionDetails<bool>, EvaluationError> {
+
+        let result = self.provider.resolve_bool_value(flag_key, context).await?;
+        Ok(result)
+    }
+
+    async fn resolve_int_value(
+        &self,
+        flag_key: &str,
+        context: &EvaluationContext,
+    ) -> Result<ResolutionDetails<i64>, EvaluationError> {
+
+        let result = self.provider.resolve_int_value(flag_key, context).await?;
+        Ok(result)
+    }
+
+    async fn resolve_float_value(
+        &self,
+        flag_key: &str,
+        context: &EvaluationContext,
+    ) -> Result<ResolutionDetails<f64>, EvaluationError> {
+
+        let result = self.provider.resolve_float_value(flag_key, context).await?;
+        Ok(result)
+    }
+
+    async fn resolve_string_value(
+        &self,
+        flag_key: &str,
+        context: &EvaluationContext,
+    ) -> Result<ResolutionDetails<String>, EvaluationError> {
+
+        let result = self.provider.resolve_string_value(flag_key, context).await?;
+        Ok(result)
+    }
+
+    async fn resolve_struct_value(
+        &self,
+        flag_key: &str,
+        context: &EvaluationContext,
+    ) -> Result<ResolutionDetails<StructValue>, EvaluationError> {
+
+        let result = self.provider.resolve_struct_value(flag_key, context).await?;
+        Ok(result)
+    }
+}