Integrate warp API, implement CRUD for book

Author: sushant-at-nitor

.env

@@ -1,3 +1,3 @@
 DATABASE_URL=sqlite://book_lending.db?mode=rwc
-RUST_LOG=warp=debug,hyper=debug
+RUST_LOG=debug,warp=debug,hyper=debug
 PORT=8005

packages/api/src/endpoints/books/books.http

@@ -0,0 +1,38 @@
+###
+# Create a new book
+POST http://localhost:8005/books
+Content-Type: application/json
+
+{
+  "title": "The Rust Programming Language",
+  "author": "Steve Klabnik, Carol Nichols",
+  "published_year": 2019,
+  "isbn": "9781593278281",
+  "total_copies": 87,
+  "available_copies": 87
+}
+
+###
+# Update a book
+PUT http://localhost:8005/books/1
+Content-Type: application/json
+
+{
+  "title": "The Rust Programming Language (2nd Edition)",
+  "author": "Steve Klabnik, Carol Nichols",
+  "published_year": 2024,
+  "isbn": "9781593278281",
+  "available_copies": 10
+}
+
+###
+# Delete a book
+DELETE http://localhost:8005/books/1
+
+###
+# Get all books (supports pagination)
+GET http://localhost:8005/books?page=1&page_size=10
+
+###
+# Get book by id
+GET http://localhost:8005/books/2

packages/api/src/endpoints/books/create.rs

@@ -0,0 +1,50 @@
+use common::server_error::ServerError;
+use std::sync::Arc;
+use warp::Filter;
+
+use application::books::{
+  BookService,
+  command_handlers::{CreateBookCommandHandler, CreateBookCommandHandlerTrait},
+};
+use domain::commands::CreateBookCommand;
+
+pub fn route<T>(
+  handler: Arc<CreateBookCommandHandler<T>>,
+) -> impl Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone
+where
+  T: BookService + Send + Sync + 'static,
+{
+  // POST /books
+  let endpoint = warp::path!("books")
+    .and(warp::post())
+    .and(with_handler(handler))
+    .and(warp::body::json())
+    .and_then(handle_create_book);
+
+  endpoint
+}
+
+fn with_handler<T>(
+  handler: Arc<CreateBookCommandHandler<T>>,
+) -> impl Filter<
+  Extract = (Arc<CreateBookCommandHandler<T>>,),
+  Error = std::convert::Infallible,
+> + Clone
+where
+  T: BookService + Send + Sync + 'static,
+{
+  warp::any().map(move || handler.clone())
+}
+
+async fn handle_create_book<T>(
+  handler: Arc<CreateBookCommandHandler<T>>,
+  cmd: CreateBookCommand,
+) -> Result<impl warp::Reply, warp::Rejection>
+where
+  T: BookService + Send + Sync + 'static,
+{
+  match handler.handle(cmd).await {
+    Ok(book) => Ok(warp::reply::json(&book)),
+    Err(_) => Err(warp::reject::custom(ServerError)),
+  }
+}

packages/api/src/endpoints/books/delete.rs

@@ -0,0 +1,55 @@
+use common::server_error::ServerError;
+use std::sync::Arc;
+use warp::Filter;
+
+use application::books::{
+  BookService,
+  command_handlers::{DeleteBookCommandHandler, DeleteBookCommandHandlerTrait},
+};
+use domain::commands::DeleteBookCommand;
+
+pub fn route<T>(
+  handler: Arc<DeleteBookCommandHandler<T>>,
+) -> impl Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone
+where
+  T: BookService + Send + Sync + 'static,
+{
+  // DELETE /books
+  let endpoint = warp::path!("books" / i32)
+    .and(warp::delete())
+    .and(with_handler(handler))
+    .and_then(handle_create_book);
+
+  endpoint
+}
+
+fn with_handler<T>(
+  handler: Arc<DeleteBookCommandHandler<T>>,
+) -> impl Filter<
+  Extract = (Arc<DeleteBookCommandHandler<T>>,),
+  Error = std::convert::Infallible,
+> + Clone
+where
+  T: BookService + Send + Sync + 'static,
+{
+  warp::any().map(move || handler.clone())
+}
+
+async fn handle_create_book<T>(
+  id: i32,
+  handler: Arc<DeleteBookCommandHandler<T>>,
+) -> Result<impl warp::Reply, warp::Rejection>
+where
+  T: BookService + Send + Sync + 'static,
+{
+  match handler.handle(DeleteBookCommand { id }).await {
+    Ok(book) => match book {
+      Some(book) => Ok(warp::reply::json(&book)),
+      None => {
+        // return 404
+        Err(warp::reject::not_found())
+      }
+    },
+    Err(_) => Err(warp::reject::custom(ServerError)),
+  }
+}

