Add blog API (#14)

Cargo.toml

@@ -15,7 +15,7 @@ members = ["api", "app", "doc", "models", "migration", "utils"]
 
 [workspace.dependencies]
 axum = { version = "0.7.5", default-features = false }
-tower = { version = "0.4.13", default-features = false }
+tower = { version = "0.5.0", default-features = false }
 sea-orm = { version = "1.0.0", default-features = false }
 serde = { version = "1", features = ["derive"] }
 serde_json = { version = "1", default-features = false }

api/src/routers/blog.rs

@@ -0,0 +1,67 @@
+use axum::{
+    extract::{Query, State},
+    http::StatusCode,
+    response::IntoResponse,
+    routing::get,
+    Router,
+};
+use sea_orm::TryIntoModel;
+
+use app::persistence::blog::{create_blog, search_blogs};
+use app::state::AppState;
+use models::params::blog::CreateBlogParams;
+use models::queries::blog::BlogQuery;
+use models::schemas::blog::{BlogListSchema, BlogSchema};
+
+use crate::error::ApiError;
+use crate::extractor::{Json, Valid};
+
+#[utoipa::path(
+    post,
+    path = "",
+    request_body = CreateBlogParams,
+    responses(
+        (status = 201, description = "Blog created", body = BlogSchema),
+        (status = 400, description = "Bad request", body = ApiErrorResponse),
+        (status = 422, description = "Validation error", body = ParamsErrorResponse),
+        (status = 500, description = "Internal server error", body = ApiErrorResponse),
+    )
+)]
+async fn blogs_post(
+    state: State<AppState>,
+    Valid(Json(params)): Valid<Json<CreateBlogParams>>,
+) -> Result<impl IntoResponse, ApiError> {
+    let blog = create_blog(&state.conn, params)
+        .await
+        .map_err(ApiError::from)?;
+
+    let blog = blog.try_into_model().unwrap();
+    Ok((StatusCode::CREATED, Json(BlogSchema::from(blog))))
+}
+
+#[utoipa::path(
+    get,
+    path = "",
+    params(
+        BlogQuery
+    ),
+    responses(
+        (status = 200, description = "List blogs", body = BlogListSchema),
+        (status = 500, description = "Internal server error", body = ApiErrorResponse),
+    )
+)]
+async fn blogs_get(
+    state: State<AppState>,
+    query: Option<Query<BlogQuery>>,
+) -> Result<impl IntoResponse, ApiError> {
+    let Query(query) = query.unwrap_or_default();
+
+    let blogs = search_blogs(&state.conn, query)
+        .await
+        .map_err(ApiError::from)?;
+    Ok(Json(BlogListSchema::from(blogs)))
+}
+
+pub fn create_blog_router() -> Router<AppState> {
+    Router::new().route("/", get(blogs_get).post(blogs_post))
+}

api/src/routers/mod.rs

@@ -1,15 +1,18 @@
 use axum::Router;
 
+pub mod blog;
 pub mod root;
 pub mod user;
 
 use app::state::AppState;
+use blog::create_blog_router;
 use root::create_root_router;
 use user::create_user_router;
 
 pub fn create_router(state: AppState) -> Router {
     Router::new()
         .nest("/users", create_user_router())
+        .nest("/blogs", create_blog_router())
         .nest("/", create_root_router())
         .with_state(state)
 }

api/src/routers/user.rs

@@ -62,6 +62,7 @@ async fn users_get(
         .map_err(ApiError::from)?;
     Ok(Json(UserListSchema::from(users)))
 }
+
 #[utoipa::path(
     get,
     path = "/{id}",

app/src/persistence/blog.rs

