retailops_sdk/

client.rs

use crate::proto::api;
use anyhow::{anyhow, Result};
use serde::{de::DeserializeOwned, Serialize};
use std::time::{SystemTime, UNIX_EPOCH};

use std::sync::Arc;
const API_BASE_URL: &str = "https://api.retailops.com";
const USER_AGENT: &str = "Integration Layer";

#[derive(serde::Serialize, serde::Deserialize)]
struct CacheEntry<T> {
    data: T,
    timestamp: u64,
}

impl<T> CacheEntry<T> {
    fn new(data: T) -> Self {
        let timestamp = SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_secs();
        Self { data, timestamp }
    }

    fn is_expired(&self) -> bool {
        let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_secs();
        let age = now - self.timestamp;
        age > 24 * 60 * 60 // 24 hours in seconds
    }
}

#[derive(Clone)]
pub struct ROClient {
    client: Arc<reqwest::Client>,
    cache: Arc<sled::Db>,
}

impl ROClient {
    pub fn new(api_key: String) -> Result<Self> {
        let mut headers = reqwest::header::HeaderMap::new();

        let credential_id = api_key
            .split("-")
            .next()
            .ok_or(anyhow!("Invalid API key - must be in format <credential_id>-<secret>"))?;

        headers.insert("apikey", reqwest::header::HeaderValue::from_str(&api_key)?);
        headers.insert(
            reqwest::header::USER_AGENT,
            reqwest::header::HeaderValue::from_static(USER_AGENT),
        );

        let client = reqwest::Client::builder().default_headers(headers).build()?;

        // Create a cache directory in a standard location
        let cache_dir = dirs::cache_dir()
            .ok_or_else(|| anyhow!("Could not determine cache directory"))?
            .join("retailops-api-cache")
            .join(credential_id);

        println!("Cache directory: {}", cache_dir.display());
        // Create the directory if it doesn't exist
        std::fs::create_dir_all(&cache_dir)?;

        // Open the database
        let cache = sled::open(cache_dir)?;

        Ok(Self {
            client: Arc::new(client),
            cache: Arc::new(cache),
        })
    }

    fn set_cache<T: Serialize>(&self, key: &str, data: &T) -> Result<()> {
        let entry = CacheEntry::new(data);
        self.cache.insert(
            key.as_bytes(),
            serde_json::to_vec(&entry).map_err(|e| anyhow!("Failed to serialize: {}", e))?,
        )?;
        Ok(())
    }

    fn get_cache<T: DeserializeOwned>(&self, key: &str) -> Result<Option<T>> {
        if let Some(cached) = self.cache.get(key.as_bytes())? {
            if let Ok(entry) = serde_json::from_slice::<CacheEntry<T>>(&cached) {
                if !entry.is_expired() {
                    return Ok(Some(entry.data));
                }
                // If entry is expired, remove it from cache
                let _ = self.cache.remove(key.as_bytes());
            }
        }
        Ok(None)
    }

    pub fn clear_cache(&self) -> Result<()> {
        self.cache.clear()?;
        Ok(())
    }

    fn parse_action_path(path: &str) -> Result<(String, String, u32)> {
        let parts: Vec<&str> = path.split('~').collect();
        if parts.len() != 2 {
            return Err(anyhow!(
                "Action path must include version number after ~ (e.g. 'namespace.action~1')"
            ));
        }

        let version = parts[1].parse::<u32>()?;
        let action_parts: Vec<&str> = parts[0].split('.').collect();
        if action_parts.len() < 2 {
            return Err(anyhow!(
                "Action path must have at least two parts before version (e.g. 'namespace.action~1')"
            ));
        }

        let action = action_parts.last().unwrap().to_string();
        let namespace = action_parts[..action_parts.len() - 1].join("/");

        Ok((namespace, action, version))
    }

    fn format_error_context(text: &str, column: usize) -> String {
        let start = column.saturating_sub(50);
        let end = (column + 50).min(text.len());
        let context = &text[start..end];

        format!("...{}...\n{}^", context, " ".repeat(50.min(column - start)))
    }

    pub async fn call<T, R>(&self, action_path: &str, params: &T) -> Result<R>
    where
        T: Serialize + ?Sized,
        R: DeserializeOwned,
    {
        let (namespace, action, version) = Self::parse_action_path(action_path)?;
        let url = format!("{}/{}/{}~{}.json", API_BASE_URL, namespace, action, version);

        let response = self.client.post(&url).json(params).send().await?;

        if !response.status().is_success() {
            return Err(anyhow!("API request failed with status: {}", response.status()));
        }

        let bytes = response.bytes().await?;
        match serde_json::from_slice(&bytes) {
            Ok(result) => Ok(result),
            Err(e) => {
                let text = String::from_utf8_lossy(&bytes);

                // Get the error location and convert to 0-based index for string slicing
                let col = e.column().saturating_sub(1);
                eprintln!(
                    "Failed to parse response from {}: {}\nContext at column {}:\n{}",
                    action_path,
                    e,
                    col + 1, // Show 1-based index in message
                    Self::format_error_context(&text, col)
                );
                Err(e.into())
            }
        }
    }

    pub async fn get_user_by_id(&self, user_id: u32) -> Result<api::config::user::User> {
        // this api call doesn't support filtering by user_id - so we have to do it
        let blank_params = serde_json::Map::new();
        use api::{config::user::User, ReadResponse};
        let result: ReadResponse<User> = self.call("config.user.read~1", &blank_params).await?;

        // find the user in the result
        if let Some(user) = result.records.iter().find(|user| user.id == user_id) {
            self.set_cache(&format!("user:{}", user_id), &user)?;
            return Ok(user.clone());
        }

        Err(anyhow!("User not found"))
    }

    pub async fn annotate_record(&self, concept: &str, record_id: u32, note: &str) -> Result<()> {
        let params = api::utility::eventlog::AnnotateRequest {
            concept: concept.to_string(),
            record_id,
            note: note.to_string(),
        };

        // Validate note length
        if note.is_empty() || note.len() > 10000 {
            return Err(anyhow!("Note must be between 1 and 10,000 characters"));
        }
        let _response: api::Response = self.call("utility.eventlog.annotate~1", &params).await?;
        Ok(())
    }
}