packages/api/src/endpoints/books/get_all.rs

@@ -0,0 +1,49 @@
+use common::server_error::ServerError;
+use std::sync::Arc;
+use warp::Filter;
+
+use application::books::{
+  query_handlers::get_all_handler::{
+    GetAllBooksQueryHandler, GetAllBooksQueryHandlerTrait,
+  },
+  service::BookService,
+};
+use domain::queries::GetAllBooksQuery;
+
+pub fn route<T>(
+  handler: Arc<GetAllBooksQueryHandler<T>>,
+) -> impl Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone
+where
+  T: BookService + Send + Sync + 'static,
+{
+  // GET /books
+  warp::path!("books")
+    .and(warp::get())
+    .and(with_handler(handler))
+    .and_then(handle_get_all_books)
+}
+
+fn with_handler<T>(
+  handler: Arc<GetAllBooksQueryHandler<T>>,
+) -> impl Filter<
+  Extract = (Arc<GetAllBooksQueryHandler<T>>,),
+  Error = std::convert::Infallible,
+> + Clone
+where
+  T: BookService + Send + Sync + 'static,
+{
+  warp::any().map(move || handler.clone())
+}
+
+async fn handle_get_all_books<T>(
+  handler: Arc<GetAllBooksQueryHandler<T>>,
+) -> Result<impl warp::Reply, warp::Rejection>
+where
+  T: BookService + Send + Sync + 'static,
+{
+  let query = GetAllBooksQuery;
+  match handler.handle(query).await {
+    Ok(books) => Ok(warp::reply::json(&books)),
+    Err(err) => Err(warp::reject::custom(ServerError)),
+  }
+}

packages/api/src/endpoints/books/get_by_id.rs

@@ -0,0 +1,55 @@
+use common::server_error::ServerError;
+use std::sync::Arc;
+use warp::Filter;
+
+use application::books::{
+  query_handlers::get_by_id_handler::{
+    GetBookByIdQueryHandler, GetBookByIdQueryHandlerTrait,
+  },
+  service::BookService,
+};
+use domain::queries::GetBookByIdQuery;
+
+pub fn route<T>(
+  handler: Arc<GetBookByIdQueryHandler<T>>,
+) -> impl Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone
+where
+  T: BookService + Send + Sync + 'static,
+{
+  // GET /books/<i32>
+  warp::path!("books" / i32)
+    .and(warp::get())
+    .and(with_handler(handler))
+    .and_then(handle_get_by_id_book)
+}
+
+fn with_handler<T>(
+  handler: Arc<GetBookByIdQueryHandler<T>>,
+) -> impl Filter<
+  Extract = (Arc<GetBookByIdQueryHandler<T>>,),
+  Error = std::convert::Infallible,
+> + Clone
+where
+  T: BookService + Send + Sync + 'static,
+{
+  warp::any().map(move || handler.clone())
+}
+
+async fn handle_get_by_id_book<T>(
+  id: i32,
+  handler: Arc<GetBookByIdQueryHandler<T>>,
+) -> Result<impl warp::Reply, warp::Rejection>
+where
+  T: BookService + Send + Sync + 'static,
+{
+  match handler.handle(GetBookByIdQuery { id }).await {
+    Ok(book) => match book {
+      Some(book) => Ok(warp::reply::json(&book)),
+      None => {
+        // return 404
+        Err(warp::reject::not_found())
+      }
+    },
+    Err(_) => Err(warp::reject::custom(ServerError)),
+  }
+}

