add support for typed nested objects and lexicon refs in graphql schema

- Add GraphQLType::LexiconRef variant to distinguish lexicon type refs from record refs
- Implement type registry to track and deduplicate generated nested object types
- Add resolve_lexicon_ref_type() to resolve and generate types for lexicon refs like community.lexicon.location.hthree
- Add generate_nested_object_type() to recursively create GraphQL types for inline objects
- Update field resolvers to wrap nested object data in NestedObjectContainer
- Support both inline object definitions and lexicon type references
- Enable nested field queries in GraphQL (e.g., homeTown { name value })

api/src/graphql/schema_builder.rs

···
     at_uri_fields: Vec<String>, // Fields with format "at-uri" for reverse joins
 }
 
+/// Type registry for tracking generated nested object types
+type TypeRegistry = HashMap<String, Object>;
+
+/// Container for nested object field values
+#[derive(Clone)]
+struct NestedObjectContainer {
+    data: serde_json::Value,
+}
+
+/// Generates a unique type name for a nested object field
+fn generate_nested_type_name(parent_type: &str, field_name: &str) -> String {
+    let mut chars = field_name.chars();
+    let capitalized_field = match chars.next() {
+        None => String::new(),
+        Some(first) => first.to_uppercase().collect::<String>() + chars.as_str(),
+    };
+    format!("{}{}", parent_type, capitalized_field)
+}
+
+/// Resolves a lexicon ref and generates a GraphQL type for it
+/// Returns the generated type name
+fn resolve_lexicon_ref_type(
+    ref_nsid: &str,
+    all_lexicons: &[serde_json::Value],
+    type_registry: &mut TypeRegistry,
+    database: &Database,
+) -> String {
+    // Generate type name from NSID
+    let type_name = nsid_to_type_name(ref_nsid);
+
+    // Check if already generated
+    if type_registry.contains_key(&type_name) {
+        return type_name;
+    }
+
+    // Find the lexicon definition
+    let lexicon = all_lexicons.iter().find(|lex| {
+        lex.get("id").and_then(|id| id.as_str()) == Some(ref_nsid)
+    });
+
+    if let Some(lex) = lexicon {
+        // Extract the main definition
+        if let Some(defs) = lex.get("defs") {
+            let fields = extract_collection_fields(defs);
+
+            if !fields.is_empty() {
+                // Generate the type using existing nested object generator
+                generate_nested_object_type(&type_name, &fields, type_registry, database);
+                return type_name;
+            }
+        }
+    }
+
+    // Fallback: couldn't resolve the ref, will use JSON
+    tracing::warn!("Could not resolve lexicon ref: {}", ref_nsid);
+    type_name
+}
+
+/// Recursively generates GraphQL object types for nested objects
+/// Returns the type name of the generated object type
+fn generate_nested_object_type(
+    type_name: &str,
+    fields: &[GraphQLField],
+    type_registry: &mut TypeRegistry,
+    database: &Database,
+) -> String {
+    // Check if type already exists in registry
+    if type_registry.contains_key(type_name) {
+        return type_name.to_string();
+    }
+
+    let mut object = Object::new(type_name);
+
+    // Add fields to the object
+    for field in fields {
+        let field_name = field.name.clone();
+        let field_name_for_field = field_name.clone(); // Clone for Field::new
+        let field_type = field.field_type.clone();
+
+        // Determine the TypeRef for this field
+        let type_ref = match &field.field_type {
+            GraphQLType::Object(nested_fields) => {
+                // Generate nested object type recursively
+                let nested_type_name = generate_nested_type_name(type_name, &field_name);
+                let actual_type_name = generate_nested_object_type(
+                    &nested_type_name,
+                    nested_fields,
+                    type_registry,
+                    database,
+                );
+
+                if field.is_required {
+                    TypeRef::named_nn(actual_type_name)
+                } else {
+                    TypeRef::named(actual_type_name)
+                }
+            }
+            GraphQLType::Array(inner) => {
+                if let GraphQLType::Object(nested_fields) = inner.as_ref() {
+                    // Generate nested object type for array items
+                    let nested_type_name = generate_nested_type_name(type_name, &field_name);
+                    let actual_type_name = generate_nested_object_type(
+                        &nested_type_name,
+                        nested_fields,
+                        type_registry,
+                        database,
+                    );
+
+                    if field.is_required {
+                        TypeRef::named_nn_list(actual_type_name)
+                    } else {
+                        TypeRef::named_list(actual_type_name)
+                    }
+                } else {
+                    // Use standard type ref for arrays of primitives
+                    graphql_type_to_typeref(&field.field_type, field.is_required)
+                }
+            }
+            _ => {
+                // Use standard type ref for other types
+                graphql_type_to_typeref(&field.field_type, field.is_required)
+            }
+        };
+
+        // Add field with resolver
+        object = object.field(Field::new(&field_name_for_field, type_ref, move |ctx| {
+            let field_name = field_name.clone();
+            let field_type = field_type.clone();
+
+            FieldFuture::new(async move {
+                // Get parent container
+                let container = ctx.parent_value.try_downcast_ref::<NestedObjectContainer>()?;
+                let value = container.data.get(&field_name);
+
+                if let Some(val) = value {
+                    if val.is_null() {
+                        return Ok(None);
+                    }
+
+                    // For nested objects, wrap in container
+                    if matches!(field_type, GraphQLType::Object(_)) {
+                        let nested_container = NestedObjectContainer {
+                            data: val.clone(),
+                        };
+                        return Ok(Some(FieldValue::owned_any(nested_container)));
+                    }
+
+                    // For arrays of objects, wrap each item
+                    if let GraphQLType::Array(inner) = &field_type {
+                        if matches!(inner.as_ref(), GraphQLType::Object(_)) {
+                            if let Some(arr) = val.as_array() {
+                                let containers: Vec<FieldValue> = arr
+                                    .iter()
+                                    .map(|item| {
+                                        let nested_container = NestedObjectContainer {
+                                            data: item.clone(),
+                                        };
+                                        FieldValue::owned_any(nested_container)
+                                    })
+                                    .collect();
+                                return Ok(Some(FieldValue::list(containers)));
+                            }
+                            return Ok(Some(FieldValue::list(Vec::<FieldValue>::new())));
+                        }
+                    }
+
+                    // For other types, return the GraphQL value
+                    let graphql_val = json_to_graphql_value(val);
+                    Ok(Some(FieldValue::value(graphql_val)))
+                } else {
+                    Ok(None)
+                }
+            })
+        }));
+    }
+
+    // Store the generated type in registry
+    type_registry.insert(type_name.to_string(), object);
+    type_name.to_string()
+}
+
 /// Builds a dynamic GraphQL schema from lexicons for a given slice
 pub async fn build_graphql_schema(database: Database, slice_uri: String, auth_base_url: String) -> Result<Schema, String> {
     // Fetch all lexicons for this slice
···
         }
     }
 
