add aggregate queries to graphql schema builder

api/src/database/records.rs

···
 use super::types::{SortField, WhereClause};
 use crate::errors::DatabaseError;
 use crate::models::{IndexedRecord, Record};
+use sqlx::Row;
 
 impl Database {
     /// Inserts a single record into the database.
···
 
         let count = query_builder.fetch_one(&self.pool).await?;
         Ok(count)
+    }
+
+    /// Queries aggregated records with GROUP BY support.
+    ///
+    /// # Arguments
+    /// * `slice_uri` - AT-URI of the slice to query
+    /// * `group_by_fields` - JSON paths to group by (e.g., ["releaseMbId", "releaseName"])
+    /// * `where_clause` - Optional WHERE conditions
+    /// * `order_by_count` - Optional ordering ("asc" or "desc")
+    /// * `limit` - Maximum number of groups to return
+    ///
+    /// # Returns
+    /// Vec of (field_values, count) tuples
+    pub async fn get_aggregated_records(
+        &self,
+        slice_uri: &str,
+        group_by_fields: &[String],
+        where_clause: Option<&WhereClause>,
+        order_by_count: Option<&str>,
+        limit: Option<i32>,
+    ) -> Result<Vec<serde_json::Value>, DatabaseError> {
+        if group_by_fields.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        let limit = limit.unwrap_or(50).min(1000);
+        let mut param_count = 1;
+
+        // Build SELECT clause with JSON field extraction
+        let select_fields: Vec<String> = group_by_fields
+            .iter()
+            .enumerate()
+            .map(|(i, field)| {
+                // Check if it's a table column
+                if matches!(field.as_str(), "did" | "collection" | "uri" | "cid" | "indexed_at") {
+                    format!("\"{}\" as field_{}", field, i)
+                } else {
+                    // JSON field
+                    format!("json->>'{}'  as field_{}", field, i)
+                }
+            })
+            .collect();
+
+        let select_clause = format!("{}, COUNT(*) as count", select_fields.join(", "));
+
+        // Build GROUP BY clause
+        let group_by_clause: Vec<String> = (0..group_by_fields.len())
+            .map(|i| format!("field_{}", i))
+            .collect();
+
+        // Build WHERE clause
+        let mut where_clauses = vec![format!("slice_uri = ${}", param_count)];
+        param_count += 1;
+
+        let (and_conditions, or_conditions) =
+            build_where_conditions(where_clause, &mut param_count);
+        where_clauses.extend(and_conditions);
+
+        if !or_conditions.is_empty() {
+            let or_clause = format!("({})", or_conditions.join(" OR "));
+            where_clauses.push(or_clause);
+        }
+
+        let where_sql = format!(" WHERE {}", where_clauses.join(" AND "));
+
+        // Build ORDER BY clause
+        let order_by_sql = match order_by_count {
+            Some("asc") => " ORDER BY count ASC",
+            Some("desc") | Some(_) | None => " ORDER BY count DESC",
+        };
+
+        let query = format!(
+            "SELECT {} FROM record{} GROUP BY {} {}  LIMIT {}",
+            select_clause, where_sql, group_by_clause.join(", "), order_by_sql, limit
+        );
+
+        let mut query_builder = sqlx::query(&query);
+        query_builder = query_builder.bind(slice_uri);
+
+        // Bind WHERE parameters manually
+        if let Some(clause) = where_clause {
+            for condition in clause.conditions.values() {
+                if let Some(eq_value) = &condition.eq {
+                    if let Some(str_val) = eq_value.as_str() {
+                        query_builder = query_builder.bind(str_val);
+                    } else {
+                        query_builder = query_builder.bind(eq_value.to_string());
+                    }
+                }
+                if let Some(in_values) = &condition.in_values {
+                    let str_values: Vec<String> = in_values
+                        .iter()
+                        .filter_map(|v| v.as_str().map(|s| s.to_string()))
+                        .collect();
+                    query_builder = query_builder.bind(str_values);
+                }
+                if let Some(contains_value) = &condition.contains {
+                    query_builder = query_builder.bind(contains_value);
+                }
+            }
+
+            if let Some(or_conditions) = &clause.or_conditions {
+                for condition in or_conditions.values() {
+                    if let Some(eq_value) = &condition.eq {
+                        if let Some(str_val) = eq_value.as_str() {
+                            query_builder = query_builder.bind(str_val);
+                        } else {
+                            query_builder = query_builder.bind(eq_value.to_string());
+                        }
+                    }
+                    if let Some(in_values) = &condition.in_values {
+                        let str_values: Vec<String> = in_values
+                            .iter()
+                            .filter_map(|v| v.as_str().map(|s| s.to_string()))
+                            .collect();
+                        query_builder = query_builder.bind(str_values);
+                    }
+                    if let Some(contains_value) = &condition.contains {
+                        query_builder = query_builder.bind(contains_value);
+                    }
+                }
+            }
+        }
+
+        let rows = query_builder.fetch_all(&self.pool).await?;
+
+        // Convert rows to JSON objects
+        let mut results = Vec::new();
+        for row in rows {
+            let mut obj = serde_json::Map::new();
+
+            // Extract grouped field values
+            for (i, field_name) in group_by_fields.iter().enumerate() {
+                let col_name = format!("field_{}", i);
+                let value: Option<String> = row.try_get(col_name.as_str()).ok();
+
+                // Try to parse as JSON first (for arrays/objects), otherwise use as string
+                let json_value = if let Some(ref str_val) = value {
+                    // Check if it looks like JSON (starts with [ or {)
+                    if str_val.starts_with('[') || str_val.starts_with('{') {
+                        // Try to parse as JSON
+                        serde_json::from_str(str_val).unwrap_or_else(|_| serde_json::Value::String(str_val.clone()))
+                    } else {
+                        serde_json::Value::String(str_val.clone())
+                    }
+                } else {
+                    serde_json::Value::Null
+                };
+
+                obj.insert(field_name.clone(), json_value);
+            }
+
+            // Extract count
+            let count: i64 = row.try_get("count").unwrap_or(0);
+            obj.insert("count".to_string(), serde_json::Value::Number(count.into()));
+
+            results.push(serde_json::Value::Object(obj));
+        }
+
+        Ok(results)
     }
 
     /// Deletes a record by URI.

