mirror of
https://github.com/Phundrak/georm.git
synced 2025-11-30 19:03:59 +00:00
feat: add defaultable field support with companion struct generation
Introduces support for `#[georm(defaultable)]` attribute on entity fields. When fields are marked as defaultable, generates companion `<Entity>Default` structs where defaultable fields become `Option<T>`, enabling easier entity creation when some fields have database defaults or are auto-generated. Key features: - Generates `<Entity>Default` structs with optional defaultable fields - Implements `Defaultable<Id, Entity>` trait with async `create` method - Validates that `Option<T>` fields cannot be marked as defaultable - Preserves field visibility in generated companion structs - Only generates companion struct when defaultable fields are present
This commit is contained in:
519
tests/defaultable_struct.rs
Normal file
519
tests/defaultable_struct.rs
Normal file
@@ -0,0 +1,519 @@
|
||||
use georm::Georm;
|
||||
|
||||
// Test struct with defaultable fields using existing table structure
|
||||
#[derive(Georm, Debug)]
|
||||
#[georm(table = "authors")]
|
||||
struct TestAuthor {
|
||||
#[georm(id, defaultable)]
|
||||
pub id: i32,
|
||||
pub name: String,
|
||||
pub biography_id: Option<i32>, // Don't mark Option fields as defaultable
|
||||
}
|
||||
|
||||
// Test struct with only ID defaultable
|
||||
#[derive(Georm)]
|
||||
#[georm(table = "authors")]
|
||||
struct MinimalDefaultable {
|
||||
#[georm(id, defaultable)]
|
||||
pub id: i32,
|
||||
pub name: String,
|
||||
pub biography_id: Option<i32>,
|
||||
}
|
||||
|
||||
// Test struct with multiple defaultable fields
|
||||
#[derive(Georm)]
|
||||
#[georm(table = "authors")]
|
||||
struct MultiDefaultable {
|
||||
#[georm(id, defaultable)]
|
||||
pub id: i32,
|
||||
#[georm(defaultable)]
|
||||
pub name: String,
|
||||
pub biography_id: Option<i32>,
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn defaultable_struct_should_exist() {
|
||||
// This test will compile only if TestAuthorDefault struct exists
|
||||
let _author_default = TestAuthorDefault {
|
||||
id: Some(1), // Should be Option<i32> since ID is defaultable
|
||||
name: "Test Author".to_string(), // Should remain String
|
||||
biography_id: None, // Should remain Option<i32>
|
||||
};
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn minimal_defaultable_struct_should_exist() {
|
||||
// MinimalDefaultableDefault should exist because ID is marked as defaultable
|
||||
let _minimal_default = MinimalDefaultableDefault {
|
||||
id: None, // Should be Option<i32>
|
||||
name: "testuser".to_string(), // Should remain String
|
||||
biography_id: None, // Should remain Option<i32>
|
||||
};
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn defaultable_fields_can_be_none() {
|
||||
let _author_default = TestAuthorDefault {
|
||||
id: None, // Can be None since it's defaultable (auto-generated)
|
||||
name: "Test Author".to_string(),
|
||||
biography_id: None, // Can remain None
|
||||
};
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn field_visibility_is_preserved() {
|
||||
let _author_default = TestAuthorDefault {
|
||||
id: Some(1), // pub
|
||||
name: "Test".to_string(), // pub
|
||||
biography_id: Some(1), // pub, Option<i32>
|
||||
};
|
||||
|
||||
// This test ensures field visibility is preserved in generated struct
|
||||
}
|
||||
|
||||
mod defaultable_tests {
|
||||
use super::*;
|
||||
use georm::Defaultable;
|
||||
use sqlx::PgPool;
|
||||
|
||||
#[sqlx::test(fixtures("../tests/fixtures/simple_struct.sql"))]
|
||||
async fn test_create_entity_from_defaultable_with_id(pool: PgPool) {
|
||||
// Test creating entity from defaultable struct with explicit ID
|
||||
let author_default = TestAuthorDefault {
|
||||
id: Some(999),
|
||||
name: "John Doe".to_string(),
|
||||
biography_id: None,
|
||||
};
|
||||
|
||||
let created_author = author_default.create(&pool).await.unwrap();
|
||||
|
||||
assert_eq!(created_author.id, 999);
|
||||
assert_eq!(created_author.name, "John Doe");
|
||||
assert_eq!(created_author.biography_id, None);
|
||||
}
|
||||
|
||||
#[sqlx::test(fixtures("../tests/fixtures/simple_struct.sql"))]
|
||||
async fn test_create_entity_from_defaultable_without_id(pool: PgPool) {
|
||||
// Test creating entity from defaultable struct with auto-generated ID
|
||||
let author_default = TestAuthorDefault {
|
||||
id: None, // Let database generate the ID
|
||||
name: "Jane Smith".to_string(),
|
||||
biography_id: None,
|
||||
};
|
||||
|
||||
let created_author = author_default.create(&pool).await.unwrap();
|
||||
|
||||
// ID should be auto-generated (positive value)
|
||||
assert!(created_author.id > 0);
|
||||
assert_eq!(created_author.name, "Jane Smith");
|
||||
assert_eq!(created_author.biography_id, None);
|
||||
}
|
||||
|
||||
#[sqlx::test(fixtures("../tests/fixtures/simple_struct.sql"))]
|
||||
async fn test_create_entity_from_minimal_defaultable(pool: PgPool) {
|
||||
// Test creating entity from minimal defaultable struct
|
||||
let minimal_default = MinimalDefaultableDefault {
|
||||
id: None,
|
||||
name: "Alice Wonder".to_string(),
|
||||
biography_id: Some(1), // Reference existing biography
|
||||
};
|
||||
|
||||
let created_author = minimal_default.create(&pool).await.unwrap();
|
||||
|
||||
assert!(created_author.id > 0);
|
||||
assert_eq!(created_author.name, "Alice Wonder");
|
||||
assert_eq!(created_author.biography_id, Some(1));
|
||||
}
|
||||
|
||||
#[sqlx::test(fixtures("../tests/fixtures/simple_struct.sql"))]
|
||||
async fn test_create_multiple_entities_from_defaultable(pool: PgPool) {
|
||||
// Test creating multiple entities to ensure ID generation works properly
|
||||
let author1_default = TestAuthorDefault {
|
||||
id: None,
|
||||
name: "Author One".to_string(),
|
||||
biography_id: None,
|
||||
};
|
||||
|
||||
let author2_default = TestAuthorDefault {
|
||||
id: None,
|
||||
name: "Author Two".to_string(),
|
||||
biography_id: None,
|
||||
};
|
||||
|
||||
let created_author1 = author1_default.create(&pool).await.unwrap();
|
||||
let created_author2 = author2_default.create(&pool).await.unwrap();
|
||||
|
||||
// Both should have unique IDs
|
||||
assert!(created_author1.id > 0);
|
||||
assert!(created_author2.id > 0);
|
||||
assert_ne!(created_author1.id, created_author2.id);
|
||||
|
||||
assert_eq!(created_author1.name, "Author One");
|
||||
assert_eq!(created_author2.name, "Author Two");
|
||||
}
|
||||
|
||||
#[sqlx::test(fixtures("../tests/fixtures/simple_struct.sql"))]
|
||||
async fn test_multiple_defaultable_fields_all_none(pool: PgPool) {
|
||||
// Test with multiple defaultable fields all set to None
|
||||
let multi_default = MultiDefaultableDefault {
|
||||
id: None,
|
||||
name: None, // This should use database default or be handled gracefully
|
||||
biography_id: None,
|
||||
};
|
||||
|
||||
let result = multi_default.create(&pool).await;
|
||||
|
||||
// This might fail if database doesn't have a default for name
|
||||
// That's expected behavior - test documents the current behavior
|
||||
match result {
|
||||
Ok(created) => {
|
||||
assert!(created.id > 0);
|
||||
// If successful, name should have some default value
|
||||
},
|
||||
Err(e) => {
|
||||
// Expected if no database default for name column
|
||||
assert!(e.to_string().contains("null") || e.to_string().contains("NOT NULL"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[sqlx::test(fixtures("../tests/fixtures/simple_struct.sql"))]
|
||||
async fn test_multiple_defaultable_fields_mixed(pool: PgPool) {
|
||||
// Test with some defaultable fields set and others None
|
||||
let multi_default = MultiDefaultableDefault {
|
||||
id: None, // Let database generate
|
||||
name: Some("Explicit Name".to_string()), // Explicit value
|
||||
biography_id: Some(1), // Reference existing biography
|
||||
};
|
||||
|
||||
let created = multi_default.create(&pool).await.unwrap();
|
||||
|
||||
assert!(created.id > 0);
|
||||
assert_eq!(created.name, "Explicit Name");
|
||||
assert_eq!(created.biography_id, Some(1));
|
||||
}
|
||||
|
||||
#[sqlx::test(fixtures("../tests/fixtures/simple_struct.sql"))]
|
||||
async fn test_multiple_defaultable_fields_all_explicit(pool: PgPool) {
|
||||
// Test with all defaultable fields having explicit values
|
||||
let multi_default = MultiDefaultableDefault {
|
||||
id: Some(888),
|
||||
name: Some("All Explicit".to_string()),
|
||||
biography_id: None,
|
||||
};
|
||||
|
||||
let created = multi_default.create(&pool).await.unwrap();
|
||||
|
||||
assert_eq!(created.id, 888);
|
||||
assert_eq!(created.name, "All Explicit");
|
||||
assert_eq!(created.biography_id, None);
|
||||
}
|
||||
|
||||
#[sqlx::test(fixtures("../tests/fixtures/simple_struct.sql"))]
|
||||
async fn test_error_duplicate_id(pool: PgPool) {
|
||||
// Test error handling for duplicate ID constraint violation
|
||||
let author1 = TestAuthorDefault {
|
||||
id: Some(777),
|
||||
name: "First Author".to_string(),
|
||||
biography_id: None,
|
||||
};
|
||||
|
||||
let author2 = TestAuthorDefault {
|
||||
id: Some(777), // Same ID - should cause constraint violation
|
||||
name: "Second Author".to_string(),
|
||||
biography_id: None,
|
||||
};
|
||||
|
||||
// First creation should succeed
|
||||
let _created1 = author1.create(&pool).await.unwrap();
|
||||
|
||||
// Second creation should fail due to duplicate key
|
||||
let result2 = author2.create(&pool).await;
|
||||
assert!(result2.is_err());
|
||||
|
||||
let error = result2.unwrap_err();
|
||||
let error_str = error.to_string();
|
||||
assert!(error_str.contains("duplicate") || error_str.contains("unique") || error_str.contains("UNIQUE"));
|
||||
}
|
||||
|
||||
#[sqlx::test(fixtures("../tests/fixtures/simple_struct.sql"))]
|
||||
async fn test_error_invalid_foreign_key(pool: PgPool) {
|
||||
// Test error handling for invalid foreign key reference
|
||||
let author_default = TestAuthorDefault {
|
||||
id: None,
|
||||
name: "Test Author".to_string(),
|
||||
biography_id: Some(99999), // Non-existent biography ID
|
||||
};
|
||||
|
||||
let result = author_default.create(&pool).await;
|
||||
|
||||
// This should fail if there's a foreign key constraint
|
||||
// If no constraint exists, it will succeed (documents current behavior)
|
||||
match result {
|
||||
Ok(created) => {
|
||||
// No foreign key constraint - this is valid behavior
|
||||
assert!(created.id > 0);
|
||||
assert_eq!(created.biography_id, Some(99999));
|
||||
},
|
||||
Err(e) => {
|
||||
// Foreign key constraint violation
|
||||
let error_str = e.to_string();
|
||||
assert!(error_str.contains("foreign") || error_str.contains("constraint") || error_str.contains("violates"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[sqlx::test(fixtures("../tests/fixtures/simple_struct.sql"))]
|
||||
async fn test_error_connection_handling(pool: PgPool) {
|
||||
// Test behavior with a closed/invalid pool
|
||||
// Note: This is tricky to test without actually closing the pool
|
||||
// Instead, we test with extremely long string that might cause issues
|
||||
let author_default = TestAuthorDefault {
|
||||
id: None,
|
||||
name: "A".repeat(10000), // Very long string - might hit database limits
|
||||
biography_id: None,
|
||||
};
|
||||
|
||||
let result = author_default.create(&pool).await;
|
||||
|
||||
// This documents current behavior - might succeed or fail depending on DB limits
|
||||
match result {
|
||||
Ok(created) => {
|
||||
assert!(created.id > 0);
|
||||
assert_eq!(created.name.len(), 10000);
|
||||
},
|
||||
Err(e) => {
|
||||
// Some kind of database limit hit
|
||||
assert!(!e.to_string().is_empty());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
mod sql_validation_tests {
|
||||
use super::*;
|
||||
|
||||
|
||||
#[sqlx::test(fixtures("../tests/fixtures/simple_struct.sql"))]
|
||||
async fn test_sql_generation_no_defaultable_fields(pool: PgPool) {
|
||||
// Test SQL generation when no defaultable fields have None values
|
||||
let author_default = TestAuthorDefault {
|
||||
id: Some(100),
|
||||
name: "Test Name".to_string(),
|
||||
biography_id: Some(1),
|
||||
};
|
||||
|
||||
// Capture the SQL by creating a custom query that logs the generated SQL
|
||||
// Since we can't directly inspect the generated SQL from the macro,
|
||||
// we test the behavior indirectly by ensuring all fields are included
|
||||
let created = author_default.create(&pool).await.unwrap();
|
||||
|
||||
// Verify all fields were properly inserted
|
||||
assert_eq!(created.id, 100);
|
||||
assert_eq!(created.name, "Test Name");
|
||||
assert_eq!(created.biography_id, Some(1));
|
||||
|
||||
// Verify the record exists in database with all expected values
|
||||
let found: TestAuthor = sqlx::query_as!(
|
||||
TestAuthor,
|
||||
"SELECT id, name, biography_id FROM authors WHERE id = $1",
|
||||
100
|
||||
)
|
||||
.fetch_one(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(found.id, 100);
|
||||
assert_eq!(found.name, "Test Name");
|
||||
assert_eq!(found.biography_id, Some(1));
|
||||
}
|
||||
|
||||
#[sqlx::test(fixtures("../tests/fixtures/simple_struct.sql"))]
|
||||
async fn test_sql_generation_with_defaultable_none(pool: PgPool) {
|
||||
// Test SQL generation when defaultable fields are None (should be excluded)
|
||||
let author_default = TestAuthorDefault {
|
||||
id: None, // This should be excluded from INSERT
|
||||
name: "Auto ID Test".to_string(),
|
||||
biography_id: None,
|
||||
};
|
||||
|
||||
let created = author_default.create(&pool).await.unwrap();
|
||||
|
||||
// ID should be auto-generated (not explicitly set)
|
||||
assert!(created.id > 0);
|
||||
assert_eq!(created.name, "Auto ID Test");
|
||||
assert_eq!(created.biography_id, None);
|
||||
|
||||
// Verify the generated ID is actually from database auto-increment
|
||||
// by checking it's different from any manually set values
|
||||
assert_ne!(created.id, 100); // Different from previous test
|
||||
}
|
||||
|
||||
#[sqlx::test(fixtures("../tests/fixtures/simple_struct.sql"))]
|
||||
async fn test_sql_generation_mixed_defaultable_fields(pool: PgPool) {
|
||||
// Test SQL with multiple defaultable fields where some are None
|
||||
let multi_default = MultiDefaultableDefault {
|
||||
id: None, // Should be excluded
|
||||
name: Some("Explicit Name".to_string()), // Should be included
|
||||
biography_id: Some(1), // Should be included
|
||||
};
|
||||
|
||||
let created = multi_default.create(&pool).await.unwrap();
|
||||
|
||||
// Verify the mixed field inclusion worked correctly
|
||||
assert!(created.id > 0); // Auto-generated
|
||||
assert_eq!(created.name, "Explicit Name"); // Explicitly set
|
||||
assert_eq!(created.biography_id, Some(1)); // Explicitly set
|
||||
}
|
||||
|
||||
#[sqlx::test(fixtures("../tests/fixtures/simple_struct.sql"))]
|
||||
async fn test_placeholder_ordering_consistency(pool: PgPool) {
|
||||
// Test that placeholders are ordered correctly when fields are dynamically included
|
||||
// Create multiple records with different field combinations
|
||||
|
||||
// First: only non-defaultable fields
|
||||
let record1 = MultiDefaultableDefault {
|
||||
id: None,
|
||||
name: None,
|
||||
biography_id: Some(1),
|
||||
};
|
||||
|
||||
// Second: all fields explicit
|
||||
let record2 = MultiDefaultableDefault {
|
||||
id: Some(201),
|
||||
name: Some("Full Record".to_string()),
|
||||
biography_id: Some(1),
|
||||
};
|
||||
|
||||
// Third: mixed combination
|
||||
let record3 = MultiDefaultableDefault {
|
||||
id: None,
|
||||
name: Some("Mixed Record".to_string()),
|
||||
biography_id: None,
|
||||
};
|
||||
|
||||
// All should succeed with correct placeholder ordering
|
||||
let result1 = record1.create(&pool).await;
|
||||
let result2 = record2.create(&pool).await;
|
||||
let result3 = record3.create(&pool).await;
|
||||
|
||||
// Handle record1 based on whether name has a database default
|
||||
match result1 {
|
||||
Ok(created1) => {
|
||||
assert!(created1.id > 0);
|
||||
assert_eq!(created1.biography_id, Some(1));
|
||||
},
|
||||
Err(_) => {
|
||||
// Expected if name field has no database default
|
||||
}
|
||||
}
|
||||
|
||||
let created2 = result2.unwrap();
|
||||
assert_eq!(created2.id, 201);
|
||||
assert_eq!(created2.name, "Full Record");
|
||||
assert_eq!(created2.biography_id, Some(1));
|
||||
|
||||
let created3 = result3.unwrap();
|
||||
assert!(created3.id > 0);
|
||||
assert_eq!(created3.name, "Mixed Record");
|
||||
assert_eq!(created3.biography_id, None);
|
||||
}
|
||||
|
||||
#[sqlx::test(fixtures("../tests/fixtures/simple_struct.sql"))]
|
||||
async fn test_field_inclusion_logic(pool: PgPool) {
|
||||
// Test that the field inclusion logic works correctly
|
||||
// by creating records that should result in different SQL queries
|
||||
|
||||
let minimal = TestAuthorDefault {
|
||||
id: None,
|
||||
name: "Minimal".to_string(),
|
||||
biography_id: None,
|
||||
};
|
||||
|
||||
let maximal = TestAuthorDefault {
|
||||
id: Some(300),
|
||||
name: "Maximal".to_string(),
|
||||
biography_id: Some(1),
|
||||
};
|
||||
|
||||
let created_minimal = minimal.create(&pool).await.unwrap();
|
||||
let created_maximal = maximal.create(&pool).await.unwrap();
|
||||
|
||||
// Minimal should have auto-generated ID, explicit name, NULL biography_id
|
||||
assert!(created_minimal.id > 0);
|
||||
assert_eq!(created_minimal.name, "Minimal");
|
||||
assert_eq!(created_minimal.biography_id, None);
|
||||
|
||||
// Maximal should have all explicit values
|
||||
assert_eq!(created_maximal.id, 300);
|
||||
assert_eq!(created_maximal.name, "Maximal");
|
||||
assert_eq!(created_maximal.biography_id, Some(1));
|
||||
|
||||
// Verify they are different records
|
||||
assert_ne!(created_minimal.id, created_maximal.id);
|
||||
}
|
||||
|
||||
#[sqlx::test(fixtures("../tests/fixtures/simple_struct.sql"))]
|
||||
async fn test_returning_clause_functionality(pool: PgPool) {
|
||||
// Test that the RETURNING * clause works correctly with dynamic fields
|
||||
let author_default = TestAuthorDefault {
|
||||
id: None, // Should be populated by RETURNING clause
|
||||
name: "Return Test".to_string(),
|
||||
biography_id: None,
|
||||
};
|
||||
|
||||
let created = author_default.create(&pool).await.unwrap();
|
||||
|
||||
// Verify RETURNING clause populated all fields correctly
|
||||
assert!(created.id > 0); // Database-generated ID returned
|
||||
assert_eq!(created.name, "Return Test"); // Explicit value returned
|
||||
assert_eq!(created.biography_id, None); // NULL value returned correctly
|
||||
|
||||
// Double-check by querying the database directly
|
||||
let verified: TestAuthor = sqlx::query_as!(
|
||||
TestAuthor,
|
||||
"SELECT id, name, biography_id FROM authors WHERE id = $1",
|
||||
created.id
|
||||
)
|
||||
.fetch_one(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(verified.id, created.id);
|
||||
assert_eq!(verified.name, created.name);
|
||||
assert_eq!(verified.biography_id, created.biography_id);
|
||||
}
|
||||
|
||||
#[sqlx::test(fixtures("../tests/fixtures/simple_struct.sql"))]
|
||||
async fn test_query_parameter_binding_order(pool: PgPool) {
|
||||
// Test that query parameters are bound in the correct order
|
||||
// This is critical for the dynamic SQL generation
|
||||
|
||||
// Create a record where the parameter order matters
|
||||
let test_record = MultiDefaultableDefault {
|
||||
id: Some(400), // This should be bound first (if included)
|
||||
name: Some("Param Order Test".to_string()), // This should be bound second (if included)
|
||||
biography_id: Some(1), // This should be bound last
|
||||
};
|
||||
|
||||
let created = test_record.create(&pool).await.unwrap();
|
||||
|
||||
// Verify all parameters were bound correctly
|
||||
assert_eq!(created.id, 400);
|
||||
assert_eq!(created.name, "Param Order Test");
|
||||
assert_eq!(created.biography_id, Some(1));
|
||||
|
||||
// Test with different parameter inclusion order
|
||||
let test_record2 = MultiDefaultableDefault {
|
||||
id: None, // Excluded - should not affect parameter order
|
||||
name: Some("No ID Test".to_string()), // Should be bound first now
|
||||
biography_id: Some(1), // Should be bound second now
|
||||
};
|
||||
|
||||
let created2 = test_record2.create(&pool).await.unwrap();
|
||||
|
||||
assert!(created2.id > 0); // Auto-generated
|
||||
assert_eq!(created2.name, "No ID Test");
|
||||
assert_eq!(created2.biography_id, Some(1));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
use georm::Georm;
|
||||
|
||||
#[derive(Debug, sqlx::FromRow, Georm, PartialEq, Eq, Default)]
|
||||
#[derive(Debug, Georm, PartialEq, Eq, Default)]
|
||||
#[georm(
|
||||
table = "biographies",
|
||||
one_to_one = [{
|
||||
@@ -13,7 +13,7 @@ pub struct Biography {
|
||||
pub content: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, sqlx::FromRow, Georm, PartialEq, Eq, Default)]
|
||||
#[derive(Debug, Georm, PartialEq, Eq, Default)]
|
||||
#[georm(table = "authors")]
|
||||
pub struct Author {
|
||||
#[georm(id)]
|
||||
@@ -35,7 +35,7 @@ impl Ord for Author {
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, sqlx::FromRow, Georm, PartialEq, Eq, Default)]
|
||||
#[derive(Debug, Georm, PartialEq, Eq, Default)]
|
||||
#[georm(
|
||||
table = "books",
|
||||
one_to_many = [
|
||||
@@ -68,7 +68,7 @@ impl Ord for Book {
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, sqlx::FromRow, Georm, PartialEq, Eq)]
|
||||
#[derive(Debug, Georm, PartialEq, Eq)]
|
||||
#[georm(table = "reviews")]
|
||||
pub struct Review {
|
||||
#[georm(id)]
|
||||
@@ -78,7 +78,7 @@ pub struct Review {
|
||||
pub review: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, sqlx::FromRow, Georm, PartialEq, Eq)]
|
||||
#[derive(Debug, Georm, PartialEq, Eq)]
|
||||
#[georm(
|
||||
table = "genres",
|
||||
many_to_many = [{
|
||||
|
||||
Reference in New Issue
Block a user