collab: Use StripeClient to retrieve prices and meters from Stripe (#31624)

This PR updates `StripeBilling` to use the `StripeClient` trait to
retrieve prices and meters from Stripe instead of using the
`stripe::Client` directly.

Release Notes:

- N/A

crates/collab/src/stripe_client/fake_stripe_client.rs

@@ -6,16 +6,23 @@ use collections::HashMap;
 use parking_lot::Mutex;
 use uuid::Uuid;
 
-use crate::stripe_client::{CreateCustomerParams, StripeClient, StripeCustomer, StripeCustomerId};
+use crate::stripe_client::{
+    CreateCustomerParams, StripeClient, StripeCustomer, StripeCustomerId, StripeMeter,
+    StripeMeterId, StripePrice, StripePriceId,
+};
 
 pub struct FakeStripeClient {
     pub customers: Arc<Mutex<HashMap<StripeCustomerId, StripeCustomer>>>,
+    pub prices: Arc<Mutex<HashMap<StripePriceId, StripePrice>>>,
+    pub meters: Arc<Mutex<HashMap<StripeMeterId, StripeMeter>>>,
 }
 
 impl FakeStripeClient {
     pub fn new() -> Self {
         Self {
             customers: Arc::new(Mutex::new(HashMap::default())),
+            prices: Arc::new(Mutex::new(HashMap::default())),
+            meters: Arc::new(Mutex::new(HashMap::default())),
         }
     }
 }
@@ -44,4 +51,16 @@ impl StripeClient for FakeStripeClient {
 
         Ok(customer)
     }
+
+    async fn list_prices(&self) -> Result<Vec<StripePrice>> {
+        let prices = self.prices.lock().values().cloned().collect();
+
+        Ok(prices)
+    }
+
+    async fn list_meters(&self) -> Result<Vec<StripeMeter>> {
+        let meters = self.meters.lock().values().cloned().collect();
+
+        Ok(meters)
+    }
 }

crates/collab/src/stripe_client/real_stripe_client.rs

@@ -3,9 +3,13 @@ use std::sync::Arc;
 
 use anyhow::{Context as _, Result};
 use async_trait::async_trait;
-use stripe::{CreateCustomer, Customer, CustomerId, ListCustomers};
+use serde::Serialize;
+use stripe::{CreateCustomer, Customer, CustomerId, ListCustomers, Price, PriceId, Recurring};
 
-use crate::stripe_client::{CreateCustomerParams, StripeClient, StripeCustomer, StripeCustomerId};
+use crate::stripe_client::{
+    CreateCustomerParams, StripeClient, StripeCustomer, StripeCustomerId, StripeMeter, StripePrice,
+    StripePriceId, StripePriceRecurring,
+};
 
 pub struct RealStripeClient {
     client: Arc<stripe::Client>,
@@ -48,6 +52,37 @@ impl StripeClient for RealStripeClient {
 
         Ok(StripeCustomer::from(customer))
     }
+
+    async fn list_prices(&self) -> Result<Vec<StripePrice>> {
+        let response = stripe::Price::list(
+            &self.client,
+            &stripe::ListPrices {
+                limit: Some(100),
+                ..Default::default()
+            },
+        )
+        .await?;
+
+        Ok(response.data.into_iter().map(StripePrice::from).collect())
+    }
+
+    async fn list_meters(&self) -> Result<Vec<StripeMeter>> {
+        #[derive(Serialize)]
+        struct Params {
+            #[serde(skip_serializing_if = "Option::is_none")]
+            limit: Option<u64>,
+        }
+
+        let response = self
+            .client
+            .get_query::<stripe::List<StripeMeter>, _>(
+                "/billing/meters",
+                Params { limit: Some(100) },
+            )
+            .await?;
+
+        Ok(response.data)
+    }
 }
 
 impl From<CustomerId> for StripeCustomerId {
@@ -72,3 +107,34 @@ impl From<Customer> for StripeCustomer {
         }
     }
 }
+
+impl From<PriceId> for StripePriceId {
+    fn from(value: PriceId) -> Self {
+        Self(value.as_str().into())
+    }
+}
+
+impl TryFrom<StripePriceId> for PriceId {
+    type Error = anyhow::Error;
+
+    fn try_from(value: StripePriceId) -> Result<Self, Self::Error> {
+        Self::from_str(value.0.as_ref()).context("failed to parse Stripe price ID")
+    }
+}
+
+impl From<Price> for StripePrice {
+    fn from(value: Price) -> Self {
+        Self {
+            id: value.id.into(),
+            unit_amount: value.unit_amount,
+            lookup_key: value.lookup_key,
+            recurring: value.recurring.map(StripePriceRecurring::from),
+        }
+    }
+}
+
+impl From<Recurring> for StripePriceRecurring {
+    fn from(value: Recurring) -> Self {
+        Self { meter: value.meter }
+    }
+}