use crate::{
AtpClient, BillingCacheConfig, BillingProvider, BillingSnapshot, CachedBillingClient,
CheckoutInput, CheckoutRequest, CheckoutResponse, PortalInput, PortalResponse, SdkError,
SdkResult, TierPolicy,
};
use async_trait::async_trait;
use axum::{
Extension, Json, Router,
body::Body,
extract::{Request, State},
http::{Extensions, HeaderMap, StatusCode},
middleware::{self, Next},
response::{IntoResponse, Response},
routing::{get, post},
};
use std::{marker::PhantomData, sync::Arc};
#[derive(Debug, Clone)]
pub struct AuthenticatedBillingUser {
pub user_id: String,
pub email: Option<String>,
}
#[async_trait]
pub trait BillingUserResolver: Send + Sync + 'static {
async fn resolve(
&self,
headers: &HeaderMap,
extensions: &Extensions,
) -> SdkResult<AuthenticatedBillingUser>;
}
pub trait BillingPrincipal: Clone + Send + Sync + 'static {
fn billing_user_id(&self) -> &str;
fn billing_email(&self) -> Option<&str> {
None
}
}
pub struct ExtensionBillingUserResolver<T>(PhantomData<T>);
impl<T> ExtensionBillingUserResolver<T> {
pub fn new() -> Self {
Self(PhantomData)
}
}
impl<T> Default for ExtensionBillingUserResolver<T> {
fn default() -> Self {
Self::new()
}
}
#[async_trait]
impl<T: BillingPrincipal> BillingUserResolver for ExtensionBillingUserResolver<T> {
async fn resolve(
&self,
_headers: &HeaderMap,
extensions: &Extensions,
) -> SdkResult<AuthenticatedBillingUser> {
let principal = extensions.get::<T>().ok_or(SdkError::Unauthorized)?;
Ok(AuthenticatedBillingUser {
user_id: principal.billing_user_id().into(),
email: principal.billing_email().map(Into::into),
})
}
}
#[derive(Debug, Clone)]
pub struct BillingContext {
pub user: AuthenticatedBillingUser,
pub snapshot: BillingSnapshot,
tier_policy: TierPolicy,
}
impl BillingContext {
pub fn tier(&self) -> &str {
&self.snapshot.status.tier
}
pub fn credits(&self) -> u64 {
self.snapshot.status.balance.total()
}
pub fn degraded(&self) -> bool {
self.snapshot.degraded
}
}
#[derive(Clone)]
struct IntegrationState {
client: AtpClient,
provider: Arc<dyn BillingProvider>,
resolver: Arc<dyn BillingUserResolver>,
tier_policy: TierPolicy,
}
#[derive(Clone)]
pub struct BillingRouter {
state: Arc<IntegrationState>,
}
impl BillingRouter {
pub fn new(client: AtpClient, resolver: Arc<dyn BillingUserResolver>) -> Self {
Self::with_cache(client, resolver, BillingCacheConfig::default())
}
pub fn with_cache(
client: AtpClient,
resolver: Arc<dyn BillingUserResolver>,
cache: BillingCacheConfig,
) -> Self {
let provider = Arc::new(CachedBillingClient::new(client.clone(), cache));
Self {
state: Arc::new(IntegrationState {
client,
provider,
resolver,
tier_policy: TierPolicy::default(),
}),
}
}
pub fn tier_policy(mut self, policy: TierPolicy) -> Self {
Arc::make_mut(&mut self.state).tier_policy = policy;
self
}
pub fn into_router(self) -> Router {
Router::new()
.route("/api/billing/status", get(status))
.route("/api/billing/balance", get(balance))
.route("/api/billing/history", get(history))
.route("/api/billing/checkout", post(checkout))
.route("/api/billing/portal", post(portal))
.route_layer({
let state = self.state.clone();
middleware::from_fn(move |request: Request, next: Next| {
let state = state.clone();
async move { resolve_identity(state, request, next).await }
})
})
.with_state(self.state)
}
pub fn with_context<S>(&self, router: Router<S>) -> Router<S>
where
S: Clone + Send + Sync + 'static,
{
let state = self.state.clone();
router.layer(middleware::from_fn(move |request: Request, next: Next| {
let state = state.clone();
async move { load_context(state, request, next).await }
}))
}
}
async fn resolve(
state: &IntegrationState,
headers: &HeaderMap,
extensions: &Extensions,
) -> SdkResult<AuthenticatedBillingUser> {
state.resolver.resolve(headers, extensions).await
}
async fn resolve_identity(
state: Arc<IntegrationState>,
mut request: Request,
next: Next,
) -> Result<Response, IntegrationError> {
let headers = request.headers().clone();
let extensions = request.extensions().clone();
let user = resolve(&state, &headers, &extensions).await?;
request.extensions_mut().insert(user);
Ok(next.run(request).await)
}
async fn load_context(
state: Arc<IntegrationState>,
mut request: Request,
next: Next,
) -> Result<Response, IntegrationError> {
let headers = request.headers().clone();
let extensions = request.extensions().clone();
let user = resolve(&state, &headers, &extensions).await?;
let snapshot = state.provider.billing_snapshot(&user.user_id).await?;
request.extensions_mut().insert(BillingContext {
user,
snapshot,
tier_policy: state.tier_policy.clone(),
});
Ok(next.run(request).await)
}
async fn status(
State(state): State<Arc<IntegrationState>>,
Extension(user): Extension<AuthenticatedBillingUser>,
) -> Result<Json<BillingSnapshot>, IntegrationError> {
Ok(Json(state.provider.billing_snapshot(&user.user_id).await?))
}
async fn balance(
State(state): State<Arc<IntegrationState>>,
Extension(user): Extension<AuthenticatedBillingUser>,
) -> Result<Json<crate::Balance>, IntegrationError> {
Ok(Json(
state
.provider
.billing_snapshot(&user.user_id)
.await?
.status
.balance,
))
}
async fn history(
State(state): State<Arc<IntegrationState>>,
Extension(user): Extension<AuthenticatedBillingUser>,
) -> Result<Json<Vec<crate::LedgerEntry>>, IntegrationError> {
Ok(Json(state.client.ledger(&user.user_id).await?))
}
async fn checkout(
State(state): State<Arc<IntegrationState>>,
Extension(user): Extension<AuthenticatedBillingUser>,
headers: HeaderMap,
Json(input): Json<CheckoutInput>,
) -> Result<Json<CheckoutResponse>, IntegrationError> {
let email = user.email.ok_or_else(|| {
SdkError::Config(
"authenticated principal does not expose an email required by Checkout".into(),
)
})?;
let request = CheckoutRequest {
user_id: user.user_id,
email,
purchase: input.purchase,
success_url: input.success_url,
cancel_url: input.cancel_url,
};
let key = headers
.get("idempotency-key")
.and_then(|value| value.to_str().ok())
.map(Into::into)
.unwrap_or_else(|| format!("checkout-{}", ulid::Ulid::new()));
Ok(Json(state.client.checkout(&request, &key).await?))
}
async fn portal(
State(state): State<Arc<IntegrationState>>,
Extension(user): Extension<AuthenticatedBillingUser>,
Json(input): Json<PortalInput>,
) -> Result<Json<PortalResponse>, IntegrationError> {
let email = user.email.ok_or_else(|| {
SdkError::Config(
"authenticated principal does not expose an email required by Portal".into(),
)
})?;
Ok(Json(PortalResponse {
portal_url: state.client.portal(&email, &input.return_url).await?,
}))
}
#[derive(Clone)]
struct TierGuard {
required: String,
}
#[derive(Clone, Copy)]
struct CreditsGuard {
minimum: u64,
}
pub fn require_tier<S>(router: Router<S>, required: impl Into<String>) -> Router<S>
where
S: Clone + Send + Sync + 'static,
{
let guard = TierGuard {
required: required.into(),
};
router.route_layer(middleware::from_fn(
move |request: Request<Body>, next: Next| {
let guard = guard.clone();
async move { tier_guard(guard, request, next).await }
},
))
}
pub fn require_credits<S>(router: Router<S>, minimum: u64) -> Router<S>
where
S: Clone + Send + Sync + 'static,
{
let guard = CreditsGuard { minimum };
router.route_layer(middleware::from_fn(
move |request: Request<Body>, next: Next| async move {
credits_guard(guard, request, next).await
},
))
}
async fn tier_guard(guard: TierGuard, request: Request<Body>, next: Next) -> Response {
let Some(context) = request.extensions().get::<BillingContext>() else {
return integration_problem("billing_context_missing", StatusCode::INTERNAL_SERVER_ERROR);
};
if !context.tier_policy.allows(context.tier(), &guard.required) {
return integration_problem("tier_required", StatusCode::FORBIDDEN);
}
next.run(request).await
}
async fn credits_guard(guard: CreditsGuard, request: Request<Body>, next: Next) -> Response {
let Some(context) = request.extensions().get::<BillingContext>() else {
return integration_problem("billing_context_missing", StatusCode::INTERNAL_SERVER_ERROR);
};
if context.credits() < guard.minimum {
return integration_problem("insufficient_credits", StatusCode::PAYMENT_REQUIRED);
}
next.run(request).await
}
fn integration_problem(code: &str, status: StatusCode) -> Response {
(status, Json(serde_json::json!({"error":{"code":code}}))).into_response()
}
struct IntegrationError(SdkError);
impl From<SdkError> for IntegrationError {
fn from(value: SdkError) -> Self {
Self(value)
}
}
impl IntoResponse for IntegrationError {
fn into_response(self) -> Response {
let status = match self.0 {
SdkError::Unauthorized => StatusCode::UNAUTHORIZED,
SdkError::InsufficientCredits => StatusCode::PAYMENT_REQUIRED,
SdkError::NotFound => StatusCode::NOT_FOUND,
SdkError::Conflict => StatusCode::CONFLICT,
_ => StatusCode::BAD_GATEWAY,
};
(status, Json(serde_json::json!({"error":{"code":"billing_unavailable","message":self.0.to_string()}}))).into_response()
}
}
#[cfg(test)]
mod tests {
use super::*;
use axum::http::Request;
use tower::ServiceExt;
fn context(tier: &str) -> BillingContext {
BillingContext {
user: AuthenticatedBillingUser {
user_id: "user-1".into(),
email: None,
},
snapshot: BillingSnapshot {
status: crate::BillingStatus {
app_id: "app-1".into(),
user_id: "user-1".into(),
tier: tier.into(),
subscription_status: "active".into(),
balance: crate::Balance {
app_id: "app-1".into(),
user_id: "user-1".into(),
subscription: 10,
..Default::default()
},
},
source: crate::SnapshotSource::Fresh,
degraded: false,
},
tier_policy: TierPolicy::default(),
}
}
#[tokio::test]
async fn tier_guard_uses_authenticated_billing_context() {
let app = require_tier(
Router::new().route("/", get(|| async { StatusCode::OK })),
"pro",
)
.layer(Extension(context("free")));
let response = app
.oneshot(Request::get("/").body(Body::empty()).unwrap())
.await
.unwrap();
assert_eq!(response.status(), StatusCode::FORBIDDEN);
}
#[tokio::test]
async fn higher_tier_passes_guard() {
let app = require_tier(
Router::new().route("/", get(|| async { StatusCode::OK })),
"pro",
)
.layer(Extension(context("team")));
let response = app
.oneshot(Request::get("/").body(Body::empty()).unwrap())
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
}
}