Diesel 2.0.0 upgrade (#2452)

[lemmy.git] / crates / db_schema / src / utils.rs

diff --git a/crates/db_schema/src/utils.rs b/crates/db_schema/src/utils.rs
index 09c5ecdd832efd9e10c5bb1ab1b3aa89b2d437cd..798786b06d1cd829b6199f294debba952dcbdd63 100644 (file)
--- a/crates/db_schema/src/utils.rs
+++ b/crates/db_schema/src/utils.rs
@@ -1,20 +1,26 @@
-use crate::newtypes::DbUrl;
+use crate::{diesel_migrations::MigrationHarness, newtypes::DbUrl, CommentSortType, SortType};
+use activitypub_federation::{core::object_id::ObjectId, traits::ApubObject};
 use chrono::NaiveDateTime;
 use diesel::{
   backend::Backend,
   deserialize::FromSql,
+  pg::Pg,
+  result::Error::QueryBuilderError,
   serialize::{Output, ToSql},
   sql_types::Text,
   Connection,
   PgConnection,
 };
-use lemmy_apub_lib::{object_id::ObjectId, traits::ApubObject};
-use lemmy_utils::LemmyError;
+use diesel_migrations::EmbeddedMigrations;
+use lemmy_utils::error::LemmyError;
 use once_cell::sync::Lazy;
 use regex::Regex;
-use std::{env, env::VarError, io::Write};
+use std::{env, env::VarError};
 use url::Url;
 
+const FETCH_LIMIT_DEFAULT: i64 = 10;
+pub const FETCH_LIMIT_MAX: i64 = 50;
+
 pub type DbPool = diesel::r2d2::Pool<diesel::r2d2::ConnectionManager<diesel::PgConnection>>;
 
 pub fn get_database_url_from_env() -> Result<String, VarError> {
@@ -26,10 +32,39 @@ pub fn fuzzy_search(q: &str) -> String {
   format!("%{}%", replaced)
 }
 
-pub fn limit_and_offset(page: Option<i64>, limit: Option<i64>) -> (i64, i64) {
-  let page = page.unwrap_or(1);
-  let limit = limit.unwrap_or(10);
+pub fn limit_and_offset(
+  page: Option<i64>,
+  limit: Option<i64>,
+) -> Result<(i64, i64), diesel::result::Error> {
+  let page = match page {
+    Some(page) => {
+      if page < 1 {
+        return Err(QueryBuilderError("Page is < 1".into()));
+      } else {
+        page
+      }
+    }
+    None => 1,
+  };
+  let limit = match limit {
+    Some(limit) => {
+      if !(1..=FETCH_LIMIT_MAX).contains(&limit) {
+        return Err(QueryBuilderError(
+          format!("Fetch limit is > {}", FETCH_LIMIT_MAX).into(),
+        ));
+      } else {
+        limit
+      }
+    }
+    None => FETCH_LIMIT_DEFAULT,
+  };
   let offset = limit * (page - 1);
+  Ok((limit, offset))
+}
+
+pub fn limit_and_offset_unlimited(page: Option<i64>, limit: Option<i64>) -> (i64, i64) {
+  let limit = limit.unwrap_or(FETCH_LIMIT_DEFAULT);
+  let offset = limit * (page.unwrap_or(1) - 1);
   (limit, offset)
 }
 
@@ -65,7 +100,7 @@ pub fn diesel_option_overwrite_to_url(
   }
 }
 
-embed_migrations!();
+pub const MIGRATIONS: EmbeddedMigrations = embed_migrations!();
 
 pub fn establish_unpooled_connection() -> PgConnection {
   let db_url = match get_database_url_from_env() {
@@ -75,9 +110,11 @@ pub fn establish_unpooled_connection() -> PgConnection {
       e
     ),
   };
-  let conn =
+  let mut conn =
     PgConnection::establish(&db_url).unwrap_or_else(|_| panic!("Error connecting to {}", db_url));
-  embedded_migrations::run(&conn).expect("load migrations");
+  let _ = &mut conn
+    .run_pending_migrations(MIGRATIONS)
+    .unwrap_or_else(|_| panic!("Couldn't run DB Migrations"));
   conn
 }
 
@@ -85,6 +122,19 @@ pub fn naive_now() -> NaiveDateTime {
   chrono::prelude::Utc::now().naive_utc()
 }
 
+pub fn post_to_comment_sort_type(sort: SortType) -> CommentSortType {
+  match sort {
+    SortType::Active | SortType::Hot => CommentSortType::Hot,
+    SortType::New | SortType::NewComments | SortType::MostComments => CommentSortType::New,
+    SortType::Old => CommentSortType::Old,
+    SortType::TopDay
+    | SortType::TopAll
+    | SortType::TopWeek
+    | SortType::TopYear
+    | SortType::TopMonth => CommentSortType::Top,
+  }
+}
+
 static EMAIL_REGEX: Lazy<Regex> = Lazy::new(|| {
   Regex::new(r"^[a-zA-Z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$")
     .expect("compile email regex")
@@ -100,12 +150,9 @@ pub mod functions {
   sql_function!(fn lower(x: Text) -> Text);
 }
 
-impl<DB: Backend> ToSql<Text, DB> for DbUrl
-where
-  String: ToSql<Text, DB>,
-{
-  fn to_sql<W: Write>(&self, out: &mut Output<W, DB>) -> diesel::serialize::Result {
-    self.0.to_string().to_sql(out)
+impl ToSql<Text, Pg> for DbUrl {
+  fn to_sql(&self, out: &mut Output<Pg>) -> diesel::serialize::Result {
+    <std::string::String as ToSql<Text, Pg>>::to_sql(&self.0.to_string(), &mut out.reborrow())
   }
 }
 
@@ -113,8 +160,8 @@ impl<DB: Backend> FromSql<Text, DB> for DbUrl
 where
   String: FromSql<Text, DB>,
 {
-  fn from_sql(bytes: Option<&DB::RawValue>) -> diesel::deserialize::Result<Self> {
-    let str = String::from_sql(bytes)?;
+  fn from_sql(value: diesel::backend::RawValue<'_, DB>) -> diesel::deserialize::Result<Self> {
+    let str = String::from_sql(value)?;
     Ok(DbUrl(Url::parse(&str)?))
   }
 }