refactor: use a consistent prefix for auto-generated names

src/cli/llm/infer_type_name.rs

@@ -1,13 +1,16 @@
 use std::collections::HashMap;
 
 use genai::chat::{ChatMessage, ChatRequest, ChatResponse};
+use indexmap::IndexSet;
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 
 use super::{Error, Result, Wizard};
 use crate::core::config::Config;
 use crate::core::Mustache;
 
+const BASE_TEMPLATE: &str = include_str!("prompts/infer_type_name.md");
+
 pub struct InferTypeName {
     wizard: Wizard<Question, Answer>,
 }
@@ -29,6 +32,8 @@
 
 #[derive(Clone, Serialize)]
 struct Question {
+    #[serde(skip_serializing_if = "IndexSet::is_empty")]
+    used_types: IndexSet<String>,
     fields: Vec<(String, String)>,
 }
 
@@ -37,6 +42,7 @@
 
     fn try_into(self) -> Result<ChatRequest> {
         let input = serde_json::to_string_pretty(&Question {
+            used_types: IndexSet::default(),
             fields: vec![
                 ("id".to_string(), "String".to_string()),
                 ("name".to_string(), "String".to_string()),
@@ -54,10 +60,10 @@
             ],
         })?;
 
-        let template_str = include_str!("prompts/infer_type_name.md");
-        let template = Mustache::parse(template_str);
+        let template = Mustache::parse(BASE_TEMPLATE);
 
         let context = json!({
+            "used_types": self.used_types,
             "input": input,
             "output": output,
         });
@@ -66,7 +72,9 @@
 
         Ok(ChatRequest::new(vec![
             ChatMessage::system(rendered_prompt),
-            ChatMessage::user(serde_json::to_string(&self)?),
+            ChatMessage::user(serde_json::to_string(&json!({
+                "fields": &self.fields,
+            }))?),
         ]))
     }
 }
@@ -76,20 +84,35 @@
         Self { wizard: Wizard::new(model, secret) }
     }
 
