add dynamic-files example

Author: sunli829

Cargo.toml

@@ -1,10 +1,12 @@
 [workspace]
+resolver = "2"
 members = [
     "models/starwars",
-    "models/dynamic-starwars",
     "models/books",
     "models/files",
     "models/token",
+    "models/dynamic-starwars",
+    "models/dynamic-files",
 
     "poem/opentelemetry-basic",
     "poem/starwars",
@@ -15,6 +17,7 @@ members = [
     "poem/dynamic-schema",
     "poem/dynamic-starwars",
     "poem/dynamic-books",
+    "poem/dynamic-upload",
 
     "actix-web/token-from-header",
     "actix-web/subscription",

models/dynamic-files/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "dynamic-files"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+async-graphql = { path = "../../.." }
+slab = "0.4.2"
+futures = "0.3.0"

models/dynamic-files/src/lib.rs

@@ -0,0 +1,108 @@
+use async_graphql::{
+    dynamic::{Field, FieldFuture, FieldValue, InputValue, Object, Schema, SchemaError, TypeRef},
+    Value,
+};
+use futures::lock::Mutex;
+use slab::Slab;
+
+pub type Storage = Mutex<Slab<FileInfo>>;
+
+#[derive(Clone)]
+pub struct FileInfo {
+    pub id: String,
+    url: String,
+}
+
+pub fn schema() -> Result<Schema, SchemaError> {
+    let file_info = Object::new("FileInfo")
+        .field(Field::new("id", TypeRef::named_nn(TypeRef::ID), |ctx| {
+            FieldFuture::new(async {
+                let file_info = ctx.parent_value.try_downcast_ref::<FileInfo>()?;
+                Ok(Some(Value::from(&file_info.id)))
+            })
+        }))
+        .field(Field::new(
+            "url",
+            TypeRef::named_nn(TypeRef::STRING),
+            |ctx| {
+                FieldFuture::new(async {
+                    let file_info = ctx.parent_value.try_downcast_ref::<FileInfo>()?;
+                    Ok(Some(Value::from(&file_info.url)))
+                })
+            },
+        ));
+
+    let query = Object::new("Query").field(Field::new(
+        "uploads",
+        TypeRef::named_nn_list_nn(file_info.type_name()),
+        |ctx| {
+            FieldFuture::new(async move {
+                let storage = ctx.data_unchecked::<Storage>().lock().await;
+                Ok(Some(FieldValue::list(
+                    storage
+                        .iter()
+                        .map(|(_, file)| FieldValue::owned_any(file.clone())),
+                )))
+            })
+        },
+    ));
+
+    let mutation = Object::new("Mutation")
+        .field(
+            Field::new(
+                "singleUpload",
+                TypeRef::named_nn(file_info.type_name()),
+                |ctx| {
+                    FieldFuture::new(async move {
+                        let mut storage = ctx.data_unchecked::<Storage>().lock().await;
+                        let file = ctx.args.try_get("file")?.upload()?;
+                        let entry = storage.vacant_entry();
+                        let upload = file.value(&ctx).unwrap();
+                        let info = FileInfo {
+                            id: entry.key().to_string(),
+                            url: upload.filename.clone(),
+                        };
+                        entry.insert(info.clone());
+                        Ok(Some(FieldValue::owned_any(info)))
+                    })
+                },
+            )
+            .argument(InputValue::new("file", TypeRef::named_nn(TypeRef::UPLOAD))),
+        )
+        .field(
+            Field::new(
+                "multipleUpload",
+                TypeRef::named_nn_list_nn(file_info.type_name()),
+                |ctx| {
+                    FieldFuture::new(async move {
+                        let mut infos = Vec::new();
+                        let mut storage = ctx.data_unchecked::<Storage>().lock().await;
+                        for item in ctx.args.try_get("files")?.list()?.iter() {
+                            let file = item.upload()?;
+                            let entry = storage.vacant_entry();
+                            let upload = file.value(&ctx).unwrap();
+                            let info = FileInfo {
+                                id: entry.key().to_string(),
+                                url: upload.filename.clone(),
+                            };
+                            entry.insert(info.clone());
+                            infos.push(FieldValue::owned_any(info))
+                        }
+                        Ok(Some(infos))
+                    })
+                },
+            )
+            .argument(InputValue::new(
+                "files",
+                TypeRef::named_nn_list_nn(TypeRef::UPLOAD),
+            )),
+        );
+
+    Schema::build(query.type_name(), Some(mutation.type_name()), None)
+        .enable_uploading()
+        .register(file_info)
+        .register(query)
+        .register(mutation)
+        .data(Storage::default())
+        .finish()
+}

models/files/src/lib.rs

@@ -28,7 +28,6 @@ pub struct MutationRoot;
 impl MutationRoot {
     async fn single_upload(&self, ctx: &Context<'_>, file: Upload) -> FileInfo {
         let mut storage = ctx.data_unchecked::<Storage>().lock().await;
-        println!("files count: {}", storage.len());
         let entry = storage.vacant_entry();
         let upload = file.value(ctx).unwrap();
         let info = FileInfo {

poem/dynamic-upload/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "dynamic-upload"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+async-graphql = { path = "../../..", features = ["dynamic-schema"] }
+async-graphql-poem = { path = "../../../integrations/poem" }
+tokio = { version = "1.8", features = ["macros", "rt-multi-thread"] }
+dynamic-files = { path = "../../models/dynamic-files" }
+poem = "1.3.48"

poem/dynamic-upload/src/main.rs

@@ -0,0 +1,22 @@
+use async_graphql::http::GraphiQLSource;
+use async_graphql_poem::GraphQL;
+use poem::{get, handler, listener::TcpListener, web::Html, IntoResponse, Route, Server};
+
+#[handler]
+async fn graphiql() -> impl IntoResponse {
+    Html(GraphiQLSource::build().endpoint("/").finish())
+}
+
+#[tokio::main]
+async fn main() {
+    let app = Route::new().at(
+        "/",
+        get(graphiql).post(GraphQL::new(dynamic_files::schema().unwrap())),
+    );
+
+    println!("GraphiQL IDE: http://localhost:8000");
+    Server::new(TcpListener::bind("0.0.0.0:8000"))
+        .run(app)
+        .await
+        .unwrap();
+}