test: change "custom_model_and_schema_path" to be compile-able

Author: hasezoey

Cargo.lock

@@ -52,5 +52,6 @@ members = [
     "test/simple_table_pg",
     "test/simple_table_mysql",
     "test/simple_table_sqlite",
+    "test/custom_model_and_schema_path",
 ]
 resolver = "2"

Cargo.toml

@@ -0,0 +1,16 @@
+[lib]
+path = "lib.rs"
+
+[package]
+name = "custom_model_and_schema_path"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+diesel = { version = "*", default-features = false, features = [
+    "postgres",
+    "chrono",
+] }
+dsync = { path = "../../" }
+chrono = { version = "*", features = ["serde"] }
+serde = { version = "*", features = ["derive"] }

test/custom_model_and_schema_path/Cargo.toml

@@ -0,0 +1,2 @@
+pub mod models;
+pub mod schema;

test/custom_model_and_schema_path/data/mod.rs

@@ -0,0 +1,2 @@
+pub mod table_a;
+pub mod table_b;

test/custom_model_and_schema_path/data/models/mod.rs

@@ -0,0 +1,79 @@
+/* @generated and managed by dsync */
+
+use crate::diesel::*;
+use crate::data::schema::*;
+use diesel::QueryResult;
+
+pub type ConnectionType = diesel::prelude::PgConnection;
+
+/// Struct representing a row in table `tableA`
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, Queryable, Selectable, QueryableByName)]
+#[diesel(table_name=tableA, primary_key(_id))]
+pub struct TableA {
+    /// Field representing column `_id`
+    pub _id: i32,
+}
+
+/// Create Struct for a row in table `tableA` for [`TableA`]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, Insertable)]
+#[diesel(table_name=tableA)]
+pub struct CreateTableA {
+    /// Field representing column `_id`
+    pub _id: i32,
+}
+
+/// Result of a `.paginate` function
+#[derive(Debug, serde::Serialize)]
+pub struct PaginationResult<T> {
+    /// Resulting items that are from the current page
+    pub items: Vec<T>,
+    /// The count of total items there are
+    pub total_items: i64,
+    /// Current page, 0-based index
+    pub page: i64,
+    /// Size of a page
+    pub page_size: i64,
+    /// Number of total possible pages, given the `page_size` and `total_items`
+    pub num_pages: i64,
+}
+
+impl TableA {
+    /// Insert a new row into `tableA` with a given [`CreateTableA`]
+    pub fn create(db: &mut ConnectionType, item: &CreateTableA) -> QueryResult<Self> {
+        use crate::data::schema::tableA::dsl::*;
+
+        insert_into(tableA).values(item).get_result::<Self>(db)
+    }
+
+    /// Get a row from `tableA`, identified by the primary key
+    pub fn read(db: &mut ConnectionType, param__id: i32) -> QueryResult<Self> {
+        use crate::data::schema::tableA::dsl::*;
+
+        tableA.filter(_id.eq(param__id)).first::<Self>(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<PaginationResult<Self>> {
+        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::<Self>(db)?;
+
+        Ok(PaginationResult {
+            items,
+            total_items,
+            page,
+            page_size,
+            /* ceiling division of integers */
+            num_pages: total_items / page_size + i64::from(total_items % page_size != 0)
+        })
+    }
+
+    /// Delete a row in `tableA`, identified by the primary key
+    pub fn delete(db: &mut ConnectionType, param__id: i32) -> QueryResult<usize> {
+        use crate::data::schema::tableA::dsl::*;
+
+        diesel::delete(tableA.filter(_id.eq(param__id))).execute(db)
+    }
+}

test/custom_model_and_schema_path/data/models/table_a/generated.rs

@@ -0,0 +1,2 @@
+pub mod generated;
+pub use generated::*;

test/custom_model_and_schema_path/data/models/table_a/mod.rs

@@ -0,0 +1,99 @@
+/* @generated and managed by dsync */
+
+use crate::diesel::*;
+use crate::data::models::table_a::TableA;
+use crate::data::schema::*;
+use diesel::QueryResult;
+
+pub type ConnectionType = diesel::prelude::PgConnection;
+
+/// Struct representing a row in table `tableB`
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, Queryable, Selectable, QueryableByName, Associations, Identifiable)]
+#[diesel(table_name=tableB, primary_key(_id), belongs_to(TableA, foreign_key=link))]
+pub struct TableB {
+    /// Field representing column `_id`
+    pub _id: i32,
+    /// Field representing column `link`
+    pub link: i32,
+}
+
+/// Create Struct for a row in table `tableB` for [`TableB`]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, Insertable)]
+#[diesel(table_name=tableB)]
+pub struct CreateTableB {
+    /// Field representing column `_id`
+    pub _id: i32,
+    /// Field representing column `link`
+    pub link: i32,
+}
+
+/// Update Struct for a row in table `tableB` for [`TableB`]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, AsChangeset, PartialEq, Default)]
+#[diesel(table_name=tableB)]
+pub struct UpdateTableB {
+    /// Field representing column `link`
+    pub link: Option<i32>,
+}
+
+/// Result of a `.paginate` function
+#[derive(Debug, serde::Serialize)]
+pub struct PaginationResult<T> {
+    /// Resulting items that are from the current page
+    pub items: Vec<T>,
+    /// The count of total items there are
+    pub total_items: i64,
+    /// Current page, 0-based index
+    pub page: i64,
+    /// Size of a page
+    pub page_size: i64,
+    /// Number of total possible pages, given the `page_size` and `total_items`
+    pub num_pages: i64,
+}
+
+impl TableB {
+    /// Insert a new row into `tableB` with a given [`CreateTableB`]
+    pub fn create(db: &mut ConnectionType, item: &CreateTableB) -> QueryResult<Self> {
+        use crate::data::schema::tableB::dsl::*;
+
+        insert_into(tableB).values(item).get_result::<Self>(db)
+    }
+
+    /// Get a row from `tableB`, identified by the primary key
+    pub fn read(db: &mut ConnectionType, param__id: i32) -> QueryResult<Self> {
+        use crate::data::schema::tableB::dsl::*;
+
+        tableB.filter(_id.eq(param__id)).first::<Self>(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<PaginationResult<Self>> {
+        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::<Self>(db)?;
+
+        Ok(PaginationResult {
+            items,
+            total_items,
+            page,
+            page_size,
+            /* ceiling division of integers */
+            num_pages: total_items / page_size + i64::from(total_items % page_size != 0)
+        })
+    }
+
+    /// Update a row in `tableB`, identified by the primary key with [`UpdateTableB`]
+    pub fn update(db: &mut ConnectionType, param__id: i32, item: &UpdateTableB) -> QueryResult<Self> {
+        use crate::data::schema::tableB::dsl::*;
+
+        diesel::update(tableB.filter(_id.eq(param__id))).set(item).get_result(db)
+    }
+
+    /// Delete a row in `tableB`, identified by the primary key
+    pub fn delete(db: &mut ConnectionType, param__id: i32) -> QueryResult<usize> {
+        use crate::data::schema::tableB::dsl::*;
+
+        diesel::delete(tableB.filter(_id.eq(param__id))).execute(db)
+    }
+}

test/custom_model_and_schema_path/data/models/table_b/generated.rs

@@ -0,0 +1,2 @@
+pub mod generated;
+pub use generated::*;

test/custom_model_and_schema_path/data/models/table_b/mod.rs

@@ -0,0 +1,2 @@
+#![allow(non_snake_case)]
+pub mod data;