[SeaORM] Update

Author: tyt2y3

SeaORM/docs/06-relation/04-complex-relations.md

@@ -79,11 +79,13 @@ assert_eq!(
 
 ## Self Referencing Relations
 
+### Belongs To
+
 ```rust title="staff.rs"
 use sea_orm::entity::prelude::*;
 
 #[sea_orm::model]
-#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
 #[sea_orm(table_name = "staff")]
 pub struct Model {
     #[sea_orm(primary_key)]
@@ -93,37 +95,76 @@ pub struct Model {
     #[sea_orm(
         self_ref,
         relation_enum = "ReportsTo",
+        relation_reverse = "Manages",
         from = "reports_to_id",
         to = "id"
     )]
     pub reports_to: HasOne<Entity>,
+    #[sea_orm(self_ref, relation_enum = "Manages", relation_reverse = "ReportsTo")]
+    pub manages: HasMany<Entity>,
 }
 
 impl ActiveModelBehavior for ActiveModel {}
 ```
 
-### Entity Loader
+(or using `compact_model` shim)
+
+```rust title="staff.rs"
+use sea_orm::entity::prelude::*;
+
+#[sea_orm::compact_model]
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "staff")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub name: String,
+    pub reports_to_id: Option<i32>,
+    #[sea_orm(self_ref, relation_enum = "ReportsTo")]
+    pub reports_to: HasOne<Entity>,
+    #[sea_orm(self_ref, relation_enum = "Manages")]
+    pub manages: HasMany<Entity>,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(belongs_to = "Entity", from = "Column::ReportsToId", to = "Column::Id")]
+    ReportsTo,
+    #[sea_orm(has_many = "Entity", via_rel = "Relation::ReportsTo")]
+    Manages,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+```
+
+#### Entity Loader
 
 ```rust
-let staff = staff::Entity::load()
-    .with(staff::Relation::ReportsTo)
+let staff = staff_compact::Entity::load()
+    .with(staff_compact::Relation::ReportsTo)
+    .with(staff_compact::Relation::Manages)
     .all(db)
     .await?;
 
 assert_eq!(staff[0].name, "Alan");
 assert_eq!(staff[0].reports_to, None);
+assert_eq!(staff[0].manages[0].name, "Ben");
+assert_eq!(staff[0].manages[1].name, "Alice");
 
 assert_eq!(staff[1].name, "Ben");
 assert_eq!(staff[1].reports_to.as_ref().unwrap().name, "Alan");
+assert!(staff[1].manages.is_empty());
 
 assert_eq!(staff[2].name, "Alice");
-assert_eq!(staff[2].reports_to.as_ref().unwrap().name, "Alan");
+assert_eq!(staff[1].reports_to.as_ref().unwrap().name, "Alan");
+assert!(staff[2].manages.is_empty());
 
 assert_eq!(staff[3].name, "Elle");
 assert_eq!(staff[3].reports_to, None);
+assert!(staff[3].manages.is_empty());
 ```
 
-### Model Loader
+#### Model Loader
 
 ```rust
 let staff = staff::Entity::find()
@@ -139,10 +180,10 @@ assert_eq!(staff[0].name, "Alan");
 assert_eq!(reports_to[0], None);
 
 assert_eq!(staff[1].name, "Ben");
-assert_eq!(reports_to[1].unwrap().name, "Alan");
+assert_eq!(reports_to[1].as_ref().unwrap().name, "Alan");
 
 assert_eq!(staff[2].name, "Alice");
-assert_eq!(reports_to[2].unwrap().name, "Alan");
+assert_eq!(reports_to[2].as_ref().unwrap().name, "Alan");
 
 assert_eq!(staff[3].name, "Elle");
 assert_eq!(reports_to[3], None);
@@ -152,11 +193,7 @@ It can work in reverse too.
 
 ```rust
 let manages = staff
-    .load_self_rev(
-        staff::Entity::find().order_by_asc(staff::Column::Id),
-        staff::Relation::ReportsTo,
-        db,
-    )
+    .load_self_many(staff::Entity, staff::Relation::Manages, db)
     .await?;
 
 assert_eq!(staff[0].name, "Alan");
@@ -174,6 +211,102 @@ assert_eq!(staff[3].name, "Elle");
 assert_eq!(manages[3].len(), 0);
 ```
 
+### Has Many (M-N)
+
+```rust title="user.rs"
+#[sea_orm::model]
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "user")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub name: String,
+    #[sea_orm(self_ref, via = "user_follower", from = "User", to = "Follower")]
+    pub followers: HasMany<Entity>,
+    #[sea_orm(self_ref, via = "user_follower", reverse)]
+    pub following: HasMany<Entity>,
+}
+```
+
+```rust title="user_follower.rs"
+#[sea_orm::model]
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq)]
+#[sea_orm(table_name = "user_follower")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub user_id: i32,
+    #[sea_orm(primary_key)]
+    pub follower_id: i32,
+    #[sea_orm(belongs_to, from = "user_id", to = "id")]
+    pub user: Option<super::user::Entity>,
+    #[sea_orm(belongs_to, relation_enum = "Follower", from = "follower_id", to = "id")]
+    pub follower: Option<super::user::Entity>,
+}
+```
+
+(or with `compact_model`)
+
+```rust
+#[sea_orm::compact_model]
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "user")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub name: String,
+    #[sea_orm(self_ref, via = "user_follower")]
+    pub followers: HasMany<Entity>,
+    #[sea_orm(self_ref, via = "user_follower", reverse)]
+    pub following: HasMany<Entity>,
+}
+
+impl RelatedSelfVia<super::user_follower::Entity> for Entity {
+    fn to() -> RelationDef {
+        super::user_follower::Relation::Follower.def()
+    }
+    fn via() -> RelationDef {
+        super::user_follower::Relation::User.def().rev()
+    }
+}
+```
+
+#### Entity Loader
+
+Join paths:
+
+```rust
+user -> profile
+     -> user_follower -> user -> profile
+     -> user_follower (reverse) -> user -> profile
+```
+
+```rust
+let users = user::Entity::load()
+    .with(profile::Entity)
+    .with((user_follower::Entity, profile::Entity))
+    .with((user_follower::Entity::REVERSE, profile::Entity))
+    .all(db)
+    .await?;
+
+assert_eq!(users[1].profile, bob.profile);
+assert_eq!(users[1].followers.len(), 1);
+assert_eq!(users[1].followers[0], sam);
+assert_eq!(users[1].following.len(), 1);
+assert_eq!(users[1].following[0], alice);
+```
+
+#### Model Loader
+
+```rust
+let users = user::Entity::find().all(db).await?;
+let followers = users.load_self_via(user_follower::Entity, db).await?;
+let following = users.load_self_via_rev(user_follower::Entity, db).await?;
+
+assert_eq!(users[1], bob);
+assert_eq!(followers[1], [sam.clone()]);
+assert_eq!(following[1], [alice.clone()]);
+```
+
 ## Diamond Relations
 
 Sometimes there exist multiple relations between a pair of entities. Here we take the simplest example, where `Bakery` can have multiple `Worker`.

SeaORM/src/components/HomepageExample.js

@@ -60,27 +60,32 @@ smart_user
         posts: HasMany::Loaded(vec![post::ModelEx {
             title: "Nice weather".into(),
             tags: HasMany::Loaded(vec![tag::ModelEx {
-                tag: "diary".into(),
+                tag: "sunny".into(),
             }]),
         }]),
     };`,
   },
