Minify introspect return value

Author: Matthew Hawkins

crates/apollo-mcp-server/src/introspection/tools/introspect.rs

@@ -1,4 +1,5 @@
 use crate::errors::McpError;
+use crate::introspection::tools::introspect::minify::Minify;
 use crate::schema_from_type;
 use crate::schema_tree_shake::{DepthLimit, SchemaTreeShaker};
 use apollo_compiler::Schema;
@@ -13,6 +14,8 @@ use serde::Deserialize;
 use std::sync::Arc;
 use tokio::sync::Mutex;
 
+mod minify;
+
 /// The name of the tool to get GraphQL schema type information
 pub const INTROSPECT_TOOL_NAME: &str = "introspect";
 
@@ -37,23 +40,15 @@ pub struct Input {
 impl Introspect {
     pub fn new(
         schema: Arc<Mutex<Valid<Schema>>>,
-        root_query_type: Option<String>,
+        _root_query_type: Option<String>,
         root_mutation_type: Option<String>,
     ) -> Self {
         Self {
             schema,
             allow_mutations: root_mutation_type.is_some(),
             tool: Tool::new(
                 INTROSPECT_TOOL_NAME,
-                format!(
-                    "Get detailed information about types from the GraphQL schema.{}{}",
-                    root_query_type
-                        .map(|t| format!(" Use the type name `{t}` to get root query fields."))
-                        .unwrap_or_default(),
-                    root_mutation_type
-                        .map(|t| format!(" Use the type name `{t}` to get root mutation fields."))
-                        .unwrap_or_default()
-                ),
+                "Get GraphQL type information;T=type,I=input,E=enum,U=union,F=interface;s=String,i=Int,f=Float,b=Boolean,d=ID;!=required,[]=list;",
                 schema_from_type!(Input),
             ),
         }
@@ -113,8 +108,8 @@ impl Introspect {
                                 extended_type.name() != root_name || type_name == root_name.as_str()
                             })
                 })
-                .map(|(_, extended_type)| extended_type.serialize())
-                .map(|serialized| serialized.to_string())
+                .map(|(_, extended_type)| extended_type)
+                .map(ExtendedType::minify)
                 .map(Content::text)
                 .collect(),
             is_error: None,

crates/apollo-mcp-server/src/introspection/tools/introspect/minify.rs

@@ -0,0 +1,110 @@
+use apollo_compiler::schema::{ExtendedType, Type};
+
+pub trait Minify {
+    fn minify(&self) -> String;
+}
+
+// TODO: descriptions
+impl Minify for ExtendedType {
+    fn minify(&self) -> String {
+        match self {
+            ExtendedType::Scalar(scalar_type) => match scalar_type.name.as_str() {
+                "String" => "s",
+                "Int" => "i",
+                "Float" => "f",
+                "Boolean" => "b",
+                "ID" => "d",
+                _ => scalar_type.name.as_str(),
+            }
+            .to_string(),
+            ExtendedType::Object(object_type) => {
+                let mut fields = String::new();
+                for (field_name, field) in object_type.fields.iter() {
+                    fields.push_str(field_name.as_str());
+                    if !field.arguments.is_empty() {
+                        fields.push('(');
+                        fields.push_str(
+                            field
+                                .arguments
+                                .iter()
+                                .map(|arg| type_name(&arg.ty))
+                                .collect::<Vec<String>>()
+                                .join(",")
+                                .as_str(),
+                        );
+                        fields.push(')');
+                    }
+                    fields.push(':');
+                    fields.push_str(&type_name(&field.ty));
+                    fields.push(',');
+                }
+                fields.pop();
+                format!("T:{}:{}", object_type.name, fields)
+            }
+            ExtendedType::Interface(interface_type) => {
+                let mut fields = String::new();
+                for (field_name, field) in interface_type.fields.iter() {
+                    fields.push_str(field_name.as_str());
+                    if !field.arguments.is_empty() {
+                        fields.push('(');
+                        fields.push_str(
+                            field
+                                .arguments
+                                .iter()
+                                .map(|arg| type_name(&arg.ty))
+                                .collect::<Vec<String>>()
+                                .join(",")
+                                .as_str(),
+                        );
+                        fields.push(')');
+                    }
+                    fields.push(':');
+                    fields.push_str(&type_name(&field.ty));
+                    fields.push(',');
+                }
+                fields.pop();
+                format!("F:{}:{}", interface_type.name, fields)
+            }
+            ExtendedType::Union(union_type) => {
+                let mut types = String::new();
+                for type_name in union_type.members.iter() {
+                    types.push_str(type_name.as_str());
+                    types.push(',');
+                }
+                types.pop();
+                format!("U:{}:{}", union_type.name, types)
+            }
+            ExtendedType::Enum(enum_type) => {
+                let mut values = String::new();
+                for value in enum_type.values.keys() {
+                    values.push_str(value.as_str());
+                    values.push(',');
+                }
+                values.pop();
+                format!("E:{}:{}", enum_type.name, values)
+            }
+            ExtendedType::InputObject(input_object_type) => {
+                let mut fields = String::new();
+                for (field_name, field) in input_object_type.fields.iter() {
+                    fields.push_str(field_name.as_str());
+                    fields.push(':');
+                    fields.push_str(&type_name(&field.ty));
+                    fields.push(',');
+                }
+                fields.pop();
+                format!("I:{}:{}", input_object_type.name, fields)
+            }
+        }
+    }
+}
+
+fn type_name(ty: &Type) -> String {
+    let name = ty.inner_named_type().as_str();
+    if ty.is_list() {
+        format!("[{name}]")
+    } else if ty.is_non_null() {
+        format!("{name}!")
+    } else {
+        name.to_string()
+    }
+}