+    /// All generated type names starts with "GEN__"
+    #[inline]
+    fn is_auto_generated(type_name: &str) -> bool {
+        type_name.starts_with("GEN__")
+    }
+
     pub async fn generate(&mut self, config: &Config) -> Result<HashMap<String, String>> {
         let mut new_name_mappings: HashMap<String, String> = HashMap::new();
-
-        // removed root type from types.
+        // Filter out root operation types and types with non-auto-generated names
         let types_to_be_processed = config
             .types
             .iter()
-            .filter(|(type_name, _)| !config.is_root_operation_type(type_name))
+            .filter(|(type_name, _)| {
+                !config.is_root_operation_type(type_name) && Self::is_auto_generated(type_name)
+            })
             .collect::<Vec<_>>();
 
+        let mut used_type_names = config
+            .types
+            .iter()
+            .filter(|(ty_name, _)| !Self::is_auto_generated(ty_name))
+            .map(|(ty_name, _)| ty_name.to_owned())
+            .collect::<IndexSet<_>>();
+
         let total = types_to_be_processed.len();
         for (i, (type_name, type_)) in types_to_be_processed.into_iter().enumerate() {
             // convert type to sdl format.
             let question = Question {
+                used_types: used_type_names.clone(),
                 fields: type_
                     .fields
                     .iter()
@@ -104,12 +127,11 @@
                     Ok(answer) => {
                         let name = &answer.suggestions.join(", ");
                         for name in answer.suggestions {
-                            if config.types.contains_key(&name)
-                                || new_name_mappings.contains_key(&name)
-                            {
+                            if config.types.contains_key(&name) || used_type_names.contains(&name) {
                                 continue;
                             }
-                            new_name_mappings.insert(name, type_name.to_owned());
+                            used_type_names.insert(name.clone());
+                            new_name_mappings.insert(type_name.to_owned(), name);
                             break;
                         }
                         tracing::info!(
@@ -142,19 +164,22 @@
             }
         }
 
-        Ok(new_name_mappings.into_iter().map(|(k, v)| (v, k)).collect())
+        Ok(new_name_mappings)
     }
 }
 
 #[cfg(test)]
 mod test {
     use genai::chat::{ChatRequest, ChatResponse, MessageContent};
+    use indexmap::indexset;
 
     use super::{Answer, Question};
+    use crate::cli::llm::InferTypeName;
 
     #[test]
     fn test_to_chat_request_conversion() {
         let question = Question {
+            used_types: indexset! {"Profile".to_owned(), "Person".to_owned()},
             fields: vec![
                 ("id".to_string(), "String".to_string()),
                 ("name".to_string(), "String".to_string()),
@@ -176,4 +201,21 @@
         let answer = Answer::try_from(resp).unwrap();
         insta::assert_debug_snapshot!(answer);
     }
+
+    #[test]
+    fn test_is_auto_generated() {
+        assert!(InferTypeName::is_auto_generated("GEN__T1"));
+        assert!(InferTypeName::is_auto_generated("GEN__T1234"));
+        assert!(InferTypeName::is_auto_generated("GEN__M1"));
+        assert!(InferTypeName::is_auto_generated("GEN__M5678"));
+        assert!(InferTypeName::is_auto_generated("GEN__Some__Type"));
+
+        assert!(!InferTypeName::is_auto_generated("Some__Type"));
+        assert!(!InferTypeName::is_auto_generated("User"));
+        assert!(!InferTypeName::is_auto_generated("T123"));
+        assert!(!InferTypeName::is_auto_generated("M1"));
+        assert!(!InferTypeName::is_auto_generated(""));
+        assert!(!InferTypeName::is_auto_generated("123T"));
+        assert!(!InferTypeName::is_auto_generated("A1234"));
+    }
 }

src/cli/llm/prompts/infer_type_name.md

@@ -1,5 +1,7 @@
 Given the sample schema of a GraphQL type, suggest 5 meaningful names for it.
-The name should be concise and preferably a single word.
+The name should be concise, preferably a single word and must not be represent in used_types list.
+
+used_types: {{used_types}}
 
 Example Input:
 {{input}}
@@ -8,5 +10,3 @@ Example Output:
 {{output}}
 
 Ensure the output is in valid JSON format.
-
-Do not add any additional text before or after the JSON.

src/cli/llm/snapshots/tailcall__cli__llm__infer_type_name__test__to_chat_request_conversion.snap

@@ -8,7 +8,7 @@ ChatRequest {
         ChatMessage {
             role: System,
             content: Text(
-                "Given the sample schema of a GraphQL type, suggest 5 meaningful names for it.\nThe name should be concise and preferably a single word.\n\nExample Input:\n{\n  \"fields\": [\n    [\n      \"id\",\n      \"String\"\n    ],\n    [\n      \"name\",\n      \"String\"\n    ],\n    [\n      \"age\",\n      \"Int\"\n    ]\n  ]\n}\n\nExample Output:\n{\n  \"suggestions\": [\n    \"Person\",\n    \"Profile\",\n    \"Member\",\n    \"Individual\",\n    \"Contact\"\n  ]\n}\n\nEnsure the output is in valid JSON format.\n\nDo not add any additional text before or after the JSON.\n",
+                "Given the sample schema of a GraphQL type, suggest 5 meaningful names for it.\nThe name should be concise, preferably a single word and must not be represent in used_types list.\n\nused_types: [\"Profile\",\"Person\"]\n\nExample Input:\n{\n  \"fields\": [\n    [\n      \"id\",\n      \"String\"\n    ],\n    [\n      \"name\",\n      \"String\"\n    ],\n    [\n      \"age\",\n      \"Int\"\n    ]\n  ]\n}\n\nExample Output:\n{\n  \"suggestions\": [\n    \"Person\",\n    \"Profile\",\n    \"Member\",\n    \"Individual\",\n    \"Contact\"\n  ]\n}\n\nEnsure the output is in valid JSON format.\n",
             ),
             extra: None,
         },

src/core/config/transformer/improve_type_names.rs

@@ -76,8 +76,10 @@ impl<'a> CandidateGeneration<'a> {
     fn generate(mut self) -> CandidateConvergence<'a> {
         for (type_name, type_info) in self.config.types.iter() {
             for (field_name, field_info) in type_info.fields.iter() {
-                if self.config.is_scalar(field_info.type_of.name()) {
-                    // If field type is scalar then ignore type name inference.
+                if self.config.is_scalar(field_info.type_of.name())
+                    || field_name.starts_with("GEN__")
+                {
+                    // If field type is scalar or auto generated then ignore type name inference.
                     continue;
                 }
 

src/core/config/transformer/merge_types/snapshots/tailcall__core__config__transformer__merge_types__type_merger__test__cyclic_merge_case.snap

@@ -6,15 +6,15 @@ schema @server @upstream {
   query: Query
 }
 
-type M1 {
+type GEN__M1 {
   body: String
   id: Int
   is_verified: Boolean
-  t1: M1
+  t1: GEN__M1
   userId: Int
 }
 
 type Query {
-  q1: M1
-  q2: M1
+  q1: GEN__M1
+  q2: GEN__M1
 }

src/core/config/transformer/merge_types/snapshots/tailcall__core__config__transformer__merge_types__type_merger__test__input_types.snap

@@ -11,12 +11,12 @@ input Far {
   tar: String
 }
 
-input M1 {
+input GEN__M1 {
   tar: String
 }
 
 type Query {
-  bar(input: M1): String @http(path: "/bar")
+  bar(input: GEN__M1): String @http(path: "/bar")
   far(input: Far): String @http(path: "/far")
-  foo(input: M1): String @http(path: "/foo")
+  foo(input: GEN__M1): String @http(path: "/foo")
 }

src/core/config/transformer/merge_types/snapshots/tailcall__core__config__transformer__merge_types__type_merger__test__interface_types.snap

@@ -2,10 +2,10 @@
 source: src/core/config/transformer/merge_types/type_merger.rs
 expression: config.to_sdl()
 ---
-interface M1 {
+interface GEN__M1 {
   a: Int
 }
 
-type C implements M1 {
+type C implements GEN__M1 {
   a: Int
 }

src/core/config/transformer/merge_types/snapshots/tailcall__core__config__transformer__merge_types__type_merger__test__merge_to_supertype.snap

@@ -6,12 +6,12 @@ schema @server @upstream {
   query: Query
 }
 
-type M1 {
+type GEN__M1 {
   id: Int
   name: JSON
 }
 
 type Query {
-  bar: M1
-  foo: M1
+  bar: GEN__M1
+  foo: GEN__M1
 }

src/core/config/transformer/merge_types/snapshots/tailcall__core__config__transformer__merge_types__type_merger__test__type_merger.snap

@@ -6,7 +6,7 @@ schema @server @upstream {
   query: Query
 }
 
-type M1 {
+type GEN__M1 {
   f1: String
   f2: Int
   f3: Boolean
@@ -15,8 +15,8 @@ type M1 {
 }
 
 type Query {
-  q1: M1
-  q2: M1
-  q3: M1
-  q4: M1
+  q1: GEN__M1
+  q2: GEN__M1
+  q3: GEN__M1
+  q4: GEN__M1
 }

src/core/config/transformer/merge_types/snapshots/tailcall__core__config__transformer__merge_types__type_merger__test__union_types.snap

@@ -6,15 +6,15 @@ schema @server @upstream(baseURL: "http://jsonplacheholder.typicode.com") {
   query: Query
 }
 
-union FooBar = Foo | M1
+union FooBar = Foo | GEN__M1
 
 type Foo {
   a: String
   bar: String
   foo: String
 }
 
-type M1 {
+type GEN__M1 {
   bar: String
 }
 

src/core/config/transformer/merge_types/type_merger.rs

@@ -1,4 +1,6 @@
-use std::collections::{BTreeMap, BTreeSet, HashSet};
+use std::collections::HashSet;
+
+use indexmap::{IndexMap, IndexSet};
 
 use super::mergeable_types::MergeableTypes;
 use super::similarity::Similarity;
@@ -31,25 +33,31 @@ impl Default for TypeMerger {
 
 impl TypeMerger {
     fn merger(&self, mut merge_counter: u32, mut config: Config) -> Config {
-        let mut type_to_merge_type_mapping = BTreeMap::new();
-        let mut similar_type_group_list: Vec<BTreeSet<String>> = vec![];
+        let mut type_to_merge_type_mapping = IndexMap::new();
+        let mut similar_type_group_list: Vec<IndexSet<String>> = vec![];
         let mut visited_types = HashSet::new();
         let mut i = 0;
         let mut stat_gen = Similarity::new(&config);
         let mergeable_types = MergeableTypes::new(&config, self.threshold);
 
+        // fixes the flaky tests.
+        let mut types = mergeable_types.iter().collect::<Vec<_>>();
+        types.sort();
+
         // step 1: identify all the types that satisfies the thresh criteria and group
         // them.
-        for type_name_1 in mergeable_types.iter() {
+        for type_name_1 in types.iter() {
+            let type_name_1 = type_name_1.as_str();
             if let Some(type_info_1) = config.types.get(type_name_1) {
                 if visited_types.contains(type_name_1) {
                     continue;
                 }
 
-                let mut similar_type_set = BTreeSet::new();
+                let mut similar_type_set = IndexSet::new();
                 similar_type_set.insert(type_name_1.to_string());
 
-                for type_name_2 in mergeable_types.iter().skip(i + 1) {
+                for type_name_2 in types.iter().skip(i + 1) {
+                    let type_name_2 = type_name_2.as_str();
                     if visited_types.contains(type_name_2)
                         || !mergeable_types.mergeable(type_name_1, type_name_2)
                     {
@@ -58,7 +66,7 @@ impl TypeMerger {
 
                     if let Some(type_info_2) = config.types.get(type_name_2) {
                         let threshold = mergeable_types.get_threshold(type_name_1, type_name_2);
-                        visited_types.insert(type_name_1.clone());
+                        visited_types.insert(type_name_1.to_owned());
                         let is_similar = stat_gen
                             .similarity(
                                 (type_name_1, type_info_1),
@@ -69,7 +77,7 @@ impl TypeMerger {
 
                         if let Ok(similar) = is_similar {
                             if similar {
-                                visited_types.insert(type_name_2.clone());
+                                visited_types.insert(type_name_2.to_owned());
                                 similar_type_set.insert(type_name_2.to_owned());
                             }
                         }
@@ -89,7 +97,7 @@ impl TypeMerger {
         // step 2: merge similar types into single merged type.
         for same_types in similar_type_group_list {
             let mut merged_into = Type::default();
-            let merged_type_name = format!("M{}", merge_counter);
+            let merged_type_name = format!("GEN__M{}", merge_counter);
             let mut did_we_merge = false;
             for type_name in same_types {
                 if let Some(type_) = config.types.get(type_name.as_str()) {