feat(gb-9065): try to reduce the amount of unused types in intro

Author: pimeys

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "grafbase-postgres"
-version = "0.3.3"
+version = "0.3.4"
 edition = "2024"
 license = "Apache-2.0"
 

cli/postgres/Cargo.toml

@@ -55,5 +55,7 @@ pub fn to_sdl(database_definition: DatabaseDefinition, config: &Config) -> Strin
         mutation::render(&database_definition, config, prefix, &mut rendered);
     }
 
+    rendered.remove_unused_types();
+
     rendered.to_string()
 }

crates/postgres-introspection/src/render.rs

@@ -55,10 +55,10 @@ impl fmt::Display for ArgumentValue<'_> {
 }
 
 pub struct Argument<'a> {
-    name: Cow<'a, str>,
-    value: ArgumentValue<'a>,
-    description: Option<Cow<'a, str>>,
-    directives: Vec<Directive<'a>>,
+    pub(super) name: Cow<'a, str>,
+    pub(super) value: ArgumentValue<'a>,
+    pub(super) description: Option<Cow<'a, str>>,
+    pub(super) directives: Vec<Directive<'a>>,
 }
 
 impl<'a> Argument<'a> {

crates/postgres-introspection/src/render/ast/directive.rs

@@ -3,10 +3,10 @@ use std::{borrow::Cow, fmt};
 use super::directive::Directive;
 
 pub struct Enum<'a> {
-    name: &'a str,
-    directives: Vec<Directive<'a>>,
-    variants: Vec<EnumVariant<'a>>,
-    description: Option<Cow<'a, str>>,
+    pub(super) name: &'a str,
+    pub(super) directives: Vec<Directive<'a>>,
+    pub(super) variants: Vec<EnumVariant<'a>>,
+    pub(super) description: Option<Cow<'a, str>>,
 }
 
 impl<'a> Enum<'a> {

crates/postgres-introspection/src/render/ast/enum.rs

@@ -6,12 +6,12 @@ use indenter::indented;
 use super::directive::{Argument, Directive};
 
 pub struct Field<'a> {
-    name: Cow<'a, str>,
-    r#type: Cow<'a, str>,
-    directives: Vec<Directive<'a>>,
-    arguments: Vec<Argument<'a>>,
-    description: Option<Cow<'a, str>>,
-    render_multiline: bool,
+    pub(super) name: Cow<'a, str>,
+    pub(super) r#type: Cow<'a, str>,
+    pub(super) directives: Vec<Directive<'a>>,
+    pub(super) arguments: Vec<Argument<'a>>,
+    pub(super) description: Option<Cow<'a, str>>,
+    pub(super) render_multiline: bool,
 }
 
 impl<'a> Field<'a> {

crates/postgres-introspection/src/render/ast/field.rs

@@ -6,10 +6,10 @@ use std::{
 use super::{directive::Directive, field::Field};
 
 pub struct InputType<'a> {
-    name: Cow<'a, str>,
-    directives: Vec<Directive<'a>>,
-    fields: Vec<Field<'a>>,
-    description: Option<Cow<'a, str>>,
+    pub(super) name: Cow<'a, str>,
+    pub(super) directives: Vec<Directive<'a>>,
+    pub(super) fields: Vec<Field<'a>>,
+    pub(super) description: Option<Cow<'a, str>>,
 }
 
 impl<'a> InputType<'a> {

crates/postgres-introspection/src/render/ast/input.rs

@@ -2,8 +2,8 @@ use std::borrow::Cow;
 use std::fmt;
 
 pub struct Scalar<'a> {
-    name: &'a str,
-    description: Option<Cow<'a, str>>,
+    pub(super) name: &'a str,
+    pub(super) description: Option<Cow<'a, str>>,
 }
 
 impl<'a> Scalar<'a> {

crates/postgres-introspection/src/render/ast/scalar.rs

@@ -1,6 +1,12 @@
-use std::fmt;
+use std::{cmp::Ordering, collections::HashSet, fmt};
 
-use super::{directive::Directive, r#enum::Enum, input::InputType, scalar::Scalar, r#type::Type};
+use super::{
+    directive::{ArgumentValue, Directive},
+    r#enum::Enum,
+    input::InputType,
+    scalar::Scalar,
+    r#type::Type,
+};
 
 #[derive(Default)]
 pub struct Schema<'a> {
@@ -35,6 +41,93 @@ impl<'a> Schema<'a> {
     pub fn push_scalar(&mut self, scalar: Scalar<'a>) {
         self.scalars.push(scalar);
     }
+
+    /// Kind of a yolo version of unused types check. But hey, it works. If somebody has lots of time
+    /// in their hands, would be great to write this with cynic ;)
+    pub fn remove_unused_types(&mut self) {
+        let mut used_types = HashSet::new();
+
+        // First pass: collect type references from regular types
+        for r#type in &self.types {
+            for field in &r#type.fields {
+                let type_name = field.r#type.replace("[", "").replace("]", "").replace("!", "");
+                used_types.insert(type_name);
+
+                // Process any arguments
+                for argument in &field.arguments {
+                    track_argument_inputs(&mut used_types, &argument.value);
+                }
+            }
+        }
+
+        // Keep resolving dependencies until we reach a fixed point
+        let mut size_before = 0;
+        while size_before != used_types.len() {
+            size_before = used_types.len();
+
+            // Process input types that are already marked as used
+            for input in &self.input_types {
+                if used_types.contains(input.name.as_ref()) {
+                    for field in &input.fields {
+                        let type_name = field.r#type.replace("[", "").replace("]", "").replace("!", "");
+                        used_types.insert(type_name);
+
+                        // Process any arguments
+                        for argument in &field.arguments {
+                            track_argument_inputs(&mut used_types, &argument.value);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Filter scalars to only keep those that are used
+        let mut scalars = Vec::new();
+        for scalar in self.scalars.drain(..) {
+            if used_types.contains(scalar.name) {
+                scalars.push(scalar);
+            }
+        }
+
+        self.scalars = scalars;
+
+        // Filter input types to only keep those that are used
+        let mut input_types = Vec::new();
+        for input in self.input_types.drain(..) {
+            if used_types.contains(input.name.as_ref()) {
+                input_types.push(input);
+            }
+        }
+        self.input_types = input_types;
+
+        self.scalars.sort_by_key(|scalar| scalar.name);
+        self.enums.sort_by_key(|r#enum| r#enum.name);
+        self.input_types.sort_by(|a, b| a.name.cmp(&b.name));
+
+        self.types.sort_by(|a, b| match (a.name.as_ref(), b.name.as_ref()) {
+            ("Query", "Mutation") => Ordering::Less,
+            ("Mutation", "Query") => Ordering::Greater,
+            ("Query", _) => Ordering::Greater,
+            ("Mutation", _) => Ordering::Greater,
+            _ => a.name.cmp(&b.name),
+        });
+    }
+}
+
+fn track_argument_inputs<'a>(used_inputs: &mut HashSet<String>, value: &'a ArgumentValue<'a>) {
+    match value {
+        ArgumentValue::Constant(constant) => {
+            let type_name = constant.replace("[", "").replace("]", "").replace("!", "");
+            used_inputs.insert(type_name);
+        }
+        ArgumentValue::Array(values) => values
+            .iter()
+            .for_each(|value| track_argument_inputs(used_inputs, value)),
+        ArgumentValue::MultiLineArray { values, .. } => values
+            .iter()
+            .for_each(|value| track_argument_inputs(used_inputs, value)),
+        _ => todo!(),
+    }
 }
 
 impl fmt::Display for Schema<'_> {

crates/postgres-introspection/src/render/ast/schema.rs

@@ -6,10 +6,10 @@ use std::{
 use super::{directive::Directive, field::Field};
 
 pub struct Type<'a> {
-    name: Cow<'a, str>,
-    directives: Vec<Directive<'a>>,
-    fields: Vec<Field<'a>>,
-    description: Option<Cow<'a, str>>,
+    pub(super) name: Cow<'a, str>,
+    pub(super) directives: Vec<Directive<'a>>,
+    pub(super) fields: Vec<Field<'a>>,
+    pub(super) description: Option<Cow<'a, str>>,
 }
 
 impl<'a> Type<'a> {