Remove panics, cleaner code

src/db/models/languages.rs

@@ -72,41 +72,30 @@ impl Language {
         relationship: AgentLanguageRelation,
     ) -> Result<Vec<User>, DatabaseError> {
         use schema::langandagents::dsl;
-        match &mut db.conn() {
+        let conn = &mut db.conn()?;
-            Ok(conn) => Ok(dsl::langandagents
+        Ok(dsl::langandagents
-                .filter(dsl::language.eq(self.id))
+            .filter(dsl::language.eq(self.id))
-                .filter(dsl::relationship.eq(relationship))
+            .filter(dsl::relationship.eq(relationship))
-                .load::<LangAndAgent>(conn)
+            .load::<LangAndAgent>(conn)
-                .map_err(|e| {
+            .map_err(|e| {
-                    DatabaseError::new(
+                DatabaseError::new(
-                        format!(
+                    format!("Failed to retrieve language relationship: {e:?}"),
-                            "Failed to retrieve language relationship: {:?}",
+                    "Database reading error",
-                            e
+                )
-                        ),
+            })?
-                        "Database reading error",
+            .iter()
-                    )
+            .map(|v| {
-                })?
+                use schema::users::dsl;
-                .iter()
+                dsl::users.find(v.agent.clone()).first::<User>(conn)
-                .map(|v| {
+            })
-                    use schema::users::dsl;
+            .filter_map(|author| match author {
-                    dsl::users.find(v.agent.clone()).first::<User>(conn)
+                Ok(val) => Some(val),
-                })
+                Err(e) => {
-                .filter_map(|author| match author {
+                    info!("Failed ot retrieve author from database: {:?}", e);
-                    Ok(val) => Some(val),
+                    None
-                    Err(e) => {
+                }
-                        info!(
+            })
-                            "Failed ot retrieve author from database: {:?}",
+            .collect::<Vec<User>>())
-                            e
-                        );
-
-                        None
-                    }
-                })
-                .collect::<Vec<User>>()),
-            Err(e) => {
-                panic!("Could not connect to the database: {:?}", e);
-            }
-        }
     }
 }
 

src/db/models/words.rs

@@ -133,22 +133,19 @@ impl Word {
     }
 
     #[graphql(description = "Language to which the word belongs")]
-    fn language(&self, context: &Context) -> Language {
+    fn language(&self, context: &Context) -> FieldResult<Language> {
         use schema::languages::dsl;
-        match &mut context.db.conn() {
+        use std::convert::Into;
-            Ok(conn) => {
+        dsl::languages
-                match dsl::languages.find(self.language).first::<Language>(conn)
+            .find(self.language)
-                {
+            .first::<Language>(&mut context.db.conn()?)
-                    Ok(lang) => lang,
+            .map_err(|e| DatabaseError::new(
-                    Err(e) => {
+                format!(
-                        panic!("Failed to retrieve language {} of word {} from database: {:?}",
+                    "Failed to retrieve language {} of word {} from database: {e:?}",
-                               self.language, self.norm, e
+                    self.language, self.norm
-                        )
+                ),
-                    }
+                "Database Error"
-                }
+            ).into())
-            }
-            Err(e) => panic!("Failed to connect to database: {:?}", e),
-        }
     }
 
     #[graphql(