Add public API for resolver-based execution (#983)

Author: SimonSapin

crates/apollo-compiler/CHANGELOG.md

@@ -17,6 +17,16 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 ## Maintenance
 ## Documentation-->
 
+# [x.x.x] (unreleased) - 2025-mm-dd
+
+## Features
+
+- **Add public API for resolver-based execution - [SimonSapin], [pull/983]**
+
+[SimonSapin]: https://github.com/SimonSapin
+[pull/983]: https://github.com/apollographql/apollo-rs/pull/983
+
+
 # [1.28.0](https://crates.io/crates/apollo-compiler/1.28.0) - 2025-04-24
 
 ## Features

crates/apollo-compiler/Cargo.toml

@@ -21,6 +21,7 @@ autotests = false # Most tests/*.rs files are modules of tests/main.rs
 ahash = "0.8.11"
 apollo-parser = { path = "../apollo-parser", version = "0.8.0" }
 ariadne = { version = "0.5.1", features = ["auto-color"] }
+futures = "0.3"
 indexmap = "2.0.0"
 rowan = "0.16.0"
 serde = { version = "1.0", features = ["derive"] }

crates/apollo-compiler/examples/async_resolvers.rs

@@ -0,0 +1,86 @@
+use apollo_compiler::resolvers::AsyncObjectValue;
+use apollo_compiler::resolvers::AsyncResolvedValue;
+use apollo_compiler::resolvers::Execution;
+use apollo_compiler::resolvers::FieldError;
+use apollo_compiler::resolvers::ResolveInfo;
+use apollo_compiler::ExecutableDocument;
+use apollo_compiler::Schema;
+use futures::future::BoxFuture;
+
+async fn async_resolvers_example() {
+    let sdl = "
+      type Query {
+        field1: String
+        field2: [Int]
+      }
+    ";
+
+    struct Query;
+
+    impl AsyncObjectValue for Query {
+        fn type_name(&self) -> &str {
+            "Query"
+        }
+
+        fn resolve_field<'a>(
+            &'a self,
+            info: &'a ResolveInfo<'a>,
+        ) -> BoxFuture<'a, Result<AsyncResolvedValue<'a>, FieldError>> {
+            Box::pin(async move {
+                match info.field_name() {
+                    "field1" => Ok(AsyncResolvedValue::leaf(self.resolve_field1().await)),
+                    "field2" => Ok(AsyncResolvedValue::list(self.resolve_field2().await)),
+                    _ => Err(self.unknown_field_error(info)),
+                }
+            })
+        }
+    }
+
+    impl Query {
+        async fn resolve_field1(&self) -> String {
+            // totally doing asynchronous I/O here
+            "string".into()
+        }
+
+        async fn resolve_field2(&self) -> [AsyncResolvedValue<'_>; 4] {
+            // very await
+            [7, 42, 0, 0].map(AsyncResolvedValue::leaf)
+        }
+    }
+
+    let query = "
+        query($skp: Boolean!) {
+            field1 @skip(if: $skp)
+            field2
+        }
+    ";
+    let variables_values = &serde_json_bytes::json!({
+        "skp": false,
+    });
+
+    let schema = Schema::parse_and_validate(sdl, "schema.graphql").unwrap();
+    let document = ExecutableDocument::parse_and_validate(&schema, query, "query.graphql").unwrap();
+    let response = Execution::new(&schema, &document)
+        .raw_variable_values(variables_values.as_object().unwrap())
+        .execute_async(&Query)
+        .await
+        .unwrap();
+    let response = serde_json::to_string_pretty(&response).unwrap();
+    expect_test::expect![[r#"
+        {
+          "data": {
+            "field1": "string",
+            "field2": [
+              7,
+              42,
+              0,
+              0
+            ]
+          }
+        }"#]]
+    .assert_eq(&response);
+}
+
+fn main() {
+    futures::executor::block_on(async_resolvers_example())
+}