crates/db_schema/src/impls/instance.rs

   1 use crate::{
   2   newtypes::InstanceId,
   3   schema::{federation_allowlist, federation_blocklist, instance},
   4   source::instance::{Instance, InstanceForm},
   5   utils::{get_conn, naive_now, DbPool},
   6 };
   7 use diesel::{dsl::insert_into, result::Error, ExpressionMethods, QueryDsl};
   8 use diesel_async::{AsyncPgConnection, RunQueryDsl};
   9 use url::Url;
  10
  11 impl Instance {
  12   async fn create_from_form_conn(
  13     conn: &mut AsyncPgConnection,
  14     form: &InstanceForm,
  15   ) -> Result<Self, Error> {
  16     // Do upsert on domain name conflict
  17     insert_into(instance::table)
  18       .values(form)
  19       .on_conflict(instance::domain)
  20       .do_update()
  21       .set(form)
  22       .get_result::<Self>(conn)
  23       .await
  24   }
  25   pub async fn create(pool: &DbPool, domain: &str) -> Result<Self, Error> {
  26     let conn = &mut get_conn(pool).await?;
  27     Self::create_conn(conn, domain).await
  28   }
  29   pub async fn create_from_actor_id(pool: &DbPool, actor_id: &Url) -> Result<Self, Error> {
  30     let domain = actor_id.host_str().expect("actor id missing a domain");
  31     Self::create(pool, domain).await
  32   }
  33   pub async fn create_conn(conn: &mut AsyncPgConnection, domain: &str) -> Result<Self, Error> {
  34     let form = InstanceForm::builder()
  35       .domain(domain.to_string())
  36       .updated(Some(naive_now()))
  37       .build();
  38     Self::create_from_form_conn(conn, &form).await
  39   }
  40   pub async fn delete(pool: &DbPool, instance_id: InstanceId) -> Result<usize, Error> {
  41     let conn = &mut get_conn(pool).await?;
  42     diesel::delete(instance::table.find(instance_id))
  43       .execute(conn)
  44       .await
  45   }
  46   pub async fn delete_all(pool: &DbPool) -> Result<usize, Error> {
  47     let conn = &mut get_conn(pool).await?;
  48     diesel::delete(instance::table).execute(conn).await
  49   }
  50   pub async fn allowlist(pool: &DbPool) -> Result<Vec<Self>, Error> {
  51     let conn = &mut get_conn(pool).await?;
  52     instance::table
  53       .inner_join(federation_allowlist::table)
  54       .select(instance::all_columns)
  55       .get_results(conn)
  56       .await
  57   }
  58
  59   pub async fn blocklist(pool: &DbPool) -> Result<Vec<Self>, Error> {
  60     let conn = &mut get_conn(pool).await?;
  61     instance::table
  62       .inner_join(federation_blocklist::table)
  63       .select(instance::all_columns)
  64       .get_results(conn)
  65       .await
  66   }
  67
  68   pub async fn linked(pool: &DbPool) -> Result<Vec<Self>, Error> {
  69     let conn = &mut get_conn(pool).await?;
  70     instance::table
  71       .left_join(federation_blocklist::table)
  72       .filter(federation_blocklist::id.is_null())
  73       .select(instance::all_columns)
  74       .get_results(conn)
  75       .await
  76   }
  77 }