packages/api/src/endpoints/books/mod.rs

@@ -0,0 +1,46 @@
+mod create;
+mod delete;
+mod get_all;
+mod get_by_id;
+mod update;
+
+use std::sync::Arc;
+use warp::Filter;
+
+use application::books::{
+  command_handlers::CreateBookCommandHandler,
+  command_handlers::DeleteBookCommandHandler,
+  command_handlers::UpdateBookCommandHandler,
+  query_handlers::GetAllBooksQueryHandler,
+  query_handlers::GetBookByIdQueryHandler,
+};
+use infrastructure::{
+  repositories::book_repository::BookRepository,
+  services::book_service::BookServiceImpl,
+};
+
+use crate::startup::AppState;
+
+pub fn register(
+  state: Arc<AppState>,
+) -> impl Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone {
+  let repo = BookRepository::new(state.db.connection.clone());
+  let service = Arc::new(BookServiceImpl::new(repo));
+  let create_handler = Arc::new(CreateBookCommandHandler::new(service.clone()));
+  let update_handler = Arc::new(UpdateBookCommandHandler::new(service.clone()));
+  let delete_handler = Arc::new(DeleteBookCommandHandler::new(service.clone()));
+  let get_all_handler = Arc::new(GetAllBooksQueryHandler::new(service.clone()));
+  let get_by_id_handler =
+    Arc::new(GetBookByIdQueryHandler::new(service.clone()));
+
+  // Each route is self-contained under /books
+  let create = create::route(create_handler);
+  let update = update::route(update_handler);
+  let delete = delete::route(delete_handler);
+  let get_all = get_all::route(get_all_handler);
+  let get_by_id = get_by_id::route(get_by_id_handler);
+
+  let routes = create.or(update).or(delete).or(get_all).or(get_by_id);
+
+  routes
+}

packages/api/src/endpoints/books/update.rs

@@ -0,0 +1,52 @@
+use common::server_error::ServerError;
+use std::sync::Arc;
+use warp::Filter;
+
+use application::books::{
+  BookService, UpdateBookCommandHandlerTrait, command_handlers::UpdateBookCommandHandler
+};
+use domain::commands::UpdateBookCommand;
+
+pub fn route<T>(
+  handler: Arc<UpdateBookCommandHandler<T>>,
+) -> impl Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone
+where
+  T: BookService + Send + Sync + 'static,
+{
+  // PUT /books/{book_id}
+  let endpoint = warp::path!("books" / i32)
+    .and(warp::put())
+    .and(with_handler(handler))
+    .and(warp::body::json())
+    .and_then(handle_update_book);
+
+  endpoint
+}
+
+fn with_handler<T>(
+  handler: Arc<UpdateBookCommandHandler<T>>,
+) -> impl Filter<
+  Extract = (Arc<UpdateBookCommandHandler<T>>,),
+  Error = std::convert::Infallible,
+> + Clone
+where
+  T: BookService + Send + Sync + 'static,
+{
+  warp::any().map(move || handler.clone())
+}
+
+async fn handle_update_book<T>(
+  book_id: i32,
+  handler: Arc<UpdateBookCommandHandler<T>>,
+  mut cmd: UpdateBookCommand,
+) -> Result<impl warp::Reply, warp::Rejection>
+where
+  T: BookService + Send + Sync + 'static,
+{
+  cmd.id = book_id;
+
+  match handler.handle(cmd).await {
+    Ok(book) => Ok(warp::reply::json(&book)),
+    Err(_) => Err(warp::reject::custom(ServerError)),
+  }
+}

packages/api/src/endpoints/mod.rs

@@ -0,0 +1,11 @@
+pub mod books;
+
+use crate::startup::AppState;
+use std::sync::Arc;
+use warp::Filter;
+
+pub fn register(
+  state: Arc<AppState>,
+) -> impl Filter<Extract = impl warp::Reply> + Clone {
+  books::register(state)
+}