feat: reworked the way parameters are passed and remove the filter ty…

…pe to avoid overheads

crates/api/src/circuit.rs

@@ -13,7 +13,7 @@ pub fn circuits(
 ) -> Result<Json<Response<Vec<Circuits>>>> {
     let conn = &mut db.from_series(series).get().unwrap();
 
-    let query = application::circuit::CircuitQueryBuilder::filter(param.into()).build();
+    let query = application::circuit::CircuitQueryBuilder::params(param).build();
 
     let res = query.query_and_count::<Circuits>(conn);
 

crates/api/src/constructor.rs

@@ -13,7 +13,7 @@ pub fn constructors(
 ) -> Result<Json<Response<Vec<Constructors>>>> {
     let conn = &mut db.from_series(series).get().unwrap();
 
-    let query = application::constructor::ConstructorQueryBuilder::filter(param.into()).build();
+    let query = application::constructor::ConstructorQueryBuilder::params(param).build();
 
     let res = query.query_and_count::<Constructors>(conn);
 

crates/api/src/constructor_standing.rs

@@ -14,8 +14,7 @@ pub fn constructor_standings(
     let conn = &mut db.from_series(series).get().unwrap();
 
     let query =
-        application::constructor_standing::ConstructorStandingQueryBuilder::filter(param.into())
-            .build();
+        application::constructor_standing::ConstructorStandingQueryBuilder::params(param).build();
 
     let res = query.query_and_count::<ConstructorStandings>(conn);
 

crates/api/src/driver.rs

@@ -13,7 +13,7 @@ pub fn driver(
 ) -> Result<Json<Response<Vec<Drivers>>>> {
     let conn = &mut db.from_series(series).get().unwrap();
 
-    let query = application::driver::DriverQueryBuilder::filter(param.into()).build();
+    let query = application::driver::DriverQueryBuilder::params(param).build();
 
     let res = query.query_and_count::<Drivers>(conn);
 

crates/application/src/circuit.rs

@@ -5,15 +5,15 @@ use crate::{
     pagination::{Paginate, Paginated},
     sql::*,
 };
-use shared::filters::GetCircuitsFilter;
+use shared::parameters::GetCircuitsParameter;
 
 pub struct CircuitQueryBuilder {
     stmt: SelectStatement,
-    filter: GetCircuitsFilter,
+    params: GetCircuitsParameter,
 }
 
 impl CircuitQueryBuilder {
-    pub fn filter(filter: GetCircuitsFilter) -> Self {
+    pub fn params(params: GetCircuitsParameter) -> Self {
         let stmt = Query::select()
             .distinct()
             .from(Circuits::Table)
@@ -34,12 +34,12 @@ impl CircuitQueryBuilder {
             )
             .to_owned();
 
-        Self { stmt, filter }
+        Self { stmt, params }
     }
 
     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;
+        let page: u64 = self.params.page.unwrap_or_default().0;
+        let limit: u64 = self.params.limit.unwrap_or_default().0;
 
         self.races_table()
             .results_table()
@@ -61,14 +61,14 @@ impl CircuitQueryBuilder {
     }
 
     fn one_of(&self) -> bool {
-        self.filter.driver_ref.is_some()
-            || self.filter.constructor_ref.is_some()
-            || self.filter.status.is_some()
-            || self.filter.grid.is_some()
-            || self.filter.fastest.is_some()
-            || self.filter.result.is_some()
-            || self.filter.year.is_some()
-            || self.filter.round.is_some()
+        self.params.driver_ref.is_some()
+            || self.params.constructor_ref.is_some()
+            || self.params.status.is_some()
+            || self.params.grid.is_some()
+            || self.params.fastest.is_some()
+            || self.params.result.is_some()
+            || self.params.year.is_some()
+            || self.params.round.is_some()
     }
 }
 
@@ -86,37 +86,37 @@ impl SqlBuilder for CircuitQueryBuilder {
     }
 
     fn check_and_drivers(&self) -> Option<SimpleExpr> {
-        self.filter.driver_ref.as_ref().map(|d| Expr::value(&**d))
+        self.params.driver_ref.as_ref().map(|d| Expr::value(&**d))
     }
 
     fn check_and_constructors(&self) -> Option<SimpleExpr> {
-        self.filter
+        self.params
             .constructor_ref
             .as_ref()
             .map(|c| Expr::value(&**c))
     }
 
     fn check_and_status(&self) -> Option<SimpleExpr> {
-        self.filter.status.as_ref().map(|s| Expr::value(**s))
+        self.params.status.as_ref().map(|s| Expr::value(**s))
     }
 
     fn check_and_grid(&self) -> Option<SimpleExpr> {
-        self.filter.grid.as_ref().map(|g| Expr::value(**g))
+        self.params.grid.as_ref().map(|g| Expr::value(**g))
     }
 
     fn check_and_result(&self) -> Option<SimpleExpr> {
-        self.filter.result.as_ref().map(|r| Expr::value(**r))
+        self.params.result.as_ref().map(|r| Expr::value(**r))
     }
 
     fn check_and_round(&self) -> Option<SimpleExpr> {
-        self.filter.round.as_ref().map(|r| Expr::value(**r))
+        self.params.round.as_ref().map(|r| Expr::value(**r))
     }
 
     fn check_and_year(&self) -> Option<SimpleExpr> {
-        self.filter.year.as_ref().map(|y| Expr::value(**y))
+        self.params.year.as_ref().map(|y| Expr::value(**y))
     }
 
     fn check_and_fastest(&self) -> Option<SimpleExpr> {
-        self.filter.fastest.as_ref().map(|f| Expr::value(**f))
+        self.params.fastest.as_ref().map(|f| Expr::value(**f))
     }
 }

crates/application/src/constructor.rs

@@ -1,19 +1,19 @@
 use sea_query::{Expr, Func, IntoTableRef, Query, SelectStatement, SimpleExpr};
 
-use shared::filters::GetConstructorsFilter;
+use shared::parameters::GetConstructorsParameter;
 
 use crate::{
     iden::*,
     pagination::{Paginate, Paginated},
 };
 
 pub struct ConstructorQueryBuilder {
-    filter: GetConstructorsFilter,
+    params: GetConstructorsParameter,
     stmt: SelectStatement,
 }
 
 impl ConstructorQueryBuilder {
-    pub fn filter(filter: GetConstructorsFilter) -> Self {
+    pub fn params(params: GetConstructorsParameter) -> Self {
         let stmt = Query::select()
             .distinct()
             .columns(
@@ -30,26 +30,26 @@ impl ConstructorQueryBuilder {
             .from(Constructors::Table)
             .to_owned();
 
-        Self { filter, stmt }
+        Self { params, stmt }
     }
 
     pub fn build(mut self) -> Paginated {
-        let page: u64 = self.filter.page.unwrap_or_default().0;
-        let limit: u64 = self.filter.limit.unwrap_or_default().0;
+        let page: u64 = self.params.page.unwrap_or_default().0;
+        let limit: u64 = self.params.limit.unwrap_or_default().0;
 
         self.join(
             |s| {
-                s.filter.year.is_some()
-                    || s.filter.circuit_ref.is_some()
-                    || s.filter.constructor_standing.is_some()
+                s.params.year.is_some()
+                    || s.params.circuit_ref.is_some()
+                    || s.params.constructor_standing.is_some()
             },
             Races::Table,
         )
         .join(Self::one_of, Results::Table)
-        .join(|s| s.filter.driver_ref.is_some(), Drivers::Table)
-        .join(|s| s.filter.circuit_ref.is_some(), Circuits::Table)
+        .join(|s| s.params.driver_ref.is_some(), Drivers::Table)
+        .join(|s| s.params.circuit_ref.is_some(), Circuits::Table)
         .join(
-            |s| s.filter.constructor_standing.is_some(),
+            |s| s.params.constructor_standing.is_some(),
             ConstructorStandings::Table,
         )
         .and_where(|s| {
@@ -59,39 +59,39 @@ impl ConstructorQueryBuilder {
             )
         })
         .and_where(|s| {
-            (s.filter.year.is_some() || s.filter.circuit_ref.is_some()).then_some(
+            (s.params.year.is_some() || s.params.circuit_ref.is_some()).then_some(
                 Expr::col((Results::Table, Results::RaceId)).equals((Races::Table, Races::RaceId)),
             )
         })
         .and_where(|s| {
-            s.filter.driver_ref.as_ref().map(|driver_ref| {
+            s.params.driver_ref.as_ref().map(|driver_ref| {
                 Expr::col((Drivers::Table, Drivers::DriverId))
                     .equals((Results::Table, Results::DriverId))
                     .and(Expr::col((Drivers::Table, Drivers::DriverRef)).eq(&**driver_ref))
             })
         })
         .and_where(|s| {
-            s.filter
+            s.params
                 .status
                 .map(|status| Expr::col((Results::Table, Results::StatusId)).eq(*status))
         })
         .and_where(|s| {
-            s.filter
+            s.params
                 .grid
                 .map(|grid| Expr::col((Results::Table, Results::Grid)).eq(*grid))
         })
         .and_where(|s| {
-            s.filter
+            s.params
                 .fastest
                 .map(|fastest| Expr::col((Results::Table, Results::Rank)).eq(*fastest))
         })
         .and_where(|s| {
-            s.filter
+            s.params
                 .result
                 .map(|result| Expr::col((Results::Table, Results::PositionText)).eq(*result))
         })
         .and_where(|s| {
-            s.filter.constructor_standing.map(|standing| {
+            s.params.constructor_standing.map(|standing| {
                 Expr::col((
                     ConstructorStandings::Table,
                     ConstructorStandings::PositionText,
@@ -111,7 +111,7 @@ impl ConstructorQueryBuilder {
             })
         })
         .and_where(|s| {
-            s.filter
+            s.params
                 .year
                 .map(|year| Expr::col((Races::Table, Races::Year)).eq(*year))
         })
@@ -123,14 +123,14 @@ impl ConstructorQueryBuilder {
     }
 
     fn and_clause(&mut self) -> &mut Self {
-        if let Some(round) = self.filter.round {
+        if let Some(round) = self.params.round {
             return self.and_where(|_| {
                 Some(Expr::col((Races::Table, Races::Round)).eq(Expr::value(*round)))
             });
         }
 
-        if self.filter.constructor_standing.is_some() {
-            let expr = self.filter.year.map_or(
+        if self.params.constructor_standing.is_some() {
+            let expr = self.params.year.map_or(
                 Expr::tuple(
                     [
                         Expr::col((Races::Table, Races::Year)),
@@ -164,13 +164,13 @@ impl ConstructorQueryBuilder {
     }
 
     fn one_of(&self) -> bool {
-        self.filter.year.is_some()
-            || self.filter.driver_ref.is_some()
-            || self.filter.status.is_some()
-            || self.filter.grid.is_some()
-            || self.filter.result.is_some()
-            || self.filter.circuit_ref.is_some()
-            || self.filter.fastest.is_some()
+        self.params.year.is_some()
+            || self.params.driver_ref.is_some()
+            || self.params.status.is_some()
+            || self.params.grid.is_some()
+            || self.params.result.is_some()
+            || self.params.circuit_ref.is_some()
+            || self.params.fastest.is_some()
     }
 
     fn join<F, R>(&mut self, f: F, table: R) -> &mut Self

crates/application/src/constructor_standing.rs

@@ -1,19 +1,19 @@
 use sea_query::{Expr, Func, IntoColumnRef, Query, SelectStatement, SimpleExpr};
 
-use shared::filters::GetConstructorStandingsFilter;
+use shared::parameters::GetConstructorStandingsParameter;
 
 use crate::{
     iden::*,
     pagination::{Paginate, Paginated},
 };
 
 pub struct ConstructorStandingQueryBuilder {
-    filter: GetConstructorStandingsFilter,
+    params: GetConstructorStandingsParameter,
     stmt: SelectStatement,
 }
 
 impl ConstructorStandingQueryBuilder {
-    pub fn filter(filter: GetConstructorStandingsFilter) -> Self {
+    pub fn params(params: GetConstructorStandingsParameter) -> Self {
         let stmt = Query::select()
             .distinct()
             .columns(
@@ -57,15 +57,15 @@ impl ConstructorStandingQueryBuilder {
             )
             .to_owned();
 
-        Self { filter, stmt }
+        Self { params, stmt }
     }
 
     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;
+        let page: u64 = self.params.page.unwrap_or_default().0;
+        let limit: u64 = self.params.limit.unwrap_or_default().0;
 
         self.and_where(|s| {
-            s.filter.position.map(|p| {
+            s.params.position.map(|p| {
                 Expr::col((
                     ConstructorStandings::Table,
                     ConstructorStandings::PositionText,
@@ -74,12 +74,12 @@ impl ConstructorStandingQueryBuilder {
             })
         })
         .and_where(|s| {
-            s.filter.constructor_ref.as_ref().map(|c| {
+            s.params.constructor_ref.as_ref().map(|c| {
                 Expr::col((Constructors::Table, Constructors::ConstructorRef)).eq(Expr::value(&**c))
             })
         })
         .and_where(|s| {
-            s.filter
+            s.params
                 .year
                 .map(|y| Expr::col((Races::Table, Races::Year)).eq(Expr::val(*y)))
         })
@@ -90,13 +90,13 @@ impl ConstructorStandingQueryBuilder {
     }
 
     fn and_clause(self) -> Self {
-        if let Some(round) = self.filter.round {
+        if let Some(round) = self.params.round {
             return self.and_where(|_| {
                 Some(Expr::col((Races::Table, Races::Round)).eq(Expr::value(*round)))
             });
         }
 
-        let expr = self.filter.year.map_or(
+        let expr = self.params.year.map_or(
             Expr::tuple(
                 [
                     Expr::col((Races::Table, Races::Year)),