[SeaORM] Edit

Author: tyt2y3

Blog/blog/2024-07-01-graphql-support-with-loco-seaography.md

@@ -41,7 +41,7 @@ You can generate Seaography Entities by using `sea-orm-cli` with the extra `--se
 sea-orm-cli generate entity -o src/models/_entities -u postgres://loco:loco@localhost:5432/loco_seaography_development --seaography
 ```
 
-```diff title="loco_seaography/src/models/_entities/notes.rs"
+```rust title="loco_seaography/src/models/_entities/notes.rs"
 use sea_orm::entity::prelude::*;
 use serde::{Serialize, Deserialize};
 

SeaORM/docs/09-schema-statement/01-create-table.md

@@ -47,7 +47,7 @@ assert_eq!(
 );
 ```
 
-To further illustrate it, we will show the SQL statement as string below.
+To further illustrate, we will show the SQL statements as string below.
 
 - PostgreSQL
     ```rust

SeaORM/docs/09-schema-statement/03-create-index.md

@@ -5,37 +5,48 @@ You can create indices from entities using [`Schema::create_index_from_entity`](
 Example [`Indexes`](https://github.com/SeaQL/sea-orm/blob/master/src/tests_cfg/indexes.rs) entity:
 
 ```rust title="indexes.rs"
-impl ColumnTrait for Column {
-    type EntityName = Entity;
-
-    fn def(&self) -> ColumnDef {
-        match self {
-            Self::Index1Attr => ColumnType::Integer.def().indexed(),
-            Self::Index2Attr => ColumnType::Integer.def().indexed().unique(),
-        }
-    }
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    #[sea_orm(indexed)]
+    pub index1_attr: i32,
+    #[sea_orm(unique, indexed)]
+    pub index2_attr: i32,
+    #[sea_orm(unique_key = "my_unique")]
+    pub unique_key_a: String,
+    #[sea_orm(unique_key = "my_unique")]
+    pub unique_key_b: String,
 }
 ```
 
 ```rust
 use sea_orm::{sea_query, tests_cfg::*, Schema};
 
 let builder = db.get_database_backend();
-let schema = Schema::new(builder);
 
-let stmts = schema.create_index_from_entity(indexes::Entity);
+let stmts = Schema::new(builder).create_index_from_entity(indexes::Entity);
 
-let idx = sea_query::Index::create()
+let idx: IndexCreateStatement = Index::create()
     .name("idx-indexes-index1_attr")
     .table(indexes::Entity)
     .col(indexes::Column::Index1Attr)
     .to_owned();
 assert_eq!(builder.build(&stmts[0]), builder.build(&idx));
 
-let idx = sea_query::Index::create()
+let idx: IndexCreateStatement = Index::create()
     .name("idx-indexes-index2_attr")
     .table(indexes::Entity)
     .col(indexes::Column::Index2Attr)
-    .to_owned();
+    .unique()
+    .take();
 assert_eq!(builder.build(&stmts[1]), builder.build(&idx));
+
+let idx: IndexCreateStatement = Index::create()
+    .name("idx-indexes-my_unique")
+    .table(indexes::Entity)
+    .col(indexes::Column::UniqueKeyA)
+    .col(indexes::Column::UniqueKeyB)
+    .unique()
+    .take();
+assert_eq!(builder.build(&stmts[2]), builder.build(&idx));
 ```

SeaORM/docs/10-graph-ql/01-seaography-intro.md

@@ -2,7 +2,7 @@
 
 If you are building a full-stack application with a web GUI these days, it's likely you'd use GraphQL as the communication interface between frontend and backend. However, building GraphQL resolvers is no easy task for backend developers.
 
-[Seaography](https://github.com/SeaQL/seaography) is a GraphQL framework built on top of SeaORM and [async-graphql](https://github.com/async-graphql/async-graphql). With just a few commands, you can launch a GraphQL server from SeaORM entities!
+[Seaography](https://github.com/SeaQL/seaography) is a GraphQL framework built on top of SeaORM and [async-graphql](https://github.com/async-graphql/async-graphql). Given a set of SeaORM entities, you can instantly launch a fully-featured GraphQL server / resolver with relational query, filters, pagination and mutations.
 
 SeaORM is dynamic by design with first-class GraphQL support. `async-graphql` `v5.0` introduced [dynamic schema](https://docs.rs/async-graphql/latest/async_graphql/dynamic/index.html) and is a perfect match with SeaORM.
 

SeaORM/docs/10-graph-ql/02-getting-started.md

@@ -6,32 +6,178 @@ This example can be found on [SeaORM + Seaography Example](https://github.com/Se
 
 To get started, all you need is a live SQL database with schema. You can code everything in Rust by writing SeaORM migrations, or design the schema with a GUI tool (e.g. [DataGrip](https://www.jetbrains.com/datagrip/)).
 
-## Install Seaography
+## Install Seaography CLI
 
-```bash
+```sh
 cargo install seaography-cli@^1.1.0
 ```
 
 ## Generate Seaography Entities
 
-```bash
+```sh
 sea-orm-cli generate entity --output-dir graphql/src/entities --seaography
 ```
 
-Generate entities with `sea-orm-cli`, but with an additional `--seaography` flag. The entities are basically good-old SeaORM entities, but with additional `RelatedEntity` enum.
+Generate entities with `sea-orm-cli` like you normally do, but with an additional `--seaography` flag. The entities are basically good-old SeaORM entities, but with an additional `RelatedEntity` enum.
+
+```rust title="examples/seaography_example/graphql/src/entities/cake.rs"
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq)]
+#[sea_orm(table_name = "cake")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub name: String,
+    #[sea_orm(column_type = "Decimal(Some((16, 4)))")]
+    pub price: Decimal,
+    pub bakery_id: i32,
+    pub gluten_free: i8,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::bakery::Entity",
+        from = "Column::BakeryId",
+        to = "super::bakery::Column::Id",
+        on_update = "Cascade",
+        on_delete = "Cascade"
+    )]
+    Bakery,
+    #[sea_orm(has_many = "super::cake_baker::Entity")]
+    CakeBaker,
+}
+
+impl Related<super::bakery::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Bakery.def()
+    }
+}
+
+impl Related<super::cake_baker::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::CakeBaker.def()
+    }
+}
+
+impl Related<super::baker::Entity> for Entity {
+    fn to() -> RelationDef {
+        super::cake_baker::Relation::Baker.def()
+    }
+    fn via() -> Option<RelationDef> {
+        Some(super::cake_baker::Relation::Cake.def().rev())
+    }
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+// Additional schema meta exposed to Seaography
++ #[derive(Copy, Clone, Debug, EnumIter, DeriveRelatedEntity)]
++ pub enum RelatedEntity {
++     #[sea_orm(entity = "super::bakery::Entity")]
++     Bakery,
++     #[sea_orm(entity = "super::cake_baker::Entity")]
++     CakeBaker,
++     #[sea_orm(entity = "super::baker::Entity")]
++     Baker,
++ }
+```
 
 ## Generate GraphQL Project
 
-```bash
-# seaography-cli <DESTINATION> <ENTITIES> <DATABASE_URL> <CRATE_NAME>
+Generating a fresh project is the easiest way to launch a GraphQL server.
+However, Seaography can easily be integrated to an existing web server built with any web framework.
+
+Seaography supports Actix, Poem and Axum out of the box.
+
+Run the following command:
+
+```sh
 seaography-cli graphql graphql/src/entities $DATABASE_URL sea-orm-seaography-example
 ```
 
+Full help:
+
+```sh
+🧭 A dynamic GraphQL framework for SeaORM
+
+Usage: seaography-cli [OPTIONS] <DESTINATION> <ENTITIES> <DATABASE_URL> <CRATE_NAME>
+
+Arguments:
+  <DESTINATION>   Project destination folder
+  <ENTITIES>      SeaORM entities folder
+  <DATABASE_URL>  Database URL to write in .env
+  <CRATE_NAME>    Crate name for generated project
+
+Options:
+  -f, --framework <FRAMEWORK>
+          Which web framework to use [default: poem] [possible values: actix, poem, axum]
+      --depth-limit <DEPTH_LIMIT>
+          GraphQL depth limit
+      --complexity-limit <COMPLEXITY_LIMIT>
+          GraphQL complexity limit
+  -h, --help
+          Print help
+  -V, --version
+          Print version
+```
+
 ## Start the server
 
-```bash
+```sh
 cd graphql
 cargo run
 ```
 
-You are of course free to modify the project to suit your needs. But the interesting bit starts at the `seaography::register_entity!` macro and the [seaography::Builder](https://docs.rs/seaography/1.1.0/seaography/builder/struct.Builder.html).
+You are of course free to modify the project to suit your needs.
+The interesting bit starts at the `seaography::register_entities!` macro in `query_root.rs`.
+You can add custom entities, queries and mutations to the GraphQL schema.
+
+## Run some queries
+
+```sh
+Visit GraphQL Playground at http://localhost:8000
+```
+
+Navigate to the GraphQL Playground, and then start running some queries!
+
+### Bakery -> Cake -> Baker
+
+```graphql
+{
+  bakery(pagination: { page: { limit: 10, page: 0 } }, orderBy: { name: ASC }) {
+    nodes {
+      name
+      cake {
+        nodes {
+          name
+          price
+          baker {
+            nodes {
+              name
+            }
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+### List gluten-free cakes and know where to buy them
+
+```graphql
+{
+  cake(filters: { glutenFree: { eq: 1 } }) {
+    nodes {
+      name
+      price
+      glutenFree
+      bakery {
+        name
+      }
+    }
+  }
+}
+```