@@ -0,0 +1,24 @@
+use sea_orm::{ActiveModelTrait, ColumnTrait, DbConn, DbErr, EntityTrait, QueryFilter, Set};
+
+use models::{domains::blog, params::blog::CreateBlogParams, queries::blog::BlogQuery};
+
+pub async fn search_blogs(db: &DbConn, query: BlogQuery) -> Result<Vec<blog::Model>, DbErr> {
+    blog::Entity::find()
+        .filter(blog::Column::Title.contains(query.title))
+        .all(db)
+        .await
+}
+
+pub async fn create_blog(
+    db: &DbConn,
+    params: CreateBlogParams,
+) -> Result<blog::ActiveModel, DbErr> {
+    blog::ActiveModel {
+        author_id: Set(params.author_id as i32),
+        title: Set(params.title),
+        content: Set(params.content),
+        ..Default::default()
+    }
+    .save(db)
+    .await
+}

app/src/persistence/mod.rs

@@ -1 +1,2 @@
+pub mod blog;
 pub mod user;

doc/src/blog.rs

@@ -0,0 +1,20 @@
+use utoipa::OpenApi;
+
+use models::params::blog::CreateBlogParams;
+use models::schemas::blog::{BlogListSchema, BlogSchema};
+
+use api::models::{ApiErrorResponse, ParamsErrorResponse};
+use api::routers::blog::*;
+
+#[derive(OpenApi)]
+#[openapi(
+    paths(blogs_get, blogs_post),
+    components(schemas(
+        CreateBlogParams,
+        BlogListSchema,
+        BlogSchema,
+        ApiErrorResponse,
+        ParamsErrorResponse,
+    ))
+)]
+pub(super) struct BlogApi;

doc/src/lib.rs

@@ -3,6 +3,7 @@ use utoipa::OpenApi;
 use utoipa_scalar::{Scalar, Servable as ScalarServable};
 use utoipa_swagger_ui::SwaggerUi;
 
+mod blog;
 mod root;
 mod user;
 
@@ -11,10 +12,12 @@ mod user;
     nest(
         (path = "/", api = root::RootApi),
         (path = "/users", api = user::UserApi),
+        (path = "/blogs", api = blog::BlogApi),
     ),
     tags(
         (name = "root", description = "Root API"),
-        (name = "user", description = "User API")
+        (name = "user", description = "User API"),
+        (name = "blog", description = "Blog API"),
 
     )
 )]

migration/src/lib.rs

@@ -1,12 +1,16 @@
 pub use sea_orm_migration::prelude::*;
 
 mod m20240101_000001_init;
+mod m20240816_160144_blog;
 
 pub struct Migrator;
 
 #[async_trait::async_trait]
 impl MigratorTrait for Migrator {
     fn migrations() -> Vec<Box<dyn MigrationTrait>> {
-        vec![Box::new(m20240101_000001_init::Migration)]
+        vec![
+            Box::new(m20240101_000001_init::Migration),
+            Box::new(m20240816_160144_blog::Migration),
+        ]
     }
 }

migration/src/m20240101_000001_init.rs

@@ -37,7 +37,7 @@ impl MigrationTrait for Migration {
 }
 
 #[derive(DeriveIden)]
-enum User {
+pub(super) enum User {
     Table,
     Id,
     Username,

migration/src/m20240816_160144_blog.rs

@@ -0,0 +1,47 @@
+use sea_orm_migration::{prelude::*, schema::*};
+
+use super::m20240101_000001_init::User;
+
+#[derive(DeriveMigrationName)]
+pub struct Migration;
+
+#[async_trait::async_trait]
+impl MigrationTrait for Migration {
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .create_table(
+                Table::create()
+                    .table(Blog::Table)
+                    .if_not_exists()
+                    .col(pk_auto(Blog::Id))
+                    .col(integer(Blog::AuthorId).not_null())
+                    .foreign_key(
+                        ForeignKey::create()
+                            .name("fk_blog_author_id")
+                            .from(Blog::Table, Blog::AuthorId)
+                            .to(User::Table, User::Id)
+                            .on_update(ForeignKeyAction::NoAction)
+                            .on_delete(ForeignKeyAction::Cascade),
+                    )
+                    .col(ColumnDef::new(Blog::Title).string().not_null())
+                    .col(ColumnDef::new(Blog::Content).string().not_null())
+                    .to_owned(),
+            )
+            .await
+    }
+
+    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .drop_table(Table::drop().table(Blog::Table).to_owned())
+            .await
+    }
+}
+
+#[derive(DeriveIden)]
+enum Blog {
+    Table,
+    Id,
+    AuthorId,
+    Title,
+    Content,
+}

