Make the handling of GraphQL in the counter example in line with other contracts. (#4400)

## Motivation

The `counter` example was processing GraphQL queries quite differently
from other examples.
We put it in line with other examples.

Fixes #2854 

## Proposal

The work is fairly standard, but forces the introduction of a
`CounterOperation` since the input
must satisfy the `GraphQLMutationRoot` trait.

## Test Plan

The CI.

## Release Plan

- Nothing to do / These changes follow the usual release cycle.

## Links

None.

Author: MathieuDutSik

Cargo.lock

@@ -8,6 +8,7 @@ edition = "2021"
 async-graphql.workspace = true
 futures.workspace = true
 linera-sdk.workspace = true
+serde.workspace = true
 serde_json.workspace = true
 
 [target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]

examples/Cargo.lock

@@ -88,7 +88,7 @@ query {
 - To increase the value of the counter by 3, perform the `increment` operation.
 ```gql,uri=http://localhost:8080/chains/$CHAIN_1/applications/$APPLICATION_ID
 mutation Increment {
-  increment(value: 3)
+  increment(field0: 3)
 }
 ```
 - Running the query again would yield `4`.

examples/counter/Cargo.toml

@@ -5,7 +5,7 @@
 
 mod state;
 
-use counter::CounterAbi;
+use counter::{CounterAbi, CounterOperation};
 use linera_sdk::{
     linera_base_types::WithContractAbi,
     views::{RootView, View},
@@ -45,7 +45,8 @@ impl Contract for CounterContract {
         self.state.value.set(value);
     }
 
-    async fn execute_operation(&mut self, operation: u64) -> u64 {
+    async fn execute_operation(&mut self, operation: CounterOperation) -> u64 {
+        let CounterOperation::Increment(operation) = operation;
         let new_value = self.state.value.get() + operation;
         self.state.value.set(new_value);
         new_value
@@ -62,6 +63,7 @@ impl Contract for CounterContract {
 
 #[cfg(test)]
 mod tests {
+    use counter::CounterOperation;
     use futures::FutureExt as _;
     use linera_sdk::{util::BlockingWait, views::View, Contract, ContractRuntime};
 
@@ -73,9 +75,10 @@ mod tests {
         let mut counter = create_and_instantiate_counter(initial_value);
 
         let increment = 42_308_u64;
+        let operation = CounterOperation::Increment(increment);
 
         let response = counter
-            .execute_operation(increment)
+            .execute_operation(operation)
             .now_or_never()
             .expect("Execution of counter operation should not await anything");
 
@@ -103,9 +106,10 @@ mod tests {
         let mut counter = create_and_instantiate_counter(initial_value);
 
         let increment = 8_u64;
+        let operation = CounterOperation::Increment(increment);
 
         let response = counter
-            .execute_operation(increment)
+            .execute_operation(operation)
             .now_or_never()
             .expect("Execution of counter operation should not await anything");
 

examples/counter/README.md

@@ -4,12 +4,22 @@
 /*! ABI of the Counter Example Application */
 
 use async_graphql::{Request, Response};
-use linera_sdk::linera_base_types::{ContractAbi, ServiceAbi};
+use linera_sdk::{
+    graphql::GraphQLMutationRoot,
+    linera_base_types::{ContractAbi, ServiceAbi},
+};
+use serde::{Deserialize, Serialize};
 
 pub struct CounterAbi;
 
+#[derive(Debug, Deserialize, Serialize, GraphQLMutationRoot)]
+pub enum CounterOperation {
+    /// Increment the counter by the given value
+    Increment(u64),
+}
+
 impl ContractAbi for CounterAbi {
-    type Operation = u64;
+    type Operation = CounterOperation;
     type Response = u64;
 }
 

examples/counter/src/contract.rs

@@ -7,13 +7,17 @@ mod state;
 
 use std::sync::Arc;
 
-use async_graphql::{EmptySubscription, Object, Request, Response, Schema};
-use linera_sdk::{linera_base_types::WithServiceAbi, views::View, Service, ServiceRuntime};
+use async_graphql::{EmptySubscription, Request, Response, Schema};
+use counter::CounterOperation;
+use linera_sdk::{
+    graphql::GraphQLMutationRoot, linera_base_types::WithServiceAbi, views::View, Service,
+    ServiceRuntime,
+};
 
 use self::state::CounterState;
 
 pub struct CounterService {
-    state: CounterState,
+    state: Arc<CounterState>,
     runtime: Arc<ServiceRuntime<Self>>,
 }
 
@@ -31,49 +35,22 @@ impl Service for CounterService {
             .await
             .expect("Failed to load state");
         CounterService {
-            state,
+            state: Arc::new(state),
             runtime: Arc::new(runtime),
         }
     }
 
     async fn handle_query(&self, request: Request) -> Response {
         let schema = Schema::build(
-            QueryRoot {
-                value: *self.state.value.get(),
-            },
-            MutationRoot {
-                runtime: self.runtime.clone(),
-            },
+            self.state.clone(),
+            CounterOperation::mutation_root(self.runtime.clone()),
             EmptySubscription,
         )
         .finish();
         schema.execute(request).await
     }
 }
 
-struct MutationRoot {
-    runtime: Arc<ServiceRuntime<CounterService>>,
-}
-
-#[Object]
-impl MutationRoot {
-    async fn increment(&self, value: u64) -> [u8; 0] {
-        self.runtime.schedule_operation(&value);
-        []
-    }
-}
-
-struct QueryRoot {
-    value: u64,
-}
-
-#[Object]
-impl QueryRoot {
-    async fn value(&self) -> &u64 {
-        &self.value
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;
@@ -94,7 +71,10 @@ mod tests {
             .expect("Failed to read from mock key value store");
         state.value.set(value);
 
-        let service = CounterService { state, runtime };
+        let service = CounterService {
+            state: Arc::new(state),
+            runtime,
+        };
         let request = Request::new("{ value }");
 
         let response = service

examples/counter/src/lib.rs

@@ -4,7 +4,7 @@
 use linera_sdk::views::{linera_views, RegisterView, RootView, ViewStorageContext};
 
 /// The application state.
-#[derive(RootView)]
+#[derive(RootView, async_graphql::SimpleObject)]
 #[view(context = ViewStorageContext)]
 pub struct CounterState {
     pub value: RegisterView<u64>,

examples/counter/src/service.rs

@@ -5,6 +5,7 @@
 
 #![cfg(not(target_arch = "wasm32"))]
 
+use counter::CounterOperation;
 use linera_sdk::test::{QueryOutcome, TestValidator};
 
 /// Test setting a counter and testing its coherency across microchains.
@@ -23,9 +24,10 @@ async fn single_chain_test() {
         .await;
 
     let increment = 15u64;
+    let operation = CounterOperation::Increment(increment);
     chain
         .add_block(|block| {
-            block.with_operation(application_id, increment);
+            block.with_operation(application_id, operation);
         })
         .await;
 

examples/counter/src/state.rs

@@ -95,7 +95,8 @@ impl Contract for MetaCounterContract {
             Message::Increment(value) => {
                 let counter_id = self.counter_id();
                 log::trace!("executing {} via {:?}", value, counter_id);
-                self.runtime.call_application(true, counter_id, &value);
+                let operation = counter::CounterOperation::Increment(value);
+                self.runtime.call_application(true, counter_id, &operation);
             }
         }
     }