Billing

[dependencies]
renox = "1.0.0-rc.6"
renox-billing = "1.0.0-rc.6"

use renox::prelude::*;
use renox_billing::{Billing, Interval, Plan};

/// The app: login pages, the account page, and subscriptions.
pub fn app() -> App {
    App::new()
        // `.account()` is the /account page, where the subscription's card goes.
        .module(Auth::new().account())
        // Brings its tables (a migration), its routes, the plans page and its card on /account.
        .module(
            Billing::new()
                .plan(Plan::new("basic", "Basic").price(900, "USD", Interval::Month))
                .plan(
                    Plan::new("pro", "Pro")
                        .price(1_900, "USD", Interval::Month)
                        .trial_days(14)
                        .feature("Unlimited projects"),
                )
                .stripe(), // STRIPE_SECRET and STRIPE_WEBHOOK_SECRET from .env
        )
}

use renox_billing::{Interval, Plan};

Plan::new("pro", "Pro")
    .price(1_900, "USD", Interval::Month) // amounts in the smallest unit: $19.00
    .trial_days(14)                        // free days, for a first subscription
    .description("For growing teams")
    .feature("Unlimited projects")         // listed on the plans page
    .feature("Priority support")
    .via("stripe")                         // the gateway; the first one set up when left out
    .price_id("stripe", "price_1Pq…")      // Stripe's Price (see below)

STRIPE_SECRET=sk_test_…
STRIPE_WEBHOOK_SECRET=whsec_…
STRIPE_PRICE_BASIC=price_…
STRIPE_PRICE_PRO=price_…

XENDIT_SECRET_KEY=xnd_development_…
XENDIT_CALLBACK_TOKEN=…

use renox_billing::{Billing, Interval, Plan};

Billing::new()
    .plan(Plan::new("pro", "Pro").price(1_900, "USD", Interval::Month))
    .plan(Plan::new("pro-idr", "Pro (IDR)").price(99_000, "IDR", Interval::Month).via("xendit"))
    .stripe()
    .xendit()

use renox::prelude::*;
use renox_billing::Billing;

async fn dashboard(State(state): State<AppState>, user: AuthUser) -> Result<View> {
    let billing = Billing::of(&state, &*user);
    let subscribed = billing.subscribed().await?;       // trial, paid, or in its grace period
    let pro = billing.subscribed_to("pro").await?;      // …to this plan
    let on_trial = billing.on_trial().await?;
    let grace = billing.on_grace_period().await?;       // canceled, not ended yet
    let subscription = billing.subscription().await?;   // the newest row, whatever its state
    let renews = subscription.and_then(|s| s.current_period_end);
    Ok(view("dashboard.html", context! { subscribed, pro, on_trial, grace, renews }))
}

use renox::prelude::*;
use renox_billing::SubscriptionRoutes;

fn routes() -> Routes {
    Routes::new()
        .get("/reports", reports)
        .require_subscription() // any plan
        .merge(
            Routes::new()
                .get("/exports", exports)
                .require_plan(&["pro", "business"]), // these plans only
        )
        .require_auth()
}

use renox::prelude::*;
use renox_billing::Billing;

async fn start(state: &AppState, user: &User) -> Result {
    Billing::of(state, user).start_trial("pro").await?;
    Ok(())
}

use renox::prelude::*;
use renox_billing::Billing;

async fn manage(state: &AppState, user: &User) -> Result {
    let billing = Billing::of(state, user);
    let url = billing.checkout("pro").await?; // the gateway's payment page: redirect there
    billing.swap("basic").await?;              // upgrade or downgrade, prorated at Stripe
    billing.cancel().await?;                   // at the period's end: the grace period
    billing.resume().await?;                   // before it ends (Stripe)
    billing.cancel_now().await?;               // access ends at once
    Ok(())
}

use renox::prelude::*;
use renox_billing::{PaymentFailed, SubscriptionCreated};

App::new()
    .listen(|e: SubscriptionCreated, _state| async move {
        tracing::info!(plan = e.subscription.plan, "a new subscription");
        Ok(())
    })
    .listen(|e: PaymentFailed, _state| async move {
        // e.g. mail the owner a link to their payment method
        tracing::warn!(amount = e.amount, "a payment failed");
        Ok(())
    })

use renox::prelude::*;
use renox_billing::{Billable, Billing, Owner};

struct Team {
    id: i64,
    name: String,
    billing_email: String,
}

impl Billable for Team {
    fn owner(&self) -> Owner {
        Owner::new("team", self.id)
            .name(self.name.clone())
            .email(self.billing_email.clone())
    }
}

async fn team_is_pro(state: &AppState, team: &Team) -> Result<bool> {
    Billing::of(state, team).subscribed_to("pro").await
}

use renox::Config;
use renox::axum::http::HeaderMap;
use renox::prelude::*;
use renox_billing::{
    BoxFuture, Checkout, CheckoutRequest, Gateway, Notice, Owner, Plan, Remote, Subscription,
    SubscriptionStatus,
};

/// A provider with a hosted checkout and JSON webhooks.
struct Acme;

