Streamline the use of GraphQLMutationRoot. (#4538)

## Motivation

The `GraphQLMutationRoot` is used for some smart contracts like
`non-fungible` when it is not needed.

## Proposal

There are two ways to implement the trait `MutationRoot`:
* One is to use the function `mutation_root` of the trait
`GraphQLMutationRoot` implemented by the derive macro. For example,
`counter`.
* Implement the trait explicitly. For example, `non-fungible`.

Therefore, two changes are made:
* When the second strategy is used, we should not implement the
`GraphQLMutationRoot` (3 cases removed).
* When the trait is being used, we formulate it as `GraphQLMutationRoot
as _` which is clearer (and examples are supposed to help).

## Test Plan

The CI.

## Release Plan

It does not break anything.

## Links

None.

Author: MathieuDutSik

examples/amm/src/service.rs

@@ -10,7 +10,7 @@ use std::sync::Arc;
 use amm::{Operation, Parameters};
 use async_graphql::{EmptySubscription, Request, Response, Schema};
 use linera_sdk::{
-    graphql::GraphQLMutationRoot, linera_base_types::WithServiceAbi, views::View, Service,
+    graphql::GraphQLMutationRoot as _, linera_base_types::WithServiceAbi, views::View, Service,
     ServiceRuntime,
 };
 

examples/counter/README.md

@@ -113,7 +113,7 @@ resulting block, if any.
 
 ```gql,uri=http://localhost:8080/chains/$CHAIN/applications/$LINERA_APPLICATION_ID
 mutation Increment {
-  increment(field0: 3)
+  increment(value: 3)
 }
 ```
 

examples/counter/src/contract.rs

@@ -46,8 +46,8 @@ impl Contract for CounterContract {
     }
 
     async fn execute_operation(&mut self, operation: CounterOperation) -> u64 {
-        let CounterOperation::Increment(operation) = operation;
-        let new_value = self.state.value.get() + operation;
+        let CounterOperation::Increment { value } = operation;
+        let new_value = self.state.value.get() + value;
         self.state.value.set(new_value);
         new_value
     }
@@ -75,7 +75,7 @@ mod tests {
         let mut counter = create_and_instantiate_counter(initial_value);
 
         let increment = 42_308_u64;
-        let operation = CounterOperation::Increment(increment);
+        let operation = CounterOperation::Increment { value: increment };
 
         let response = counter
             .execute_operation(operation)
@@ -106,7 +106,7 @@ mod tests {
         let mut counter = create_and_instantiate_counter(initial_value);
 
         let increment = 8_u64;
-        let operation = CounterOperation::Increment(increment);
+        let operation = CounterOperation::Increment { value: increment };
 
         let response = counter
             .execute_operation(operation)

examples/counter/src/lib.rs

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

examples/counter/src/service.rs

@@ -7,12 +7,9 @@ mod state;
 
 use std::sync::Arc;
 
-use async_graphql::{EmptySubscription, Request, Response, Schema};
+use async_graphql::{EmptySubscription, Object, Request, Response, Schema};
 use counter::CounterOperation;
-use linera_sdk::{
-    graphql::GraphQLMutationRoot, linera_base_types::WithServiceAbi, views::View, Service,
-    ServiceRuntime,
-};
+use linera_sdk::{linera_base_types::WithServiceAbi, views::View, Service, ServiceRuntime};
 
 use self::state::CounterState;
 
@@ -43,14 +40,29 @@ impl Service for CounterService {
     async fn handle_query(&self, request: Request) -> Response {
         let schema = Schema::build(
             self.state.clone(),
-            CounterOperation::mutation_root(self.runtime.clone()),
+            MutationRoot {
+                runtime: 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] {
+        let operation = CounterOperation::Increment { value };
+        self.runtime.schedule_operation(&operation);
+        []
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;

examples/counter/tests/single_chain.rs

@@ -24,7 +24,7 @@ async fn single_chain_test() {
         .await;
 
     let increment = 15u64;
-    let operation = CounterOperation::Increment(increment);
+    let operation = CounterOperation::Increment { value: increment };
     chain
         .add_block(|block| {
             block.with_operation(application_id, operation);

examples/crowd-funding/src/service.rs

@@ -10,7 +10,7 @@ use std::sync::Arc;
 use async_graphql::{EmptySubscription, Request, Response, Schema};
 use crowd_funding::Operation;
 use linera_sdk::{
-    graphql::GraphQLMutationRoot,
+    graphql::GraphQLMutationRoot as _,
     linera_base_types::{ApplicationId, WithServiceAbi},
     views::View,
     Service, ServiceRuntime,

examples/ethereum-tracker/src/service.rs

@@ -12,7 +12,7 @@ use async_graphql::{EmptySubscription, Request, Response, Schema};
 use ethereum_tracker::Operation;
 use linera_sdk::{
     ethereum::{EthereumDataType, EthereumEvent, EthereumQueries, ServiceEthereumClient},
-    graphql::GraphQLMutationRoot,
+    graphql::GraphQLMutationRoot as _,
     linera_base_types::WithServiceAbi,
     views::View,
     Service, ServiceRuntime,

examples/fungible/src/service.rs

@@ -11,7 +11,7 @@ use async_graphql::{EmptySubscription, Object, Request, Response, Schema};
 use fungible::{OwnerSpender, Parameters};
 use linera_sdk::{
     abis::fungible::FungibleOperation,
-    graphql::GraphQLMutationRoot,
+    graphql::GraphQLMutationRoot as _,
     linera_base_types::{AccountOwner, Amount, WithServiceAbi},
     views::{MapView, View},
     Service, ServiceRuntime,

examples/gen-nft/src/lib.rs

@@ -7,7 +7,6 @@ use std::fmt::{Display, Formatter};
 
 use async_graphql::{InputObject, Request, Response, SimpleObject};
 use linera_sdk::{
-    graphql::GraphQLMutationRoot,
     linera_base_types::{Account, AccountOwner, ApplicationId, ChainId, ContractAbi, ServiceAbi},
     ToBcsBytes,
 };
@@ -34,7 +33,7 @@ impl ServiceAbi for GenNftAbi {
 }
 
 /// An operation.
-#[derive(Debug, Deserialize, Serialize, GraphQLMutationRoot)]
+#[derive(Debug, Deserialize, Serialize)]
 pub enum Operation {
     /// Mints a token
     Mint {