graphql, tests: _logs queries only return fields selected in query

Author: fordN

graphql/src/execution/execution.rs

@@ -345,43 +345,75 @@ pub(crate) async fn execute_root_selection_set_uncached(
             )]
         })?;
 
-        // Convert log entries to GraphQL values
+        // Get _Log_ type from schema for field selection
+        let log_type_def = ctx.query.schema.get_named_type("_Log_").ok_or_else(|| {
+            vec![QueryExecutionError::AbstractTypeError(
+                "_Log_ type not found in schema".to_string(),
+            )]
+        })?;
+        let log_object_type = match log_type_def {
+            s::TypeDefinition::Object(obj) => sast::ObjectType::from(Arc::new(obj.clone())),
+            _ => {
+                return Err(vec![QueryExecutionError::AbstractTypeError(
+                    "_Log_ is not an object type".to_string(),
+                )])
+            }
+        };
+
+        // Convert log entries to GraphQL values, respecting field selection
         let log_values: Vec<r::Value> = log_entries
             .into_iter()
             .map(|entry| {
-                // Convert arguments Vec<(String, String)> to GraphQL objects
-                let arguments: Vec<r::Value> = entry
-                    .arguments
-                    .into_iter()
-                    .map(|(key, value)| {
-                        object! {
-                            key: key,
-                            value: value,
-                            __typename: "_LogArgument_"
-                        }
-                    })
-                    .collect();
-
-                // Convert log level to string
+                // Convert log level to string (needed by multiple fields)
                 let level_str = entry.level.as_str().to_uppercase();
+                let mut results = Vec::new();
 
-                object! {
-                    id: entry.id,
-                    subgraphId: entry.subgraph_id.to_string(),
-                    timestamp: entry.timestamp,
-                    level: level_str,
-                    text: entry.text,
-                    arguments: arguments,
-                    meta: object! {
-                        module: entry.meta.module,
-                        line: r::Value::Int(entry.meta.line),
-                        column: r::Value::Int(entry.meta.column),
-                        __typename: "_LogMeta_"
-                    },
-                    __typename: "_Log_"
+                // Iterate over requested fields (same pattern as entity queries)
+                for log_field in field
+                    .selection_set
+                    .fields_for(&log_object_type)
+                    .map_err(|e| vec![e])?
+                {
+                    let response_key = log_field.response_key();
+
+                    // Map field name to LogEntry value (replaces prefetched_object lookup)
+                    let value = match log_field.name.as_str() {
+                        "id" => entry.id.clone().into_value(),
+                        "subgraphId" => entry.subgraph_id.to_string().into_value(),
+                        "timestamp" => entry.timestamp.clone().into_value(),
+                        "level" => level_str.clone().into_value(),
+                        "text" => entry.text.clone().into_value(),
+                        "arguments" => {
+                            // Convert arguments Vec<(String, String)> to GraphQL objects
+                            let args: Vec<r::Value> = entry
+                                .arguments
+                                .iter()
+                                .map(|(key, value)| {
+                                    object! {
+                                        key: key.clone(),
+                                        value: value.clone(),
+                                        __typename: "_LogArgument_"
+                                    }
+                                })
+                                .collect();
+                            r::Value::List(args)
+                        }
+                        "meta" => object! {
+                            module: entry.meta.module.clone(),
+                            line: r::Value::Int(entry.meta.line),
+                            column: r::Value::Int(entry.meta.column),
+                            __typename: "_LogMeta_"
+                        },
+                        "__typename" => "_Log_".into_value(),
+                        _ => continue, // Unknown field, skip it
+                    };
+
+                    results.push((Word::from(response_key), value));
                 }
+
+                Ok(r::Value::Object(Object::from_iter(results)))
             })
-            .collect();
+            .collect::<Result<Vec<_>, Vec<QueryExecutionError>>>()?;
 
         let response_key = Word::from(field.response_key());
         let logs_object = Object::from_iter(vec![(response_key, r::Value::List(log_values))]);

tests/tests/integration_tests.rs

@@ -1529,6 +1529,55 @@ async fn test_logs_query(ctx: TestContext) -> anyhow::Result<()> {
         error_msg
     );
 
+    // Test 7: Field selection - verify only requested fields are returned
+    let query = r#"{
+            _logs(first: 1) {
+                id
+                timestamp
+            }
+        }"#
+    .to_string();
+    let resp = subgraph.query(&query).await?;
+
+    let logs = resp["data"]["_logs"]
+        .as_array()
+        .context("Expected _logs to be an array")?;
+
+    if !logs.is_empty() {
+        let log = &logs[0];
+
+        // Verify requested fields are present
+        assert!(log.get("id").is_some(), "Expected id field to be present");
+        assert!(
+            log.get("timestamp").is_some(),
+            "Expected timestamp field to be present"
+        );
+
+        // Verify non-requested fields are NOT present
+        assert!(
+            log.get("text").is_none(),
+            "Expected text field to NOT be present (field selection bug)"
+        );
+        assert!(
+            log.get("level").is_none(),
+            "Expected level field to NOT be present (field selection bug)"
+        );
+        assert!(
+            log.get("subgraphId").is_none(),
+            "Expected subgraphId field to NOT be present (field selection bug)"
+        );
+        assert!(
+            log.get("arguments").is_none(),
+            "Expected arguments field to NOT be present (field selection bug)"
+        );
+        assert!(
+            log.get("meta").is_none(),
+            "Expected meta field to NOT be present (field selection bug)"
+        );
+
+        println!("✓ Field selection works correctly - only requested fields returned");
+    }
+
     Ok(())
 }