impl Gateway for Acme {
    fn name(&self) -> &str {
        "acme"
    }
    fn label(&self) -> &str {
        "Acme Pay"
    }
    fn configured(&self, config: &Config) -> bool {
        config.var("ACME_KEY").is_some()
    }
    fn create_customer<'a>(&'a self, state: &'a AppState, owner: &'a Owner) -> BoxFuture<'a, Result<String>> {
        Box::pin(async move {
            let made: renox::serde_json::Value = state
                .http
                .post("https://api.acme.test/customers")
                .json(&json!({ "email": owner.email, "reference": owner.key() }))
                .send()
                .await?
                .error_for_status()?
                .json()?;
            Ok(made["id"].as_str().unwrap_or_default().to_owned())
        })
    }
    fn checkout<'a>(&'a self, state: &'a AppState, request: &'a CheckoutRequest) -> BoxFuture<'a, Result<Checkout>> {
        Box::pin(async move {
            // Send the metadata along: the webhooks bring it back.
            let metadata: std::collections::HashMap<_, _> = request.metadata().into_iter().collect();
            let session: renox::serde_json::Value = state
                .http
                .post("https://api.acme.test/subscriptions")
                .json(&json!({
                    "customer": request.customer_id,
                    "amount": request.plan.amount,
                    "currency": request.plan.currency,
                    "return_url": request.success_url,
                    "metadata": metadata,
                }))
                .send()
                .await?
                .error_for_status()?
                .json()?;
            Ok(Checkout::redirect(session["pay_url"].as_str().unwrap_or_default()))
        })
    }
    fn swap<'a>(&'a self, _state: &'a AppState, subscription: &'a Subscription, plan: &'a Plan, _prorate: bool) -> BoxFuture<'a, Result<Remote>> {
        Box::pin(async move {
            // … call the provider …
            Ok(Remote::new(subscription.gateway_id.clone().unwrap_or_default()).plan(plan.key.clone()))
        })
    }
    fn cancel<'a>(&'a self, _state: &'a AppState, subscription: &'a Subscription, at_period_end: bool) -> BoxFuture<'a, Result<Remote>> {
        Box::pin(async move {
            let remote = Remote::new(subscription.gateway_id.clone().unwrap_or_default());
            Ok(if at_period_end {
                remote.ends_at(subscription.current_period_end)
            } else {
                remote.status(SubscriptionStatus::Canceled)
            })
        })
    }
    fn verify_webhook(&self, config: &Config, headers: &HeaderMap, body: &[u8]) -> Result {
        let key = config.var("ACME_WEBHOOK_KEY").unwrap_or_default();
        let signature = headers.get("acme-signature").and_then(|v| v.to_str().ok()).unwrap_or_default();
        renox::webhook::ensure(renox::webhook::verify_hmac_sha256(key, body, signature))
    }
    fn parse_webhook(&self, body: &[u8]) -> Result<Vec<Notice>> {
        let event: renox::serde_json::Value = renox::serde_json::from_slice(body)?;
        let sub = &event["subscription"];
        let status = match sub["status"].as_str() {
            Some("active") => SubscriptionStatus::Active,
            Some("canceled") => SubscriptionStatus::Canceled,
            _ => SubscriptionStatus::Incomplete,
        };
        let mut remote = Remote::new(sub["id"].as_str().unwrap_or_default()).status(status);
        if let Some(owner) = sub["metadata"]["renox_billable"].as_str() {
            remote = remote.owner(owner);
        }
        if let Some(plan) = sub["metadata"]["renox_plan"].as_str() {
            remote = remote.plan(plan);
        }
        if let Some(at) = event["created"].as_i64() {
            remote = remote.at(at); // orders late events
        }
        Ok(vec![Notice::Subscription(remote)])
    }
}

renox_billing::Billing::new().gateway(Acme)

use renox::http::FakeResponse;
use renox::prelude::*;
use renox::testing::TestApp;
use renox_billing::{Billing, Interval, Plan, Stripe};

async fn demo() {
    let app = TestApp::new(
        App::new().module(Auth::new()).module(
            Billing::new()
                .plan(Plan::new("pro", "Pro").price(1_900, "USD", Interval::Month).price_id("stripe", "price_pro"))
                // Keys in code: tests don't read `.env`.
                .gateway(Stripe::new("sk_test", "whsec_test")),
        ),
    )
    .await;
    let user = User::register(app.db(), "Ana", "[email protected]", "a long password").await.unwrap();
    app.acting_as(&user);

    // Subscribing: a customer, then a Checkout Session.
    let http = app.fake_http();
    http.on("POST https://api.stripe.com/v1/customers", FakeResponse::json(200, json!({ "id": "cus_1" })));
    http.on(
        "POST https://api.stripe.com/v1/checkout/sessions",
        FakeResponse::json(200, json!({ "id": "cs_1", "url": "https://checkout.stripe.com/c/pay/cs_1" })),
    );
    app.post("/billing/checkout/pro", &[]).await.assert_redirect("https://checkout.stripe.com/c/pay/cs_1");

    // Stripe's webhook, signed with the test secret.
    let now = renox::db::now().timestamp();
    let payload = json!({
        "id": "evt_1",
        "type": "customer.subscription.created",
        "created": now,
        "data": { "object": {
            "id": "sub_1",
            "customer": "cus_1",
            "status": "active",
            "metadata": { "renox_billable": format!("user:{}", user.id), "renox_plan": "pro" },
            "items": { "data": [{ "id": "si_1", "price": { "id": "price_pro" } }] },
        } },
    })
    .to_string();
    let signature = renox::webhook::hmac_sha256_hex("whsec_test", format!("{now}.{payload}"));
    app.request()
        .header("stripe-signature", &format!("t={now},v1={signature}"))
        .post_body("/billing/webhooks/stripe", "application/json", payload)
        .await
        .assert_ok();
    app.run_jobs().await;
    assert!(Billing::of(app.state(), &user).subscribed().await.unwrap());
}