+    // Initialize type registry for nested object types
+    let mut type_registry: TypeRegistry = HashMap::new();
+
     // Second pass: create types and queries
     for lexicon in &lexicons {
         // get_lexicons_by_slice returns {lexicon: 1, id: "nsid", defs: {...}}
···
                 slice_uri.clone(),
                 &all_collections,
                 auth_base_url.clone(),
+                &mut type_registry,
+                &lexicons,
             );
 
             // Create edge and connection types for this collection (Relay standard)
···
         schema_builder = schema_builder.register(mutation_input);
     }
 
+    // Register all nested object types from the type registry
+    for (_, nested_type) in type_registry {
+        schema_builder = schema_builder.register(nested_type);
+    }
+
     schema_builder
         .finish()
         .map_err(|e| format!("Schema build error: {:?}", e))
···
     slice_uri: String,
     all_collections: &[CollectionMeta],
     auth_base_url: String,
+    type_registry: &mut TypeRegistry,
+    all_lexicons: &[serde_json::Value],
 ) -> Object {
     let mut object = Object::new(type_name);
 
···
         let field_type = field.field_type.clone();
         let db_clone = database.clone();
 
-        let type_ref = graphql_type_to_typeref(&field.field_type, field.is_required);
+        // Determine type ref - handle nested objects and lexicon refs specially
+        let type_ref = match &field.field_type {
+            GraphQLType::LexiconRef(ref_nsid) => {
+                // Resolve lexicon ref and generate type for it
+                let resolved_type_name = resolve_lexicon_ref_type(
+                    ref_nsid,
+                    all_lexicons,
+                    type_registry,
+                    &database,
+                );
+
+                if field.is_required {
+                    TypeRef::named_nn(resolved_type_name)
+                } else {
+                    TypeRef::named(resolved_type_name)
+                }
+            }
+            GraphQLType::Object(nested_fields) => {
+                // Generate nested object type
+                let nested_type_name = generate_nested_type_name(type_name, &field_name);
+                let actual_type_name = generate_nested_object_type(
+                    &nested_type_name,
+                    nested_fields,
+                    type_registry,
+                    &database,
+                );
+
+                if field.is_required {
+                    TypeRef::named_nn(actual_type_name)
+                } else {
+                    TypeRef::named(actual_type_name)
+                }
+            }
+            GraphQLType::Array(inner) => {
+                match inner.as_ref() {
+                    GraphQLType::LexiconRef(ref_nsid) => {
+                        // Resolve lexicon ref for array items
+                        let resolved_type_name = resolve_lexicon_ref_type(
+                            ref_nsid,
+                            all_lexicons,
+                            type_registry,
+                            &database,
+                        );
+
+                        if field.is_required {
+                            TypeRef::named_nn_list(resolved_type_name)
+                        } else {
+                            TypeRef::named_list(resolved_type_name)
+                        }
+                    }
+                    GraphQLType::Object(nested_fields) => {
+                        // Generate nested object type for array items
+                        let nested_type_name = generate_nested_type_name(type_name, &field_name);
+                        let actual_type_name = generate_nested_object_type(
+                            &nested_type_name,
+                            nested_fields,
+                            type_registry,
+                            &database,
+                        );
+
+                        if field.is_required {
+                            TypeRef::named_nn_list(actual_type_name)
+                        } else {
+                            TypeRef::named_list(actual_type_name)
+                        }
+                    }
+                    _ => graphql_type_to_typeref(&field.field_type, field.is_required),
+                }
+            }
+            _ => graphql_type_to_typeref(&field.field_type, field.is_required),
+        };
 
         object = object.field(Field::new(&field_name_for_field, type_ref, move |ctx| {
             let field_name = field_name.clone();
···
                         }
                     }
 
-                    // For non-ref fields, return the raw JSON value
+                    // Check if this is a lexicon ref field
+                    if matches!(field_type, GraphQLType::LexiconRef(_)) {
+                        let nested_container = NestedObjectContainer {
+                            data: val.clone(),
+                        };
+                        return Ok(Some(FieldValue::owned_any(nested_container)));
+                    }
+
+                    // Check if this is a nested object field
+                    if matches!(field_type, GraphQLType::Object(_)) {
+                        let nested_container = NestedObjectContainer {
+                            data: val.clone(),
+                        };
+                        return Ok(Some(FieldValue::owned_any(nested_container)));
+                    }
+
+                    // Check if this is an array of nested objects or lexicon refs
+                    if let GraphQLType::Array(inner) = &field_type {
+                        if matches!(inner.as_ref(), GraphQLType::LexiconRef(_)) || matches!(inner.as_ref(), GraphQLType::Object(_)) {
+                            if let Some(arr) = val.as_array() {
+                                let containers: Vec<FieldValue> = arr
+                                    .iter()
+                                    .map(|item| {
+                                        let nested_container = NestedObjectContainer {
+                                            data: item.clone(),
+                                        };
+                                        FieldValue::owned_any(nested_container)
+                                    })
+                                    .collect();
+                                return Ok(Some(FieldValue::list(containers)));
+                            }
+                            return Ok(Some(FieldValue::list(Vec::<FieldValue>::new())));
+                        }
+                    }
+
+                    // For non-ref, non-object fields, return the raw JSON value
                     let graphql_val = json_to_graphql_value(val);
                     Ok(Some(FieldValue::value(graphql_val)))
                 } else {
···
             // Always nullable since blob data might be missing or malformed
             TypeRef::named("Blob")
         }
-        GraphQLType::Json | GraphQLType::Ref | GraphQLType::Object(_) | GraphQLType::Union => {
-            // JSON scalar type - linked records and complex objects return as JSON
+        GraphQLType::Json | GraphQLType::Ref | GraphQLType::LexiconRef(_) | GraphQLType::Object(_) | GraphQLType::Union => {
+            // JSON scalar type - linked records, lexicon refs, and complex objects return as JSON (fallback)
             if is_required {
                 TypeRef::named_nn("JSON")
             } else {

api/src/graphql/types.rs

···
     Float,
     /// Reference to another record (for strongRef)
     Ref,
+    /// Reference to a lexicon type definition (e.g., community.lexicon.location.hthree)
+    LexiconRef(String),
     /// Array of a type
     Array(Box<GraphQLType>),
     /// Object with nested fields
···
         "unknown" => GraphQLType::Json,
         "null" => GraphQLType::Json,
         "ref" => {
-            // Check if this is a strongRef (link to another record)
+            // Check if this is a strongRef (link to another record) or a lexicon type ref
             let ref_name = lexicon_def
                 .get("ref")
                 .and_then(|r| r.as_str())
···
 
             if ref_name == "com.atproto.repo.strongRef" {
                 GraphQLType::Ref
+            } else if !ref_name.is_empty() {
+                // This is a reference to a lexicon type definition
+                GraphQLType::LexiconRef(ref_name.to_string())
             } else {
                 GraphQLType::Json
             }