models/README.md

@@ -7,3 +7,7 @@ Only dependencies for modelling are allowed:
 - SeaORM (domain models and database)
 - validator (parameter validation)
 - utoipa (openapi)
+
+## SeaORM
+
+Write migration files first, then generate models.

models/src/domains/blog.rs

@@ -0,0 +1,33 @@
+//! `SeaORM` Entity, @generated by sea-orm-codegen 1.0.0
+
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq)]
+#[sea_orm(table_name = "blog")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub author_id: i32,
+    pub title: String,
+    pub content: String,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::user::Entity",
+        from = "Column::AuthorId",
+        to = "super::user::Column::Id",
+        on_update = "NoAction",
+        on_delete = "Cascade"
+    )]
+    User,
+}
+
+impl Related<super::user::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::User.def()
+    }
+}
+
+impl ActiveModelBehavior for ActiveModel {}

models/src/domains/mod.rs

@@ -1,5 +1,6 @@
-//! `SeaORM` Entity. Generated by sea-orm-codegen 0.12.15
+//! `SeaORM` Entity, @generated by sea-orm-codegen 1.0.0
 
 pub mod prelude;
 
+pub mod blog;
 pub mod user;

models/src/domains/prelude.rs

@@ -1,3 +1,4 @@
-//! `SeaORM` Entity. Generated by sea-orm-codegen 0.12.15
+//! `SeaORM` Entity, @generated by sea-orm-codegen 1.0.0
 
+pub use super::blog::Entity as Blog;
 pub use super::user::Entity as User;

models/src/domains/user.rs

@@ -1,4 +1,4 @@
-//! `SeaORM` Entity. Generated by sea-orm-codegen 0.12.15
+//! `SeaORM` Entity, @generated by sea-orm-codegen 1.0.0
 
 use sea_orm::entity::prelude::*;
 
@@ -7,11 +7,20 @@ use sea_orm::entity::prelude::*;
 pub struct Model {
     #[sea_orm(primary_key)]
     pub id: i32,
-    #[sea_orm(column_type = "Text", unique)]
+    #[sea_orm(unique)]
     pub username: String,
 }
 
 #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {}
+pub enum Relation {
+    #[sea_orm(has_many = "super::blog::Entity")]
+    Blog,
+}
+
+impl Related<super::blog::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Blog.def()
+    }
+}
 
 impl ActiveModelBehavior for ActiveModel {}

models/src/params/blog.rs

@@ -0,0 +1,14 @@
+use serde::Deserialize;
+use utoipa::ToSchema;
+use validator::Validate;
+
+#[derive(Deserialize, Validate, ToSchema)]
+pub struct CreateBlogParams {
+    pub author_id: u32,
+
+    #[validate(length(min = 2))]
+    pub title: String,
+
+    #[validate(length(min = 2))]
+    pub content: String,
+}

models/src/params/mod.rs

@@ -1 +1,2 @@
+pub mod blog;
 pub mod user;

models/src/queries/blog.rs

@@ -0,0 +1,9 @@
+use serde::Deserialize;
+use utoipa::IntoParams;
+
+#[derive(Deserialize, Default, IntoParams)]
+#[into_params(style = Form, parameter_in = Query)]
+pub struct BlogQuery {
+    #[param(nullable = true)]
+    pub title: String,
+}

models/src/queries/mod.rs

@@ -1 +1,2 @@
+pub mod blog;
 pub mod user;