Implement TryFromForm for all types (#24)

* impl TryFromRow and TryFromUuid for Pathfinder types

Created two macros to derive the two traits on a given struct, because
the general process of getting a row from the database and making a
struct from it is mostly the same for all types, with some odd cases.
These are covered with a number of attributes that inform how the traits
are implemented.

In the future, some of those attributes should be able to be removed in
favor of parsing the field's type, but that's too much work for the
current deadline we have, and more attributes is easier to implement.

There is no guarantee the generated code even works: that's the upcoming
commit(s).

[TVRN-10]

* migration to diesel pt 1

This commit adds most, if not all, of the diesel-related annotations for
types in tavern_pathfinder. Due to needing to `use` enum types derived
in tavern_pathfinder, the diesel migrations are stored in tavern_server.
So far, this also simpilifies the amount of custom macros needed in
tavern_derive.

Committing now as a good checkpoint to use moving forward, starting with
creating a patch file for `schema.rs` to add the custom enum types.

* migration to diesel pt 2

Hundreds of compiler errors have been fixed (though many were the same
errors in multiple contexts). Currently all that remains is implementing
the tavern-related DB traits on objects, which the custom derive macros
will help implement them on the DB____ types, which helps with
implementing the actual Pathfinder types.

Among other changes, of note is the addition of a patch file for
schema.rs to add imports for the enums created by diesel-derive-enum.

The biggest change is that all of the code was merged under
tavern_server. While we wanted the Pathfinder types in a separate
library, using that with Diesel just added too much complexity.

* run cargo fmt

* diesel migration: implement database traits

Not all operations are implemented on Effect and Feat, but the required
Get* methods are, automatically. `class.rs` and `character.rs` have not
yet been touched.

* (mostly) finish db impl for types

This commit finishes enough impls that the server compiles without
errors. Some types almost certainly need to have Insert/Update/Delete
implemented for them, but that can wait until they are needed.

* implement TryFromForm for all datatypes

Author: Shadow53

tavern_derive/src/lib.rs

@@ -166,7 +166,7 @@ pub fn impl_enum_display(input: TokenStream) -> TokenStream {
             input.ident.span(),
             "this macro only works on enums with all unit variants"
         )
-        .into();
+        .into()
     };
 
     for v in input.variants.pairs() {
@@ -206,6 +206,60 @@ pub fn impl_enum_display(input: TokenStream) -> TokenStream {
     result.into()
 }
 
+#[proc_macro_derive(FromStr)]
+pub fn impl_enum_from_str(input: TokenStream) -> TokenStream {
+    let input = syn::parse_macro_input!(input as syn::DeriveInput);
+    let name = &input.ident;
+
+    let input = if let Data::Enum(e) = &input.data {
+        e
+    } else {
+        return compile_error_args!(
+            input.ident.span(),
+            "this macro only works on enums with all unit variants"
+        )
+        .into();
+    };
+
+    for v in input.variants.pairs() {
+        match v.value().fields {
+            Fields::Unit => {}
+            _ => {
+                return compile_error_args!(
+                    v.value().ident.span(),
+                    "this macro only works on enums with all unit variants"
+                )
+                .into()
+            }
+        }
+    }
+
+    let var_words = input
+        .variants
+        .pairs()
+        .map(|v| v.value().ident.to_string().to_case(Case::Lower));
+
+    let var = input.variants.pairs().zip(var_words).map(|(v, s)| {
+        let v = &v.value().ident;
+        quote! { if val == #s { std::result::Result::<_,_>::Ok(#name::#v) } else }
+    });
+
+    let error_str = format!("invalid value for {}: {}", name, "{}");
+
+    let result = quote! {
+        impl std::str::FromStr for #name {
+            type Err = crate::status::Error;
+            fn from_str(val: &str) -> std::result::Result<Self, Self::Err> {
+                #(#var)* {
+                    std::result::Result::<_,_>::Err(Self::Err::new(format!(#error_str, val)))
+                }
+            }
+        }
+    };
+
+    result.into()
+}
+
 #[proc_macro_derive(GetById, attributes(table_name, tavern))]
 pub fn derive_get_by_id(input: TokenStream) -> TokenStream {
     let input = syn::parse_macro_input!(input as DeriveInput);

tavern_server/src/auth.rs

@@ -311,8 +311,8 @@ impl TryFrom<Form> for User {
     type Error = Rejection;
 
     fn try_from(form: Form) -> Result<Self, Self::Error> {
-        let username = forms::get_form_text_field(&form, FIELD_USERNAME)?;
-        let email = forms::get_form_text_field(&form, FIELD_EMAIL)?;
+        let username = forms::get_required_form_text_field(&form, FIELD_USERNAME)?;
+        let email = forms::get_required_form_text_field(&form, FIELD_EMAIL)?;
         let is_admin = form
             .get(FIELD_IS_ADMIN)
             .map(|field| {
@@ -469,7 +469,7 @@ struct RegistrationInfo {
 impl TryFrom<Form> for RegistrationInfo {
     type Error = Rejection;
     fn try_from(form: Form) -> Result<Self, Self::Error> {
-        let password = forms::get_form_text_field(&form, FIELD_PASSWORD)?;
+        let password = forms::get_required_form_text_field(&form, FIELD_PASSWORD)?;
 
         let info = RegistrationInfo {
             user: User::try_from(form)?,

tavern_server/src/db.rs

@@ -1,7 +1,7 @@
-use crate::status;
+use crate::status::{self, Error as StatusError};
 use diesel::prelude::*;
 use diesel::r2d2::{ConnectionManager, Pool, PooledConnection};
-use diesel::result;
+use diesel::result::Error as DieselError;
 use lazy_static::lazy_static;
 use std::fmt::{self, Display};
 use std::sync::Arc;
@@ -12,6 +12,7 @@ use warp::filters::BoxedFilter;
 use warp::{Filter, Rejection};
 
 pub use tavern_derive::*;
+use nebula_status::{Status, StatusCode};
 
 #[cfg(test)]
 mod tests {
@@ -51,9 +52,10 @@ lazy_static! {
 
 embed_migrations!();
 
-pub async fn init() -> Result<(), Error> {
-    let mut conn = get_connection().await?;
-    embedded_migrations::run(&conn).map_err(Error::Migration)
+pub async fn init() -> Result<(), String> {
+    let conn = get_connection().await
+        .map_err(|err| format!("error while getting connection: {:#?}", err))?;
+    embedded_migrations::run(&conn).map_err(|err| format!("error while running migrations: {:#?}", err))
 }
 
 async fn get_filter_connection() -> Result<Connection, Rejection> {
@@ -72,6 +74,7 @@ pub struct PostgreSQLOpt {
         long = "db-host",
         env = "TAVERN_DB_HOST",
         help = "the domain name or IP address of the database host"
+
     )]
     host: String,
     #[structopt(
@@ -140,18 +143,35 @@ pub enum Error {
     Connection(::r2d2::Error),
     InvalidValues(Vec<String>),
     Migration(diesel_migrations::RunMigrationsError),
-    RunQuery(result::Error),
+    RunQuery(DieselError),
     NoRows,
     UserUnauthorized(Uuid),
     Other(String),
 }
 
-impl From<result::Error> for Error {
-    fn from(err: result::Error) -> Self {
+impl From<DieselError> for Error {
+    fn from(err: DieselError) -> Self {
         Error::RunQuery(err)
     }
 }
 
+impl From<Error> for Rejection {
+    fn from(err: Error) -> Self {
+        match err {
+            Error::InvalidValues(list) => {
+                let error = StatusError::new(format!("invalid values for {}", list.join(", ")));
+                Status::with_data(&StatusCode::BAD_REQUEST, error).into()
+            },
+            Error::UserUnauthorized(id) => {
+                Status::new(&StatusCode::UNAUTHORIZED).into()
+            },
+            err => {
+                status::server_error_into_rejection(err.to_string())
+            }
+        }
+    }
+}
+
 impl Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

tavern_server/src/forms.rs

@@ -1,7 +1,11 @@
-use crate::status::Error;
+use crate::status::{self, Error};
 use nebula_form::Form;
 use nebula_status::{Status, StatusCode};
 use warp::Rejection;
+use uuid::Uuid;
+use std::str::FromStr;
+use crate::db::{Connection, GetById, Error as DBError};
+use diesel::result::Error as DieselError;
 
 #[cfg(test)]
 mod tests {
@@ -32,15 +36,15 @@ mod tests {
     #[test]
     fn get_form_text_field_works() {
         let form = generate_form();
-        let value =
-            super::get_form_text_field(&form, FIELD_TEXT_FOO).expect("this should not fail");
+        let value: String =
+            super::get_required_form_text_field(&form, FIELD_TEXT_FOO).expect("this should not fail");
         assert_eq!(&value, VALUE_TEXT_FOO);
     }
 
     #[test]
     fn get_file_field_as_text_fails() {
         let form = generate_form();
-        match super::get_form_text_field(&form, FIELD_FILE_BAZ) {
+        match super::get_required_form_text_field::<String>(&form, FIELD_FILE_BAZ) {
             Ok(_) => assert!(false, "file as text should not have returned successfully"),
             Err(_) => assert!(true),
         }
@@ -49,7 +53,7 @@ mod tests {
     #[test]
     fn get_missing_field_as_text_fails() {
         let form = generate_form();
-        match super::get_form_text_field(&form, FIELD_MISSING_OOPS) {
+        match super::get_required_form_text_field::<String>(&form, FIELD_MISSING_OOPS) {
             Ok(_) => assert!(false, "getting a missing field should not succeed"),
             Err(_) => assert!(true),
         }
@@ -88,10 +92,68 @@ pub(crate) fn field_is_invalid_error(field_name: &str) -> Rejection {
 
 /// Retrieve the specified *text* field from the form or return a relevant
 /// error.
-pub(crate) fn get_form_text_field(form: &Form, field_name: &str) -> Result<String, Rejection> {
+pub(crate) fn get_optional_form_text_field<T: FromStr>(form: &Form, field_name: &str) -> Result<Option<T>, Rejection> {
     form.get(field_name)
-        .ok_or_else(|| missing_field_error(field_name))?
-        .as_text()
-        .map(|txt| txt.to_string())
-        .ok_or_else(|| field_is_file_error(field_name))
+        .map(|val| {
+            val.as_text()
+                .map(|txt| {
+                    txt.parse()
+                })
+                .transpose()
+                .map_err(|_| field_is_file_error(field_name))
+        }).transpose()
+        .map(|opt| opt.flatten())
 }
+
+/// Retrieve the specified *text* field from the form or return a relevant
+/// error.
+pub(crate) fn get_required_form_text_field<T: FromStr>(form: &Form, field_name: &str) -> Result<T, Rejection> {
+    get_optional_form_text_field(form, field_name)?
+        .ok_or_else(|| missing_field_error(field_name))
+}
+
+pub(crate) fn value_by_id<T: GetById>(id: Uuid, conn: &Connection) -> Result<T, Rejection> {
+    T::db_get_by_id(&id, conn)
+        .map_err(|err| {
+            match err {
+                DBError::RunQuery(err) => {
+                    match err {
+                        DieselError::NotFound => {
+                            let error = Error::new(format!{"invalid id: {}", id});
+                            Status::with_data(&StatusCode::BAD_REQUEST, error).into()
+                        },
+                        err => status::server_error_into_rejection(err.to_string())
+                    }
+                },
+                err => status::server_error_into_rejection(err.to_string()),
+            }
+        })
+}
+
+pub(crate) fn valid_id<T: GetById>(id: Uuid, conn: &Connection) -> Result<Uuid, Rejection> {
+    value_by_id::<T>(id, conn)
+        .map(|_| id)
+}
+
+pub(crate) fn valid_id_or_new<T: GetById>(id: Option<Uuid>, conn: &Connection) -> Result<Uuid, Rejection> {
+    match id {
+        None => Ok(Uuid::new_v4()),
+        Some(id) => valid_id::<T>(id, conn)
+    }
+}
+
+pub(crate) fn db_error_to_rejection(err: DBError, field: &str) -> Rejection {
+    match err {
+        DBError::RunQuery(err) => {
+            match err {
+                DieselError::NotFound => field_is_invalid_error(field),
+                err => Rejection::from(DBError::RunQuery(err)),
+            }
+        },
+        err => Rejection::from(err),
+    }
+}
+
+pub trait TryFromForm {
+    fn try_from_form(conn: &Connection, form: Form, this_id: Option<Uuid>, parent_id: Option<Uuid>) -> Result<Self, Rejection> where Self: Sized;
+}