api/src/graphql/schema_builder.rs

···
                 ))
                 .description(format!("Query {} records", nsid)),
             );
+
+            // Add aggregated query field for this collection
+            let aggregated_query_name = format!("{}Aggregated", collection_query_name);
+            let aggregated_type_name = format!("{}Aggregated", &type_name);
+
+            // Create aggregated type
+            let aggregated_type = create_aggregated_type(&aggregated_type_name, &fields);
+            objects_to_register.push(aggregated_type);
+
+            let db_clone_agg = database.clone();
+            let slice_clone_agg = slice_uri.clone();
+            let nsid_clone_agg = nsid.to_string();
+
+            query = query.field(
+                Field::new(
+                    &aggregated_query_name,
+                    TypeRef::named_nn_list_nn(&aggregated_type_name),
+                    move |ctx| {
+                        let db = db_clone_agg.clone();
+                        let slice = slice_clone_agg.clone();
+                        let collection = nsid_clone_agg.clone();
+
+                        FieldFuture::new(async move {
+                            // Parse groupBy argument
+                            let group_by_fields: Vec<String> = match ctx.args.get("groupBy") {
+                                Some(val) => {
+                                    if let Ok(list) = val.list() {
+                                        list.iter()
+                                            .filter_map(|v| v.string().ok().map(|s| s.to_string()))
+                                            .collect()
+                                    } else {
+                                        Vec::new()
+                                    }
+                                }
+                                None => Vec::new(),
+                            };
+
+                            if group_by_fields.is_empty() {
+                                return Err(Error::new("groupBy is required for aggregated queries"));
+                            }
+
+                            // Parse limit argument
+                            let limit: i32 = match ctx.args.get("limit") {
+                                Some(val) => val.i64().unwrap_or(50) as i32,
+                                None => 50,
+                            };
+
+                            // Parse orderBy argument
+                            let order_by_count: Option<String> = match ctx.args.get("orderBy") {
+                                Some(val) => {
+                                    if let Ok(obj) = val.object() {
+                                        obj.get("count")
+                                            .and_then(|v| v.string().ok())
+                                            .map(|s| s.to_string())
+                                    } else {
+                                        None
+                                    }
+                                }
+                                None => None,
+                            };
+
+                            // Build where clause for this collection
+                            let mut where_clause = crate::models::WhereClause {
+                                conditions: HashMap::new(),
+                                or_conditions: None,
+                            };
+
+                            // Always filter by collection
+                            where_clause.conditions.insert(
+                                "collection".to_string(),
+                                crate::models::WhereCondition {
+                                    eq: Some(serde_json::Value::String(collection.clone())),
+                                    in_values: None,
+                                    contains: None,
+                                },
+                            );
+
+                            // Parse where argument if provided
+                            if let Some(where_val) = ctx.args.get("where") {
+                                if let Ok(where_obj) = where_val.object() {
+                                    for (field_name, condition_val) in where_obj.iter() {
+                                        if let Ok(condition_obj) = condition_val.object() {
+                                            let mut where_condition = crate::models::WhereCondition {
+                                                eq: None,
+                                                in_values: None,
+                                                contains: None,
+                                            };
+
+                                            // Parse eq condition
+                                            if let Some(eq_val) = condition_obj.get("eq") {
+                                                if let Ok(eq_str) = eq_val.string() {
+                                                    where_condition.eq = Some(serde_json::Value::String(eq_str.to_string()));
+                                                } else if let Ok(eq_i64) = eq_val.i64() {
+                                                    where_condition.eq = Some(serde_json::Value::Number(eq_i64.into()));
+                                                }
+                                            }
+
+                                            // Parse in condition
+                                            if let Some(in_val) = condition_obj.get("in") {
+                                                if let Ok(in_list) = in_val.list() {
+                                                    let mut values = Vec::new();
+                                                    for item in in_list.iter() {
+                                                        if let Ok(s) = item.string() {
+                                                            values.push(serde_json::Value::String(s.to_string()));
+                                                        } else if let Ok(i) = item.i64() {
+                                                            values.push(serde_json::Value::Number(i.into()));
+                                                        }
+                                                    }
+                                                    where_condition.in_values = Some(values);
+                                                }
+                                            }
+
+                                            // Parse contains condition
+                                            if let Some(contains_val) = condition_obj.get("contains") {
+                                                if let Ok(contains_str) = contains_val.string() {
+                                                    where_condition.contains = Some(contains_str.to_string());
+                                                }
+                                            }
+
+                                            where_clause.conditions.insert(field_name.to_string(), where_condition);
+                                        }
+                                    }
+                                }
+                            }
+
+                            // Resolve actorHandle to did if present
+                            if let Some(actor_handle_condition) = where_clause.conditions.remove("actorHandle") {
+                                let mut handles = Vec::new();
+                                if let Some(eq_value) = &actor_handle_condition.eq {
+                                    if let Some(handle_str) = eq_value.as_str() {
+                                        handles.push(handle_str.to_string());
+                                    }
+                                }
+                                if let Some(in_values) = &actor_handle_condition.in_values {
+                                    for value in in_values {
+                                        if let Some(handle_str) = value.as_str() {
+                                            handles.push(handle_str.to_string());
+                                        }
+                                    }
+                                }
+
+                                if !handles.is_empty() {
+                                    match db.resolve_handles_to_dids(&handles, &slice).await {
+                                        Ok(dids) => {
+                                            if !dids.is_empty() {
+                                                let did_condition = if dids.len() == 1 {
+                                                    crate::models::WhereCondition {
+                                                        eq: Some(serde_json::Value::String(dids[0].clone())),
+                                                        in_values: None,
+                                                        contains: None,
+                                                    }
+                                                } else {
+                                                    crate::models::WhereCondition {
+                                                        eq: None,
+                                                        in_values: Some(dids.into_iter().map(|d| serde_json::Value::String(d)).collect()),
+                                                        contains: None,
+                                                    }
+                                                };
+                                                where_clause.conditions.insert("did".to_string(), did_condition);
+                                            }
+                                        }
+                                        Err(_) => {
+                                            // If resolution fails, skip the condition
+                                        }
+                                    }
+                                }
+                            }
+
+                            // Query database for aggregated records
+                            let results = db
+                                .get_aggregated_records(
+                                    &slice,
+                                    &group_by_fields,
+                                    Some(&where_clause),
+                                    order_by_count.as_deref(),
+                                    Some(limit),
+                                )
+                                .await
+                                .map_err(|e| {
+                                    Error::new(format!("Aggregation query failed: {}", e))
+                                })?;
+
+                            // Convert JSON values to GraphQL values
+                            let field_values: Vec<FieldValue<'_>> = results
+                                .into_iter()
+                                .map(|json_val| FieldValue::owned_any(json_val))
+                                .collect();
+
+                            Ok(Some(FieldValue::list(field_values)))
+                        })
+                    },
+                )
+                .argument(async_graphql::dynamic::InputValue::new(
+                    "groupBy",
+                    TypeRef::named_nn_list_nn(TypeRef::STRING),
+                ))
+                .argument(async_graphql::dynamic::InputValue::new(
+                    "where",
+                    TypeRef::named("JSON"),
+                ))
+                .argument(async_graphql::dynamic::InputValue::new(
+                    "orderBy",
+                    TypeRef::named("AggregationOrderBy"),
+                ))
+                .argument(async_graphql::dynamic::InputValue::new(
+                    "limit",
+                    TypeRef::named(TypeRef::INT),
+                ))
+                .description(format!("Aggregated query for {} records with GROUP BY support", nsid)),
+            );
         }
     }
 
