From 54f62cfeb6c8835ecf86e55539ea55eabe81e587 Mon Sep 17 00:00:00 2001 From: Haris <4259838+Wulf@users.noreply.github.com> Date: Sat, 28 Oct 2023 18:51:18 -0400 Subject: [PATCH 1/6] Add filter() fn, update pagination() fn --- src/bin/main.rs | 13 +++ src/code.rs | 105 ++++++++++++++++-- src/lib.rs | 18 ++- .../models/todos/generated.rs | 53 +++++++-- .../models/todos/generated.rs | 53 +++++++-- .../models/todos/generated.rs | 53 +++++++-- .../models/todos/generated.rs | 68 ++++++++++-- .../models/todos/generated.rs | 63 +++++++++-- .../models/todos/generated.rs | 63 +++++++++-- .../models/tableA/generated.rs | 48 ++++++-- .../models/tableB/generated.rs | 53 +++++++-- .../models/tableA/generated.rs | 48 ++++++-- .../models/tableB/generated.rs | 53 +++++++-- .../models/todos/generated.rs | 48 ++++++-- .../models/users/generated.rs | 58 ++++++++-- .../models/table1/generated.rs | 48 ++++++-- .../models/table2/generated.rs | 48 ++++++-- .../models/table1/generated.rs | 48 ++++++-- .../models/table2/generated.rs | 48 ++++++-- .../models/table1.rs | 48 ++++++-- .../models/table2.rs | 48 ++++++-- .../models/table1/generated.rs | 48 ++++++-- .../models/table2/generated.rs | 48 ++++++-- test/simple_table/models/todos/generated.rs | 83 ++++++++++++-- .../models/todos/generated.rs | 73 ++++++++++-- .../models/todos/generated.rs | 73 ++++++++++-- .../models/todos/generated.rs | 73 ++++++++++-- test/single_model_file/models/table1.rs | 48 ++++++-- test/single_model_file/models/table2.rs | 48 ++++++-- .../models/fang_tasks/generated.rs | 93 ++++++++++++++-- 30 files changed, 1415 insertions(+), 257 deletions(-) diff --git a/src/bin/main.rs b/src/bin/main.rs index 08f04469..4e8493bf 100644 --- a/src/bin/main.rs +++ b/src/bin/main.rs @@ -102,6 +102,18 @@ pub struct MainOptions { /// Generate the "ConnectionType" type only once in a "common.rs" file #[arg(long = "once-connection-type")] pub once_connection_type: bool, + + /// Set which diesel backend to use (something which implements `diesel::backend::Backend`) + /// Deisel provides the following backends: + /// - `diesel::pg::Pg` + /// - `diesel::sqlite::Sqlite` + /// - `diesel::mysql::Mysql` + /// + /// See `crate::GenerationConfig::diesel_backend` for more details. + /// + /// Default is "diesel::pg::Pg" + #[arg(long = "diesel-backend", default_value = "diesel::pg::Pg")] + pub diesel_backend: String, } #[derive(Debug, ValueEnum, Clone, PartialEq, Default)] @@ -203,6 +215,7 @@ fn actual_main() -> dsync::Result<()> { model_path: args.model_path, once_common_structs: args.once_common_structs, once_connection_type: args.once_connection_type, + diesel_backend: args.diesel_backend, }, )?; diff --git a/src/code.rs b/src/code.rs index 89ef9a1f..4501cfc5 100644 --- a/src/code.rs +++ b/src/code.rs @@ -215,7 +215,7 @@ impl<'a> Struct<'a> { /// Render the full struct fn render(&mut self) { let ty = self.ty; - let table = &self.table; + let table = self.table; let primary_keys: Vec = table.primary_key_column_names(); @@ -422,25 +422,62 @@ impl {struct_name} {{ )); buffer.push_str(&format!(r##" - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub{async_keyword} fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> {{ + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub{async_keyword} fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: {struct_name}Filter) -> QueryResult> {{ use {schema_path}{table_name}::dsl::*; - let page_size = if page_size < 1 {{ 1 }} else {{ page_size }}; - let total_items = {table_name}.count().get_result(db){await_keyword}?; - let items = {table_name}.limit(page_size).offset(page * page_size).load::(db){await_keyword}?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db){await_keyword}?; Ok(PaginationResult {{ items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }}) }} "##)); + // Table::filter() helper fn + { + let diesel_backend = config.diesel_backend.clone(); + let filters = table + .columns + .iter() + .map(|column| { + let column_name = column.name.to_string(); + format!( + r##" + if let Some(filter_{column_name}) = filter.{column_name}.clone() {{ + query = query.filter({schema_path}{table_name}::{column_name}.eq(filter_{column_name})); + }}"## + ) + }) + .collect::>() + .join(""); + buffer.push_str(&format!( + r##" + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: {struct_name}Filter, + ) -> {schema_path}{table_name}::BoxedQuery<'a, {diesel_backend}> {{ + let mut query = {schema_path}{table_name}::table.into_boxed(); + + {filters} + + query + }} +"## + )); + } + // TODO: If primary key columns are attached to the form struct (not optionally) // then don't require item_id_params (otherwise it'll be duplicated) @@ -470,10 +507,56 @@ impl {struct_name} {{ )); buffer.push_str( - r##" -}"##, + r#" +}"#, ); + // generate filter struct for filter() helper function + { + let filter_fields = table + .columns + .iter() + .map(|column| { + let column_name = column.name.to_string(); + format!( + "pub {column_name}: Option<{column_type}>,", + column_name = column_name, + column_type = if column.is_nullable { + format!("Option<{}>", column.ty) + } else { + column.ty.clone() + } + ) + }) + .collect::>() + .join("\n "); + let filter_fields_default = table + .columns + .iter() + .map(|column| { + let column_name = column.name.to_string(); + format!("{column_name}: None,") + }) + .collect::>() + .join("\n "); + buffer.push_str(&format!( + r##" +#[derive(Clone)] +pub struct {struct_name}Filter {{ + {filter_fields} +}} + +impl Default for {struct_name}Filter {{ + fn default() -> {struct_name}Filter {{ + {struct_name}Filter {{ + {filter_fields_default} + }} + }} +}} +"## + )); + } + buffer } diff --git a/src/lib.rs b/src/lib.rs index 305db755..0fc0c769 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -214,14 +214,26 @@ impl<'a> Default for TableOptions<'a> { #[derive(Debug, Clone)] pub struct GenerationConfig<'a> { - /// Specific Table options for a given table + /// Specific code generation options for a particular table pub table_options: HashMap<&'a str, TableOptions<'a>>, - /// Default table options, used when not in `table_options` + /// Default table options, can be overriden by `table_options` pub default_table_options: TableOptions<'a>, /// Connection type to insert /// - /// Example: `diesel::SqliteConnection` + /// For example: + /// - `diesel::pg::PgConnection` (default) + /// - `diesel::sqlite::SqliteConnection` + /// - `diesel::mysql::MysqlConnection` + /// - or, your custom diesel connection type (struct which implements `diesel::connection::Connection`) pub connection_type: String, + /// Diesel backend + /// + /// For example: + /// - `diesel::pg::Pg` (default) + /// - `diesel::sqlite::Sqlite` + /// - `diesel::mysql::Mysql` + /// - or, your custom diesel backend type (struct which implements `diesel::backend::Backend`) + pub diesel_backend: String, /// Diesel schema import path /// /// by default `crate::schema::` diff --git a/test/autogenerated_all/models/todos/generated.rs b/test/autogenerated_all/models/todos/generated.rs index 12a5c285..9a75dae0 100644 --- a/test/autogenerated_all/models/todos/generated.rs +++ b/test/autogenerated_all/models/todos/generated.rs @@ -47,24 +47,45 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = todos.count().get_result(db)?; - let items = todos.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TodosFilter, + ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::todos::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::todos::id.eq(filter_id)); + } + if let Some(filter_created_at) = filter.created_at.clone() { + query = query.filter(crate::schema::todos::created_at.eq(filter_created_at)); + } + + query + } + pub fn update(db: &mut ConnectionType, param_id: i32, item: &UpdateTodos) -> QueryResult { use crate::schema::todos::dsl::*; @@ -77,4 +98,18 @@ impl Todos { diesel::delete(todos.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TodosFilter { + pub id: Option, + pub created_at: Option, +} + +impl Default for TodosFilter { + fn default() -> TodosFilter { + TodosFilter { + id: None, + created_at: None, + } + } +} diff --git a/test/autogenerated_attributes/models/todos/generated.rs b/test/autogenerated_attributes/models/todos/generated.rs index 90fcf2cc..bf66d653 100644 --- a/test/autogenerated_attributes/models/todos/generated.rs +++ b/test/autogenerated_attributes/models/todos/generated.rs @@ -52,24 +52,45 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = todos.count().get_result(db)?; - let items = todos.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TodosFilter, + ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::todos::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::todos::id.eq(filter_id)); + } + if let Some(filter_created_at) = filter.created_at.clone() { + query = query.filter(crate::schema::todos::created_at.eq(filter_created_at)); + } + + query + } + pub fn update(db: &mut ConnectionType, param_id: i32, item: &UpdateTodos) -> QueryResult { use crate::schema::todos::dsl::*; @@ -82,4 +103,18 @@ impl Todos { diesel::delete(todos.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TodosFilter { + pub id: Option, + pub created_at: Option, +} + +impl Default for TodosFilter { + fn default() -> TodosFilter { + TodosFilter { + id: None, + created_at: None, + } + } +} diff --git a/test/autogenerated_primary_keys/models/todos/generated.rs b/test/autogenerated_primary_keys/models/todos/generated.rs index fcb0fd23..040f0d36 100644 --- a/test/autogenerated_primary_keys/models/todos/generated.rs +++ b/test/autogenerated_primary_keys/models/todos/generated.rs @@ -52,24 +52,45 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = todos.count().get_result(db)?; - let items = todos.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TodosFilter, + ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::todos::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::todos::id.eq(filter_id)); + } + if let Some(filter_text) = filter.text.clone() { + query = query.filter(crate::schema::todos::text.eq(filter_text)); + } + + query + } + pub fn update(db: &mut ConnectionType, param_id: i32, item: &UpdateTodos) -> QueryResult { use crate::schema::todos::dsl::*; @@ -82,4 +103,18 @@ impl Todos { diesel::delete(todos.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TodosFilter { + pub id: Option, + pub text: Option, +} + +impl Default for TodosFilter { + fn default() -> TodosFilter { + TodosFilter { + id: None, + text: None, + } + } +} diff --git a/test/cleanup_generated_content/models/todos/generated.rs b/test/cleanup_generated_content/models/todos/generated.rs index 2cb0655d..96eee3da 100644 --- a/test/cleanup_generated_content/models/todos/generated.rs +++ b/test/cleanup_generated_content/models/todos/generated.rs @@ -60,24 +60,54 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = todos.count().get_result(db)?; - let items = todos.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TodosFilter, + ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::todos::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::todos::id.eq(filter_id)); + } + if let Some(filter_text) = filter.text.clone() { + query = query.filter(crate::schema::todos::text.eq(filter_text)); + } + if let Some(filter_completed) = filter.completed.clone() { + query = query.filter(crate::schema::todos::completed.eq(filter_completed)); + } + if let Some(filter_created_at) = filter.created_at.clone() { + query = query.filter(crate::schema::todos::created_at.eq(filter_created_at)); + } + if let Some(filter_updated_at) = filter.updated_at.clone() { + query = query.filter(crate::schema::todos::updated_at.eq(filter_updated_at)); + } + + query + } + pub fn update(db: &mut ConnectionType, param_id: i32, item: &UpdateTodos) -> QueryResult { use crate::schema::todos::dsl::*; @@ -90,4 +120,24 @@ impl Todos { diesel::delete(todos.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TodosFilter { + pub id: Option, + pub text: Option, + pub completed: Option, + pub created_at: Option>, + pub updated_at: Option>, +} + +impl Default for TodosFilter { + fn default() -> TodosFilter { + TodosFilter { + id: None, + text: None, + completed: None, + created_at: None, + updated_at: None, + } + } +} diff --git a/test/create_update_str_cow/models/todos/generated.rs b/test/create_update_str_cow/models/todos/generated.rs index b186fe90..06700656 100644 --- a/test/create_update_str_cow/models/todos/generated.rs +++ b/test/create_update_str_cow/models/todos/generated.rs @@ -59,24 +59,51 @@ impl Todos { todos.filter(text.eq(param_text)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = todos.count().get_result(db)?; - let items = todos.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TodosFilter, + ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::todos::table.into_boxed(); + + + if let Some(filter_text) = filter.text.clone() { + query = query.filter(crate::schema::todos::text.eq(filter_text)); + } + if let Some(filter_text_nullable) = filter.text_nullable.clone() { + query = query.filter(crate::schema::todos::text_nullable.eq(filter_text_nullable)); + } + if let Some(filter_varchar) = filter.varchar.clone() { + query = query.filter(crate::schema::todos::varchar.eq(filter_varchar)); + } + if let Some(filter_varchar_nullable) = filter.varchar_nullable.clone() { + query = query.filter(crate::schema::todos::varchar_nullable.eq(filter_varchar_nullable)); + } + + query + } + pub fn update(db: &mut ConnectionType, param_text: String, item: &UpdateTodos) -> QueryResult { use crate::schema::todos::dsl::*; @@ -89,4 +116,22 @@ impl Todos { diesel::delete(todos.filter(text.eq(param_text))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TodosFilter { + pub text: Option, + pub text_nullable: Option>, + pub varchar: Option, + pub varchar_nullable: Option>, +} + +impl Default for TodosFilter { + fn default() -> TodosFilter { + TodosFilter { + text: None, + text_nullable: None, + varchar: None, + varchar_nullable: None, + } + } +} diff --git a/test/create_update_str_str/models/todos/generated.rs b/test/create_update_str_str/models/todos/generated.rs index 49226d0a..986b149a 100644 --- a/test/create_update_str_str/models/todos/generated.rs +++ b/test/create_update_str_str/models/todos/generated.rs @@ -59,24 +59,51 @@ impl Todos { todos.filter(text.eq(param_text)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = todos.count().get_result(db)?; - let items = todos.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TodosFilter, + ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::todos::table.into_boxed(); + + + if let Some(filter_text) = filter.text.clone() { + query = query.filter(crate::schema::todos::text.eq(filter_text)); + } + if let Some(filter_text_nullable) = filter.text_nullable.clone() { + query = query.filter(crate::schema::todos::text_nullable.eq(filter_text_nullable)); + } + if let Some(filter_varchar) = filter.varchar.clone() { + query = query.filter(crate::schema::todos::varchar.eq(filter_varchar)); + } + if let Some(filter_varchar_nullable) = filter.varchar_nullable.clone() { + query = query.filter(crate::schema::todos::varchar_nullable.eq(filter_varchar_nullable)); + } + + query + } + pub fn update(db: &mut ConnectionType, param_text: String, item: &UpdateTodos) -> QueryResult { use crate::schema::todos::dsl::*; @@ -89,4 +116,22 @@ impl Todos { diesel::delete(todos.filter(text.eq(param_text))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TodosFilter { + pub text: Option, + pub text_nullable: Option>, + pub varchar: Option, + pub varchar_nullable: Option>, +} + +impl Default for TodosFilter { + fn default() -> TodosFilter { + TodosFilter { + text: None, + text_nullable: None, + varchar: None, + varchar_nullable: None, + } + } +} diff --git a/test/custom_model_and_schema_path/models/tableA/generated.rs b/test/custom_model_and_schema_path/models/tableA/generated.rs index ee0dbd28..70bf9ab8 100644 --- a/test/custom_model_and_schema_path/models/tableA/generated.rs +++ b/test/custom_model_and_schema_path/models/tableA/generated.rs @@ -46,28 +46,58 @@ impl TableA { tableA.filter(_id.eq(param__id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TableAFilter) -> QueryResult> { use crate::data::schema::tableA::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = tableA.count().get_result(db)?; - let items = tableA.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TableAFilter, + ) -> crate::data::schema::tableA::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::data::schema::tableA::table.into_boxed(); + + + if let Some(filter__id) = filter._id.clone() { + query = query.filter(crate::data::schema::tableA::_id.eq(filter__id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param__id: i32) -> QueryResult { use crate::data::schema::tableA::dsl::*; diesel::delete(tableA.filter(_id.eq(param__id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TableAFilter { + pub _id: Option, +} + +impl Default for TableAFilter { + fn default() -> TableAFilter { + TableAFilter { + _id: None, + } + } +} diff --git a/test/custom_model_and_schema_path/models/tableB/generated.rs b/test/custom_model_and_schema_path/models/tableB/generated.rs index 8c058699..604827c3 100644 --- a/test/custom_model_and_schema_path/models/tableB/generated.rs +++ b/test/custom_model_and_schema_path/models/tableB/generated.rs @@ -53,24 +53,45 @@ impl TableB { tableB.filter(_id.eq(param__id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TableBFilter) -> QueryResult> { use crate::data::schema::tableB::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = tableB.count().get_result(db)?; - let items = tableB.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TableBFilter, + ) -> crate::data::schema::tableB::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::data::schema::tableB::table.into_boxed(); + + + if let Some(filter__id) = filter._id.clone() { + query = query.filter(crate::data::schema::tableB::_id.eq(filter__id)); + } + if let Some(filter_link) = filter.link.clone() { + query = query.filter(crate::data::schema::tableB::link.eq(filter_link)); + } + + query + } + pub fn update(db: &mut ConnectionType, param__id: i32, item: &UpdateTableB) -> QueryResult { use crate::data::schema::tableB::dsl::*; @@ -83,4 +104,18 @@ impl TableB { diesel::delete(tableB.filter(_id.eq(param__id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TableBFilter { + pub _id: Option, + pub link: Option, +} + +impl Default for TableBFilter { + fn default() -> TableBFilter { + TableBFilter { + _id: None, + link: None, + } + } +} diff --git a/test/custom_model_path/models/tableA/generated.rs b/test/custom_model_path/models/tableA/generated.rs index 1ef02b7c..149490b8 100644 --- a/test/custom_model_path/models/tableA/generated.rs +++ b/test/custom_model_path/models/tableA/generated.rs @@ -46,28 +46,58 @@ impl TableA { tableA.filter(_id.eq(param__id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TableAFilter) -> QueryResult> { use crate::schema::tableA::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = tableA.count().get_result(db)?; - let items = tableA.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TableAFilter, + ) -> crate::schema::tableA::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::tableA::table.into_boxed(); + + + if let Some(filter__id) = filter._id.clone() { + query = query.filter(crate::schema::tableA::_id.eq(filter__id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param__id: i32) -> QueryResult { use crate::schema::tableA::dsl::*; diesel::delete(tableA.filter(_id.eq(param__id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TableAFilter { + pub _id: Option, +} + +impl Default for TableAFilter { + fn default() -> TableAFilter { + TableAFilter { + _id: None, + } + } +} diff --git a/test/custom_model_path/models/tableB/generated.rs b/test/custom_model_path/models/tableB/generated.rs index 5ccec4ac..3244c59e 100644 --- a/test/custom_model_path/models/tableB/generated.rs +++ b/test/custom_model_path/models/tableB/generated.rs @@ -53,24 +53,45 @@ impl TableB { tableB.filter(_id.eq(param__id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TableBFilter) -> QueryResult> { use crate::schema::tableB::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = tableB.count().get_result(db)?; - let items = tableB.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TableBFilter, + ) -> crate::schema::tableB::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::tableB::table.into_boxed(); + + + if let Some(filter__id) = filter._id.clone() { + query = query.filter(crate::schema::tableB::_id.eq(filter__id)); + } + if let Some(filter_link) = filter.link.clone() { + query = query.filter(crate::schema::tableB::link.eq(filter_link)); + } + + query + } + pub fn update(db: &mut ConnectionType, param__id: i32, item: &UpdateTableB) -> QueryResult { use crate::schema::tableB::dsl::*; @@ -83,4 +104,18 @@ impl TableB { diesel::delete(tableB.filter(_id.eq(param__id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TableBFilter { + pub _id: Option, + pub link: Option, +} + +impl Default for TableBFilter { + fn default() -> TableBFilter { + TableBFilter { + _id: None, + link: None, + } + } +} diff --git a/test/manual_primary_keys/models/todos/generated.rs b/test/manual_primary_keys/models/todos/generated.rs index 4bcdb7f0..82cca02f 100644 --- a/test/manual_primary_keys/models/todos/generated.rs +++ b/test/manual_primary_keys/models/todos/generated.rs @@ -46,28 +46,58 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = todos.count().get_result(db)?; - let items = todos.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TodosFilter, + ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::todos::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::todos::id.eq(filter_id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param_id: i32) -> QueryResult { use crate::schema::todos::dsl::*; diesel::delete(todos.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TodosFilter { + pub id: Option, +} + +impl Default for TodosFilter { + fn default() -> TodosFilter { + TodosFilter { + id: None, + } + } +} diff --git a/test/multiple_primary_keys/models/users/generated.rs b/test/multiple_primary_keys/models/users/generated.rs index 579d05d3..84054340 100644 --- a/test/multiple_primary_keys/models/users/generated.rs +++ b/test/multiple_primary_keys/models/users/generated.rs @@ -55,24 +55,48 @@ impl Users { users.filter(name.eq(param_name)).filter(address.eq(param_address)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: UsersFilter) -> QueryResult> { use crate::schema::users::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = users.count().get_result(db)?; - let items = users.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: UsersFilter, + ) -> crate::schema::users::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::users::table.into_boxed(); + + + if let Some(filter_name) = filter.name.clone() { + query = query.filter(crate::schema::users::name.eq(filter_name)); + } + if let Some(filter_address) = filter.address.clone() { + query = query.filter(crate::schema::users::address.eq(filter_address)); + } + if let Some(filter_secret) = filter.secret.clone() { + query = query.filter(crate::schema::users::secret.eq(filter_secret)); + } + + query + } + pub fn update(db: &mut ConnectionType, param_name: String, param_address: String, item: &UpdateUsers) -> QueryResult { use crate::schema::users::dsl::*; @@ -85,4 +109,20 @@ impl Users { diesel::delete(users.filter(name.eq(param_name)).filter(address.eq(param_address))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct UsersFilter { + pub name: Option, + pub address: Option, + pub secret: Option, +} + +impl Default for UsersFilter { + fn default() -> UsersFilter { + UsersFilter { + name: None, + address: None, + secret: None, + } + } +} diff --git a/test/once_common_structs/models/table1/generated.rs b/test/once_common_structs/models/table1/generated.rs index 9fb85dee..7c785853 100644 --- a/test/once_common_structs/models/table1/generated.rs +++ b/test/once_common_structs/models/table1/generated.rs @@ -32,28 +32,58 @@ impl Table1 { table1.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table1Filter) -> QueryResult> { use crate::schema::table1::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = table1.count().get_result(db)?; - let items = table1.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: Table1Filter, + ) -> crate::schema::table1::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::table1::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::table1::id.eq(filter_id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param_id: crate::schema::sql_types::Int) -> QueryResult { use crate::schema::table1::dsl::*; diesel::delete(table1.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct Table1Filter { + pub id: Option, +} + +impl Default for Table1Filter { + fn default() -> Table1Filter { + Table1Filter { + id: None, + } + } +} diff --git a/test/once_common_structs/models/table2/generated.rs b/test/once_common_structs/models/table2/generated.rs index 39a45fdc..c8d168f6 100644 --- a/test/once_common_structs/models/table2/generated.rs +++ b/test/once_common_structs/models/table2/generated.rs @@ -32,28 +32,58 @@ impl Table2 { table2.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table2Filter) -> QueryResult> { use crate::schema::table2::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = table2.count().get_result(db)?; - let items = table2.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: Table2Filter, + ) -> crate::schema::table2::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::table2::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::table2::id.eq(filter_id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param_id: crate::schema::sql_types::Int) -> QueryResult { use crate::schema::table2::dsl::*; diesel::delete(table2.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct Table2Filter { + pub id: Option, +} + +impl Default for Table2Filter { + fn default() -> Table2Filter { + Table2Filter { + id: None, + } + } +} diff --git a/test/once_common_structs_once_connection_type/models/table1/generated.rs b/test/once_common_structs_once_connection_type/models/table1/generated.rs index bbf169af..18b78dbb 100644 --- a/test/once_common_structs_once_connection_type/models/table1/generated.rs +++ b/test/once_common_structs_once_connection_type/models/table1/generated.rs @@ -29,28 +29,58 @@ impl Table1 { table1.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table1Filter) -> QueryResult> { use crate::schema::table1::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = table1.count().get_result(db)?; - let items = table1.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: Table1Filter, + ) -> crate::schema::table1::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::table1::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::table1::id.eq(filter_id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param_id: crate::schema::sql_types::Int) -> QueryResult { use crate::schema::table1::dsl::*; diesel::delete(table1.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct Table1Filter { + pub id: Option, +} + +impl Default for Table1Filter { + fn default() -> Table1Filter { + Table1Filter { + id: None, + } + } +} diff --git a/test/once_common_structs_once_connection_type/models/table2/generated.rs b/test/once_common_structs_once_connection_type/models/table2/generated.rs index f7b2425b..4c296f08 100644 --- a/test/once_common_structs_once_connection_type/models/table2/generated.rs +++ b/test/once_common_structs_once_connection_type/models/table2/generated.rs @@ -29,28 +29,58 @@ impl Table2 { table2.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table2Filter) -> QueryResult> { use crate::schema::table2::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = table2.count().get_result(db)?; - let items = table2.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: Table2Filter, + ) -> crate::schema::table2::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::table2::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::table2::id.eq(filter_id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param_id: crate::schema::sql_types::Int) -> QueryResult { use crate::schema::table2::dsl::*; diesel::delete(table2.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct Table2Filter { + pub id: Option, +} + +impl Default for Table2Filter { + fn default() -> Table2Filter { + Table2Filter { + id: None, + } + } +} diff --git a/test/once_common_structs_once_connection_type_single_file/models/table1.rs b/test/once_common_structs_once_connection_type_single_file/models/table1.rs index bbf169af..18b78dbb 100644 --- a/test/once_common_structs_once_connection_type_single_file/models/table1.rs +++ b/test/once_common_structs_once_connection_type_single_file/models/table1.rs @@ -29,28 +29,58 @@ impl Table1 { table1.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table1Filter) -> QueryResult> { use crate::schema::table1::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = table1.count().get_result(db)?; - let items = table1.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: Table1Filter, + ) -> crate::schema::table1::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::table1::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::table1::id.eq(filter_id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param_id: crate::schema::sql_types::Int) -> QueryResult { use crate::schema::table1::dsl::*; diesel::delete(table1.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct Table1Filter { + pub id: Option, +} + +impl Default for Table1Filter { + fn default() -> Table1Filter { + Table1Filter { + id: None, + } + } +} diff --git a/test/once_common_structs_once_connection_type_single_file/models/table2.rs b/test/once_common_structs_once_connection_type_single_file/models/table2.rs index f7b2425b..4c296f08 100644 --- a/test/once_common_structs_once_connection_type_single_file/models/table2.rs +++ b/test/once_common_structs_once_connection_type_single_file/models/table2.rs @@ -29,28 +29,58 @@ impl Table2 { table2.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table2Filter) -> QueryResult> { use crate::schema::table2::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = table2.count().get_result(db)?; - let items = table2.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: Table2Filter, + ) -> crate::schema::table2::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::table2::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::table2::id.eq(filter_id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param_id: crate::schema::sql_types::Int) -> QueryResult { use crate::schema::table2::dsl::*; diesel::delete(table2.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct Table2Filter { + pub id: Option, +} + +impl Default for Table2Filter { + fn default() -> Table2Filter { + Table2Filter { + id: None, + } + } +} diff --git a/test/once_connection_type/models/table1/generated.rs b/test/once_connection_type/models/table1/generated.rs index 9a7a44e1..c8c5bbc1 100644 --- a/test/once_connection_type/models/table1/generated.rs +++ b/test/once_connection_type/models/table1/generated.rs @@ -39,28 +39,58 @@ impl Table1 { table1.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table1Filter) -> QueryResult> { use crate::schema::table1::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = table1.count().get_result(db)?; - let items = table1.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: Table1Filter, + ) -> crate::schema::table1::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::table1::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::table1::id.eq(filter_id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param_id: crate::schema::sql_types::Int) -> QueryResult { use crate::schema::table1::dsl::*; diesel::delete(table1.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct Table1Filter { + pub id: Option, +} + +impl Default for Table1Filter { + fn default() -> Table1Filter { + Table1Filter { + id: None, + } + } +} diff --git a/test/once_connection_type/models/table2/generated.rs b/test/once_connection_type/models/table2/generated.rs index 4e1b27a8..5a8d92d7 100644 --- a/test/once_connection_type/models/table2/generated.rs +++ b/test/once_connection_type/models/table2/generated.rs @@ -39,28 +39,58 @@ impl Table2 { table2.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table2Filter) -> QueryResult> { use crate::schema::table2::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = table2.count().get_result(db)?; - let items = table2.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: Table2Filter, + ) -> crate::schema::table2::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::table2::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::table2::id.eq(filter_id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param_id: crate::schema::sql_types::Int) -> QueryResult { use crate::schema::table2::dsl::*; diesel::delete(table2.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct Table2Filter { + pub id: Option, +} + +impl Default for Table2Filter { + fn default() -> Table2Filter { + Table2Filter { + id: None, + } + } +} diff --git a/test/simple_table/models/todos/generated.rs b/test/simple_table/models/todos/generated.rs index 13f8da2e..154b2050 100644 --- a/test/simple_table/models/todos/generated.rs +++ b/test/simple_table/models/todos/generated.rs @@ -68,24 +68,63 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = todos.count().get_result(db)?; - let items = todos.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TodosFilter, + ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::todos::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::todos::id.eq(filter_id)); + } + if let Some(filter_unsigned) = filter.unsigned.clone() { + query = query.filter(crate::schema::todos::unsigned.eq(filter_unsigned)); + } + if let Some(filter_unsigned_nullable) = filter.unsigned_nullable.clone() { + query = query.filter(crate::schema::todos::unsigned_nullable.eq(filter_unsigned_nullable)); + } + if let Some(filter_text) = filter.text.clone() { + query = query.filter(crate::schema::todos::text.eq(filter_text)); + } + if let Some(filter_completed) = filter.completed.clone() { + query = query.filter(crate::schema::todos::completed.eq(filter_completed)); + } + if let Some(filter_type_) = filter.type_.clone() { + query = query.filter(crate::schema::todos::type_.eq(filter_type_)); + } + if let Some(filter_created_at) = filter.created_at.clone() { + query = query.filter(crate::schema::todos::created_at.eq(filter_created_at)); + } + if let Some(filter_updated_at) = filter.updated_at.clone() { + query = query.filter(crate::schema::todos::updated_at.eq(filter_updated_at)); + } + + query + } + pub fn update(db: &mut ConnectionType, param_id: i32, item: &UpdateTodos) -> QueryResult { use crate::schema::todos::dsl::*; @@ -98,4 +137,30 @@ impl Todos { diesel::delete(todos.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TodosFilter { + pub id: Option, + pub unsigned: Option, + pub unsigned_nullable: Option>, + pub text: Option, + pub completed: Option, + pub type_: Option, + pub created_at: Option>, + pub updated_at: Option>, +} + +impl Default for TodosFilter { + fn default() -> TodosFilter { + TodosFilter { + id: None, + unsigned: None, + unsigned_nullable: None, + text: None, + completed: None, + type_: None, + created_at: None, + updated_at: None, + } + } +} diff --git a/test/simple_table_async/models/todos/generated.rs b/test/simple_table_async/models/todos/generated.rs index e75d4fb6..09482f02 100644 --- a/test/simple_table_async/models/todos/generated.rs +++ b/test/simple_table_async/models/todos/generated.rs @@ -63,24 +63,57 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db).await } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub async fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub async fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = todos.count().get_result(db).await?; - let items = todos.limit(page_size).offset(page * page_size).load::(db).await?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db).await?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TodosFilter, + ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::todos::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::todos::id.eq(filter_id)); + } + if let Some(filter_unsigned) = filter.unsigned.clone() { + query = query.filter(crate::schema::todos::unsigned.eq(filter_unsigned)); + } + if let Some(filter_text) = filter.text.clone() { + query = query.filter(crate::schema::todos::text.eq(filter_text)); + } + if let Some(filter_completed) = filter.completed.clone() { + query = query.filter(crate::schema::todos::completed.eq(filter_completed)); + } + if let Some(filter_created_at) = filter.created_at.clone() { + query = query.filter(crate::schema::todos::created_at.eq(filter_created_at)); + } + if let Some(filter_updated_at) = filter.updated_at.clone() { + query = query.filter(crate::schema::todos::updated_at.eq(filter_updated_at)); + } + + query + } + pub async fn update(db: &mut ConnectionType, param_id: i32, item: &UpdateTodos) -> QueryResult { use crate::schema::todos::dsl::*; @@ -93,4 +126,26 @@ impl Todos { diesel::delete(todos.filter(id.eq(param_id))).execute(db).await } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TodosFilter { + pub id: Option, + pub unsigned: Option, + pub text: Option, + pub completed: Option, + pub created_at: Option>, + pub updated_at: Option>, +} + +impl Default for TodosFilter { + fn default() -> TodosFilter { + TodosFilter { + id: None, + unsigned: None, + text: None, + completed: None, + created_at: None, + updated_at: None, + } + } +} diff --git a/test/simple_table_custom_schema_path/models/todos/generated.rs b/test/simple_table_custom_schema_path/models/todos/generated.rs index faea7dd0..2f84a925 100644 --- a/test/simple_table_custom_schema_path/models/todos/generated.rs +++ b/test/simple_table_custom_schema_path/models/todos/generated.rs @@ -62,24 +62,57 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::data::schema::todos::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = todos.count().get_result(db)?; - let items = todos.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TodosFilter, + ) -> crate::data::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::data::schema::todos::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::data::schema::todos::id.eq(filter_id)); + } + if let Some(filter_unsigned) = filter.unsigned.clone() { + query = query.filter(crate::data::schema::todos::unsigned.eq(filter_unsigned)); + } + if let Some(filter_text) = filter.text.clone() { + query = query.filter(crate::data::schema::todos::text.eq(filter_text)); + } + if let Some(filter_completed) = filter.completed.clone() { + query = query.filter(crate::data::schema::todos::completed.eq(filter_completed)); + } + if let Some(filter_created_at) = filter.created_at.clone() { + query = query.filter(crate::data::schema::todos::created_at.eq(filter_created_at)); + } + if let Some(filter_updated_at) = filter.updated_at.clone() { + query = query.filter(crate::data::schema::todos::updated_at.eq(filter_updated_at)); + } + + query + } + pub fn update(db: &mut ConnectionType, param_id: i32, item: &UpdateTodos) -> QueryResult { use crate::data::schema::todos::dsl::*; @@ -92,4 +125,26 @@ impl Todos { diesel::delete(todos.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TodosFilter { + pub id: Option, + pub unsigned: Option, + pub text: Option, + pub completed: Option, + pub created_at: Option>, + pub updated_at: Option>, +} + +impl Default for TodosFilter { + fn default() -> TodosFilter { + TodosFilter { + id: None, + unsigned: None, + text: None, + completed: None, + created_at: None, + updated_at: None, + } + } +} diff --git a/test/simple_table_no_serde/models/todos/generated.rs b/test/simple_table_no_serde/models/todos/generated.rs index 2e7676ea..af2db11b 100644 --- a/test/simple_table_no_serde/models/todos/generated.rs +++ b/test/simple_table_no_serde/models/todos/generated.rs @@ -62,24 +62,57 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = todos.count().get_result(db)?; - let items = todos.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TodosFilter, + ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::todos::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::todos::id.eq(filter_id)); + } + if let Some(filter_unsigned) = filter.unsigned.clone() { + query = query.filter(crate::schema::todos::unsigned.eq(filter_unsigned)); + } + if let Some(filter_text) = filter.text.clone() { + query = query.filter(crate::schema::todos::text.eq(filter_text)); + } + if let Some(filter_completed) = filter.completed.clone() { + query = query.filter(crate::schema::todos::completed.eq(filter_completed)); + } + if let Some(filter_created_at) = filter.created_at.clone() { + query = query.filter(crate::schema::todos::created_at.eq(filter_created_at)); + } + if let Some(filter_updated_at) = filter.updated_at.clone() { + query = query.filter(crate::schema::todos::updated_at.eq(filter_updated_at)); + } + + query + } + pub fn update(db: &mut ConnectionType, param_id: i32, item: &UpdateTodos) -> QueryResult { use crate::schema::todos::dsl::*; @@ -92,4 +125,26 @@ impl Todos { diesel::delete(todos.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TodosFilter { + pub id: Option, + pub unsigned: Option, + pub text: Option, + pub completed: Option, + pub created_at: Option>, + pub updated_at: Option>, +} + +impl Default for TodosFilter { + fn default() -> TodosFilter { + TodosFilter { + id: None, + unsigned: None, + text: None, + completed: None, + created_at: None, + updated_at: None, + } + } +} diff --git a/test/single_model_file/models/table1.rs b/test/single_model_file/models/table1.rs index e202479b..e4673af0 100644 --- a/test/single_model_file/models/table1.rs +++ b/test/single_model_file/models/table1.rs @@ -41,28 +41,58 @@ impl Table1 { table1.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table1Filter) -> QueryResult> { use crate::schema::table1::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = table1.count().get_result(db)?; - let items = table1.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: Table1Filter, + ) -> crate::schema::table1::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::table1::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::table1::id.eq(filter_id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param_id: crate::schema::sql_types::Int) -> QueryResult { use crate::schema::table1::dsl::*; diesel::delete(table1.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct Table1Filter { + pub id: Option, +} + +impl Default for Table1Filter { + fn default() -> Table1Filter { + Table1Filter { + id: None, + } + } +} diff --git a/test/single_model_file/models/table2.rs b/test/single_model_file/models/table2.rs index f87ab9db..881e8f1e 100644 --- a/test/single_model_file/models/table2.rs +++ b/test/single_model_file/models/table2.rs @@ -41,28 +41,58 @@ impl Table2 { table2.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table2Filter) -> QueryResult> { use crate::schema::table2::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = table2.count().get_result(db)?; - let items = table2.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: Table2Filter, + ) -> crate::schema::table2::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::table2::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::table2::id.eq(filter_id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param_id: crate::schema::sql_types::Int) -> QueryResult { use crate::schema::table2::dsl::*; diesel::delete(table2.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct Table2Filter { + pub id: Option, +} + +impl Default for Table2Filter { + fn default() -> Table2Filter { + Table2Filter { + id: None, + } + } +} diff --git a/test/use_statements/models/fang_tasks/generated.rs b/test/use_statements/models/fang_tasks/generated.rs index 7323a394..af8668a1 100644 --- a/test/use_statements/models/fang_tasks/generated.rs +++ b/test/use_statements/models/fang_tasks/generated.rs @@ -77,24 +77,69 @@ impl FangTasks { fang_tasks.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: FangTasksFilter) -> QueryResult> { use crate::schema::fang_tasks::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = fang_tasks.count().get_result(db)?; - let items = fang_tasks.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: FangTasksFilter, + ) -> crate::schema::fang_tasks::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::fang_tasks::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::fang_tasks::id.eq(filter_id)); + } + if let Some(filter_metadata) = filter.metadata.clone() { + query = query.filter(crate::schema::fang_tasks::metadata.eq(filter_metadata)); + } + if let Some(filter_error_message) = filter.error_message.clone() { + query = query.filter(crate::schema::fang_tasks::error_message.eq(filter_error_message)); + } + if let Some(filter_state) = filter.state.clone() { + query = query.filter(crate::schema::fang_tasks::state.eq(filter_state)); + } + if let Some(filter_task_type) = filter.task_type.clone() { + query = query.filter(crate::schema::fang_tasks::task_type.eq(filter_task_type)); + } + if let Some(filter_uniq_hash) = filter.uniq_hash.clone() { + query = query.filter(crate::schema::fang_tasks::uniq_hash.eq(filter_uniq_hash)); + } + if let Some(filter_retries) = filter.retries.clone() { + query = query.filter(crate::schema::fang_tasks::retries.eq(filter_retries)); + } + if let Some(filter_scheduled_at) = filter.scheduled_at.clone() { + query = query.filter(crate::schema::fang_tasks::scheduled_at.eq(filter_scheduled_at)); + } + if let Some(filter_created_at) = filter.created_at.clone() { + query = query.filter(crate::schema::fang_tasks::created_at.eq(filter_created_at)); + } + if let Some(filter_updated_at) = filter.updated_at.clone() { + query = query.filter(crate::schema::fang_tasks::updated_at.eq(filter_updated_at)); + } + + query + } + pub fn update(db: &mut ConnectionType, param_id: uuid::Uuid, item: &UpdateFangTasks) -> QueryResult { use crate::schema::fang_tasks::dsl::*; @@ -107,4 +152,34 @@ impl FangTasks { diesel::delete(fang_tasks.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct FangTasksFilter { + pub id: Option, + pub metadata: Option, + pub error_message: Option>, + pub state: Option, + pub task_type: Option, + pub uniq_hash: Option>, + pub retries: Option, + pub scheduled_at: Option>, + pub created_at: Option>, + pub updated_at: Option>, +} + +impl Default for FangTasksFilter { + fn default() -> FangTasksFilter { + FangTasksFilter { + id: None, + metadata: None, + error_message: None, + state: None, + task_type: None, + uniq_hash: None, + retries: None, + scheduled_at: None, + created_at: None, + updated_at: None, + } + } +} From c3dbfaa00d116fb133da09d299b42dc4b112d831 Mon Sep 17 00:00:00 2001 From: Haris <4259838+Wulf@users.noreply.github.com> Date: Sat, 28 Oct 2023 18:57:29 -0400 Subject: [PATCH 2/6] Fix compilation issue --- src/code.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/code.rs b/src/code.rs index 4501cfc5..b21aa9ee 100644 --- a/src/code.rs +++ b/src/code.rs @@ -583,7 +583,7 @@ pub struct PaginationResult {{ }} "##, serde_derive = if table_options.get_serde() { - "Serialize" + "serde::Serialize" } else { "" } From cc0ecf2c22ef13190801f2207ddd265d1a0be86b Mon Sep 17 00:00:00 2001 From: Haris <4259838+Wulf@users.noreply.github.com> Date: Sat, 28 Oct 2023 18:59:56 -0400 Subject: [PATCH 3/6] Another compilation issue --- src/code.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/code.rs b/src/code.rs index b21aa9ee..9968f4a2 100644 --- a/src/code.rs +++ b/src/code.rs @@ -593,7 +593,7 @@ pub struct PaginationResult {{ /// Generate connection-type type pub fn generate_connection_type(config: &GenerationConfig) -> String { format!( - "\ntype ConnectionType = {connection_type};", + "\npub type ConnectionType = {connection_type};", connection_type = config.connection_type, ) } From dc072745dd7ee64491ed15ec89c57c19433f1893 Mon Sep 17 00:00:00 2001 From: Haris <4259838+Wulf@users.noreply.github.com> Date: Sat, 28 Oct 2023 19:03:01 -0400 Subject: [PATCH 4/6] BREAKING: Remove tsync from the default feature set --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index fcb93c0d..cb11d340 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -11,7 +11,7 @@ authors = ["Haris <4259838+Wulf@users.noreply.github.com>"] edition = "2021" [features] -default = ["tsync", "backtrace"] +default = ["backtrace"] tsync = [] async = [] backtrace = [] From e47070c310ca5026fedec34d00e17e8b096bd22e Mon Sep 17 00:00:00 2001 From: Haris <4259838+Wulf@users.noreply.github.com> Date: Sat, 28 Oct 2023 19:04:16 -0400 Subject: [PATCH 5/6] Add Default implementation for GenerationConfig --- src/lib.rs | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/src/lib.rs b/src/lib.rs index 0fc0c769..d3667343 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -248,6 +248,21 @@ pub struct GenerationConfig<'a> { pub once_connection_type: bool, } +impl<'a> Default for GenerationConfig<'a> { + fn default() -> Self { + Self { + table_options: Default::default(), + default_table_options: Default::default(), + connection_type: "diesel::pg::PgConnection".into(), + diesel_backend: "diesel::pg::Pg".into(), + schema_path: "crate::schema::".into(), + model_path: "crate::models::".into(), + once_common_structs: true, + once_connection_type: true, + } + } +} + impl GenerationConfig<'_> { pub fn table(&self, name: &str) -> TableOptions<'_> { let t = self From 9e7a27a719950c60c317588de99840b0e0bcf660 Mon Sep 17 00:00:00 2001 From: Haris <4259838+Wulf@users.noreply.github.com> Date: Sat, 28 Oct 2023 19:05:40 -0400 Subject: [PATCH 6/6] Generate test diffs --- test/autogenerated_all/models/todos/generated.rs | 4 ++-- test/autogenerated_attributes/models/todos/generated.rs | 4 ++-- test/autogenerated_primary_keys/models/todos/generated.rs | 4 ++-- test/cleanup_generated_content/models/todos/generated.rs | 4 ++-- test/create_update_str_cow/models/todos/generated.rs | 4 ++-- test/create_update_str_str/models/todos/generated.rs | 4 ++-- test/custom_model_and_schema_path/models/tableA/generated.rs | 4 ++-- test/custom_model_and_schema_path/models/tableB/generated.rs | 4 ++-- test/custom_model_path/models/tableA/generated.rs | 4 ++-- test/custom_model_path/models/tableB/generated.rs | 4 ++-- test/manual_primary_keys/models/todos/generated.rs | 4 ++-- test/multiple_primary_keys/models/users/generated.rs | 4 ++-- test/once_common_structs/models/common.rs | 2 +- test/once_common_structs/models/table1/generated.rs | 2 +- test/once_common_structs/models/table2/generated.rs | 2 +- .../once_common_structs_once_connection_type/models/common.rs | 4 ++-- .../models/common.rs | 4 ++-- test/once_connection_type/models/common.rs | 2 +- test/once_connection_type/models/table1/generated.rs | 2 +- test/once_connection_type/models/table2/generated.rs | 2 +- test/simple_table/models/todos/generated.rs | 4 ++-- test/simple_table_async/models/todos/generated.rs | 4 ++-- .../simple_table_custom_schema_path/models/todos/generated.rs | 4 ++-- test/simple_table_no_serde/models/todos/generated.rs | 2 +- test/single_model_file/models/table1.rs | 4 ++-- test/single_model_file/models/table2.rs | 4 ++-- test/use_statements/models/fang_tasks/generated.rs | 4 ++-- 27 files changed, 47 insertions(+), 47 deletions(-) diff --git a/test/autogenerated_all/models/todos/generated.rs b/test/autogenerated_all/models/todos/generated.rs index 9a75dae0..b62267c5 100644 --- a/test/autogenerated_all/models/todos/generated.rs +++ b/test/autogenerated_all/models/todos/generated.rs @@ -6,7 +6,7 @@ use diesel::QueryResult; use serde::{Deserialize, Serialize}; -type ConnectionType = diesel::r2d2::PooledConnection>; +pub type ConnectionType = diesel::r2d2::PooledConnection>; #[derive(Debug, Serialize, Deserialize, Clone, Queryable, Insertable, AsChangeset, Selectable)] #[diesel(table_name=todos, primary_key(id))] @@ -23,7 +23,7 @@ pub struct UpdateTodos { } -#[derive(Debug, Serialize)] +#[derive(Debug, serde::Serialize)] pub struct PaginationResult { pub items: Vec, pub total_items: i64, diff --git a/test/autogenerated_attributes/models/todos/generated.rs b/test/autogenerated_attributes/models/todos/generated.rs index bf66d653..b6ed300d 100644 --- a/test/autogenerated_attributes/models/todos/generated.rs +++ b/test/autogenerated_attributes/models/todos/generated.rs @@ -6,7 +6,7 @@ use diesel::QueryResult; use serde::{Deserialize, Serialize}; -type ConnectionType = diesel::r2d2::PooledConnection>; +pub type ConnectionType = diesel::r2d2::PooledConnection>; #[derive(Debug, Serialize, Deserialize, Clone, Queryable, Insertable, AsChangeset, Selectable)] #[diesel(table_name=todos, primary_key(id))] @@ -28,7 +28,7 @@ pub struct UpdateTodos { } -#[derive(Debug, Serialize)] +#[derive(Debug, serde::Serialize)] pub struct PaginationResult { pub items: Vec, pub total_items: i64, diff --git a/test/autogenerated_primary_keys/models/todos/generated.rs b/test/autogenerated_primary_keys/models/todos/generated.rs index 040f0d36..7da88634 100644 --- a/test/autogenerated_primary_keys/models/todos/generated.rs +++ b/test/autogenerated_primary_keys/models/todos/generated.rs @@ -6,7 +6,7 @@ use diesel::QueryResult; use serde::{Deserialize, Serialize}; -type ConnectionType = diesel::r2d2::PooledConnection>; +pub type ConnectionType = diesel::r2d2::PooledConnection>; #[derive(Debug, Serialize, Deserialize, Clone, Queryable, Insertable, AsChangeset, Selectable)] #[diesel(table_name=todos, primary_key(id))] @@ -28,7 +28,7 @@ pub struct UpdateTodos { } -#[derive(Debug, Serialize)] +#[derive(Debug, serde::Serialize)] pub struct PaginationResult { pub items: Vec, pub total_items: i64, diff --git a/test/cleanup_generated_content/models/todos/generated.rs b/test/cleanup_generated_content/models/todos/generated.rs index 96eee3da..311b7480 100644 --- a/test/cleanup_generated_content/models/todos/generated.rs +++ b/test/cleanup_generated_content/models/todos/generated.rs @@ -6,7 +6,7 @@ use diesel::QueryResult; use serde::{Deserialize, Serialize}; -type ConnectionType = diesel::r2d2::PooledConnection>; +pub type ConnectionType = diesel::r2d2::PooledConnection>; #[derive(Debug, Serialize, Deserialize, Clone, Queryable, Insertable, AsChangeset, Selectable)] #[diesel(table_name=todos, primary_key(id))] @@ -36,7 +36,7 @@ pub struct UpdateTodos { } -#[derive(Debug, Serialize)] +#[derive(Debug, serde::Serialize)] pub struct PaginationResult { pub items: Vec, pub total_items: i64, diff --git a/test/create_update_str_cow/models/todos/generated.rs b/test/create_update_str_cow/models/todos/generated.rs index 06700656..10bfd3ff 100644 --- a/test/create_update_str_cow/models/todos/generated.rs +++ b/test/create_update_str_cow/models/todos/generated.rs @@ -6,7 +6,7 @@ use diesel::QueryResult; use serde::{Deserialize, Serialize}; -type ConnectionType = diesel::r2d2::PooledConnection>; +pub type ConnectionType = diesel::r2d2::PooledConnection>; #[derive(Debug, Serialize, Deserialize, Clone, Queryable, Insertable, AsChangeset, Selectable)] #[diesel(table_name=todos, primary_key(text))] @@ -35,7 +35,7 @@ pub struct UpdateTodos<'a> { } -#[derive(Debug, Serialize)] +#[derive(Debug, serde::Serialize)] pub struct PaginationResult { pub items: Vec, pub total_items: i64, diff --git a/test/create_update_str_str/models/todos/generated.rs b/test/create_update_str_str/models/todos/generated.rs index 986b149a..f68f1ac4 100644 --- a/test/create_update_str_str/models/todos/generated.rs +++ b/test/create_update_str_str/models/todos/generated.rs @@ -6,7 +6,7 @@ use diesel::QueryResult; use serde::{Deserialize, Serialize}; -type ConnectionType = diesel::r2d2::PooledConnection>; +pub type ConnectionType = diesel::r2d2::PooledConnection>; #[derive(Debug, Serialize, Deserialize, Clone, Queryable, Insertable, AsChangeset, Selectable)] #[diesel(table_name=todos, primary_key(text))] @@ -35,7 +35,7 @@ pub struct UpdateTodos<'a> { } -#[derive(Debug, Serialize)] +#[derive(Debug, serde::Serialize)] pub struct PaginationResult { pub items: Vec, pub total_items: i64, diff --git a/test/custom_model_and_schema_path/models/tableA/generated.rs b/test/custom_model_and_schema_path/models/tableA/generated.rs index 70bf9ab8..42e84f02 100644 --- a/test/custom_model_and_schema_path/models/tableA/generated.rs +++ b/test/custom_model_and_schema_path/models/tableA/generated.rs @@ -6,7 +6,7 @@ use diesel::QueryResult; use serde::{Deserialize, Serialize}; -type ConnectionType = diesel::r2d2::PooledConnection>; +pub type ConnectionType = diesel::r2d2::PooledConnection>; #[derive(Debug, Serialize, Deserialize, Clone, Queryable, Insertable, Selectable)] #[diesel(table_name=tableA, primary_key(_id))] @@ -22,7 +22,7 @@ pub struct CreateTableA { -#[derive(Debug, Serialize)] +#[derive(Debug, serde::Serialize)] pub struct PaginationResult { pub items: Vec, pub total_items: i64, diff --git a/test/custom_model_and_schema_path/models/tableB/generated.rs b/test/custom_model_and_schema_path/models/tableB/generated.rs index 604827c3..e4b6fbd6 100644 --- a/test/custom_model_and_schema_path/models/tableB/generated.rs +++ b/test/custom_model_and_schema_path/models/tableB/generated.rs @@ -6,7 +6,7 @@ use diesel::QueryResult; use serde::{Deserialize, Serialize}; use crate::data::models::table_a::TableA; -type ConnectionType = diesel::r2d2::PooledConnection>; +pub type ConnectionType = diesel::r2d2::PooledConnection>; #[derive(Debug, Serialize, Deserialize, Clone, Queryable, Insertable, AsChangeset, Identifiable, Associations, Selectable)] #[diesel(table_name=tableB, primary_key(_id), belongs_to(TableA, foreign_key=link))] @@ -29,7 +29,7 @@ pub struct UpdateTableB { } -#[derive(Debug, Serialize)] +#[derive(Debug, serde::Serialize)] pub struct PaginationResult { pub items: Vec, pub total_items: i64, diff --git a/test/custom_model_path/models/tableA/generated.rs b/test/custom_model_path/models/tableA/generated.rs index 149490b8..db9d6c50 100644 --- a/test/custom_model_path/models/tableA/generated.rs +++ b/test/custom_model_path/models/tableA/generated.rs @@ -6,7 +6,7 @@ use diesel::QueryResult; use serde::{Deserialize, Serialize}; -type ConnectionType = diesel::r2d2::PooledConnection>; +pub type ConnectionType = diesel::r2d2::PooledConnection>; #[derive(Debug, Serialize, Deserialize, Clone, Queryable, Insertable, Selectable)] #[diesel(table_name=tableA, primary_key(_id))] @@ -22,7 +22,7 @@ pub struct CreateTableA { -#[derive(Debug, Serialize)] +#[derive(Debug, serde::Serialize)] pub struct PaginationResult { pub items: Vec, pub total_items: i64, diff --git a/test/custom_model_path/models/tableB/generated.rs b/test/custom_model_path/models/tableB/generated.rs index 3244c59e..13c4d203 100644 --- a/test/custom_model_path/models/tableB/generated.rs +++ b/test/custom_model_path/models/tableB/generated.rs @@ -6,7 +6,7 @@ use diesel::QueryResult; use serde::{Deserialize, Serialize}; use crate::data::models::table_a::TableA; -type ConnectionType = diesel::r2d2::PooledConnection>; +pub type ConnectionType = diesel::r2d2::PooledConnection>; #[derive(Debug, Serialize, Deserialize, Clone, Queryable, Insertable, AsChangeset, Identifiable, Associations, Selectable)] #[diesel(table_name=tableB, primary_key(_id), belongs_to(TableA, foreign_key=link))] @@ -29,7 +29,7 @@ pub struct UpdateTableB { } -#[derive(Debug, Serialize)] +#[derive(Debug, serde::Serialize)] pub struct PaginationResult { pub items: Vec, pub total_items: i64, diff --git a/test/manual_primary_keys/models/todos/generated.rs b/test/manual_primary_keys/models/todos/generated.rs index 82cca02f..8e62c20b 100644 --- a/test/manual_primary_keys/models/todos/generated.rs +++ b/test/manual_primary_keys/models/todos/generated.rs @@ -6,7 +6,7 @@ use diesel::QueryResult; use serde::{Deserialize, Serialize}; -type ConnectionType = diesel::r2d2::PooledConnection>; +pub type ConnectionType = diesel::r2d2::PooledConnection>; #[derive(Debug, Serialize, Deserialize, Clone, Queryable, Insertable, Selectable)] #[diesel(table_name=todos, primary_key(id))] @@ -22,7 +22,7 @@ pub struct CreateTodos { -#[derive(Debug, Serialize)] +#[derive(Debug, serde::Serialize)] pub struct PaginationResult { pub items: Vec, pub total_items: i64, diff --git a/test/multiple_primary_keys/models/users/generated.rs b/test/multiple_primary_keys/models/users/generated.rs index 84054340..1d1d7d92 100644 --- a/test/multiple_primary_keys/models/users/generated.rs +++ b/test/multiple_primary_keys/models/users/generated.rs @@ -6,7 +6,7 @@ use diesel::QueryResult; use serde::{Deserialize, Serialize}; -type ConnectionType = diesel::r2d2::PooledConnection>; +pub type ConnectionType = diesel::r2d2::PooledConnection>; #[derive(Debug, Serialize, Deserialize, Clone, Queryable, Insertable, AsChangeset, Selectable)] #[diesel(table_name=users, primary_key(name,address))] @@ -31,7 +31,7 @@ pub struct UpdateUsers { } -#[derive(Debug, Serialize)] +#[derive(Debug, serde::Serialize)] pub struct PaginationResult { pub items: Vec, pub total_items: i64, diff --git a/test/once_common_structs/models/common.rs b/test/once_common_structs/models/common.rs index f47c7b10..8465a6a8 100644 --- a/test/once_common_structs/models/common.rs +++ b/test/once_common_structs/models/common.rs @@ -1,5 +1,5 @@ /* @generated and managed by dsync */ -#[derive(Debug, Serialize)] +#[derive(Debug, serde::Serialize)] pub struct PaginationResult { pub items: Vec, pub total_items: i64, diff --git a/test/once_common_structs/models/table1/generated.rs b/test/once_common_structs/models/table1/generated.rs index 7c785853..c35c7722 100644 --- a/test/once_common_structs/models/table1/generated.rs +++ b/test/once_common_structs/models/table1/generated.rs @@ -7,7 +7,7 @@ use crate::models::common::*; use serde::{Deserialize, Serialize}; -type ConnectionType = diesel::r2d2::PooledConnection>; +pub type ConnectionType = diesel::r2d2::PooledConnection>; #[derive(Debug, Serialize, Deserialize, Clone, Queryable, Insertable, Selectable)] #[diesel(table_name=table1, primary_key(id))] diff --git a/test/once_common_structs/models/table2/generated.rs b/test/once_common_structs/models/table2/generated.rs index c8d168f6..6f7857d0 100644 --- a/test/once_common_structs/models/table2/generated.rs +++ b/test/once_common_structs/models/table2/generated.rs @@ -7,7 +7,7 @@ use crate::models::common::*; use serde::{Deserialize, Serialize}; -type ConnectionType = diesel::r2d2::PooledConnection>; +pub type ConnectionType = diesel::r2d2::PooledConnection>; #[derive(Debug, Serialize, Deserialize, Clone, Queryable, Insertable, Selectable)] #[diesel(table_name=table2, primary_key(id))] diff --git a/test/once_common_structs_once_connection_type/models/common.rs b/test/once_common_structs_once_connection_type/models/common.rs index 1e121d61..6461713b 100644 --- a/test/once_common_structs_once_connection_type/models/common.rs +++ b/test/once_common_structs_once_connection_type/models/common.rs @@ -1,5 +1,5 @@ /* @generated and managed by dsync */ -#[derive(Debug, Serialize)] +#[derive(Debug, serde::Serialize)] pub struct PaginationResult { pub items: Vec, pub total_items: i64, @@ -9,4 +9,4 @@ pub struct PaginationResult { pub num_pages: i64, } -type ConnectionType = diesel::r2d2::PooledConnection>; \ No newline at end of file +pub type ConnectionType = diesel::r2d2::PooledConnection>; \ No newline at end of file diff --git a/test/once_common_structs_once_connection_type_single_file/models/common.rs b/test/once_common_structs_once_connection_type_single_file/models/common.rs index 1e121d61..6461713b 100644 --- a/test/once_common_structs_once_connection_type_single_file/models/common.rs +++ b/test/once_common_structs_once_connection_type_single_file/models/common.rs @@ -1,5 +1,5 @@ /* @generated and managed by dsync */ -#[derive(Debug, Serialize)] +#[derive(Debug, serde::Serialize)] pub struct PaginationResult { pub items: Vec, pub total_items: i64, @@ -9,4 +9,4 @@ pub struct PaginationResult { pub num_pages: i64, } -type ConnectionType = diesel::r2d2::PooledConnection>; \ No newline at end of file +pub type ConnectionType = diesel::r2d2::PooledConnection>; \ No newline at end of file diff --git a/test/once_connection_type/models/common.rs b/test/once_connection_type/models/common.rs index 38564fe1..485fdf62 100644 --- a/test/once_connection_type/models/common.rs +++ b/test/once_connection_type/models/common.rs @@ -1,2 +1,2 @@ /* @generated and managed by dsync */ -type ConnectionType = diesel::r2d2::PooledConnection>; \ No newline at end of file +pub type ConnectionType = diesel::r2d2::PooledConnection>; \ No newline at end of file diff --git a/test/once_connection_type/models/table1/generated.rs b/test/once_connection_type/models/table1/generated.rs index c8c5bbc1..48a7965b 100644 --- a/test/once_connection_type/models/table1/generated.rs +++ b/test/once_connection_type/models/table1/generated.rs @@ -15,7 +15,7 @@ pub struct Table1 { -#[derive(Debug, Serialize)] +#[derive(Debug, serde::Serialize)] pub struct PaginationResult { pub items: Vec, pub total_items: i64, diff --git a/test/once_connection_type/models/table2/generated.rs b/test/once_connection_type/models/table2/generated.rs index 5a8d92d7..ff9509e0 100644 --- a/test/once_connection_type/models/table2/generated.rs +++ b/test/once_connection_type/models/table2/generated.rs @@ -15,7 +15,7 @@ pub struct Table2 { -#[derive(Debug, Serialize)] +#[derive(Debug, serde::Serialize)] pub struct PaginationResult { pub items: Vec, pub total_items: i64, diff --git a/test/simple_table/models/todos/generated.rs b/test/simple_table/models/todos/generated.rs index 154b2050..0acaa9e5 100644 --- a/test/simple_table/models/todos/generated.rs +++ b/test/simple_table/models/todos/generated.rs @@ -6,7 +6,7 @@ use diesel::QueryResult; use serde::{Deserialize, Serialize}; -type ConnectionType = diesel::r2d2::PooledConnection>; +pub type ConnectionType = diesel::r2d2::PooledConnection>; #[derive(Debug, Serialize, Deserialize, Clone, Queryable, Insertable, AsChangeset, Selectable)] #[diesel(table_name=todos, primary_key(id))] @@ -44,7 +44,7 @@ pub struct UpdateTodos { } -#[derive(Debug, Serialize)] +#[derive(Debug, serde::Serialize)] pub struct PaginationResult { pub items: Vec, pub total_items: i64, diff --git a/test/simple_table_async/models/todos/generated.rs b/test/simple_table_async/models/todos/generated.rs index 09482f02..99a5e0fa 100644 --- a/test/simple_table_async/models/todos/generated.rs +++ b/test/simple_table_async/models/todos/generated.rs @@ -7,7 +7,7 @@ use serde::{Deserialize, Serialize}; use diesel_async::RunQueryDsl; -type ConnectionType = diesel_async::pooled_connection::deadpool::Object; +pub type ConnectionType = diesel_async::pooled_connection::deadpool::Object; #[derive(Debug, Serialize, Deserialize, Clone, Queryable, Insertable, AsChangeset, Selectable)] #[diesel(table_name=todos, primary_key(id))] @@ -39,7 +39,7 @@ pub struct UpdateTodos { } -#[derive(Debug, Serialize)] +#[derive(Debug, serde::Serialize)] pub struct PaginationResult { pub items: Vec, pub total_items: i64, diff --git a/test/simple_table_custom_schema_path/models/todos/generated.rs b/test/simple_table_custom_schema_path/models/todos/generated.rs index 2f84a925..0c838dee 100644 --- a/test/simple_table_custom_schema_path/models/todos/generated.rs +++ b/test/simple_table_custom_schema_path/models/todos/generated.rs @@ -6,7 +6,7 @@ use diesel::QueryResult; use serde::{Deserialize, Serialize}; -type ConnectionType = diesel::r2d2::PooledConnection>; +pub type ConnectionType = diesel::r2d2::PooledConnection>; #[derive(Debug, Serialize, Deserialize, Clone, Queryable, Insertable, AsChangeset, Selectable)] #[diesel(table_name=todos, primary_key(id))] @@ -38,7 +38,7 @@ pub struct UpdateTodos { } -#[derive(Debug, Serialize)] +#[derive(Debug, serde::Serialize)] pub struct PaginationResult { pub items: Vec, pub total_items: i64, diff --git a/test/simple_table_no_serde/models/todos/generated.rs b/test/simple_table_no_serde/models/todos/generated.rs index af2db11b..1252dbf0 100644 --- a/test/simple_table_no_serde/models/todos/generated.rs +++ b/test/simple_table_no_serde/models/todos/generated.rs @@ -6,7 +6,7 @@ use diesel::QueryResult; -type ConnectionType = diesel::r2d2::PooledConnection>; +pub type ConnectionType = diesel::r2d2::PooledConnection>; #[derive(Debug, Clone, Queryable, Insertable, AsChangeset, Selectable)] #[diesel(table_name=todos, primary_key(id))] diff --git a/test/single_model_file/models/table1.rs b/test/single_model_file/models/table1.rs index e4673af0..0e067273 100644 --- a/test/single_model_file/models/table1.rs +++ b/test/single_model_file/models/table1.rs @@ -6,7 +6,7 @@ use diesel::QueryResult; use serde::{Deserialize, Serialize}; -type ConnectionType = diesel::r2d2::PooledConnection>; +pub type ConnectionType = diesel::r2d2::PooledConnection>; #[derive(Debug, Serialize, Deserialize, Clone, Queryable, Insertable, Selectable)] #[diesel(table_name=table1, primary_key(id))] @@ -17,7 +17,7 @@ pub struct Table1 { -#[derive(Debug, Serialize)] +#[derive(Debug, serde::Serialize)] pub struct PaginationResult { pub items: Vec, pub total_items: i64, diff --git a/test/single_model_file/models/table2.rs b/test/single_model_file/models/table2.rs index 881e8f1e..14eb716a 100644 --- a/test/single_model_file/models/table2.rs +++ b/test/single_model_file/models/table2.rs @@ -6,7 +6,7 @@ use diesel::QueryResult; use serde::{Deserialize, Serialize}; -type ConnectionType = diesel::r2d2::PooledConnection>; +pub type ConnectionType = diesel::r2d2::PooledConnection>; #[derive(Debug, Serialize, Deserialize, Clone, Queryable, Insertable, Selectable)] #[diesel(table_name=table2, primary_key(id))] @@ -17,7 +17,7 @@ pub struct Table2 { -#[derive(Debug, Serialize)] +#[derive(Debug, serde::Serialize)] pub struct PaginationResult { pub items: Vec, pub total_items: i64, diff --git a/test/use_statements/models/fang_tasks/generated.rs b/test/use_statements/models/fang_tasks/generated.rs index af8668a1..52e77c86 100644 --- a/test/use_statements/models/fang_tasks/generated.rs +++ b/test/use_statements/models/fang_tasks/generated.rs @@ -6,7 +6,7 @@ use diesel::QueryResult; use serde::{Deserialize, Serialize}; -type ConnectionType = diesel::r2d2::PooledConnection>; +pub type ConnectionType = diesel::r2d2::PooledConnection>; #[derive(Debug, Serialize, Deserialize, Clone, Queryable, Insertable, AsChangeset, Selectable)] #[diesel(table_name=fang_tasks, primary_key(id))] @@ -53,7 +53,7 @@ pub struct UpdateFangTasks { } -#[derive(Debug, Serialize)] +#[derive(Debug, serde::Serialize)] pub struct PaginationResult { pub items: Vec, pub total_items: i64,