feat: added paginator

Added a pagination system. For now it uses 2 queries (COUNT OVER not supported).

Cargo.toml

@@ -20,12 +20,5 @@ proc-macro2 = "1.0.78"
 quote = "1.0.35"
 syn = { version = "2.0.48", features = ["parsing"] }
 sea-query = { version = "0.30.7", features = ["backend-mysql"] }
-sea-query-diesel = { version = "0.1.0", features = [
-    "mysql",
-    "with-chrono",
-    "with-rust_decimal",
-    "with-bigdecimal",
-] }
 r2d2 = "0.8.10"
-diesel = { version = "2.1.5", features = ["mysql", "chrono", "r2d2"] }
 mysql = { version = "25.0.0" }

bin/api/src/main.rs

@@ -9,5 +9,5 @@ fn rocket() -> _ {
 
     rocket::build()
         .mount("/api", api_lib::handlers::handlers())
-        .manage(mysql::Pool::new("mysql://user:password@localhost:3306/f1db").unwrap())
+        .manage(infrastructure::ConnectionPool::try_new().unwrap())
 }

crates/api/Cargo.toml

@@ -7,7 +7,6 @@ edition = "2021"
 
 [dependencies]
 rocket.workspace = true
-diesel.workspace = true
 serde.workspace = true
 r2d2.workspace = true
 serde_json.workspace = true

crates/api/src/circuit.rs

@@ -1,28 +1,29 @@
-use diesel::{Connection, RunQueryDsl};
-use mysql::prelude::Queryable;
-use mysql::Pool;
 use rocket::serde::json::Json;
 use rocket::{get, routes, State};
 
-use application;
+use application::{self, models::Circuits};
 use infrastructure::ConnectionPool;
 use shared::prelude::*;
 
 #[get("/<series>/circuits?<param..>")]
 pub fn circuits(
-    db: &State<Pool>,
+    db: &State<ConnectionPool>,
     series: Series,
     param: shared::parameters::GetCircuitsParameter,
-) -> Result<()> {
-    let mut conn = db.get_conn().unwrap();
+) -> Result<Json<Response<Vec<Circuits>>>> {
+    let conn = &mut db.from_series(series).get().unwrap();
 
     let query = application::circuit::CircuitQueryBuilder::filter(param.into()).build();
 
-    let res: Vec<application::models::Circuits> = conn.query(query).unwrap();
+    let res = query.query_and_count::<Circuits>(conn);
 
-    println!("{:?}", res);
+    let response = Response {
+        data: res.0,
+        pagination: res.1,
+        series,
+    };
 
-    Ok(())
+    Ok(Json(response))
 }
 
 pub fn handlers() -> Vec<rocket::Route> {

crates/api/src/lib.rs

@@ -2,8 +2,6 @@
 
 pub mod circuit;
 
-type Backend = diesel::mysql::Mysql;
-
 pub mod handlers {
     use crate::*;
     use rocket::Route;

crates/application/Cargo.toml

@@ -7,8 +7,8 @@ edition = "2021"
 
 [dependencies]
 sea-query.workspace = true
-sea-query-diesel.workspace = true
-diesel.workspace = true
 mysql.workspace = true
+serde.workspace = true
 
 shared.workspace = true
+infrastructure.workspace = true

crates/application/src/circuit.rs

@@ -1,8 +1,9 @@
-use diesel::QueryResult;
 use sea_query::{Expr, Query, SelectStatement};
-use sea_query_diesel::{DieselBinder, SeaQuery};
 
-use crate::iden::*;
+use crate::{
+    iden::*,
+    pagination::{Paginate, Paginated},
+};
 use shared::filters::GetCircuitsFilter;
 
 pub struct CircuitQueryBuilder {
@@ -12,28 +13,40 @@ pub struct CircuitQueryBuilder {
 
 impl CircuitQueryBuilder {
     pub fn filter(filter: GetCircuitsFilter) -> Self {
-        let mut stmt = Query::select();
-        stmt.distinct().from(Circuits::Table).columns(
-            [
-                Circuits::CircuitId,
-                Circuits::CircuitRef,
-                Circuits::Name,
-                Circuits::Location,
-                Circuits::Country,
-                Circuits::Lat,
-                Circuits::Lng,
-                Circuits::Alt,
-                Circuits::Url,
-            ]
-            .into_iter()
-            .map(|c| (Circuits::Table, c)),
-        );
+        let stmt = Query::select()
+            .distinct()
+            .from(Circuits::Table)
+            .columns(
+                [
+                    Circuits::CircuitId,
+                    Circuits::CircuitRef,
+                    Circuits::Name,
+                    Circuits::Location,
+                    Circuits::Country,
+                    Circuits::Lat,
+                    Circuits::Lng,
+                    Circuits::Alt,
+                    Circuits::Url,
+                ]
+                .into_iter()
+                .map(|c| (Circuits::Table, c)),
+            )
+            .to_owned();
 
         Self { stmt, filter }
     }
 
-    pub fn build(self) -> String {
-        self.stmt.to_string(sea_query::MysqlQueryBuilder)
+    pub fn build(self) -> Paginated {
+        let page: u64 = self.filter.page.unwrap_or_default().0;
+        let limit: u64 = self.filter.limit.unwrap_or_default().0;
+
+        self.races_table()
+            .results_table()
+            .constructors_table()
+            .drivers_table()
+            .stmt
+            .paginate(page)
+            .per_page(limit)
     }
 
     fn one_of(&self) -> bool {