crates/db_schema/src/impls/actor_language.rs

   1 use crate::{
   2   diesel::JoinOnDsl,
   3   newtypes::{CommunityId, InstanceId, LanguageId, LocalUserId, SiteId},
   4   schema::{local_site, site, site_language},
   5   source::{
   6     actor_language::{
   7       CommunityLanguage,
   8       CommunityLanguageForm,
   9       LocalUserLanguage,
  10       LocalUserLanguageForm,
  11       SiteLanguage,
  12       SiteLanguageForm,
  13     },
  14     language::Language,
  15     site::Site,
  16   },
  17   utils::{get_conn, DbPool},
  18 };
  19 use diesel::{
  20   delete,
  21   dsl::{count, exists},
  22   insert_into,
  23   result::Error,
  24   select,
  25   ExpressionMethods,
  26   QueryDsl,
  27 };
  28 use diesel_async::{AsyncPgConnection, RunQueryDsl};
  29 use lemmy_utils::error::{LemmyError, LemmyErrorType};
  30 use tokio::sync::OnceCell;
  31
  32 pub const UNDETERMINED_ID: LanguageId = LanguageId(0);
  33
  34 impl LocalUserLanguage {
  35   pub async fn read(
  36     pool: &mut DbPool<'_>,
  37     for_local_user_id: LocalUserId,
  38   ) -> Result<Vec<LanguageId>, Error> {
  39     use crate::schema::local_user_language::dsl::{
  40       language_id,
  41       local_user_id,
  42       local_user_language,
  43     };
  44     let conn = &mut get_conn(pool).await?;
  45
  46     conn
  47       .build_transaction()
  48       .run(|conn| {
  49         Box::pin(async move {
  50           let langs = local_user_language
  51             .filter(local_user_id.eq(for_local_user_id))
  52             .order(language_id)
  53             .select(language_id)
  54             .get_results(conn)
  55             .await?;
  56           convert_read_languages(conn, langs).await
  57         }) as _
  58       })
  59       .await
  60   }
  61
  62   /// Update the user's languages.
  63   ///
  64   /// If no language_id vector is given, it will show all languages
  65   pub async fn update(
  66     pool: &mut DbPool<'_>,
  67     language_ids: Vec<LanguageId>,
  68     for_local_user_id: LocalUserId,
  69   ) -> Result<(), Error> {
  70     let conn = &mut get_conn(pool).await?;
  71     let mut lang_ids = convert_update_languages(conn, language_ids).await?;
  72
  73     // No need to update if languages are unchanged
  74     let current = LocalUserLanguage::read(&mut conn.into(), for_local_user_id).await?;
  75     if current == lang_ids {
  76       return Ok(());
  77     }
  78
  79     // TODO: Force enable undetermined language for all users. This is necessary because many posts
  80     //       don't have a language tag (e.g. those from other federated platforms), so Lemmy users
  81     //       won't see them if undetermined language is disabled.
  82     //       This hack can be removed once a majority of posts have language tags, or when it is
  83     //       clearer for new users that they need to enable undetermined language.
  84     //       See https://github.com/LemmyNet/lemmy-ui/issues/999
  85     if !lang_ids.contains(&UNDETERMINED_ID) {
  86       lang_ids.push(UNDETERMINED_ID);
  87     }
  88
  89     conn
  90       .build_transaction()
  91       .run(|conn| {
  92         Box::pin(async move {
  93           use crate::schema::local_user_language::dsl::{local_user_id, local_user_language};
  94           // Clear the current user languages
  95           delete(local_user_language.filter(local_user_id.eq(for_local_user_id)))
  96             .execute(conn)
  97             .await?;
  98
  99           for l in lang_ids {
 100             let form = LocalUserLanguageForm {
 101               local_user_id: for_local_user_id,
 102               language_id: l,
 103             };
 104             insert_into(local_user_language)
 105               .values(form)
 106               .get_result::<Self>(conn)
 107               .await?;
 108           }
 109           Ok(())
 110         }) as _
 111       })
 112       .await
 113   }
 114 }
 115
 116 impl SiteLanguage {
 117   pub async fn read_local_raw(pool: &mut DbPool<'_>) -> Result<Vec<LanguageId>, Error> {
 118     let conn = &mut get_conn(pool).await?;
 119     site::table
 120       .inner_join(local_site::table)
 121       .inner_join(site_language::table)
 122       .order(site_language::id)
 123       .select(site_language::language_id)
 124       .load(conn)
 125       .await
 126   }
 127
 128   pub async fn read(pool: &mut DbPool<'_>, for_site_id: SiteId) -> Result<Vec<LanguageId>, Error> {
 129     let conn = &mut get_conn(pool).await?;
 130     let langs = site_language::table
 131       .filter(site_language::site_id.eq(for_site_id))
 132       .order(site_language::language_id)
 133       .select(site_language::language_id)
 134       .load(conn)
 135       .await?;
 136
 137     convert_read_languages(conn, langs).await
 138   }
 139
 140   pub async fn update(
 141     pool: &mut DbPool<'_>,
 142     language_ids: Vec<LanguageId>,
 143     site: &Site,
 144   ) -> Result<(), Error> {
 145     let conn = &mut get_conn(pool).await?;
 146     let for_site_id = site.id;
 147     let instance_id = site.instance_id;
 148     let lang_ids = convert_update_languages(conn, language_ids).await?;
 149
 150     // No need to update if languages are unchanged
 151     let current = SiteLanguage::read(&mut conn.into(), site.id).await?;
 152     if current == lang_ids {
 153       return Ok(());
 154     }
 155
 156     conn
 157       .build_transaction()
 158       .run(|conn| {
 159         Box::pin(async move {
 160           use crate::schema::site_language::dsl::{site_id, site_language};
 161
 162           // Clear the current languages
 163           delete(site_language.filter(site_id.eq(for_site_id)))
 164             .execute(conn)
 165             .await?;
 166
 167           for l in lang_ids {
 168             let form = SiteLanguageForm {
 169               site_id: for_site_id,
 170               language_id: l,
 171             };
 172             insert_into(site_language)
 173               .values(form)
 174               .get_result::<Self>(conn)
 175               .await?;
 176           }
 177
 178           CommunityLanguage::limit_languages(conn, instance_id).await?;
 179
 180           Ok(())
 181         }) as _
 182       })
 183       .await
 184   }
 185 }
 186
 187 impl CommunityLanguage {
 188   /// Returns true if the given language is one of configured languages for given community
 189   pub async fn is_allowed_community_language(
 190     pool: &mut DbPool<'_>,
 191     for_language_id: Option<LanguageId>,
 192     for_community_id: CommunityId,
 193   ) -> Result<(), LemmyError> {
 194     use crate::schema::community_language::dsl::{community_id, community_language, language_id};
 195     let conn = &mut get_conn(pool).await?;
 196
 197     if let Some(for_language_id) = for_language_id {
 198       let is_allowed = select(exists(
 199         community_language
 200           .filter(language_id.eq(for_language_id))
 201           .filter(community_id.eq(for_community_id)),
 202       ))
 203       .get_result(conn)
 204       .await?;
 205
 206       if is_allowed {
 207         Ok(())
 208       } else {
 209         Err(LemmyErrorType::LanguageNotAllowed)?
 210       }
 211     } else {
 212       Ok(())
 213     }
 214   }
 215
 216   /// When site languages are updated, delete all languages of local communities which are not
 217   /// also part of site languages. This is because post/comment language is only checked against
 218   /// community language, and it shouldnt be possible to post content in languages which are not
 219   /// allowed by local site.
 220   async fn limit_languages(
 221     conn: &mut AsyncPgConnection,
 222     for_instance_id: InstanceId,
 223   ) -> Result<(), Error> {
 224     use crate::schema::{
 225       community::dsl as c,
 226       community_language::dsl as cl,
 227       site_language::dsl as sl,
 228     };
 229     let community_languages: Vec<LanguageId> = cl::community_language
 230       .left_outer_join(sl::site_language.on(cl::language_id.eq(sl::language_id)))
 231       .inner_join(c::community)
 232       .filter(c::instance_id.eq(for_instance_id))
 233       .filter(sl::language_id.is_null())
 234       .select(cl::language_id)
 235       .get_results(conn)
 236       .await?;
 237
 238     for c in community_languages {
 239       delete(cl::community_language.filter(cl::language_id.eq(c)))
 240         .execute(conn)
 241         .await?;
 242     }
 243     Ok(())
 244   }
 245
 246   pub async fn read(
 247     pool: &mut DbPool<'_>,
 248     for_community_id: CommunityId,
 249   ) -> Result<Vec<LanguageId>, Error> {
 250     use crate::schema::community_language::dsl::{community_id, community_language, language_id};
 251     let conn = &mut get_conn(pool).await?;
 252     let langs = community_language
 253       .filter(community_id.eq(for_community_id))
 254       .order(language_id)
 255       .select(language_id)
 256       .get_results(conn)
 257       .await?;
 258     convert_read_languages(conn, langs).await
 259   }
 260
 261   pub async fn update(
 262     pool: &mut DbPool<'_>,
 263     mut language_ids: Vec<LanguageId>,
 264     for_community_id: CommunityId,
 265   ) -> Result<(), Error> {
 266     if language_ids.is_empty() {
 267       language_ids = SiteLanguage::read_local_raw(pool).await?;
 268     }
 269     let conn = &mut get_conn(pool).await?;
 270     let lang_ids = convert_update_languages(conn, language_ids).await?;
 271
 272     // No need to update if languages are unchanged
 273     let current = CommunityLanguage::read(&mut conn.into(), for_community_id).await?;
 274     if current == lang_ids {
 275       return Ok(());
 276     }
 277
 278     conn
 279       .build_transaction()
 280       .run(|conn| {
 281         Box::pin(async move {
 282           use crate::schema::community_language::dsl::{community_id, community_language};
 283           // Clear the current languages
 284           delete(community_language.filter(community_id.eq(for_community_id)))
 285             .execute(conn)
 286             .await?;
 287
 288           for l in lang_ids {
 289             let form = CommunityLanguageForm {
 290               community_id: for_community_id,
 291               language_id: l,
 292             };
 293             insert_into(community_language)
 294               .values(form)
 295               .get_result::<Self>(conn)
 296               .await?;
 297           }
 298           Ok(())
 299         }) as _
 300       })
 301       .await
 302   }
 303 }
 304
 305 pub async fn default_post_language(
 306   pool: &mut DbPool<'_>,
 307   community_id: CommunityId,
 308   local_user_id: LocalUserId,
 309 ) -> Result<Option<LanguageId>, Error> {
 310   use crate::schema::{community_language::dsl as cl, local_user_language::dsl as ul};
 311   let conn = &mut get_conn(pool).await?;
 312   let mut intersection = ul::local_user_language
 313     .inner_join(cl::community_language.on(ul::language_id.eq(cl::language_id)))
 314     .filter(ul::local_user_id.eq(local_user_id))
 315     .filter(cl::community_id.eq(community_id))
 316     .select(cl::language_id)
 317     .get_results::<LanguageId>(conn)
 318     .await?;
 319
 320   if intersection.len() == 1 {
 321     Ok(intersection.pop())
 322   } else if intersection.len() == 2 && intersection.contains(&UNDETERMINED_ID) {
 323     intersection.retain(|i| i != &UNDETERMINED_ID);
 324     Ok(intersection.pop())
 325   } else {
 326     Ok(None)
 327   }
 328 }
 329
 330 /// If no language is given, set all languages
 331 async fn convert_update_languages(
 332   conn: &mut AsyncPgConnection,
 333   language_ids: Vec<LanguageId>,
 334 ) -> Result<Vec<LanguageId>, Error> {
 335   if language_ids.is_empty() {
 336     Ok(
 337       Language::read_all(&mut conn.into())
 338         .await?
 339         .into_iter()
 340         .map(|l| l.id)
 341         .collect(),
 342     )
 343   } else {
 344     Ok(language_ids)
 345   }
 346 }
 347
 348 /// If all languages are returned, return empty vec instead
 349 async fn convert_read_languages(
 350   conn: &mut AsyncPgConnection,
 351   language_ids: Vec<LanguageId>,
 352 ) -> Result<Vec<LanguageId>, Error> {
 353   static ALL_LANGUAGES_COUNT: OnceCell<usize> = OnceCell::const_new();
 354   let count = ALL_LANGUAGES_COUNT
 355     .get_or_init(|| async {
 356       use crate::schema::language::dsl::{id, language};
 357       let count: i64 = language
 358         .select(count(id))
 359         .first(conn)
 360         .await
 361         .expect("read number of languages");
 362       count as usize
 363     })
 364     .await;
 365
 366   if &language_ids.len() == count {
 367     Ok(vec![])
 368   } else {
 369     Ok(language_ids)
 370   }
 371 }
 372
 373 #[cfg(test)]
 374 mod tests {
 375   use super::*;
 376   use crate::{
 377     impls::actor_language::{
 378       convert_read_languages,
 379       convert_update_languages,
 380       default_post_language,
 381       get_conn,
 382       CommunityLanguage,
 383       DbPool,
 384       Language,
 385       LanguageId,
 386       LocalUserLanguage,
 387       QueryDsl,
 388       RunQueryDsl,
 389       SiteLanguage,
 390     },
 391     source::{
 392       community::{Community, CommunityInsertForm},
 393       instance::Instance,
 394       local_site::{LocalSite, LocalSiteInsertForm},
 395       local_user::{LocalUser, LocalUserInsertForm},
 396       person::{Person, PersonInsertForm},
 397       site::{Site, SiteInsertForm},
 398     },
 399     traits::Crud,
 400     utils::build_db_pool_for_tests,
 401   };
 402   use serial_test::serial;
 403
 404   async fn test_langs1(pool: &mut DbPool<'_>) -> Vec<LanguageId> {
 405     vec![
 406       Language::read_id_from_code(pool, Some("en"))
 407         .await
 408         .unwrap()
 409         .unwrap(),
 410       Language::read_id_from_code(pool, Some("fr"))
 411         .await
 412         .unwrap()
 413         .unwrap(),
 414       Language::read_id_from_code(pool, Some("ru"))
 415         .await
 416         .unwrap()
 417         .unwrap(),
 418     ]
 419   }
 420   async fn test_langs2(pool: &mut DbPool<'_>) -> Vec<LanguageId> {
 421     vec![
 422       Language::read_id_from_code(pool, Some("fi"))
 423         .await
 424         .unwrap()
 425         .unwrap(),
 426       Language::read_id_from_code(pool, Some("se"))
 427         .await
 428         .unwrap()
 429         .unwrap(),
 430     ]
 431   }
 432
 433   async fn create_test_site(pool: &mut DbPool<'_>) -> (Site, Instance) {
 434     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
 435       .await
 436       .unwrap();
 437
 438     let site_form = SiteInsertForm::builder()
 439       .name("test site".to_string())
 440       .instance_id(inserted_instance.id)
 441       .build();
 442     let site = Site::create(pool, &site_form).await.unwrap();
 443
 444     // Create a local site, since this is necessary for local languages
 445     let local_site_form = LocalSiteInsertForm::builder().site_id(site.id).build();
 446     LocalSite::create(pool, &local_site_form).await.unwrap();
 447
 448     (site, inserted_instance)
 449   }
 450
 451   #[tokio::test]
 452   #[serial]
 453   async fn test_convert_update_languages() {
 454     let pool = &build_db_pool_for_tests().await;
 455     let pool = &mut pool.into();
 456
 457     // call with empty vec, returns all languages
 458     let conn = &mut get_conn(pool).await.unwrap();
 459     let converted1 = convert_update_languages(conn, vec![]).await.unwrap();
 460     assert_eq!(184, converted1.len());
 461
 462     // call with nonempty vec, returns same vec
 463     let test_langs = test_langs1(&mut conn.into()).await;
 464     let converted2 = convert_update_languages(conn, test_langs.clone())
 465       .await
 466       .unwrap();
 467     assert_eq!(test_langs, converted2);
 468   }
 469   #[tokio::test]
 470   #[serial]
 471   async fn test_convert_read_languages() {
 472     use crate::schema::language::dsl::{id, language};
 473     let pool = &build_db_pool_for_tests().await;
 474     let pool = &mut pool.into();
 475
 476     // call with all languages, returns empty vec
 477     let conn = &mut get_conn(pool).await.unwrap();
 478     let all_langs = language.select(id).get_results(conn).await.unwrap();
 479     let converted1: Vec<LanguageId> = convert_read_languages(conn, all_langs).await.unwrap();
 480     assert_eq!(0, converted1.len());
 481
 482     // call with nonempty vec, returns same vec
 483     let test_langs = test_langs1(&mut conn.into()).await;
 484     let converted2 = convert_read_languages(conn, test_langs.clone())
 485       .await
 486       .unwrap();
 487     assert_eq!(test_langs, converted2);
 488   }
 489
 490   #[tokio::test]
 491   #[serial]
 492   async fn test_site_languages() {
 493     let pool = &build_db_pool_for_tests().await;
 494     let pool = &mut pool.into();
 495
 496     let (site, instance) = create_test_site(pool).await;
 497     let site_languages1 = SiteLanguage::read_local_raw(pool).await.unwrap();
 498     // site is created with all languages
 499     assert_eq!(184, site_languages1.len());
 500
 501     let test_langs = test_langs1(pool).await;
 502     SiteLanguage::update(pool, test_langs.clone(), &site)
 503       .await
 504       .unwrap();
 505
 506     let site_languages2 = SiteLanguage::read_local_raw(pool).await.unwrap();
 507     // after update, site only has new languages
 508     assert_eq!(test_langs, site_languages2);
 509
 510     Site::delete(pool, site.id).await.unwrap();
 511     Instance::delete(pool, instance.id).await.unwrap();
 512     LocalSite::delete(pool).await.unwrap();
 513   }
 514
 515   #[tokio::test]
 516   #[serial]
 517   async fn test_user_languages() {
 518     let pool = &build_db_pool_for_tests().await;
 519     let pool = &mut pool.into();
 520
 521     let (site, instance) = create_test_site(pool).await;
 522     let mut test_langs = test_langs1(pool).await;
 523     SiteLanguage::update(pool, test_langs.clone(), &site)
 524       .await
 525       .unwrap();
 526
 527     let person_form = PersonInsertForm::builder()
 528       .name("my test person".to_string())
 529       .public_key("pubkey".to_string())
 530       .instance_id(instance.id)
 531       .build();
 532     let person = Person::create(pool, &person_form).await.unwrap();
 533     let local_user_form = LocalUserInsertForm::builder()
 534       .person_id(person.id)
 535       .password_encrypted("my_pw".to_string())
 536       .build();
 537
 538     let local_user = LocalUser::create(pool, &local_user_form).await.unwrap();
 539     let local_user_langs1 = LocalUserLanguage::read(pool, local_user.id).await.unwrap();
 540
 541     // new user should be initialized with site languages and undetermined
 542     //test_langs.push(UNDETERMINED_ID);
 543     //test_langs.sort();
 544     test_langs.insert(0, UNDETERMINED_ID);
 545     assert_eq!(test_langs, local_user_langs1);
 546
 547     // update user languages
 548     let test_langs2 = test_langs2(pool).await;
 549     LocalUserLanguage::update(pool, test_langs2, local_user.id)
 550       .await
 551       .unwrap();
 552     let local_user_langs2 = LocalUserLanguage::read(pool, local_user.id).await.unwrap();
 553     assert_eq!(3, local_user_langs2.len());
 554
 555     Person::delete(pool, person.id).await.unwrap();
 556     LocalUser::delete(pool, local_user.id).await.unwrap();
 557     Site::delete(pool, site.id).await.unwrap();
 558     LocalSite::delete(pool).await.unwrap();
 559     Instance::delete(pool, instance.id).await.unwrap();
 560   }
 561
 562   #[tokio::test]
 563   #[serial]
 564   async fn test_community_languages() {
 565     let pool = &build_db_pool_for_tests().await;
 566     let pool = &mut pool.into();
 567     let (site, instance) = create_test_site(pool).await;
 568     let test_langs = test_langs1(pool).await;
 569     SiteLanguage::update(pool, test_langs.clone(), &site)
 570       .await
 571       .unwrap();
 572
 573     let read_site_langs = SiteLanguage::read(pool, site.id).await.unwrap();
 574     assert_eq!(test_langs, read_site_langs);
 575
 576     // Test the local ones are the same
 577     let read_local_site_langs = SiteLanguage::read_local_raw(pool).await.unwrap();
 578     assert_eq!(test_langs, read_local_site_langs);
 579
 580     let community_form = CommunityInsertForm::builder()
 581       .name("test community".to_string())
 582       .title("test community".to_string())
 583       .public_key("pubkey".to_string())
 584       .instance_id(instance.id)
 585       .build();
 586     let community = Community::create(pool, &community_form).await.unwrap();
 587     let community_langs1 = CommunityLanguage::read(pool, community.id).await.unwrap();
 588
 589     // community is initialized with site languages
 590     assert_eq!(test_langs, community_langs1);
 591
 592     let allowed_lang1 =
 593       CommunityLanguage::is_allowed_community_language(pool, Some(test_langs[0]), community.id)
 594         .await;
 595     assert!(allowed_lang1.is_ok());
 596
 597     let test_langs2 = test_langs2(pool).await;
 598     let allowed_lang2 =
 599       CommunityLanguage::is_allowed_community_language(pool, Some(test_langs2[0]), community.id)
 600         .await;
 601     assert!(allowed_lang2.is_err());
 602
 603     // limit site languages to en, fi. after this, community languages should be updated to
 604     // intersection of old languages (en, fr, ru) and (en, fi), which is only fi.
 605     SiteLanguage::update(pool, vec![test_langs[0], test_langs2[0]], &site)
 606       .await
 607       .unwrap();
 608     let community_langs2 = CommunityLanguage::read(pool, community.id).await.unwrap();
 609     assert_eq!(vec![test_langs[0]], community_langs2);
 610
 611     // update community languages to different ones
 612     CommunityLanguage::update(pool, test_langs2.clone(), community.id)
 613       .await
 614       .unwrap();
 615     let community_langs3 = CommunityLanguage::read(pool, community.id).await.unwrap();
 616     assert_eq!(test_langs2, community_langs3);
 617
 618     Community::delete(pool, community.id).await.unwrap();
 619     Site::delete(pool, site.id).await.unwrap();
 620     LocalSite::delete(pool).await.unwrap();
 621     Instance::delete(pool, instance.id).await.unwrap();
 622   }
 623
 624   #[tokio::test]
 625   #[serial]
 626   async fn test_default_post_language() {
 627     let pool = &build_db_pool_for_tests().await;
 628     let pool = &mut pool.into();
 629     let (site, instance) = create_test_site(pool).await;
 630     let test_langs = test_langs1(pool).await;
 631     let test_langs2 = test_langs2(pool).await;
 632
 633     let community_form = CommunityInsertForm::builder()
 634       .name("test community".to_string())
 635       .title("test community".to_string())
 636       .public_key("pubkey".to_string())
 637       .instance_id(instance.id)
 638       .build();
 639     let community = Community::create(pool, &community_form).await.unwrap();
 640     CommunityLanguage::update(pool, test_langs, community.id)
 641       .await
 642       .unwrap();
 643
 644     let person_form = PersonInsertForm::builder()
 645       .name("my test person".to_string())
 646       .public_key("pubkey".to_string())
 647       .instance_id(instance.id)
 648       .build();
 649     let person = Person::create(pool, &person_form).await.unwrap();
 650     let local_user_form = LocalUserInsertForm::builder()
 651       .person_id(person.id)
 652       .password_encrypted("my_pw".to_string())
 653       .build();
 654     let local_user = LocalUser::create(pool, &local_user_form).await.unwrap();
 655     LocalUserLanguage::update(pool, test_langs2, local_user.id)
 656       .await
 657       .unwrap();
 658
 659     // no overlap in user/community languages, so defaults to undetermined
 660     let def1 = default_post_language(pool, community.id, local_user.id)
 661       .await
 662       .unwrap();
 663     assert_eq!(None, def1);
 664
 665     let ru = Language::read_id_from_code(pool, Some("ru"))
 666       .await
 667       .unwrap()
 668       .unwrap();
 669     let test_langs3 = vec![
 670       ru,
 671       Language::read_id_from_code(pool, Some("fi"))
 672         .await
 673         .unwrap()
 674         .unwrap(),
 675       Language::read_id_from_code(pool, Some("se"))
 676         .await
 677         .unwrap()
 678         .unwrap(),
 679       UNDETERMINED_ID,
 680     ];
 681     LocalUserLanguage::update(pool, test_langs3, local_user.id)
 682       .await
 683       .unwrap();
 684
 685     // this time, both have ru as common lang
 686     let def2 = default_post_language(pool, community.id, local_user.id)
 687       .await
 688       .unwrap();
 689     assert_eq!(Some(ru), def2);
 690
 691     Person::delete(pool, person.id).await.unwrap();
 692     Community::delete(pool, community.id).await.unwrap();
 693     LocalUser::delete(pool, local_user.id).await.unwrap();
 694     Site::delete(pool, site.id).await.unwrap();
 695     LocalSite::delete(pool).await.unwrap();
 696     Instance::delete(pool, instance.id).await.unwrap();
 697   }
 698 }