+  {
+    title: 'Nested ActiveModel',
+    summary: `Persist an entire object graph: user, profile (1-1), posts (1-N), and tags (M-N) in a single operation using a fluent builder API. SeaORM automatically determines the dependencies and inserts or deletes objects in the correct order.`,
+    code: `let user = user::ActiveModel::builder()
+    .set_name("Bob")
+    .set_email("[email protected]")
+    .set_profile(profile::ActiveModel::builder().set_picture("image.jpg"))
+    .add_post(
+        post::ActiveModel::builder()
+            .set_title("Nice weather")
+            .add_tag(tag::ActiveModel::builder().set_tag("sunny")),
+    )
+    .save(db)
+    .await?;`
+  },
   {
     title: 'Entity First Workflow',
     summary: `SeaORM 2.0 supports a first-class Entity First Workflow: simply define new entities or add columns to existing ones, and SeaORM will automatically detect the changes and create the new tables, columns, unique keys, and foreign keys.`,
-    code: `let item = Item { name: "Bob" }; // nested parameter access
-let ids = [2, 3, 4]; // expanded by the .. operator
-
-let user: Option<user::Model> = user::Entity::find()
-    .from_raw_sql(raw_sql!(
-        Sqlite,
-        r#"SELECT "id", "name" FROM "user"
-           WHERE "name" LIKE {item.name}
-           AND "id" in ({..ids})
-        "#
-    ))
-    .one(db)
-    .await?;`
+    code: `// SeaORM resolves foreign key dependencies and creates the tables in topological order.
+// Requires the entity-registry and schema-sync feature flags.
+db.get_schema_registry("my_crate::entity::*").sync(db).await;`
   },
   {
     title: 'Ergonomic Raw SQL',

SeaORM/src/components/HomepageFeatures.js

@@ -4,6 +4,24 @@ import styles from './HomepageFeatures.module.css';
 import { MdCloud, MdCheckCircle, MdFlashOn, MdFlight } from "react-icons/md";
 
 const FeatureList = [
+  {
+    title: 'Advanced Relations',
+    icon: <MdFlashOn size={26} />,
+    description: (
+      <>
+        Model complex relationships 1-1, 1-N, M-N, and even self-referential in a high-level, conceptual way.
+      </>
+    ),
+  },
+  {
+    title: 'Familiar Concepts',
+    icon: <MdFlight size={26} />,
+    description: (
+      <>
+        Inspired by popular ORMs in the Ruby, Python, and Node.js ecosystem, SeaORM offers a developer experience that feels instantly recognizable.
+      </>
+    ),
+  },
   {
     title: 'Feature Rich',
     icon: <MdCloud size={26} />,