attempt improving naming convention across the board

Author: resolritter

entities/src/book.rs

@@ -1,5 +1,5 @@
 use crate::data::{
-    Book, BookBorrowByTitlePayload, BookCreationPayload, BookEndBorrowByTitlePayload,
+    Book, BookBorrowByTitlePayload, BookCreatePayload, BookEndBorrowByTitlePayload,
     BookOkResponse, BookPublic,
 };
 use crate::{
@@ -46,7 +46,7 @@ pub async fn end_borrow(server_addr: &str, payload: &BookEndBorrowByTitlePayload
     r
 }
 
-pub fn do_post(server_addr: &str, payload: &BookCreationPayload) -> RequestBuilder {
+pub fn do_create(server_addr: &str, payload: &BookCreatePayload) -> RequestBuilder {
     surf::post(format!(
         concat!(server_root!(), book_route_root!()),
         server_addr
@@ -55,8 +55,8 @@ pub fn do_post(server_addr: &str, payload: &BookCreationPayload) -> RequestBuild
     .header("X-Auth", payload.access_token.clone())
     .content_type(JSON)
 }
-pub async fn post(server_addr: &str, payload: &BookCreationPayload) -> (String, Book) {
-    let mut response = do_post(server_addr, payload).await.unwrap();
+pub async fn create(server_addr: &str, payload: &BookCreatePayload) -> (String, Book) {
+    let mut response = do_create(server_addr, payload).await.unwrap();
     assert!(response.status() == StatusCode::Created);
     let str_body = response.body_string().await.unwrap();
     let value = serde_json::from_str::<BookOkResponse>(&str_body).unwrap();

entities/src/data.rs

@@ -27,8 +27,8 @@ structout::generate!(
         BookGetByTitlePayload => [include(title)],
         BookBorrowByTitleRequestBody => [include(borrow_length), upsert(pub borrow_id: BorrowBookId)],
         BookEndBorrowByTitlePayload => [include(title), upsert(pub access_token: String)],
-        BookCreationPayloadRequestBody => [include(title)],
-        BookCreationPayload => [include(title), upsert(pub access_token: String)],
+        BookCreatePayloadRequestBody => [include(title)],
+        BookCreatePayload => [include(title), upsert(pub access_token: String)],
         BookBorrowByTitlePayload => [include(title, borrow_length), upsert(pub borrow_id: BorrowBookId)]
     }
 );
@@ -50,7 +50,7 @@ structout::generate!(
         pub access_token: String,
     } => {
         User => [],
-        UserCreationPayload => [omit(access_token), upsert(pub requester_access_token: Option<String>)],
+        UserCreatePayload => [omit(access_token), upsert(pub requester_access_token: Option<String>)],
         // TODO auth should support password as well
         UserLoginPayload => [include(email)],
     }

entities/src/user.rs

@@ -1,18 +1,18 @@
-use crate::data::{User, UserCreationPayload, UserLoginPayload, UserOkResponse};
+use crate::data::{User, UserCreatePayload, UserLoginPayload, UserOkResponse};
 use crate::{server_root, session_route};
 use surf::{self, http::mime::JSON, Response, StatusCode};
 
 pub const USER_ROUTE: &str = "user";
 
-pub async fn do_create(server_addr: &str, payload: &UserCreationPayload) -> Response {
+pub async fn do_create(server_addr: &str, payload: &UserCreatePayload) -> Response {
     surf::post(format!("{}/{}", server_addr, USER_ROUTE))
         .body(serde_json::json!(payload))
         .content_type(JSON)
         .await
         .unwrap()
 }
 
-pub async fn create(server_addr: &str, payload: &UserCreationPayload) -> (String, User) {
+pub async fn create(server_addr: &str, payload: &UserCreatePayload) -> (String, User) {
     let mut response = do_create(server_addr, payload).await;
     assert!(response.status() == StatusCode::Created);
     let str_body = response.body_string().await.unwrap();

server/src/main.rs

@@ -228,7 +228,6 @@ fn root(
                 .delete(resources::book::end_borrow);
 
             server.at(session_route!()).post(resources::user::login);
-
             server
                 .at(entities::user::USER_ROUTE)
                 .post(resources::user::post);

server/src/messages.rs

@@ -8,14 +8,14 @@ pub enum ActorGroups {
     User,
 }
 
-resource_messaging::generate!(User, [(Creation, Result<User, String>), (Login, User)]);
+resource_messaging::generate!(User, [(Create, Result<User, String>), (Login, User)]);
 resource_messaging::generate!(
     Book,
     [
         (BorrowByTitle, String),
         (GetByTitle, Book),
         (EndBorrowByTitle, ()),
-        (Creation, Result<Book, String>),
+        (Create, Result<Book, String>),
         (PublicList, Vec<BookPublic>),
     ]
 );
@@ -26,7 +26,7 @@ impl Loggable for BookMsg {
             BookMsg::GetByTitle(msg) => format!("{:#?}", msg.payload),
             BookMsg::BorrowByTitle(msg) => format!("{:#?}", msg.payload),
             BookMsg::EndBorrowByTitle(msg) => format!("{:#?}", msg.payload),
-            BookMsg::Creation(msg) => format!("{:#?}", msg.payload),
+            BookMsg::Create(msg) => format!("{:#?}", msg.payload),
             BookMsg::PublicList(msg) => format!("{:#?}", msg.payload),
         }
     }
@@ -35,7 +35,7 @@ impl Loggable for BookMsg {
 impl Loggable for UserMsg {
     fn to_log(&self) -> String {
         match self {
-            UserMsg::Creation(msg) => format!("{:#?}", msg.payload),
+            UserMsg::Create(msg) => format!("{:#?}", msg.payload),
             UserMsg::Login(msg) => format!("{:#?}", msg.payload),
         }
     }

server/src/resources/book.rs

@@ -1,14 +1,14 @@
 use crate::auth::require_auth_token;
 use crate::messages::{
-    BookBorrowByTitleMsg, BookCreationMsg, BookEndBorrowByTitleMsg, BookGetByTitleMsg,
+    BookBorrowByTitleMsg, BookCreateMsg, BookEndBorrowByTitleMsg, BookGetByTitleMsg,
     BookPublicListMsg,
 };
 use crate::resources::user::check_access_mask;
 use crate::resources::ResponseData;
 use crate::state::ServerState;
 use entities::{
-    access_mask, Book, BookBorrowByTitlePayload, BookBorrowByTitleRequestBody, BookCreationPayload,
-    BookCreationPayloadRequestBody, BookEndBorrowByTitlePayload, BookGetByTitlePayload, BookPublic,
+    access_mask, Book, BookBorrowByTitlePayload, BookBorrowByTitleRequestBody, BookCreatePayload,
+    BookCreatePayloadRequestBody, BookEndBorrowByTitlePayload, BookGetByTitlePayload, BookPublic,
     BookPublicListPayload,
 };
 use percent_encoding::percent_decode;
@@ -135,7 +135,7 @@ actor_response_handler::generate!({
 
 #[inline(always)]
 pub async fn create(
-    msg: &BookCreationMsg,
+    msg: &BookCreateMsg,
 ) -> Result<ResponseData<Result<Book, String>>, sqlx::Error> {
     let is_authorized = check_access_mask(
         &msg.payload.access_token,
@@ -173,11 +173,11 @@ pub async fn create(
     }
 }
 #[inline(always)]
-async fn extract_post(req: &mut Request<ServerState>) -> tide::Result<BookCreationPayload> {
+async fn extract_post(req: &mut Request<ServerState>) -> tide::Result<BookCreatePayload> {
     match require_auth_token(&req).await {
         (StatusCode::Ok, Some(access_token)) => {
-            let body = req.body_json::<BookCreationPayloadRequestBody>().await?;
-            Ok(BookCreationPayload {
+            let body = req.body_json::<BookCreatePayloadRequestBody>().await?;
+            Ok(BookCreatePayload {
                 title: body.title,
                 access_token,
             })
@@ -189,11 +189,13 @@ actor_response_handler::generate!({
     name: post,
     actor: Book,
     response_type: Result<Book, String>,
-    tag: Creation
+    tag: Create
 });
 
 #[inline(always)]
-pub async fn borrow_by_id(msg: &BookBorrowByTitleMsg) -> Result<ResponseData<String>, sqlx::Error> {
+pub async fn borrow_by_title(
+    msg: &BookBorrowByTitleMsg,
+) -> Result<ResponseData<String>, sqlx::Error> {
     let now = match SystemTime::now().duration_since(SystemTime::UNIX_EPOCH) {
         Ok(n) => n.as_secs(),
         Err(_) => panic!("SystemTime before UNIX EPOCH!"),
@@ -261,7 +263,7 @@ actor_response_handler::generate!({
 });
 
 #[inline(always)]
-pub async fn public_list_by_query(
+pub async fn list_public(
     msg: &BookPublicListMsg,
 ) -> Result<ResponseData<Vec<BookPublic>>, sqlx::Error> {
     let result = if let Some(title_query) = &msg.payload.query {
@@ -294,10 +296,10 @@ actor_response_handler::generate!({
 
 endpoint_actor::generate!({ actor: Book }, {
     GetByTitle: get_by_title,
-    BorrowByTitle: borrow_by_id,
+    BorrowByTitle: borrow_by_title,
     EndBorrowByTitle: end_borrow_by_title,
-    Creation: create,
-    PublicList: public_list_by_query
+    Create: create,
+    PublicList: list_public
 });
 
 pub async fn seed(pool: &PgPool) -> Vec<Book> {

server/src/resources/user.rs

@@ -1,7 +1,7 @@
-use crate::messages::{UserCreationMsg, UserLoginMsg};
+use crate::messages::{UserCreateMsg, UserLoginMsg};
 use crate::resources::ResponseData;
 use crate::state::ServerState;
-use entities::{access_mask, User, UserCreationPayload, UserLoginPayload};
+use entities::{access_mask, User, UserCreatePayload, UserLoginPayload};
 use sqlx::postgres::{PgDone, PgPool, PgRow};
 use sqlx::Row;
 use tide::{Request, StatusCode};
@@ -24,21 +24,6 @@ pub async fn check_access_token(access_token: &str, db_pool: &PgPool) -> Result<
     )
 }
 
-pub async fn create_super_user(
-    email: &str,
-    access_token: &str,
-    db_pool: &PgPool,
-) -> Result<PgDone, sqlx::Error> {
-    Ok(
-        sqlx::query(r#"INSERT INTO "user" (email, access_token, access_mask) VALUES ($1, $2, $3)"#)
-            .bind(email)
-            .bind(access_token)
-            .bind(access_mask::ADMIN)
-            .execute(db_pool)
-            .await?,
-    )
-}
-
 pub async fn check_access_mask(
     token: &str,
     target_mask: i32,
@@ -80,8 +65,8 @@ actor_response_handler::generate!({
 });
 
 #[inline(always)]
-pub async fn create_user(
-    msg: &UserCreationMsg,
+pub async fn create(
+    msg: &UserCreateMsg,
 ) -> Result<ResponseData<Result<User, String>>, sqlx::Error> {
     let is_authorized = match &msg.payload.requester_access_token {
         Some(token) => check_access_mask(token, access_mask::ADMIN, msg.db_pool).await?,
@@ -122,17 +107,32 @@ pub async fn create_user(
     }
 }
 #[inline(always)]
-async fn extract_post(req: &mut Request<ServerState>) -> tide::Result<UserCreationPayload> {
-    Ok(req.body_json::<UserCreationPayload>().await?)
+async fn extract_post(req: &mut Request<ServerState>) -> tide::Result<UserCreatePayload> {
+    Ok(req.body_json::<UserCreatePayload>().await?)
 }
 actor_response_handler::generate!({
     name: post,
     actor: User,
     response_type: Result<User, String>,
-    tag: Creation
+    tag: Create
 });
 
 endpoint_actor::generate!({ actor: User }, {
-    Creation: create_user,
+    Create: create,
     Login: create_session,
 });
+
+pub async fn create_super_user(
+    email: &str,
+    access_token: &str,
+    db_pool: &PgPool,
+) -> Result<PgDone, sqlx::Error> {
+    Ok(
+        sqlx::query(r#"INSERT INTO "user" (email, access_token, access_mask) VALUES ($1, $2, $3)"#)
+            .bind(email)
+            .bind(access_token)
+            .bind(access_mask::ADMIN)
+            .execute(db_pool)
+            .await?,
+    )
+}