Refactor billing to manage subscriptions/invoices internally

backend/src/routes/tenants.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use axum::{
     Json,
-    extract::{Path, State},
+    extract::{Path, Query, State},
 };
 use chrono::Utc;
 use serde::{Deserialize, Serialize};
@@ -10,6 +10,7 @@ use serde::{Deserialize, Serialize};
 use crate::api::{Api, AuthedPubkey};
 use crate::models::Tenant;
 use crate::web::{ApiResult, internal, map_unique_error, ok};
+use crate::{command, env, query};
 
 #[derive(Serialize)]
 pub struct TenantResponse {
@@ -17,9 +18,8 @@ pub struct TenantResponse {
     pub nwc_is_set: bool,
     pub nwc_error: Option<String>,
     pub created_at: i64,
+    pub billing_anchor: Option<i64>,
     pub stripe_customer_id: String,
-    pub stripe_subscription_id: Option<String>,
-    pub past_due_at: Option<i64>,
 }
 
 impl From<Tenant> for TenantResponse {
@@ -29,39 +29,30 @@ impl From<Tenant> for TenantResponse {
             pubkey: t.pubkey,
             nwc_error: t.nwc_error,
             created_at: t.created_at,
+            billing_anchor: t.billing_anchor,
             stripe_customer_id: t.stripe_customer_id,
-            stripe_subscription_id: t.stripe_subscription_id,
-            past_due_at: t.past_due_at,
         }
     }
 }
 
-#[derive(Deserialize)]
-pub struct UpdateTenantRequest {
-    pub nwc_url: Option<String>,
-}
-
 pub async fn list_tenants(
     State(api): State<Arc<Api>>,
     AuthedPubkey(auth): AuthedPubkey,
 ) -> ApiResult {
     api.require_admin(&auth)?;
 
-    let tenants = api.query.list_tenants().await.map_err(internal)?;
+    let tenants = query::list_tenants().await.map_err(internal)?;
     ok(tenants
         .into_iter()
         .map(TenantResponse::from)
         .collect::<Vec<_>>())
 }
 
-/// Creates the tenant row for the calling pubkey. Idempotent: if the tenant
-/// already exists (including a unique-constraint race) we return the existing
-/// row.
 pub async fn create_tenant(
     State(api): State<Arc<Api>>,
     AuthedPubkey(pubkey): AuthedPubkey,
 ) -> ApiResult {
-    if let Some(t) = api.query.get_tenant(&pubkey).await.map_err(internal)? {
+    if let Some(t) = query::get_tenant(&pubkey).await.map_err(internal)? {
         return ok(TenantResponse::from(t));
     }
 
@@ -84,10 +75,10 @@ pub async fn create_tenant(
         ..Default::default()
     };
 
-    match api.command.create_tenant(&tenant).await {
+    match command::create_tenant(&tenant).await {
         Ok(()) => ok(TenantResponse::from(tenant)),
         Err(e) if matches!(map_unique_error(&e), Some("pubkey-exists")) => {
-            match api.query.get_tenant(&pubkey).await {
+            match query::get_tenant(&pubkey).await {
                 Ok(Some(t)) => ok(TenantResponse::from(t)),
                 Ok(None) => Err(internal("tenant row missing after unique-constraint race")),
                 Err(e) => Err(internal(e)),
@@ -107,6 +98,11 @@ pub async fn get_tenant(
     ok(TenantResponse::from(tenant))
 }
 
+#[derive(Deserialize)]
+pub struct UpdateTenantRequest {
+    pub nwc_url: Option<String>,
+}
+
 pub async fn update_tenant(
     State(api): State<Arc<Api>>,
     AuthedPubkey(auth): AuthedPubkey,
@@ -121,11 +117,11 @@ pub async fn update_tenant(
         if nwc_url.is_empty() {
             tenant.nwc_url = String::new();
         } else {
-            tenant.nwc_url = api.env.encrypt(&nwc_url).map_err(internal)?;
+            tenant.nwc_url = env::get().encrypt(&nwc_url).map_err(internal)?;
         }
     }
 
-    api.command.update_tenant(&tenant).await.map_err(internal)?;
+    command::update_tenant(&tenant).await.map_err(internal)?;
     ok(TenantResponse::from(tenant))
 }
 
@@ -136,10 +132,47 @@ pub async fn list_tenant_relays(
 ) -> ApiResult {
     api.require_admin_or_tenant(&auth, &pubkey)?;
 
-    let relays = api
-        .query
-        .list_relays_for_tenant(&pubkey)
+    let relays = query::list_relays_for_tenant(&pubkey)
         .await
         .map_err(internal)?;
     ok(relays)
 }
+
+
+pub async fn list_tenant_invoices(
+    State(api): State<Arc<Api>>,
+    AuthedPubkey(auth): AuthedPubkey,
+    Path(pubkey): Path<String>,
+) -> ApiResult {
+    api.require_admin_or_tenant(&auth, &pubkey)?;
+
+    let invoices = query::list_invoices(&pubkey)
+        .await
+        .map_err(internal)?;
+
+    ok(invoices)
+}
+
+#[derive(Deserialize)]
+pub struct StripeSessionParams {
+    return_url: Option<String>,
+}
+
+pub async fn create_stripe_session(
+    State(api): State<Arc<Api>>,
+    AuthedPubkey(auth): AuthedPubkey,
+    Path(pubkey): Path<String>,
+    Query(params): Query<StripeSessionParams>,
+) -> ApiResult {
+    api.require_tenant(&auth, &pubkey)?;
+
+    let tenant = api.get_tenant_or_404(&pubkey).await?;
+
+    let url = api
+        .stripe
+        .create_portal_session(&tenant.stripe_customer_id, params.return_url.as_deref())
+        .await
+        .map_err(internal)?;
+
+    ok(serde_json::json!({ "url": url }))
+}