stripe_request.rs

use std::marker::PhantomData;

use serde::de::DeserializeOwned;
use serde::Serialize;

use crate::request_strategy::RequestStrategy;

#[derive(Debug, Copy, Clone)]
pub enum StripeMethod {
    Get,
    Post,
    Delete,
}

pub trait StripeClient {
    type Err;

    fn execute<T: DeserializeOwned>(
        &self,
        req: CustomizedStripeRequest<T>,
    ) -> impl std::future::Future<Output = Result<T, Self::Err>>;
}

pub trait StripeBlockingClient {
    type Err;

    fn execute<T: DeserializeOwned>(&self, req: CustomizedStripeRequest<T>)
        -> Result<T, Self::Err>;
}

pub trait StripeRequest {
    type Output;

    fn build(&self) -> RequestBuilder;

    fn customize(&self) -> CustomizedStripeRequest<Self::Output> {
        CustomizedStripeRequest {
            inner: self.build(),
            request_strategy: RequestStrategy::Once,
            _output: PhantomData,
        }
    }
}

pub struct CustomizedStripeRequest<T> {
    pub inner: RequestBuilder,
    pub request_strategy: RequestStrategy,
    _output: PhantomData<T>,
}

impl<T: DeserializeOwned> CustomizedStripeRequest<T> {
    pub async fn send<C: StripeClient>(self, client: &C) -> Result<T, C::Err> {
        client.execute(self).await
    }

    pub fn send_blocking<C: StripeBlockingClient>(self, client: &C) -> Result<T, C::Err> {
        client.execute(self)
    }
}

pub struct RequestBuilder {
    pub query: Option<String>,
    pub body: Option<String>,
    pub path: String,
    pub method: StripeMethod,
}

impl RequestBuilder {
    pub fn new(method: StripeMethod, path: impl Into<String>) -> Self {
        Self { path: path.into(), method, query: None, body: None }
    }

    pub fn query<P: Serialize>(mut self, params: &P) -> Self {
        self.query = Some(serde_qs::to_string(params).expect("valid serialization"));
        self
    }

    pub fn form<F: Serialize>(mut self, form: &F) -> Self {
        self.body = Some(serde_qs::to_string(form).expect("valid serialization"));
        self
    }
}