Refactor billing to manage subscriptions/invoices internally

backend/src/routes/relays.rs

@@ -9,6 +9,7 @@ use regex::Regex;
 use serde::Deserialize;
 
 use crate::api::{Api, AuthedPubkey};
+use crate::{command, query};
 use crate::models::{
     RELAY_STATUS_ACTIVE, RELAY_STATUS_DELINQUENT, RELAY_STATUS_INACTIVE, Relay,
 };
@@ -17,46 +18,13 @@ use crate::web::{
     parse_bool_default, unprocessable,
 };
 
-#[derive(Deserialize)]
-pub struct CreateRelayRequest {
-    pub tenant: String,
-    pub subdomain: String,
-    pub plan: String,
-    pub info_name: String,
-    pub info_icon: String,
-    pub info_description: String,
-    pub policy_public_join: i64,
-    pub policy_strip_signatures: i64,
-    pub groups_enabled: i64,
-    pub management_enabled: i64,
-    pub blossom_enabled: i64,
-    pub livekit_enabled: i64,
-    pub push_enabled: i64,
-}
-
-#[derive(Deserialize)]
-pub struct UpdateRelayRequest {
-    pub subdomain: Option<String>,
-    pub plan: Option<String>,
-    pub info_name: Option<String>,
-    pub info_icon: Option<String>,
-    pub info_description: Option<String>,
-    pub policy_public_join: Option<i64>,
-    pub policy_strip_signatures: Option<i64>,
-    pub groups_enabled: Option<i64>,
-    pub management_enabled: Option<i64>,
-    pub blossom_enabled: Option<i64>,
-    pub livekit_enabled: Option<i64>,
-    pub push_enabled: Option<i64>,
-}
-
 pub async fn list_relays(
     State(api): State<Arc<Api>>,
     AuthedPubkey(auth): AuthedPubkey,
 ) -> ApiResult {
     api.require_admin(&auth)?;
 
-    let relays = api.query.list_relays().await.map_err(internal)?;
+    let relays = query::list_relays().await.map_err(internal)?;
     ok(relays)
 }
 
@@ -78,9 +46,7 @@ pub async fn list_relay_activity(
     let relay = api.get_relay_or_404(&id).await?;
     api.require_admin_or_tenant(&auth, &relay.tenant)?;
 
-    let activity = api
-        .query
-        .list_activity_for_resource(&id)
+    let activity = query::list_activity_for_resource(&id)
         .await
         .map_err(internal)?;
     ok(serde_json::json!({ "activity": activity }))
@@ -98,6 +64,23 @@ pub async fn list_relay_members(
     ok(serde_json::json!({ "members": members }))
 }
 
+#[derive(Deserialize)]
+pub struct CreateRelayRequest {
+    pub tenant: String,
+    pub subdomain: String,
+    pub plan: String,
+    pub info_name: String,
+    pub info_icon: String,
+    pub info_description: String,
+    pub policy_public_join: i64,
+    pub policy_strip_signatures: i64,
+    pub groups_enabled: i64,
+    pub management_enabled: i64,
+    pub blossom_enabled: i64,
+    pub livekit_enabled: i64,
+    pub push_enabled: i64,
+}
+
 pub async fn create_relay(
     State(api): State<Arc<Api>>,
     AuthedPubkey(auth): AuthedPubkey,
@@ -129,15 +112,31 @@ pub async fn create_relay(
         ..Default::default()
     };
 
-    let relay = prepare_relay(&api, relay)?;
+    let relay = prepare_relay(relay)?;
 
-    api.command
-        .create_relay(&relay)
+    command::create_relay(&relay)
         .await
         .map_err(map_relay_write_error)?;
+
     created(relay)
 }
 
+#[derive(Deserialize)]
+pub struct UpdateRelayRequest {
+    pub subdomain: Option<String>,
+    pub plan: Option<String>,
+    pub info_name: Option<String>,
+    pub info_icon: Option<String>,
+    pub info_description: Option<String>,
+    pub policy_public_join: Option<i64>,
+    pub policy_strip_signatures: Option<i64>,
+    pub groups_enabled: Option<i64>,
+    pub management_enabled: Option<i64>,
+    pub blossom_enabled: Option<i64>,
+    pub livekit_enabled: Option<i64>,
+    pub push_enabled: Option<i64>,
+}
+
 pub async fn update_relay(
     State(api): State<Arc<Api>>,
     AuthedPubkey(auth): AuthedPubkey,
@@ -145,6 +144,7 @@ pub async fn update_relay(
     Json(payload): Json<UpdateRelayRequest>,
 ) -> ApiResult {
     let mut relay = api.get_relay_or_404(&id).await?;
+
     api.require_admin_or_tenant(&auth, &relay.tenant)?;
 
     let current_plan = relay.plan.clone();
@@ -187,17 +187,15 @@ pub async fn update_relay(
         relay.push_enabled = v;
     }
 
-    let relay = prepare_relay(&api, relay)?;
+    let relay = prepare_relay(relay)?;
 
     let plan_changed = requested_plan
         .as_deref()
         .is_some_and(|requested| requested != current_plan);
 
     if plan_changed {
-        let selected_plan = api
-            .query
-            .get_plan(&relay.plan)
-            .expect("validated plan must exist");
+        let selected_plan =
+            query::get_plan(&relay.plan).expect("validated plan must exist");
         if let Some(limit) = selected_plan.members {
             let current_members = fetch_relay_members(&api, &relay)
                 .await
@@ -214,10 +212,10 @@ pub async fn update_relay(
         }
     }
 
-    api.command
-        .update_relay(&relay)
+    command::update_relay(&relay)
         .await
         .map_err(map_relay_write_error)?;
+
     ok(relay)
 }
 
@@ -237,10 +235,10 @@ pub async fn deactivate_relay(
         return Err(bad_request("relay-is-inactive", "relay is already inactive"));
     }
 
-    api.command
-        .deactivate_relay(&relay)
+    command::deactivate_relay(&relay)
         .await
         .map_err(internal)?;
+
     ok(())
 }
 
@@ -260,7 +258,8 @@ pub async fn reactivate_relay(
         return Err(bad_request("relay-is-active", "relay is already active"));
     }
 
-    api.command.activate_relay(&relay).await.map_err(internal)?;
+    command::activate_relay(&relay).await.map_err(internal)?;
+
     ok(())
 }
 
@@ -279,15 +278,13 @@ const RESERVED_SUBDOMAINS: [&str; 3] = ["api", "admin", "internal"];
 static SUBDOMAIN_RE: LazyLock<Regex> =
     LazyLock::new(|| Regex::new(r"^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$").unwrap());
 
-fn prepare_relay(api: &Api, mut relay: Relay) -> Result<Relay, ApiError> {
+fn prepare_relay(mut relay: Relay) -> Result<Relay, ApiError> {
     if !SUBDOMAIN_RE.is_match(&relay.subdomain)
         || RESERVED_SUBDOMAINS.contains(&relay.subdomain.as_str()) {
         return Err(unprocessable("invalid-subdomain", "subdomain is invalid"));
     }
 
-    let plan = api
-        .query
-        .get_plan(&relay.plan)
+    let plan = query::get_plan(&relay.plan)
         .ok_or_else(|| unprocessable("invalid-plan", "plan not found"))?;
 
     if (!plan.blossom && relay.blossom_enabled == 1) || (!plan.livekit && relay.livekit_enabled == 1) {