[GraphQL] Add a separate timeout field in ServiceConfig for mutations

crates/sui-graphql-rpc/schema/current_progress_schema.graphql

@@ -3063,6 +3063,11 @@ type ServiceConfig {
 	"""
 	maxPageSize: Int!
 	"""
+	Maximum time in milliseconds that it will wait to get the results from the execution. Note,
+	that the transaction might be still queued for execution beyond this timeout.
+	"""
+	mutationTimeoutMs: Int!
+	"""
 	Maximum time in milliseconds that will be spent to serve one request.
 	"""
 	requestTimeoutMs: Int!

crates/sui-graphql-rpc/src/config.rs

@@ -27,6 +27,7 @@ const MAX_TYPE_NODES: u32 = 256;
 const MAX_MOVE_VALUE_DEPTH: u32 = 128;
 
 pub(crate) const DEFAULT_REQUEST_TIMEOUT_MS: u64 = 40_000;
+pub(crate) const DEFAULT_MUTATION_TIMEOUT_MS: u64 = 60_000;
 
 const DEFAULT_IDE_TITLE: &str = "Sui GraphQL IDE";
 
@@ -126,6 +127,8 @@ pub struct Limits {
     #[serde(default)]
     pub max_page_size: u64,
     #[serde(default)]
+    pub mutation_timeout_ms: u64,
+    #[serde(default)]
     pub request_timeout_ms: u64,
     #[serde(default)]
     pub max_type_argument_depth: u32,
@@ -300,6 +303,12 @@ impl ServiceConfig {
         self.limits.max_page_size
     }
 
+    /// Maximum time in milliseconds that it will wait to get the results from the execution. Note
+    /// that the transaction might take longer to execute than this timeout.
+    async fn mutation_timeout_ms(&self) -> u64 {
+        self.limits.mutation_timeout_ms
+    }
+
     /// Maximum time in milliseconds that will be spent to serve one request.
     async fn request_timeout_ms(&self) -> u64 {
         self.limits.request_timeout_ms
@@ -483,6 +492,7 @@ impl Default for Limits {
             max_db_query_cost: MAX_DB_QUERY_COST,
             default_page_size: DEFAULT_PAGE_SIZE,
             max_page_size: MAX_PAGE_SIZE,
+            mutation_timeout_ms: DEFAULT_MUTATION_TIMEOUT_MS,
             request_timeout_ms: DEFAULT_REQUEST_TIMEOUT_MS,
             max_type_argument_depth: MAX_TYPE_ARGUMENT_DEPTH,
             max_type_argument_width: MAX_TYPE_ARGUMENT_WIDTH,
@@ -537,6 +547,7 @@ mod tests {
                 max-db-query-cost = 50
                 default-page-size = 20
                 max-page-size = 50
+                mutation-timeout-ms = 60000
                 request-timeout-ms = 27000
                 max-type-argument-depth = 32
                 max-type-argument-width = 64
@@ -555,6 +566,7 @@ mod tests {
                 max_db_query_cost: 50,
                 default_page_size: 20,
                 max_page_size: 50,
+                mutation_timeout_ms: 60_000,
                 request_timeout_ms: 27_000,
                 max_type_argument_depth: 32,
                 max_type_argument_width: 64,
@@ -617,6 +629,7 @@ mod tests {
                 max-db-query-cost = 20
                 default-page-size = 10
                 max-page-size = 20
+                mutation-timeout-ms = 60000
                 request-timeout-ms = 30000
                 max-type-argument-depth = 32
                 max-type-argument-width = 64
@@ -638,6 +651,7 @@ mod tests {
                 max_db_query_cost: 20,
                 default_page_size: 10,
                 max_page_size: 20,
+                mutation_timeout_ms: 60_000,
                 request_timeout_ms: 30_000,
                 max_type_argument_depth: 32,
                 max_type_argument_width: 64,

crates/sui-graphql-rpc/src/extensions/timeout.rs

@@ -3,7 +3,7 @@
 
 use async_graphql::{
     extensions::{Extension, ExtensionContext, ExtensionFactory, NextExecute, NextParseQuery},
-    parser::types::ExecutableDocument,
+    parser::types::{ExecutableDocument, OperationType},
     Response, ServerError, ServerResult,
 };
 use async_graphql_value::Variables;
@@ -22,12 +22,14 @@ pub(crate) struct Timeout;
 #[derive(Debug, Default)]
 struct TimeoutExt {
     pub query: Mutex<Option<String>>,
+    pub is_mutation: Mutex<bool>,
 }
 
 impl ExtensionFactory for Timeout {
     fn create(&self) -> Arc<dyn Extension> {
         Arc::new(TimeoutExt {
             query: Mutex::new(None),
+            is_mutation: Mutex::new(false),
         })
     }
 }
@@ -42,6 +44,13 @@ impl Extension for TimeoutExt {
         next: NextParseQuery<'_>,
     ) -> ServerResult<ExecutableDocument> {
         let document = next.run(ctx, query, variables).await?;
+        let is_mutation = document
+            .operations
+            .iter()
+            .any(|(_, operation)| operation.node.ty == OperationType::Mutation);
+        if is_mutation {
+            *self.is_mutation.lock().unwrap() = true;
+        }
         *self.query.lock().unwrap() = Some(ctx.stringify_execute_doc(&document, variables));
         Ok(document)
     }
@@ -52,10 +61,16 @@ impl Extension for TimeoutExt {
         operation_name: Option<&str>,
         next: NextExecute<'_>,
     ) -> Response {
-        let cfg = ctx
-            .data::<ServiceConfig>()
+        let cfg: &ServiceConfig = ctx
+            .data()
             .expect("No service config provided in schema data");
-        let request_timeout = Duration::from_millis(cfg.limits.request_timeout_ms);
+        // increase the timeout if the request is a mutation
+        let request_timeout = if *self.is_mutation.lock().unwrap() {
+            Duration::from_millis(cfg.limits.mutation_timeout_ms)
+        } else {
+            Duration::from_millis(cfg.limits.request_timeout_ms)
+        };
+
         timeout(request_timeout, next.run(ctx, operation_name))
             .await
             .unwrap_or_else(|_| {
@@ -74,13 +89,18 @@ impl Extension for TimeoutExt {
                     %error_code,
                     %query
                 );
-                Response::from_errors(vec![ServerError::new(
+                let error_msg = if *self.is_mutation.lock().unwrap() {
+                    format!(
+                        "Mutation request timed out. Limit: {}s",
+                        request_timeout.as_secs_f32()
+                    )
+                } else {
                     format!(
-                        "Request timed out. Limit: {}s",
+                        "Query request timed out. Limit: {}s",
                         request_timeout.as_secs_f32()
-                    ),
-                    None,
-                )])
+                    )
+                };
+                Response::from_errors(vec![ServerError::new(error_msg, None)])
             })
     }
 }

crates/sui-graphql-rpc/tests/snapshots/snapshot_tests__schema_sdl_export.snap

@@ -3067,6 +3067,11 @@ type ServiceConfig {
 	"""
 	maxPageSize: Int!
 	"""
+	Maximum time in milliseconds that it will wait to get the results from the execution. Note,
+	that the transaction might be still queued for execution beyond this timeout.
+	"""
+	mutationTimeoutMs: Int!
+	"""
 	Maximum time in milliseconds that will be spent to serve one request.
 	"""
 	requestTimeoutMs: Int!
@@ -4213,3 +4218,4 @@ schema {
 	query: Query
 	mutation: Mutation
 }
+