bachs-sdk 0.1.0

Unofficial Rust SDK for the Bachs API — payments and billing for internet businesses.
Documentation
use crate::client::Bachs;
use crate::common::{FlexObject, ListParams, ListResponse, Metadata, Timestamp};
use crate::error::BachsResult;
use reqwest::Method;
use serde::{Deserialize, Serialize};

/// There is no `subscriptions.create` — subscriptions are created by
/// completing a [`crate::checkout_sessions::CheckoutSessions::create`] call
/// against a recurring product. This module only manages subscriptions that
/// already exist.
#[derive(Debug, Clone, Deserialize)]
pub struct Subscription {
    /// Prefixed with `sub_`.
    pub subscription_id: String,
    #[serde(default)]
    pub customer_id: Option<String>,
    #[serde(default)]
    pub status: Option<String>,
    #[serde(default)]
    pub metadata: Metadata,
    pub created_at: Timestamp,
    #[serde(default)]
    pub updated_at: Option<Timestamp>,
    #[serde(flatten)]
    pub extra: FlexObject,
}

#[derive(Debug, Clone, Default, Serialize)]
pub struct UpdateSubscriptionRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata: Option<Metadata>,
}

impl UpdateSubscriptionRequest {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn metadata(mut self, metadata: Metadata) -> Self {
        self.metadata = Some(metadata);
        self
    }
}

/// Whether a cancellation takes effect immediately or at the end of the
/// current billing period.
#[derive(Debug, Clone, Copy, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum CancellationTiming {
    Immediately,
    AtPeriodEnd,
}

#[derive(Debug, Clone, Serialize)]
pub struct CancelSubscriptionRequest {
    pub timing: CancellationTiming,
}

impl Default for CancelSubscriptionRequest {
    fn default() -> Self {
        Self {
            timing: CancellationTiming::AtPeriodEnd,
        }
    }
}

pub struct Subscriptions<'a> {
    pub(crate) client: &'a Bachs,
}

impl<'a> Subscriptions<'a> {
    pub async fn get(&self, subscription_id: &str) -> BachsResult<Subscription> {
        self.client
            .send::<(), _>(
                Method::GET,
                &format!("/v1/subscriptions/{subscription_id}"),
                None,
                None,
                None,
            )
            .await
    }

    pub async fn update(
        &self,
        subscription_id: &str,
        req: &UpdateSubscriptionRequest,
    ) -> BachsResult<Subscription> {
        self.client
            .send(
                Method::PATCH,
                &format!("/v1/subscriptions/{subscription_id}"),
                Some(req),
                None,
                None,
            )
            .await
    }

    /// Cancel a subscription. Defaults to cancelling at the end of the
    /// current billing period; pass `CancellationTiming::Immediately` for an
    /// immediate cancellation.
    pub async fn cancel(
        &self,
        subscription_id: &str,
        req: &CancelSubscriptionRequest,
    ) -> BachsResult<Subscription> {
        self.client
            .send(
                Method::POST,
                &format!("/v1/subscriptions/{subscription_id}/cancel"),
                Some(req),
                None,
                None,
            )
            .await
    }

    pub async fn list(&self, params: &ListParams) -> BachsResult<ListResponse<Subscription>> {
        let query = params.to_query();
        self.client
            .send::<(), _>(Method::GET, "/v1/subscriptions", None, Some(&query), None)
            .await
    }
}