librjss 2.2.2

Robust client library for Juragan Subsystem
Documentation
use crate::client::RjssClient;
use crate::handler::error::JssError;
use serde::{Serialize, de::DeserializeOwned};
use std::collections::HashMap;
use tracing::instrument;

pub struct ResourceBuilder<'a> {
    client: &'a RjssClient,
    doctype: String,
    filters: Vec<(String, String, String)>,
    fields: Option<Vec<String>>,
    order_by: Option<String>,
    limit: Option<u32>,
    limit_start: Option<u32>,
}

impl<'a> ResourceBuilder<'a> {
    pub(crate) fn new(client: &'a RjssClient, doctype: &str) -> Self {
        ResourceBuilder {
            client,
            doctype: doctype.to_string(),
            filters: Vec::new(),
            fields: None,
            order_by: None,
            limit: None,
            limit_start: None,
        }
    }

    pub fn filter(mut self, field: &str, operator: &str, value: &str) -> Self {
        self.filters
            .push((field.to_string(), operator.to_string(), value.to_string()));
        self
    }

    pub fn fields(mut self, fields: Vec<&str>) -> Self {
        self.fields = Some(fields.into_iter().map(|s| s.to_string()).collect());
        self
    }

    pub fn order_by(mut self, order: &str) -> Self {
        self.order_by = Some(order.to_string());
        self
    }

    pub fn limit(mut self, limit: u32) -> Self {
        if limit == 0 {
            tracing::warn!("limit set to 0, using default 200");
            self.limit = Some(200);
        } else {
            self.limit = Some(limit);
        }
        self
    }

    pub fn limit_start(mut self, start: u32) -> Self {
        self.limit_start = Some(start);
        self
    }

    #[instrument(skip(self), fields(doctype = %self.doctype))]
    pub async fn execute_raw(&self) -> Result<String, JssError> {
        let mut path = format!("/api/resource/{}", self.doctype);
        let mut params = Vec::new();

        if !self.filters.is_empty() {
            let filters_json: Vec<[String; 3]> = self
                .filters
                .iter()
                .map(|(f, op, v)| [f.clone(), op.clone(), v.clone()])
                .collect();
            let filters_str = serde_json::to_string(&filters_json)
                .map_err(|e| JssError::Parse(format!("Failed to serialize filters: {e}")))?;
            params.push(format!("filters={}", urlencoding::encode(&filters_str)));
        }

        if let Some(ref fields) = self.fields {
            params.push(format!(
                "fields={}",
                urlencoding::encode(&serde_json::to_string(fields).unwrap_or_default())
            ));
        }

        if let Some(ref order) = self.order_by {
            params.push(format!("order_by={}", urlencoding::encode(order)));
        }

        if let Some(limit) = self.limit {
            params.push(format!("limit_page_length={limit}"));
        }

        if let Some(start) = self.limit_start {
            params.push(format!("limit_start={start}"));
        }

        if !params.is_empty() {
            path = format!("{path}?{}", params.join("&"));
        }

        self.client.authenticated_get(&path).await
    }

    pub async fn execute<T: DeserializeOwned>(&self) -> Result<T, JssError> {
        let body = self.execute_raw().await?;
        serde_json::from_str(&body)
            .map_err(|e| JssError::Parse(format!("Failed to parse response: {e}")))
    }

    pub async fn all<T: DeserializeOwned>(&self) -> Result<Vec<T>, JssError> {
        let page_size = 200u32;
        let mut all_data = Vec::new();
        let mut start = 0u32;

        loop {
            let builder = ResourceBuilder {
                client: self.client,
                doctype: self.doctype.clone(),
                filters: self.filters.clone(),
                fields: self.fields.clone(),
                order_by: self.order_by.clone(),
                limit: Some(page_size),
                limit_start: Some(start),
            };

            let response: serde_json::Value = builder.execute().await?;
            let data = response["data"].as_array().cloned().unwrap_or_default();
            if data.is_empty() {
                break;
            }

            all_data.extend(data);
            start += page_size;
        }

        let all_json = serde_json::Value::Array(all_data);
        serde_json::from_value(all_json)
            .map_err(|e| JssError::Parse(format!("Failed to deserialize all data: {e}")))
    }
}

impl RjssClient {
    pub fn doctype(&self, name: &str) -> ResourceBuilder<'_> {
        ResourceBuilder::new(self, name)
    }

    pub async fn get_doc(&self, doctype: &str, name: &str) -> Result<String, JssError> {
        let path = format!("/api/resource/{doctype}/{name}");
        self.authenticated_get(&path).await
    }

    pub async fn create_doc(
        &self,
        doctype: &str,
        data: &impl Serialize,
    ) -> Result<String, JssError> {
        let path = format!("/api/resource/{doctype}");
        let body = serde_json::to_string(data)
            .map_err(|e| JssError::Parse(format!("Failed to serialize data: {e}")))?;
        self.authenticated_post(&path, &body).await
    }

    pub async fn update_doc(
        &self,
        doctype: &str,
        name: &str,
        data: &impl Serialize,
    ) -> Result<String, JssError> {
        let path = format!("/api/resource/{doctype}/{name}");
        let body = serde_json::to_string(data)
            .map_err(|e| JssError::Parse(format!("Failed to serialize data: {e}")))?;
        self.authenticated_put(&path, &body).await
    }

    pub async fn delete_doc(&self, doctype: &str, name: &str) -> Result<String, JssError> {
        let path = format!("/api/resource/{doctype}/{name}");
        self.authenticated_delete(&path).await
    }

    pub async fn call_method(
        &self,
        method: &str,
        args: Option<HashMap<String, String>>,
    ) -> Result<String, JssError> {
        let path = format!("/api/method/{method}");
        let body = if let Some(args) = args {
            serde_json::to_string(&args)
                .map_err(|e| JssError::Parse(format!("Failed to serialize method args: {e}")))?
        } else {
            "{}".to_string()
        };
        self.authenticated_post(&path, &body).await
    }
}