···
 
     let int_condition_input = create_int_condition_input();
     schema_builder = schema_builder.register(int_condition_input);
+
+    // Register AggregationOrderBy input type
+    let aggregation_order_by_input = create_aggregation_order_by_input();
+    schema_builder = schema_builder.register(aggregation_order_by_input);
 
     // Register PageInfo type
     let page_info_type = create_page_info_type();
···
 
     result
 }
+
+/// Creates an aggregated type for GROUP BY queries
+/// Returns a dynamic object with the grouped fields plus a count field
+fn create_aggregated_type(type_name: &str, fields: &[GraphQLField]) -> Object {
+    let mut aggregated = Object::new(type_name);
+
+    // Add fields from the lexicon that can be grouped
+    // Use JSON type for all fields to support both strings and complex types
+    for field in fields {
+        let field_name = field.name.clone();
+        let field_name_clone = field_name.clone();
+        aggregated = aggregated.field(Field::new(&field_name, TypeRef::named("JSON"), move |ctx| {
+            let field_name = field_name_clone.clone();
+            FieldFuture::new(async move {
+                let json_value = ctx.parent_value.try_downcast_ref::<serde_json::Value>()?;
+                if let Some(obj) = json_value.as_object() {
+                    if let Some(value) = obj.get(&field_name) {
+                        // Convert serde_json::Value to async_graphql::Value
+                        let graphql_value = serde_json_to_graphql_value(value);
+                        return Ok(Some(graphql_value));
+                    }
+                }
+                Ok(None)
+            })
+        }));
+    }
+
+    // Add count field
+    aggregated = aggregated.field(Field::new("count", TypeRef::named_nn(TypeRef::INT), |ctx| {
+        FieldFuture::new(async move {
+            let json_value = ctx.parent_value.try_downcast_ref::<serde_json::Value>()?;
+            if let Some(obj) = json_value.as_object() {
+                if let Some(count) = obj.get("count") {
+                    if let Some(count_i64) = count.as_i64() {
+                        return Ok(Some(GraphQLValue::from(count_i64 as i32)));
+                    }
+                }
+            }
+            Ok(Some(GraphQLValue::from(0)))
+        })
+    }));
+
+    aggregated
+}
+
+/// Creates the AggregationOrderBy input type for ordering by count
+fn create_aggregation_order_by_input() -> InputObject {
+    InputObject::new("AggregationOrderBy")
+        .field(InputValue::new("count", TypeRef::named("SortDirection")))
+}
+
+/// Converts a serde_json::Value to an async_graphql::Value
+fn serde_json_to_graphql_value(value: &serde_json::Value) -> GraphQLValue {
+    match value {
+        serde_json::Value::Null => GraphQLValue::Null,
+        serde_json::Value::Bool(b) => GraphQLValue::Boolean(*b),
+        serde_json::Value::Number(n) => {
+            if let Some(i) = n.as_i64() {
+                GraphQLValue::Number(i.into())
+            } else if let Some(f) = n.as_f64() {
+                GraphQLValue::Number(serde_json::Number::from_f64(f).unwrap().into())
+            } else {
+                GraphQLValue::Null
+            }
+        }
+        serde_json::Value::String(s) => GraphQLValue::String(s.clone()),
+        serde_json::Value::Array(arr) => {
+            let values: Vec<GraphQLValue> = arr.iter().map(serde_json_to_graphql_value).collect();
+            GraphQLValue::List(values)
+        }
+        serde_json::Value::Object(obj) => {
+            let mut map = async_graphql::indexmap::IndexMap::new();
+            for (k, v) in obj {
+                map.insert(async_graphql::Name::new(k), serde_json_to_graphql_value(v));
+            }
+            GraphQLValue::Object(map)
+        }
+    }
+}