+28

api/src/api/xrpc_dynamic.rs

··· 132 132 where_conditions.insert( 133 133 "did".to_string(), 134 134 WhereCondition { 135 135 + gt: None, 136 136 + gte: None, 137 137 + lt: None, 138 138 + lte: None, 135 139 eq: Some(serde_json::Value::String(author_str.to_string())), 136 140 in_values: None, 137 141 contains: None, ··· 145 149 where_conditions.insert( 146 150 "did".to_string(), 147 151 WhereCondition { 152 152 + gt: None, 153 153 + gte: None, 154 154 + lt: None, 155 155 + lte: None, 148 156 eq: None, 149 157 in_values: Some(authors), 150 158 contains: None, ··· 161 169 where_conditions.insert( 162 170 field.to_string(), 163 171 WhereCondition { 172 172 + gt: None, 173 173 + gte: None, 174 174 + lt: None, 175 175 + lte: None, 164 176 eq: None, 165 177 in_values: None, 166 178 contains: Some(query_str.to_string()), ··· 172 184 where_conditions.insert( 173 185 "collection".to_string(), 174 186 WhereCondition { 187 187 + gt: None, 188 188 + gte: None, 189 189 + lt: None, 190 190 + lte: None, 175 191 eq: Some(serde_json::Value::String(collection.clone())), 176 192 in_values: None, 177 193 contains: None, ··· 307 323 where_clause.conditions.insert( 308 324 "collection".to_string(), 309 325 WhereCondition { 326 326 + gt: None, 327 327 + gte: None, 328 328 + lt: None, 329 329 + lte: None, 310 330 eq: Some(serde_json::Value::String(collection.clone())), 311 331 in_values: None, 312 332 contains: None, ··· 385 405 where_clause.conditions.insert( 386 406 "collection".to_string(), 387 407 WhereCondition { 408 408 + gt: None, 409 409 + gte: None, 410 410 + lt: None, 411 411 + lte: None, 388 412 eq: Some(collection.clone().into()), 389 413 contains: None, 390 414 in_values: None, ··· 444 468 where_clause.conditions.insert( 445 469 "collection".to_string(), 446 470 WhereCondition { 471 471 + gt: None, 472 472 + gte: None, 473 473 + lt: None, 474 474 + lte: None, 447 475 eq: Some(collection.clone().into()), 448 476 in_values: None, 449 477 contains: None,

+790

api/src/api/xrpc_dynamic.rs.bak

··· 1 1 + use atproto_client::com::atproto::repo::{ 2 2 + CreateRecordRequest, CreateRecordResponse, DeleteRecordRequest, PutRecordRequest, 3 3 + PutRecordResponse, create_record, delete_record, put_record, 4 4 + }; 5 5 + use axum::{ 6 6 + extract::{Path, Query, State}, 7 7 + http::HeaderMap, 8 8 + response::Json, 9 9 + }; 10 10 + use chrono::Utc; 11 11 + use serde::Deserialize; 12 12 + 13 13 + use crate::AppState; 14 14 + use crate::auth::{ 15 15 + extract_bearer_token, get_atproto_auth_for_user_cached, verify_oauth_token_cached, 16 16 + }; 17 17 + use crate::errors::AppError; 18 18 + use crate::models::{ 19 19 + IndexedRecord, Record, SliceRecordsOutput, SliceRecordsParams, SortField, WhereCondition, 20 20 + }; 21 21 + use std::collections::HashMap; 22 22 + 23 23 + 24 24 + #[derive(Deserialize)] 25 25 + pub struct GetRecordParams { 26 26 + pub uri: String, 27 27 + pub slice: String, 28 28 + } 29 29 + 30 30 + // Dynamic XRPC handler that routes based on method name (for GET requests) 31 31 + pub async fn dynamic_xrpc_handler( 32 32 + Path(method): Path<String>, 33 33 + State(state): State<AppState>, 34 34 + Query(params): Query<serde_json::Value>, 35 35 + ) -> Result<Json<serde_json::Value>, AppError> { 36 36 + // Parse the XRPC method (e.g., "social.grain.gallery.getRecords") 37 37 + if method.ends_with(".getRecords") { 38 38 + let collection = method.trim_end_matches(".getRecords").to_string(); 39 39 + dynamic_get_records_handler(collection, state, params).await 40 40 + } else if method.ends_with(".countRecords") { 41 41 + let collection = method.trim_end_matches(".countRecords").to_string(); 42 42 + dynamic_count_records_handler(collection, state, params).await 43 43 + } else if method.ends_with(".getRecord") { 44 44 + let collection = method.trim_end_matches(".getRecord").to_string(); 45 45 + dynamic_get_record_impl(collection, state, params).await 46 46 + } else { 47 47 + Err(AppError::NotFound("Unknown XRPC method".to_string())) 48 48 + } 49 49 + } 50 50 + 51 51 + // Dynamic XRPC handler for POST requests (create, update, delete) 52 52 + pub async fn dynamic_xrpc_post_handler( 53 53 + Path(method): Path<String>, 54 54 + State(state): State<AppState>, 55 55 + headers: HeaderMap, 56 56 + Json(body): Json<serde_json::Value>, 57 57 + ) -> Result<Json<serde_json::Value>, AppError> { 58 58 + // Handle dynamic collection methods (e.g., social.grain.gallery.createRecord) 59 59 + if method.ends_with(".getRecords") { 60 60 + let collection = method.trim_end_matches(".getRecords").to_string(); 61 61 + dynamic_get_records_post_handler(collection, state, body).await 62 62 + } else if method.ends_with(".countRecords") { 63 63 + let collection = method.trim_end_matches(".countRecords").to_string(); 64 64 + dynamic_count_records_post_handler(collection, state, body).await 65 65 + } else if method.ends_with(".createRecord") { 66 66 + let collection = method.trim_end_matches(".createRecord").to_string(); 67 67 + dynamic_collection_create_impl(state, headers, body, collection).await 68 68 + } else if method.ends_with(".updateRecord") { 69 69 + let collection = method.trim_end_matches(".updateRecord").to_string(); 70 70 + dynamic_collection_update_impl(state, headers, body, collection).await 71 71 + } else if method.ends_with(".deleteRecord") { 72 72 + let collection = method.trim_end_matches(".deleteRecord").to_string(); 73 73 + dynamic_collection_delete_impl(state, headers, body, collection).await 74 74 + } else { 75 75 + Err(AppError::NotFound("Method not found".to_string())) 76 76 + } 77 77 + } 78 78 + 79 79 + // Handler for get records using unified where clause approach 80 80 + async fn dynamic_get_records_handler( 81 81 + collection: String, 82 82 + state: AppState, 83 83 + params: serde_json::Value, 84 84 + ) -> Result<Json<serde_json::Value>, AppError> { 85 85 + // Parse parameters into SliceRecordsParams format 86 86 + let slice = params 87 87 + .get("slice") 88 88 + .and_then(|v| v.as_str()) 89 89 + .ok_or(AppError::BadRequest("Missing slice parameter".to_string()))? 90 90 + .to_string(); 91 91 + 92 92 + let limit = params.get("limit").and_then(|v| { 93 93 + if let Some(s) = v.as_str() { 94 94 + s.parse::<i32>().ok() 95 95 + } else { 96 96 + v.as_i64().map(|i| i as i32) 97 97 + } 98 98 + }); 99 99 + 100 100 + let cursor = params 101 101 + .get("cursor") 102 102 + .and_then(|v| v.as_str()) 103 103 + .map(|s| s.to_string()); 104 104 + 105 105 + // Parse sortBy from params - convert legacy sort string to new array format if present 106 106 + let sort_by = params.get("sort").and_then(|v| v.as_str()).map(|sort_str| { 107 107 + // Convert legacy "field:direction" format to new array format 108 108 + let mut sort_fields = Vec::new(); 109 109 + for sort_item in sort_str.split(',') { 110 110 + let parts: Vec<&str> = sort_item.trim().split(':').collect(); 111 111 + if parts.len() == 2 { 112 112 + sort_fields.push(SortField { 113 113 + field: parts[0].trim().to_string(), 114 114 + direction: parts[1].trim().to_string(), 115 115 + }); 116 116 + } else if parts.len() == 1 && !parts[0].is_empty() { 117 117 + // Default to ascending if no direction specified 118 118 + sort_fields.push(SortField { 119 119 + field: parts[0].trim().to_string(), 120 120 + direction: "asc".to_string(), 121 121 + }); 122 122 + } 123 123 + } 124 124 + sort_fields 125 125 + }); 126 126 + 127 127 + // Parse where conditions from query params if present 128 128 + let mut where_conditions = HashMap::new(); 129 129 + 130 130 + // Handle legacy author/authors params by converting to where clause 131 131 + if let Some(author_str) = params.get("author").and_then(|v| v.as_str()) { 132 132 + where_conditions.insert( 133 133 + "did".to_string(), 134 134 + WhereCondition { 135 135 + eq: Some(serde_json::Value::String(author_str.to_string())), 136 136 + in_values: None, 137 137 + contains: None, 138 138 + }, 139 139 + ); 140 140 + } else if let Some(authors_str) = params.get("authors").and_then(|v| v.as_str()) { 141 141 + let authors: Vec<serde_json::Value> = authors_str 142 142 + .split(',') 143 143 + .map(|s| serde_json::Value::String(s.trim().to_string())) 144 144 + .collect(); 145 145 + where_conditions.insert( 146 146 + "did".to_string(), 147 147 + WhereCondition { 148 148 + eq: None, 149 149 + in_values: Some(authors), 150 150 + contains: None, 151 151 + }, 152 152 + ); 153 153 + } 154 154 + 155 155 + // Handle legacy query param by converting to where clause with contains 156 156 + if let Some(query_str) = params.get("query").and_then(|v| v.as_str()) { 157 157 + let field = params 158 158 + .get("field") 159 159 + .and_then(|v| v.as_str()) 160 160 + .unwrap_or("text"); // Default to text field for search 161 161 + where_conditions.insert( 162 162 + field.to_string(), 163 163 + WhereCondition { 164 164 + eq: None, 165 165 + in_values: None, 166 166 + contains: Some(query_str.to_string()), 167 167 + }, 168 168 + ); 169 169 + } 170 170 + 171 171 + // Add collection filter to where conditions 172 172 + where_conditions.insert( 173 173 + "collection".to_string(), 174 174 + WhereCondition { 175 175 + eq: Some(serde_json::Value::String(collection.clone())), 176 176 + in_values: None, 177 177 + contains: None, 178 178 + }, 179 179 + ); 180 180 + 181 181 + let where_clause = Some(crate::models::WhereClause { 182 182 + conditions: where_conditions, 183 183 + or_conditions: None, 184 184 + }); 185 185 + 186 186 + let records_params = SliceRecordsParams { 187 187 + slice, 188 188 + limit, 189 189 + cursor, 190 190 + where_clause, 191 191 + sort_by: sort_by.clone(), 192 192 + }; 193 193 + 194 194 + // First verify the collection belongs to this slice 195 195 + let slice_collections = state 196 196 + .database 197 197 + .get_slice_collections_list(&records_params.slice) 198 198 + .await 199 199 + .map_err(|_| AppError::Internal("Database error".to_string()))?; 200 200 + 201 201 + // Special handling: network.slices.lexicon is always allowed as it defines the schema 202 202 + if collection != "network.slices.lexicon" && !slice_collections.contains(&collection) { 203 203 + return Err(AppError::NotFound("Collection not found".to_string())); 204 204 + } 205 205 + 206 206 + // Use the unified database method 207 207 + match state 208 208 + .database 209 209 + .get_slice_collections_records( 210 210 + &records_params.slice, 211 211 + records_params.limit, 212 212 + records_params.cursor.as_deref(), 213 213 + sort_by.as_ref(), 214 214 + records_params.where_clause.as_ref(), 215 215 + ) 216 216 + .await 217 217 + { 218 218 + Ok((records, cursor)) => { 219 219 + // No need to filter - collection filter is in the SQL query now 220 220 + 221 221 + let indexed_records: Vec<IndexedRecord> = records 222 222 + .into_iter() 223 223 + .map(|record| IndexedRecord { 224 224 + uri: record.uri, 225 225 + cid: record.cid, 226 226 + did: record.did, 227 227 + collection: record.collection, 228 228 + value: record.json, 229 229 + indexed_at: record.indexed_at.to_rfc3339(), 230 230 + }) 231 231 + .collect(); 232 232 + 233 233 + let output = SliceRecordsOutput { 234 234 + records: indexed_records, 235 235 + cursor, 236 236 + }; 237 237 + 238 238 + Ok(Json( 239 239 + serde_json::to_value(output).map_err(|_| AppError::Internal("Serialization error".to_string()))?, 240 240 + )) 241 241 + } 242 242 + Err(_) => Err(AppError::Internal("Database error".to_string())), 243 243 + } 244 244 + } 245 245 + 246 246 + // Implementation for get record 247 247 + async fn dynamic_get_record_impl( 248 248 + collection: String, 249 249 + state: AppState, 250 250 + params: serde_json::Value, 251 251 + ) -> Result<Json<serde_json::Value>, AppError> { 252 252 + let get_params: GetRecordParams = 253 253 + serde_json::from_value(params).map_err(|_| AppError::BadRequest("Invalid parameters".to_string()))?; 254 254 + 255 255 + // First verify the collection belongs to this slice 256 256 + let slice_collections = state 257 257 + .database 258 258 + .get_slice_collections_list(&get_params.slice) 259 259 + .await 260 260 + .map_err(|_| AppError::Internal("Database error".to_string()))?; 261 261 + 262 262 + // Special handling: network.slices.lexicon is always allowed as it defines the schema 263 263 + if collection != "network.slices.lexicon" && !slice_collections.contains(&collection) { 264 264 + return Err(AppError::NotFound("Collection not found".to_string())); 265 265 + } 266 266 + 267 267 + // Use direct database query by URI for efficiency 268 268 + match state.database.get_record(&get_params.uri).await { 269 269 + Ok(Some(record)) => { 270 270 + let json_value = 271 271 + serde_json::to_value(record).map_err(|_| AppError::Internal("Serialization error".to_string()))?; 272 272 + Ok(Json(json_value)) 273 273 + } 274 274 + Ok(None) => Err(AppError::NotFound("Record not found".to_string())), 275 275 + Err(_e) => Err(AppError::Internal("Database error".to_string())), 276 276 + } 277 277 + } 278 278 + 279 279 + // Handler for get records via POST with JSON body 280 280 + async fn dynamic_get_records_post_handler( 281 281 + collection: String, 282 282 + state: AppState, 283 283 + body: serde_json::Value, 284 284 + ) -> Result<Json<serde_json::Value>, AppError> { 285 285 + // Parse the JSON body into SliceRecordsParams 286 286 + let mut records_params: SliceRecordsParams = serde_json::from_value(body).map_err(|_| AppError::BadRequest("Invalid request body".to_string()))?; 287 287 + 288 288 + // First verify the collection belongs to this slice 289 289 + let slice_collections = state 290 290 + .database 291 291 + .get_slice_collections_list(&records_params.slice) 292 292 + .await 293 293 + .map_err(|_| AppError::Internal("Database error".to_string()))?; 294 294 + 295 295 + // Special handling: network.slices.lexicon is always allowed as it defines the schema 296 296 + if collection != "network.slices.lexicon" && !slice_collections.contains(&collection) { 297 297 + return Err(AppError::NotFound("Collection not found".to_string())); 298 298 + } 299 299 + 300 300 + // Add collection filter to where conditions 301 301 + let mut where_clause = records_params 302 302 + .where_clause 303 303 + .unwrap_or(crate::models::WhereClause { 304 304 + conditions: HashMap::new(), 305 305 + or_conditions: None, 306 306 + }); 307 307 + where_clause.conditions.insert( 308 308 + "collection".to_string(), 309 309 + WhereCondition { 310 310 + eq: Some(serde_json::Value::String(collection.clone())), 311 311 + in_values: None, 312 312 + contains: None, 313 313 + }, 314 314 + ); 315 315 + records_params.where_clause = Some(where_clause); 316 316 + 317 317 + // Use the unified database method 318 318 + match state 319 319 + .database 320 320 + .get_slice_collections_records( 321 321 + &records_params.slice, 322 322 + records_params.limit, 323 323 + records_params.cursor.as_deref(), 324 324 + records_params.sort_by.as_ref(), 325 325 + records_params.where_clause.as_ref(), 326 326 + ) 327 327 + .await 328 328 + { 329 329 + Ok((records, cursor)) => { 330 330 + // No need to filter - collection filter is in the SQL query now 331 331 + 332 332 + // Transform Record to IndexedRecord for the response 333 333 + let indexed_records: Vec<IndexedRecord> = records 334 334 + .into_iter() 335 335 + .map(|record| IndexedRecord { 336 336 + uri: record.uri, 337 337 + cid: record.cid, 338 338 + did: record.did, 339 339 + collection: record.collection, 340 340 + value: record.json, 341 341 + indexed_at: record.indexed_at.to_rfc3339(), 342 342 + }) 343 343 + .collect(); 344 344 + 345 345 + let output = SliceRecordsOutput { 346 346 + records: indexed_records, 347 347 + cursor, 348 348 + }; 349 349 + 350 350 + Ok(Json(serde_json::to_value(output).map_err(|e| AppError::Internal(format!("Serialization error: {}", e)))?)) 351 351 + } 352 352 + Err(e) => Err(AppError::Internal(format!("Database error: {}", e))), 353 353 + } 354 354 + } 355 355 + 356 356 + // Dynamic count records handler for GET requests 357 357 + async fn dynamic_count_records_handler( 358 358 + collection: String, 359 359 + state: AppState, 360 360 + params: serde_json::Value, 361 361 + ) -> Result<Json<serde_json::Value>, AppError> { 362 362 + // Convert query parameters to SliceRecordsParams 363 363 + let mut records_params: SliceRecordsParams = 364 364 + serde_json::from_value(params).map_err(|_| AppError::BadRequest("Invalid parameters".to_string()))?; 365 365 + 366 366 + // First verify the collection belongs to this slice 367 367 + let slice_collections = state 368 368 + .database 369 369 + .get_slice_collections_list(&records_params.slice) 370 370 + .await 371 371 + .map_err(|_| AppError::Internal("Database error".to_string()))?; 372 372 + 373 373 + // Special handling: network.slices.lexicon is always allowed as it defines the schema 374 374 + if collection != "network.slices.lexicon" && !slice_collections.contains(&collection) { 375 375 + return Err(AppError::NotFound("Collection not found".to_string())); 376 376 + } 377 377 + 378 378 + // Add collection filter to where conditions 379 379 + let mut where_clause = records_params 380 380 + .where_clause 381 381 + .unwrap_or(crate::models::WhereClause { 382 382 + conditions: HashMap::new(), 383 383 + or_conditions: None, 384 384 + }); 385 385 + where_clause.conditions.insert( 386 386 + "collection".to_string(), 387 387 + WhereCondition { 388 388 + eq: Some(collection.clone().into()), 389 389 + contains: None, 390 390 + in_values: None, 391 391 + }, 392 392 + ); 393 393 + records_params.where_clause = Some(where_clause); 394 394 + 395 395 + match state 396 396 + .database 397 397 + .count_slice_collections_records( 398 398 + &records_params.slice, 399 399 + records_params.where_clause.as_ref(), 400 400 + ) 401 401 + .await 402 402 + { 403 403 + Ok(count) => Ok(Json(serde_json::json!({ 404 404 + "success": true, 405 405 + "count": count, 406 406 + "message": null 407 407 + }))), 408 408 + Err(_) => Ok(Json(serde_json::json!({ 409 409 + "success": false, 410 410 + "count": 0, 411 411 + "message": "Failed to count records" 412 412 + }))), 413 413 + } 414 414 + } 415 415 + 416 416 + // Dynamic count records handler for POST requests 417 417 + async fn dynamic_count_records_post_handler( 418 418 + collection: String, 419 419 + state: AppState, 420 420 + body: serde_json::Value, 421 421 + ) -> Result<Json<serde_json::Value>, AppError> { 422 422 + // Parse the JSON body into SliceRecordsParams 423 423 + let mut records_params: SliceRecordsParams = serde_json::from_value(body).map_err(|_| AppError::BadRequest("Invalid request body".to_string()))?; 424 424 + 425 425 + // First verify the collection belongs to this slice 426 426 + let slice_collections = state 427 427 + .database 428 428 + .get_slice_collections_list(&records_params.slice) 429 429 + .await 430 430 + .map_err(|_| AppError::Internal("Database error".to_string()))?; 431 431 + 432 432 + // Special handling: network.slices.lexicon is always allowed as it defines the schema 433 433 + if collection != "network.slices.lexicon" && !slice_collections.contains(&collection) { 434 434 + return Err(AppError::NotFound("Collection not found".to_string())); 435 435 + } 436 436 + 437 437 + // Add collection filter to where conditions 438 438 + let mut where_clause = records_params 439 439 + .where_clause 440 440 + .unwrap_or(crate::models::WhereClause { 441 441 + conditions: HashMap::new(), 442 442 + or_conditions: None, 443 443 + }); 444 444 + where_clause.conditions.insert( 445 445 + "collection".to_string(), 446 446 + WhereCondition { 447 447 + eq: Some(collection.clone().into()), 448 448 + in_values: None, 449 449 + contains: None, 450 450 + }, 451 451 + ); 452 452 + records_params.where_clause = Some(where_clause); 453 453 + 454 454 + match state 455 455 + .database 456 456 + .count_slice_collections_records( 457 457 + &records_params.slice, 458 458 + records_params.where_clause.as_ref(), 459 459 + ) 460 460 + .await 461 461 + { 462 462 + Ok(count) => Ok(Json(serde_json::json!({ 463 463 + "success": true, 464 464 + "count": count, 465 465 + "message": null 466 466 + }))), 467 467 + Err(_) => Ok(Json(serde_json::json!({ 468 468 + "success": false, 469 469 + "count": 0, 470 470 + "message": "Failed to count records" 471 471 + }))), 472 472 + } 473 473 + } 474 474 + 475 475 + // Dynamic collection create (e.g., social.grain.gallery.createRecord) 476 476 + async fn dynamic_collection_create_impl( 477 477 + state: AppState, 478 478 + headers: HeaderMap, 479 479 + body: serde_json::Value, 480 480 + collection: String, 481 481 + ) -> Result<Json<serde_json::Value>, AppError> { 482 482 + // Extract and verify OAuth token 483 483 + let token = extract_bearer_token(&headers).map_err(|_| AppError::AuthRequired("Missing bearer token".to_string()))?; 484 484 + let user_info = verify_oauth_token_cached( 485 485 + &token, 486 486 + &state.config.auth_base_url, 487 487 + Some(state.auth_cache.clone()), 488 488 + ) 489 489 + .await 490 490 + .map_err(|_| AppError::AuthRequired("Invalid token".to_string()))?; 491 491 + 492 492 + // Get AT Protocol DPoP auth and PDS URL (with caching) 493 493 + let (dpop_auth, pds_url) = get_atproto_auth_for_user_cached( 494 494 + &token, 495 495 + &state.config.auth_base_url, 496 496 + Some(state.auth_cache.clone()), 497 497 + ) 498 498 + .await 499 499 + .map_err(|_| AppError::AuthRequired("Invalid token".to_string()))?; 500 500 + 501 501 + // Extract the repo DID from user info 502 502 + let repo = user_info.did.unwrap_or(user_info.sub); 503 503 + 504 504 + // Create HTTP client 505 505 + let http_client = reqwest::Client::new(); 506 506 + 507 507 + // Extract slice URI, rkey, and record value from structured body 508 508 + let slice_uri = body 509 509 + .get("slice") 510 510 + .and_then(|v| v.as_str()) 511 511 + .ok_or_else(|| AppError::BadRequest("Missing parameter".to_string()))? 512 512 + .to_string(); 513 513 + 514 514 + let record_key = body 515 515 + .get("rkey") 516 516 + .and_then(|v| v.as_str()) 517 517 + .filter(|s| !s.is_empty()) // Filter out empty strings 518 518 + .map(|s| s.to_string()); 519 519 + 520 520 + let record_data = body 521 521 + .get("record") 522 522 + .ok_or_else(|| AppError::BadRequest("Missing parameter".to_string()))? 523 523 + .clone(); 524 524 + 525 525 + // Validate the record against its lexicon 526 526 + 527 527 + // For network.slices.lexicon collection, validate against the system slice 528 528 + let validation_slice_uri = if collection == "network.slices.lexicon" { 529 529 + &state.config.system_slice_uri 530 530 + } else { 531 531 + &slice_uri 532 532 + }; 533 533 + 534 534 + // Get lexicons for validation 535 535 + match state 536 536 + .database 537 537 + .get_lexicons_by_slice(validation_slice_uri) 538 538 + .await 539 539 + { 540 540 + Ok(lexicons) if !lexicons.is_empty() => { 541 541 + if let Err(e) = 542 542 + slices_lexicon::validate_record(lexicons, &collection, record_data.clone()) 543 543 + { 544 544 + return Err(AppError::BadRequest(format!("ValidationError: {}", e))); 545 545 + } 546 546 + } 547 547 + _ => { 548 548 + // If no lexicons found, continue without validation (backwards compatibility) 549 549 + } 550 550 + } 551 551 + 552 552 + // Create record using AT Protocol functions with DPoP 553 553 + 554 554 + let create_request = CreateRecordRequest { 555 555 + repo: repo.clone(), 556 556 + collection: collection.clone(), 557 557 + record_key, 558 558 + record: record_data.clone(), 559 559 + swap_commit: None, 560 560 + validate: false, 561 561 + }; 562 562 + 563 563 + let result = create_record( 564 564 + &http_client, 565 565 + &atproto_client::client::Auth::DPoP(dpop_auth), 566 566 + &pds_url, 567 567 + create_request, 568 568 + ) 569 569 + .await 570 570 + .map_err(|_e| AppError::Internal("AT Protocol request failed".to_string()))?; 571 571 + 572 572 + // Extract URI and CID from the response enum 573 573 + let (uri, cid) = match result { 574 574 + CreateRecordResponse::StrongRef { uri, cid, .. } => (uri, cid), 575 575 + CreateRecordResponse::Error(_e) => { 576 576 + return Err(AppError::Internal("AT Protocol response error".to_string())); 577 577 + } 578 578 + }; 579 579 + 580 580 + // Also store in local database for indexing 581 581 + let record = Record { 582 582 + uri: uri.clone(), 583 583 + cid: cid.clone(), 584 584 + did: repo, 585 585 + collection, 586 586 + json: record_data, 587 587 + indexed_at: Utc::now(), 588 588 + slice_uri: Some(slice_uri), 589 589 + }; 590 590 + 591 591 + // Store in local database (ignore errors as AT Protocol operation succeeded) 592 592 + let _insert_result = state.database.insert_record(&record).await; 593 593 + 594 594 + Ok(Json(serde_json::json!({ 595 595 + "uri": uri, 596 596 + "cid": cid, 597 597 + }))) 598 598 + } 599 599 + 600 600 + // Dynamic collection update (e.g., social.grain.gallery.updateRecord) 601 601 + async fn dynamic_collection_update_impl( 602 602 + state: AppState, 603 603 + headers: HeaderMap, 604 604 + body: serde_json::Value, 605 605 + collection: String, 606 606 + ) -> Result<Json<serde_json::Value>, AppError> { 607 607 + // Extract and verify OAuth token 608 608 + let token = extract_bearer_token(&headers).map_err(|_| AppError::AuthRequired("Missing bearer token".to_string()))?; 609 609 + let user_info = verify_oauth_token_cached( 610 610 + &token, 611 611 + &state.config.auth_base_url, 612 612 + Some(state.auth_cache.clone()), 613 613 + ) 614 614 + .await 615 615 + .map_err(|_| AppError::AuthRequired("Invalid token".to_string()))?; 616 616 + 617 617 + // Get AT Protocol DPoP auth and PDS URL (with caching) 618 618 + let (dpop_auth, pds_url) = get_atproto_auth_for_user_cached( 619 619 + &token, 620 620 + &state.config.auth_base_url, 621 621 + Some(state.auth_cache.clone()), 622 622 + ) 623 623 + .await 624 624 + .map_err(|_| AppError::AuthRequired("Invalid token".to_string()))?; 625 625 + 626 626 + // Extract slice URI, rkey, and record value from structured body 627 627 + let slice_uri = body 628 628 + .get("slice") 629 629 + .and_then(|v| v.as_str()) 630 630 + .ok_or_else(|| AppError::BadRequest("Missing parameter".to_string()))? 631 631 + .to_string(); 632 632 + 633 633 + let rkey = body 634 634 + .get("rkey") 635 635 + .and_then(|v| v.as_str()) 636 636 + .ok_or_else(|| AppError::BadRequest("Missing parameter".to_string()))? 637 637 + .to_string(); 638 638 + 639 639 + let record_data = body 640 640 + .get("record") 641 641 + .ok_or_else(|| AppError::BadRequest("Missing parameter".to_string()))? 642 642 + .clone(); 643 643 + 644 644 + // Extract repo from user info 645 645 + let repo = user_info.did.unwrap_or(user_info.sub); 646 646 + 647 647 + // Validate the record against its lexicon 648 648 + 649 649 + // For network.slices.lexicon collection, validate against the system slice 650 650 + let validation_slice_uri = if collection == "network.slices.lexicon" { 651 651 + &state.config.system_slice_uri 652 652 + } else { 653 653 + &slice_uri 654 654 + }; 655 655 + 656 656 + // Get lexicons for validation 657 657 + match state 658 658 + .database 659 659 + .get_lexicons_by_slice(validation_slice_uri) 660 660 + .await 661 661 + { 662 662 + Ok(lexicons) if !lexicons.is_empty() => { 663 663 + if let Err(e) = 664 664 + slices_lexicon::validate_record(lexicons, &collection, record_data.clone()) 665 665 + { 666 666 + return Err(AppError::BadRequest(format!("ValidationError: {}", e))); 667 667 + } 668 668 + } 669 669 + _ => { 670 670 + // If no lexicons found, continue without validation (backwards compatibility) 671 671 + } 672 672 + } 673 673 + 674 674 + // Create HTTP client 675 675 + let http_client = reqwest::Client::new(); 676 676 + 677 677 + // Update record using AT Protocol functions with DPoP 678 678 + let put_request = PutRecordRequest { 679 679 + repo: repo.clone(), 680 680 + collection: collection.clone(), 681 681 + record_key: rkey, 682 682 + record: record_data.clone(), 683 683 + swap_record: None, 684 684 + swap_commit: None, 685 685 + validate: false, 686 686 + }; 687 687 + 688 688 + let result = put_record( 689 689 + &http_client, 690 690 + &atproto_client::client::Auth::DPoP(dpop_auth), 691 691 + &pds_url, 692 692 + put_request, 693 693 + ) 694 694 + .await 695 695 + .map_err(|_| AppError::Internal("AT Protocol request failed".to_string()))?; 696 696 + 697 697 + // Extract URI and CID from the response enum 698 698 + let (uri, cid) = match result { 699 699 + PutRecordResponse::StrongRef { uri, cid, .. } => (uri, cid), 700 700 + PutRecordResponse::Error(_) => { 701 701 + return Err(AppError::Internal("AT Protocol response error".to_string())); 702 702 + } 703 703 + }; 704 704 + 705 705 + // Also update in local database for indexing 706 706 + let record = Record { 707 707 + uri: uri.clone(), 708 708 + cid: cid.clone(), 709 709 + did: repo, 710 710 + collection, 711 711 + json: record_data, 712 712 + indexed_at: Utc::now(), 713 713 + slice_uri: Some(slice_uri), 714 714 + }; 715 715 + 716 716 + // Update in local database (ignore errors as AT Protocol operation succeeded) 717 717 + let _ = state.database.update_record(&record).await; 718 718 + 719 719 + Ok(Json(serde_json::json!({ 720 720 + "uri": uri, 721 721 + "cid": cid, 722 722 + }))) 723 723 + } 724 724 + 725 725 + // Dynamic collection delete (e.g., social.grain.gallery.delete) 726 726 + async fn dynamic_collection_delete_impl( 727 727 + state: AppState, 728 728 + headers: HeaderMap, 729 729 + body: serde_json::Value, 730 730 + collection: String, 731 731 + ) -> Result<Json<serde_json::Value>, AppError> { 732 732 + // Extract and verify OAuth token 733 733 + let token = extract_bearer_token(&headers).map_err(|_| AppError::AuthRequired("Missing bearer token".to_string()))?; 734 734 + let user_info = verify_oauth_token_cached( 735 735 + &token, 736 736 + &state.config.auth_base_url, 737 737 + Some(state.auth_cache.clone()), 738 738 + ) 739 739 + .await 740 740 + .map_err(|_| AppError::AuthRequired("Invalid token".to_string()))?; 741 741 + 742 742 + // Get AT Protocol DPoP auth and PDS URL (with caching) 743 743 + let (dpop_auth, pds_url) = get_atproto_auth_for_user_cached( 744 744 + &token, 745 745 + &state.config.auth_base_url, 746 746 + Some(state.auth_cache.clone()), 747 747 + ) 748 748 + .await 749 749 + .map_err(|_| AppError::AuthRequired("Invalid token".to_string()))?; 750 750 + 751 751 + // Extract repo and rkey from body 752 752 + let repo = user_info.did.unwrap_or(user_info.sub); 753 753 + let rkey = body["rkey"] 754 754 + .as_str() 755 755 + .ok_or_else(|| AppError::BadRequest("Missing parameter".to_string()))? 756 756 + .to_string(); 757 757 + 758 758 + // Create HTTP client 759 759 + let http_client = reqwest::Client::new(); 760 760 + 761 761 + // Delete record using AT Protocol functions with DPoP 762 762 + let delete_request = DeleteRecordRequest { 763 763 + repo: repo.clone(), 764 764 + collection: collection.clone(), 765 765 + record_key: rkey.clone(), 766 766 + swap_record: None, 767 767 + swap_commit: None, 768 768 + }; 769 769 + 770 770 + delete_record( 771 771 + &http_client, 772 772 + &atproto_client::client::Auth::DPoP(dpop_auth), 773 773 + &pds_url, 774 774 + delete_request, 775 775 + ) 776 776 + .await 777 777 + .map_err(|_| AppError::Internal("AT Protocol request failed".to_string()))?; 778 778 + 779 779 + // Also delete from local database (from all slices) 780 780 + let uri = format!("at://{}/{}/{}", repo, collection, rkey); 781 781 + 782 782 + // Handle cascade deletion before deleting the record 783 783 + if let Err(e) = state.database.handle_cascade_deletion(&uri, &collection).await { 784 784 + tracing::warn!("Cascade deletion failed for {}: {}", uri, e); 785 785 + } 786 786 + 787 787 + let _ = state.database.delete_record_by_uri(&uri, None).await; 788 788 + 789 789 + Ok(Json(serde_json::json!({}))) 790 790 + }

+92

api/src/database/query_builder.rs

··· 147 147 }; 148 148 *param_count += 1; 149 149 clause 150 150 + } else if let Some(_gt_value) = &condition.gt { 151 151 + let clause = match field { 152 152 + "indexed_at" => { 153 153 + format!("{} > ${}::timestamptz", field, param_count) 154 154 + } 155 155 + "did" | "collection" | "uri" | "cid" => { 156 156 + format!("{} > ${}", field, param_count) 157 157 + } 158 158 + _ => { 159 159 + let json_path = build_json_path(field); 160 160 + format!("{} > ${}", json_path, param_count) 161 161 + } 162 162 + }; 163 163 + *param_count += 1; 164 164 + clause 165 165 + } else if let Some(_gte_value) = &condition.gte { 166 166 + let clause = match field { 167 167 + "indexed_at" => { 168 168 + format!("{} >= ${}::timestamptz", field, param_count) 169 169 + } 170 170 + "did" | "collection" | "uri" | "cid" => { 171 171 + format!("{} >= ${}", field, param_count) 172 172 + } 173 173 + _ => { 174 174 + let json_path = build_json_path(field); 175 175 + format!("{} >= ${}", json_path, param_count) 176 176 + } 177 177 + }; 178 178 + *param_count += 1; 179 179 + clause 180 180 + } else if let Some(_lt_value) = &condition.lt { 181 181 + let clause = match field { 182 182 + "indexed_at" => { 183 183 + format!("{} < ${}::timestamptz", field, param_count) 184 184 + } 185 185 + "did" | "collection" | "uri" | "cid" => { 186 186 + format!("{} < ${}", field, param_count) 187 187 + } 188 188 + _ => { 189 189 + let json_path = build_json_path(field); 190 190 + format!("{} < ${}", json_path, param_count) 191 191 + } 192 192 + }; 193 193 + *param_count += 1; 194 194 + clause 195 195 + } else if let Some(_lte_value) = &condition.lte { 196 196 + let clause = match field { 197 197 + "indexed_at" => { 198 198 + format!("{} <= ${}::timestamptz", field, param_count) 199 199 + } 200 200 + "did" | "collection" | "uri" | "cid" => { 201 201 + format!("{} <= ${}", field, param_count) 202 202 + } 203 203 + _ => { 204 204 + let json_path = build_json_path(field); 205 205 + format!("{} <= ${}", json_path, param_count) 206 206 + } 207 207 + }; 208 208 + *param_count += 1; 209 209 + clause 150 210 } else { 151 211 String::new() 152 212 } ··· 236 296 237 297 if let Some(contains_value) = &condition.contains { 238 298 query_builder = query_builder.bind(contains_value); 299 299 + } 300 300 + 301 301 + if let Some(gt_value) = &condition.gt { 302 302 + if let Some(str_val) = gt_value.as_str() { 303 303 + query_builder = query_builder.bind(str_val); 304 304 + } else { 305 305 + query_builder = query_builder.bind(gt_value); 306 306 + } 307 307 + } 308 308 + 309 309 + if let Some(gte_value) = &condition.gte { 310 310 + if let Some(str_val) = gte_value.as_str() { 311 311 + query_builder = query_builder.bind(str_val); 312 312 + } else { 313 313 + query_builder = query_builder.bind(gte_value); 314 314 + } 315 315 + } 316 316 + 317 317 + if let Some(lt_value) = &condition.lt { 318 318 + if let Some(str_val) = lt_value.as_str() { 319 319 + query_builder = query_builder.bind(str_val); 320 320 + } else { 321 321 + query_builder = query_builder.bind(lt_value); 322 322 + } 323 323 + } 324 324 + 325 325 + if let Some(lte_value) = &condition.lte { 326 326 + if let Some(str_val) = lte_value.as_str() { 327 327 + query_builder = query_builder.bind(str_val); 328 328 + } else { 329 329 + query_builder = query_builder.bind(lte_value); 330 330 + } 239 331 } 240 332 241 333 query_builder

+143 -12

api/src/database/records.rs

··· 217 217 sort_by: Option<&Vec<SortField>>, 218 218 where_clause: Option<&WhereClause>, 219 219 ) -> Result<(Vec<Record>, Option<String>), DatabaseError> { 220 220 - let limit = limit.unwrap_or(50).min(100); 220 220 + // Default to 50 for API requests, but support unlimited queries for DataLoader 221 221 + let limit = limit.unwrap_or(50); 221 222 222 223 let mut where_clauses = Vec::new(); 223 224 let mut param_count = 1; ··· 433 434 if let Some(contains_value) = &condition.contains { 434 435 query_builder = query_builder.bind(contains_value); 435 436 } 437 437 + if let Some(gt_value) = &condition.gt { 438 438 + if let Some(str_val) = gt_value.as_str() { 439 439 + query_builder = query_builder.bind(str_val); 440 440 + } else { 441 441 + query_builder = query_builder.bind(gt_value); 442 442 + } 443 443 + } 444 444 + if let Some(gte_value) = &condition.gte { 445 445 + if let Some(str_val) = gte_value.as_str() { 446 446 + query_builder = query_builder.bind(str_val); 447 447 + } else { 448 448 + query_builder = query_builder.bind(gte_value); 449 449 + } 450 450 + } 451 451 + if let Some(lt_value) = &condition.lt { 452 452 + if let Some(str_val) = lt_value.as_str() { 453 453 + query_builder = query_builder.bind(str_val); 454 454 + } else { 455 455 + query_builder = query_builder.bind(lt_value); 456 456 + } 457 457 + } 458 458 + if let Some(lte_value) = &condition.lte { 459 459 + if let Some(str_val) = lte_value.as_str() { 460 460 + query_builder = query_builder.bind(str_val); 461 461 + } else { 462 462 + query_builder = query_builder.bind(lte_value); 463 463 + } 464 464 + } 436 465 } 437 466 438 467 if let Some(or_conditions) = &clause.or_conditions { ··· 454 483 if let Some(contains_value) = &condition.contains { 455 484 query_builder = query_builder.bind(contains_value); 456 485 } 486 486 + if let Some(gt_value) = &condition.gt { 487 487 + if let Some(str_val) = gt_value.as_str() { 488 488 + query_builder = query_builder.bind(str_val); 489 489 + } else { 490 490 + query_builder = query_builder.bind(gt_value); 491 491 + } 492 492 + } 493 493 + if let Some(gte_value) = &condition.gte { 494 494 + if let Some(str_val) = gte_value.as_str() { 495 495 + query_builder = query_builder.bind(str_val); 496 496 + } else { 497 497 + query_builder = query_builder.bind(gte_value); 498 498 + } 499 499 + } 500 500 + if let Some(lt_value) = &condition.lt { 501 501 + if let Some(str_val) = lt_value.as_str() { 502 502 + query_builder = query_builder.bind(str_val); 503 503 + } else { 504 504 + query_builder = query_builder.bind(lt_value); 505 505 + } 506 506 + } 507 507 + if let Some(lte_value) = &condition.lte { 508 508 + if let Some(str_val) = lte_value.as_str() { 509 509 + query_builder = query_builder.bind(str_val); 510 510 + } else { 511 511 + query_builder = query_builder.bind(lte_value); 512 512 + } 513 513 + } 457 514 } 458 515 } 459 516 } ··· 476 533 pub async fn get_aggregated_records( 477 534 &self, 478 535 slice_uri: &str, 479 479 - group_by_fields: &[String], 536 536 + group_by_fields: &[crate::models::GroupByField], 480 537 where_clause: Option<&WhereClause>, 481 538 order_by_count: Option<&str>, 482 539 limit: Option<i32>, ··· 488 545 let limit = limit.unwrap_or(50).min(1000); 489 546 let mut param_count = 1; 490 547 491 491 - // Build SELECT clause with JSON field extraction 548 548 + // Build SELECT clause with JSON field extraction and optional date truncation 492 549 let select_fields: Vec<String> = group_by_fields 493 550 .iter() 494 551 .enumerate() 495 495 - .map(|(i, field)| { 496 496 - // Check if it's a table column 497 497 - if matches!(field.as_str(), "did" | "collection" | "uri" | "cid" | "indexed_at") { 498 498 - format!("\"{}\" as field_{}", field, i) 499 499 - } else { 500 500 - // JSON field 501 501 - format!("json->>'{}' as field_{}", field, i) 552 552 + .map(|(i, group_by_field)| { 553 553 + match group_by_field { 554 554 + crate::models::GroupByField::Simple(field) => { 555 555 + // Check if it's a table column 556 556 + if matches!(field.as_str(), "did" | "collection" | "uri" | "cid" | "indexed_at") { 557 557 + format!("\"{}\" as field_{}", field, i) 558 558 + } else { 559 559 + // JSON field 560 560 + format!("json->>'{}' as field_{}", field, i) 561 561 + } 562 562 + } 563 563 + crate::models::GroupByField::Truncated { field, interval } => { 564 564 + // Date truncation using PostgreSQL's date_trunc function 565 565 + let interval_str = interval.to_pg_interval(); 566 566 + 567 567 + // Check if it's a table column 568 568 + if field == "indexed_at" { 569 569 + format!("date_trunc('{}', \"{}\")::text as field_{}", interval_str, field, i) 570 570 + } else { 571 571 + // JSON field - cast to timestamp for date_trunc, then to text 572 572 + format!("date_trunc('{}', (json->>'{}')::timestamp)::text as field_{}", interval_str, field, i) 573 573 + } 574 574 + } 502 575 } 503 576 }) 504 577 .collect(); ··· 536 609 select_clause, where_sql, group_by_clause.join(", "), order_by_sql, limit 537 610 ); 538 611 612 612 + tracing::debug!("Generated SQL: {}", query); 613 613 + 539 614 let mut query_builder = sqlx::query(&query); 540 615 query_builder = query_builder.bind(slice_uri); 541 616 ··· 559 634 if let Some(contains_value) = &condition.contains { 560 635 query_builder = query_builder.bind(contains_value); 561 636 } 637 637 + if let Some(gt_value) = &condition.gt { 638 638 + if let Some(str_val) = gt_value.as_str() { 639 639 + query_builder = query_builder.bind(str_val); 640 640 + } else { 641 641 + query_builder = query_builder.bind(gt_value.to_string()); 642 642 + } 643 643 + } 644 644 + if let Some(gte_value) = &condition.gte { 645 645 + if let Some(str_val) = gte_value.as_str() { 646 646 + query_builder = query_builder.bind(str_val); 647 647 + } else { 648 648 + query_builder = query_builder.bind(gte_value.to_string()); 649 649 + } 650 650 + } 651 651 + if let Some(lt_value) = &condition.lt { 652 652 + if let Some(str_val) = lt_value.as_str() { 653 653 + query_builder = query_builder.bind(str_val); 654 654 + } else { 655 655 + query_builder = query_builder.bind(lt_value.to_string()); 656 656 + } 657 657 + } 658 658 + if let Some(lte_value) = &condition.lte { 659 659 + if let Some(str_val) = lte_value.as_str() { 660 660 + query_builder = query_builder.bind(str_val); 661 661 + } else { 662 662 + query_builder = query_builder.bind(lte_value.to_string()); 663 663 + } 664 664 + } 562 665 } 563 666 564 667 if let Some(or_conditions) = &clause.or_conditions { ··· 580 683 if let Some(contains_value) = &condition.contains { 581 684 query_builder = query_builder.bind(contains_value); 582 685 } 686 686 + if let Some(gt_value) = &condition.gt { 687 687 + if let Some(str_val) = gt_value.as_str() { 688 688 + query_builder = query_builder.bind(str_val); 689 689 + } else { 690 690 + query_builder = query_builder.bind(gt_value.to_string()); 691 691 + } 692 692 + } 693 693 + if let Some(gte_value) = &condition.gte { 694 694 + if let Some(str_val) = gte_value.as_str() { 695 695 + query_builder = query_builder.bind(str_val); 696 696 + } else { 697 697 + query_builder = query_builder.bind(gte_value.to_string()); 698 698 + } 699 699 + } 700 700 + if let Some(lt_value) = &condition.lt { 701 701 + if let Some(str_val) = lt_value.as_str() { 702 702 + query_builder = query_builder.bind(str_val); 703 703 + } else { 704 704 + query_builder = query_builder.bind(lt_value.to_string()); 705 705 + } 706 706 + } 707 707 + if let Some(lte_value) = &condition.lte { 708 708 + if let Some(str_val) = lte_value.as_str() { 709 709 + query_builder = query_builder.bind(str_val); 710 710 + } else { 711 711 + query_builder = query_builder.bind(lte_value.to_string()); 712 712 + } 713 713 + } 583 714 } 584 715 } 585 716 } ··· 592 723 let mut obj = serde_json::Map::new(); 593 724 594 725 // Extract grouped field values 595 595 - for (i, field_name) in group_by_fields.iter().enumerate() { 726 726 + for (i, group_by_field) in group_by_fields.iter().enumerate() { 596 727 let col_name = format!("field_{}", i); 597 728 let value: Option<String> = row.try_get(col_name.as_str()).ok(); 598 729 ··· 609 740 serde_json::Value::Null 610 741 }; 611 742 612 612 - obj.insert(field_name.clone(), json_value); 743 743 + obj.insert(group_by_field.field_name().to_string(), json_value); 613 744 } 614 745 615 746 // Extract count

+9 -1

api/src/database/types.rs

··· 9 9 10 10 /// Represents a single condition in a WHERE clause. 11 11 /// 12 12 - /// Supports three types of operations: 12 12 + /// Supports multiple types of operations: 13 13 /// - `eq`: Exact match (field = value) 14 14 /// - `in_values`: Array membership (field IN (...)) 15 15 /// - `contains`: Pattern matching (field ILIKE '%value%') 16 16 + /// - `gt`: Greater than (field > value) 17 17 + /// - `gte`: Greater than or equal (field >= value) 18 18 + /// - `lt`: Less than (field < value) 19 19 + /// - `lte`: Less than or equal (field <= value) 16 20 #[derive(Debug, Clone, Serialize, Deserialize)] 17 21 #[serde(rename_all = "camelCase")] 18 22 pub struct WhereCondition { ··· 20 24 #[serde(rename = "in")] 21 25 pub in_values: Option<Vec<Value>>, 22 26 pub contains: Option<String>, 27 27 + pub gt: Option<Value>, 28 28 + pub gte: Option<Value>, 29 29 + pub lt: Option<Value>, 30 30 + pub lte: Option<Value>, 23 31 } 24 32 25 33 /// Represents a complete WHERE clause with AND/OR conditions.

+298

api/src/graphql/dataloader.rs

··· 1 1 + //! DataLoader implementation for batching database queries 2 2 + //! 3 3 + //! This module provides a DataLoader that batches multiple requests for records 4 4 + //! into single database queries, eliminating the N+1 query problem. 5 5 + 6 6 + use async_graphql::dataloader::{DataLoader as AsyncGraphQLDataLoader, Loader}; 7 7 + use std::collections::HashMap; 8 8 + use std::sync::Arc; 9 9 + 10 10 + use crate::database::Database; 11 11 + use crate::models::{IndexedRecord, WhereClause, WhereCondition}; 12 12 + 13 13 + /// Key for batching record queries by collection and DID 14 14 + #[derive(Debug, Clone, Hash, Eq, PartialEq)] 15 15 + pub struct CollectionDidKey { 16 16 + pub slice_uri: String, 17 17 + pub collection: String, 18 18 + pub did: String, 19 19 + } 20 20 + 21 21 + /// Loader for batching record queries by collection and DID 22 22 + pub struct CollectionDidLoader { 23 23 + db: Database, 24 24 + } 25 25 + 26 26 + impl CollectionDidLoader { 27 27 + pub fn new(db: Database) -> Self { 28 28 + Self { db } 29 29 + } 30 30 + } 31 31 + 32 32 + impl Loader<CollectionDidKey> for CollectionDidLoader { 33 33 + type Value = Vec<IndexedRecord>; 34 34 + type Error = Arc<String>; 35 35 + 36 36 + async fn load(&self, keys: &[CollectionDidKey]) -> Result<HashMap<CollectionDidKey, Self::Value>, Self::Error> { 37 37 + // Group keys by slice_uri and collection for optimal batching 38 38 + let mut grouped: HashMap<(String, String), Vec<String>> = HashMap::new(); 39 39 + 40 40 + for key in keys { 41 41 + grouped 42 42 + .entry((key.slice_uri.clone(), key.collection.clone())) 43 43 + .or_insert_with(Vec::new) 44 44 + .push(key.did.clone()); 45 45 + } 46 46 + 47 47 + let mut results: HashMap<CollectionDidKey, Vec<IndexedRecord>> = HashMap::new(); 48 48 + 49 49 + // Execute one query per (slice, collection) combination 50 50 + for ((slice_uri, collection), dids) in grouped { 51 51 + let mut where_clause = WhereClause { 52 52 + conditions: HashMap::new(), 53 53 + or_conditions: None, 54 54 + }; 55 55 + 56 56 + // Filter by collection 57 57 + where_clause.conditions.insert( 58 58 + "collection".to_string(), 59 59 + WhereCondition { 60 60 + gt: None, 61 61 + gte: None, 62 62 + lt: None, 63 63 + lte: None, 64 64 + eq: Some(serde_json::Value::String(collection.clone())), 65 65 + in_values: None, 66 66 + contains: None, 67 67 + }, 68 68 + ); 69 69 + 70 70 + // Filter by DIDs using IN clause for batching 71 71 + where_clause.conditions.insert( 72 72 + "did".to_string(), 73 73 + WhereCondition { 74 74 + gt: None, 75 75 + gte: None, 76 76 + lt: None, 77 77 + lte: None, 78 78 + eq: None, 79 79 + in_values: Some( 80 80 + dids.iter() 81 81 + .map(|did| serde_json::Value::String(did.clone())) 82 82 + .collect() 83 83 + ), 84 84 + contains: None, 85 85 + }, 86 86 + ); 87 87 + 88 88 + // Query database with no limit - load all records for batched filtering 89 89 + match self.db.get_slice_collections_records( 90 90 + &slice_uri, 91 91 + None, // No limit - load all records for this DID 92 92 + None, // cursor 93 93 + None, // sort 94 94 + Some(&where_clause), 95 95 + ).await { 96 96 + Ok((records, _cursor)) => { 97 97 + // Group results by DID 98 98 + for record in records { 99 99 + let key = CollectionDidKey { 100 100 + slice_uri: slice_uri.clone(), 101 101 + collection: collection.clone(), 102 102 + did: record.did.clone(), 103 103 + }; 104 104 + 105 105 + // Convert Record to IndexedRecord 106 106 + let indexed_record = IndexedRecord { 107 107 + uri: record.uri, 108 108 + cid: record.cid, 109 109 + did: record.did, 110 110 + collection: record.collection, 111 111 + value: record.json, 112 112 + indexed_at: record.indexed_at.to_rfc3339(), 113 113 + }; 114 114 + 115 115 + results 116 116 + .entry(key) 117 117 + .or_insert_with(Vec::new) 118 118 + .push(indexed_record); 119 119 + } 120 120 + } 121 121 + Err(e) => { 122 122 + tracing::error!("DataLoader batch query failed for {}/{}: {}", slice_uri, collection, e); 123 123 + // Return empty results for failed queries rather than failing the entire batch 124 124 + } 125 125 + } 126 126 + } 127 127 + 128 128 + // Ensure all requested keys have an entry (even if empty) 129 129 + for key in keys { 130 130 + results.entry(key.clone()).or_insert_with(Vec::new); 131 131 + } 132 132 + 133 133 + Ok(results) 134 134 + } 135 135 + } 136 136 + 137 137 + /// Key for batching record queries by collection and parent URI (for reverse joins) 138 138 + #[derive(Debug, Clone, Hash, Eq, PartialEq)] 139 139 + pub struct CollectionUriKey { 140 140 + pub slice_uri: String, 141 141 + pub collection: String, 142 142 + pub parent_uri: String, 143 143 + pub reference_field: String, // Field name that contains the reference (e.g., "subject") 144 144 + } 145 145 + 146 146 + /// Loader for batching record queries by collection and parent URI 147 147 + /// Used for reverse joins where we need to find records that reference a parent URI 148 148 + pub struct CollectionUriLoader { 149 149 + db: Database, 150 150 + } 151 151 + 152 152 + impl CollectionUriLoader { 153 153 + pub fn new(db: Database) -> Self { 154 154 + Self { db } 155 155 + } 156 156 + } 157 157 + 158 158 + impl Loader<CollectionUriKey> for CollectionUriLoader { 159 159 + type Value = Vec<IndexedRecord>; 160 160 + type Error = Arc<String>; 161 161 + 162 162 + async fn load(&self, keys: &[CollectionUriKey]) -> Result<HashMap<CollectionUriKey, Self::Value>, Self::Error> { 163 163 + // Group keys by (slice_uri, collection, reference_field) for optimal batching 164 164 + let mut grouped: HashMap<(String, String, String), Vec<String>> = HashMap::new(); 165 165 + 166 166 + for key in keys { 167 167 + grouped 168 168 + .entry((key.slice_uri.clone(), key.collection.clone(), key.reference_field.clone())) 169 169 + .or_insert_with(Vec::new) 170 170 + .push(key.parent_uri.clone()); 171 171 + } 172 172 + 173 173 + let mut results: HashMap<CollectionUriKey, Vec<IndexedRecord>> = HashMap::new(); 174 174 + 175 175 + // Execute one query per (slice, collection, reference_field) combination 176 176 + for ((slice_uri, collection, reference_field), parent_uris) in grouped { 177 177 + let mut where_clause = WhereClause { 178 178 + conditions: HashMap::new(), 179 179 + or_conditions: None, 180 180 + }; 181 181 + 182 182 + // Filter by collection 183 183 + where_clause.conditions.insert( 184 184 + "collection".to_string(), 185 185 + WhereCondition { 186 186 + gt: None, 187 187 + gte: None, 188 188 + lt: None, 189 189 + lte: None, 190 190 + eq: Some(serde_json::Value::String(collection.clone())), 191 191 + in_values: None, 192 192 + contains: None, 193 193 + }, 194 194 + ); 195 195 + 196 196 + // Filter by parent URIs using IN clause on the reference field 197 197 + // This queries: WHERE json->>'reference_field' IN (parent_uri1, parent_uri2, ...) 198 198 + where_clause.conditions.insert( 199 199 + reference_field.clone(), 200 200 + WhereCondition { 201 201 + gt: None, 202 202 + gte: None, 203 203 + lt: None, 204 204 + lte: None, 205 205 + eq: None, 206 206 + in_values: Some( 207 207 + parent_uris.iter() 208 208 + .map(|uri| serde_json::Value::String(uri.clone())) 209 209 + .collect() 210 210 + ), 211 211 + contains: None, 212 212 + }, 213 213 + ); 214 214 + 215 215 + // Query database with no limit - load all records for batched filtering 216 216 + match self.db.get_slice_collections_records( 217 217 + &slice_uri, 218 218 + None, // No limit - load all records matching parent URIs 219 219 + None, // cursor 220 220 + None, // sort 221 221 + Some(&where_clause), 222 222 + ).await { 223 223 + Ok((records, _cursor)) => { 224 224 + // Group results by parent URI (extract from the reference field) 225 225 + for record in records { 226 226 + // Try to extract URI - could be plain string or strongRef object 227 227 + let parent_uri = record.json.get(&reference_field).and_then(|v| { 228 228 + // First try as plain string 229 229 + if let Some(uri_str) = v.as_str() { 230 230 + return Some(uri_str.to_string()); 231 231 + } 232 232 + // Then try as strongRef 233 233 + crate::graphql::dataloaders::extract_uri_from_strong_ref(v) 234 234 + }); 235 235 + 236 236 + if let Some(parent_uri) = parent_uri { 237 237 + let key = CollectionUriKey { 238 238 + slice_uri: slice_uri.clone(), 239 239 + collection: collection.clone(), 240 240 + parent_uri: parent_uri.clone(), 241 241 + reference_field: reference_field.clone(), 242 242 + }; 243 243 + 244 244 + // Convert Record to IndexedRecord 245 245 + let indexed_record = IndexedRecord { 246 246 + uri: record.uri, 247 247 + cid: record.cid, 248 248 + did: record.did, 249 249 + collection: record.collection, 250 250 + value: record.json, 251 251 + indexed_at: record.indexed_at.to_rfc3339(), 252 252 + }; 253 253 + 254 254 + results 255 255 + .entry(key) 256 256 + .or_insert_with(Vec::new) 257 257 + .push(indexed_record); 258 258 + } 259 259 + } 260 260 + } 261 261 + Err(e) => { 262 262 + tracing::error!("CollectionUriLoader batch query failed for {}/{}: {}", slice_uri, collection, e); 263 263 + // Return empty results for failed queries rather than failing the entire batch 264 264 + } 265 265 + } 266 266 + } 267 267 + 268 268 + // Ensure all requested keys have an entry (even if empty) 269 269 + for key in keys { 270 270 + results.entry(key.clone()).or_insert_with(Vec::new); 271 271 + } 272 272 + 273 273 + Ok(results) 274 274 + } 275 275 + } 276 276 + 277 277 + /// Context data that includes the DataLoader 278 278 + #[derive(Clone)] 279 279 + pub struct GraphQLContext { 280 280 + #[allow(dead_code)] 281 281 + pub collection_did_loader: Arc<AsyncGraphQLDataLoader<CollectionDidLoader>>, 282 282 + pub collection_uri_loader: Arc<AsyncGraphQLDataLoader<CollectionUriLoader>>, 283 283 + } 284 284 + 285 285 + impl GraphQLContext { 286 286 + pub fn new(db: Database) -> Self { 287 287 + Self { 288 288 + collection_did_loader: Arc::new(AsyncGraphQLDataLoader::new( 289 289 + CollectionDidLoader::new(db.clone()), 290 290 + tokio::spawn 291 291 + )), 292 292 + collection_uri_loader: Arc::new(AsyncGraphQLDataLoader::new( 293 293 + CollectionUriLoader::new(db), 294 294 + tokio::spawn 295 295 + )), 296 296 + } 297 297 + } 298 298 + }

+24 -5

api/src/graphql/handler.rs

··· 15 15 16 16 use crate::errors::AppError; 17 17 use crate::AppState; 18 18 + use crate::graphql::GraphQLContext; 18 19 19 20 /// Global schema cache (one schema per slice) 20 21 /// This prevents rebuilding the schema on every request ··· 65 66 } 66 67 }; 67 68 68 68 - Ok(schema.execute(req.into_inner()).await.into()) 69 69 + // Create GraphQL context with DataLoader 70 70 + let gql_context = GraphQLContext::new(state.database.clone()); 71 71 + 72 72 + // Execute query with context 73 73 + Ok(schema 74 74 + .execute(req.into_inner().data(gql_context)) 75 75 + .await 76 76 + .into()) 69 77 } 70 78 71 79 /// GraphiQL UI handler ··· 198 206 } 199 207 }; 200 208 209 209 + // Create GraphQL context with DataLoader 210 210 + let gql_context = GraphQLContext::new(state.database.clone()); 211 211 + 201 212 // Upgrade to WebSocket and handle GraphQL subscriptions manually 202 213 Ok(ws 203 214 .protocols(["graphql-transport-ws", "graphql-ws"]) 204 204 - .on_upgrade(move |socket| handle_graphql_ws(socket, schema))) 215 215 + .on_upgrade(move |socket| handle_graphql_ws(socket, schema, gql_context))) 205 216 } 206 217 207 218 /// Handle GraphQL WebSocket connection 208 208 - async fn handle_graphql_ws(socket: WebSocket, schema: Schema) { 219 219 + async fn handle_graphql_ws(socket: WebSocket, schema: Schema, gql_context: GraphQLContext) { 209 220 let (ws_sender, ws_receiver) = socket.split(); 210 221 211 222 // Convert axum WebSocket messages to strings for async-graphql ··· 216 227 }) 217 228 }); 218 229 219 219 - // Create GraphQL WebSocket handler 220 220 - let mut stream = GraphQLWebSocket::new(schema, input, WebSocketProtocols::GraphQLWS); 230 230 + // Create GraphQL WebSocket handler with context 231 231 + let mut stream = GraphQLWebSocket::new(schema.clone(), input, WebSocketProtocols::GraphQLWS) 232 232 + .on_connection_init(move |_| { 233 233 + let gql_ctx = gql_context.clone(); 234 234 + async move { 235 235 + let mut data = async_graphql::Data::default(); 236 236 + data.insert(gql_ctx); 237 237 + Ok(data) 238 238 + } 239 239 + }); 221 240 222 241 // Send GraphQL messages back through WebSocket 223 242 let mut ws_sender = ws_sender;

+2

api/src/graphql/mod.rs

··· 5 5 6 6 mod schema_builder; 7 7 mod dataloaders; 8 8 + mod dataloader; 8 9 mod types; 9 10 pub mod handler; 10 11 pub mod pubsub; ··· 12 13 pub use schema_builder::build_graphql_schema; 13 14 pub use handler::{graphql_handler, graphql_playground, graphql_subscription_handler}; 14 15 pub use pubsub::{RecordUpdateEvent, RecordOperation, PUBSUB}; 16 16 + pub use dataloader::GraphQLContext;

+658 -143

api/src/graphql/schema_builder.rs

··· 15 15 use crate::database::Database; 16 16 use crate::graphql::types::{extract_collection_fields, extract_record_key, GraphQLField, GraphQLType}; 17 17 use crate::graphql::PUBSUB; 18 18 + use crate::graphql::dataloader::GraphQLContext; 18 19 19 20 /// Metadata about a collection for cross-referencing 20 21 #[derive(Clone)] ··· 22 23 nsid: String, 23 24 key_type: String, // "tid", "literal:self", or "any" 24 25 type_name: String, // GraphQL type name for this collection 26 26 + at_uri_fields: Vec<String>, // Fields with format "at-uri" for reverse joins 25 27 } 26 28 27 29 /// Builds a dynamic GraphQL schema from lexicons for a given slice ··· 52 54 // Build Query root type and collect all object types 53 55 let mut query = Object::new("Query"); 54 56 let mut objects_to_register = Vec::new(); 57 57 + let mut where_inputs_to_register = Vec::new(); 58 58 + let mut group_by_enums_to_register = Vec::new(); 55 59 56 60 // First pass: collect metadata about all collections for cross-referencing 57 61 let mut all_collections: Vec<CollectionMeta> = Vec::new(); ··· 68 72 let fields = extract_collection_fields(defs); 69 73 if !fields.is_empty() { 70 74 if let Some(key_type) = extract_record_key(defs) { 75 75 + // Extract at-uri field names for reverse joins 76 76 + let at_uri_fields: Vec<String> = fields.iter() 77 77 + .filter(|f| f.format.as_deref() == Some("at-uri")) 78 78 + .map(|f| f.name.clone()) 79 79 + .collect(); 80 80 + 81 81 + if !at_uri_fields.is_empty() { 82 82 + tracing::debug!( 83 83 + "Collection {} has at-uri fields: {:?}", 84 84 + nsid, 85 85 + at_uri_fields 86 86 + ); 87 87 + } 88 88 + 71 89 all_collections.push(CollectionMeta { 72 90 nsid: nsid.to_string(), 73 91 key_type, 74 92 type_name: nsid_to_type_name(nsid), 93 93 + at_uri_fields, 75 94 }); 76 95 } 77 96 } ··· 102 121 let edge_type = create_edge_type(&type_name); 103 122 let connection_type = create_connection_type(&type_name); 104 123 124 124 + // Create WhereInput type for this collection 125 125 + let mut where_input = InputObject::new(format!("{}WhereInput", type_name)); 126 126 + 127 127 + // Collect lexicon field names to avoid duplicates 128 128 + let lexicon_field_names: std::collections::HashSet<&str> = 129 129 + fields.iter().map(|f| f.name.as_str()).collect(); 130 130 + 131 131 + // Add system fields available on all records (skip if already in lexicon) 132 132 + let system_fields = [ 133 133 + ("indexedAt", "DateTimeFilter"), 134 134 + ("uri", "StringFilter"), 135 135 + ("cid", "StringFilter"), 136 136 + ("did", "StringFilter"), 137 137 + ("collection", "StringFilter"), 138 138 + ("actorHandle", "StringFilter"), 139 139 + ]; 140 140 + 141 141 + for (field_name, filter_type) in system_fields { 142 142 + if !lexicon_field_names.contains(field_name) { 143 143 + where_input = where_input.field(InputValue::new(field_name, TypeRef::named(filter_type))); 144 144 + } 145 145 + } 146 146 + 147 147 + // Add fields from the lexicon 148 148 + for field in &fields { 149 149 + let filter_type = match field.field_type { 150 150 + GraphQLType::Int => "IntFilter", 151 151 + _ => "StringFilter", // Default to StringFilter for strings and other types 152 152 + }; 153 153 + where_input = where_input.field(InputValue::new(&field.name, TypeRef::named(filter_type))); 154 154 + } 155 155 + 156 156 + // Create GroupByField enum for this collection 157 157 + let mut group_by_enum = Enum::new(format!("{}GroupByField", type_name)); 158 158 + group_by_enum = group_by_enum.item(EnumItem::new("indexedAt")); 159 159 + 160 160 + for field in &fields { 161 161 + group_by_enum = group_by_enum.item(EnumItem::new(&field.name)); 162 162 + } 163 163 + 164 164 + // Create collection-specific GroupByFieldInput 165 165 + let group_by_input = InputObject::new(format!("{}GroupByFieldInput", type_name)) 166 166 + .field(InputValue::new("field", TypeRef::named_nn(format!("{}GroupByField", type_name)))) 167 167 + .field(InputValue::new("interval", TypeRef::named("DateInterval"))); 168 168 + 169 169 + // Create collection-specific SortFieldInput 170 170 + let sort_field_input = InputObject::new(format!("{}SortFieldInput", type_name)) 171 171 + .field(InputValue::new("field", TypeRef::named_nn(format!("{}GroupByField", type_name)))) 172 172 + .field(InputValue::new("direction", TypeRef::named("SortDirection"))); 173 173 + 105 174 // Collect the types to register with schema later 106 175 objects_to_register.push(record_type); 107 176 objects_to_register.push(edge_type); 108 177 objects_to_register.push(connection_type); 178 178 + where_inputs_to_register.push(where_input); 179 179 + where_inputs_to_register.push(group_by_input); 180 180 + where_inputs_to_register.push(sort_field_input); 181 181 + group_by_enums_to_register.push(group_by_enum); 109 182 110 183 // Add query field for this collection 111 184 let collection_query_name = nsid_to_query_name(nsid); ··· 143 216 for item in list.iter() { 144 217 if let Ok(obj) = item.object() { 145 218 let field = obj.get("field") 146 146 - .and_then(|v| v.string().ok()) 147 147 - .unwrap_or("indexedAt") 148 148 - .to_string(); 219 219 + .and_then(|v| v.enum_name().ok().map(|s| s.to_string())) 220 220 + .unwrap_or_else(|| "indexedAt".to_string()); 149 221 let direction = obj.get("direction") 150 150 - .and_then(|v| v.string().ok()) 151 151 - .unwrap_or("desc") 152 152 - .to_string(); 222 222 + .and_then(|v| v.enum_name().ok().map(|s| s.to_string())) 223 223 + .unwrap_or_else(|| "desc".to_string()); 153 224 sort_fields.push(crate::models::SortField { field, direction }); 154 225 } 155 226 } ··· 171 242 where_clause.conditions.insert( 172 243 "collection".to_string(), 173 244 crate::models::WhereCondition { 245 245 + gt: None, 246 246 + gte: None, 247 247 + lt: None, 248 248 + lte: None, 174 249 eq: Some(serde_json::Value::String(collection.clone())), 175 250 in_values: None, 176 251 contains: None, ··· 184 259 for (field_name, condition_val) in where_obj.iter() { 185 260 if let Ok(condition_obj) = condition_val.object() { 186 261 let mut where_condition = crate::models::WhereCondition { 262 262 + gt: None, 263 263 + gte: None, 264 264 + lt: None, 265 265 + lte: None, 187 266 eq: None, 188 267 in_values: None, 189 268 contains: None, ··· 220 299 } 221 300 } 222 301 223 223 - where_clause.conditions.insert(field_name.to_string(), where_condition); 302 302 + // Parse gt condition 303 303 + if let Some(gt_val) = condition_obj.get("gt") { 304 304 + if let Ok(gt_str) = gt_val.string() { 305 305 + where_condition.gt = Some(serde_json::Value::String(gt_str.to_string())); 306 306 + } else if let Ok(gt_i64) = gt_val.i64() { 307 307 + where_condition.gt = Some(serde_json::Value::Number(gt_i64.into())); 308 308 + } 309 309 + } 310 310 + 311 311 + // Parse gte condition 312 312 + if let Some(gte_val) = condition_obj.get("gte") { 313 313 + if let Ok(gte_str) = gte_val.string() { 314 314 + where_condition.gte = Some(serde_json::Value::String(gte_str.to_string())); 315 315 + } else if let Ok(gte_i64) = gte_val.i64() { 316 316 + where_condition.gte = Some(serde_json::Value::Number(gte_i64.into())); 317 317 + } 318 318 + } 319 319 + 320 320 + // Parse lt condition 321 321 + if let Some(lt_val) = condition_obj.get("lt") { 322 322 + if let Ok(lt_str) = lt_val.string() { 323 323 + where_condition.lt = Some(serde_json::Value::String(lt_str.to_string())); 324 324 + } else if let Ok(lt_i64) = lt_val.i64() { 325 325 + where_condition.lt = Some(serde_json::Value::Number(lt_i64.into())); 326 326 + } 327 327 + } 328 328 + 329 329 + // Parse lte condition 330 330 + if let Some(lte_val) = condition_obj.get("lte") { 331 331 + if let Ok(lte_str) = lte_val.string() { 332 332 + where_condition.lte = Some(serde_json::Value::String(lte_str.to_string())); 333 333 + } else if let Ok(lte_i64) = lte_val.i64() { 334 334 + where_condition.lte = Some(serde_json::Value::Number(lte_i64.into())); 335 335 + } 336 336 + } 337 337 + 338 338 + // Convert indexedAt to indexed_at for database column 339 339 + let db_field_name = if field_name == "indexedAt" { 340 340 + "indexed_at".to_string() 341 341 + } else { 342 342 + field_name.to_string() 343 343 + }; 344 344 + 345 345 + where_clause.conditions.insert(db_field_name, where_condition); 224 346 } 225 347 } 226 348 } ··· 251 373 // Replace actorHandle condition with did condition 252 374 let did_condition = if dids.len() == 1 { 253 375 crate::models::WhereCondition { 376 376 + gt: None, 377 377 + gte: None, 378 378 + lt: None, 379 379 + lte: None, 254 380 eq: Some(serde_json::Value::String(dids[0].clone())), 255 381 in_values: None, 256 382 contains: None, 257 383 } 258 384 } else { 259 385 crate::models::WhereCondition { 386 386 + gt: None, 387 387 + gte: None, 388 388 + lt: None, 389 389 + lte: None, 260 390 eq: None, 261 391 in_values: Some(dids.into_iter().map(|d| serde_json::Value::String(d)).collect()), 262 392 contains: None, ··· 344 474 )) 345 475 .argument(async_graphql::dynamic::InputValue::new( 346 476 "sortBy", 347 347 - TypeRef::named_list("SortField"), 477 477 + TypeRef::named_list(format!("{}SortFieldInput", type_name)), 348 478 )) 349 479 .argument(async_graphql::dynamic::InputValue::new( 350 480 "where", 351 351 - TypeRef::named("JSON"), 481 481 + TypeRef::named(format!("{}WhereInput", type_name)), 352 482 )) 353 483 .description(format!("Query {} records", nsid)), 354 484 ); ··· 376 506 377 507 FieldFuture::new(async move { 378 508 // Parse groupBy argument 379 379 - let group_by_fields: Vec<String> = match ctx.args.get("groupBy") { 509 509 + let group_by_fields: Vec<crate::models::GroupByField> = match ctx.args.get("groupBy") { 380 510 Some(val) => { 381 511 if let Ok(list) = val.list() { 382 382 - list.iter() 383 383 - .filter_map(|v| v.string().ok().map(|s| s.to_string())) 384 384 - .collect() 512 512 + let mut fields = Vec::new(); 513 513 + for item in list.iter() { 514 514 + if let Ok(obj) = item.object() { 515 515 + // Get field name from enum 516 516 + let field_name = obj.get("field") 517 517 + .and_then(|v| v.enum_name().ok().map(|s| s.to_string())) 518 518 + .ok_or_else(|| Error::new("Missing field name in groupBy"))?; 519 519 + 520 520 + // Get optional interval 521 521 + if let Some(interval_val) = obj.get("interval") { 522 522 + if let Ok(interval_str) = interval_val.enum_name() { 523 523 + // Parse interval string to DateInterval 524 524 + let interval = match interval_str { 525 525 + "second" => crate::models::DateInterval::Second, 526 526 + "minute" => crate::models::DateInterval::Minute, 527 527 + "hour" => crate::models::DateInterval::Hour, 528 528 + "day" => crate::models::DateInterval::Day, 529 529 + "week" => crate::models::DateInterval::Week, 530 530 + "month" => crate::models::DateInterval::Month, 531 531 + "quarter" => crate::models::DateInterval::Quarter, 532 532 + "year" => crate::models::DateInterval::Year, 533 533 + _ => return Err(Error::new(format!("Invalid interval: {}", interval_str))), 534 534 + }; 535 535 + fields.push(crate::models::GroupByField::Truncated { 536 536 + field: field_name, 537 537 + interval, 538 538 + }); 539 539 + } else { 540 540 + return Err(Error::new("Invalid interval value")); 541 541 + } 542 542 + } else { 543 543 + // No interval, simple field 544 544 + fields.push(crate::models::GroupByField::Simple(field_name)); 545 545 + } 546 546 + } else { 547 547 + return Err(Error::new("Invalid groupBy item")); 548 548 + } 549 549 + } 550 550 + fields 385 551 } else { 386 552 Vec::new() 387 553 } ··· 423 589 where_clause.conditions.insert( 424 590 "collection".to_string(), 425 591 crate::models::WhereCondition { 592 592 + gt: None, 593 593 + gte: None, 594 594 + lt: None, 595 595 + lte: None, 426 596 eq: Some(serde_json::Value::String(collection.clone())), 427 597 in_values: None, 428 598 contains: None, ··· 435 605 for (field_name, condition_val) in where_obj.iter() { 436 606 if let Ok(condition_obj) = condition_val.object() { 437 607 let mut where_condition = crate::models::WhereCondition { 608 608 + gt: None, 609 609 + gte: None, 610 610 + lt: None, 611 611 + lte: None, 438 612 eq: None, 439 613 in_values: None, 440 614 contains: None, ··· 471 645 } 472 646 } 473 647 474 474 - where_clause.conditions.insert(field_name.to_string(), where_condition); 648 648 + // Parse gt condition 649 649 + if let Some(gt_val) = condition_obj.get("gt") { 650 650 + if let Ok(gt_str) = gt_val.string() { 651 651 + where_condition.gt = Some(serde_json::Value::String(gt_str.to_string())); 652 652 + } else if let Ok(gt_i64) = gt_val.i64() { 653 653 + where_condition.gt = Some(serde_json::Value::Number(gt_i64.into())); 654 654 + } 655 655 + } 656 656 + 657 657 + // Parse gte condition 658 658 + if let Some(gte_val) = condition_obj.get("gte") { 659 659 + if let Ok(gte_str) = gte_val.string() { 660 660 + where_condition.gte = Some(serde_json::Value::String(gte_str.to_string())); 661 661 + } else if let Ok(gte_i64) = gte_val.i64() { 662 662 + where_condition.gte = Some(serde_json::Value::Number(gte_i64.into())); 663 663 + } 664 664 + } 665 665 + 666 666 + // Parse lt condition 667 667 + if let Some(lt_val) = condition_obj.get("lt") { 668 668 + if let Ok(lt_str) = lt_val.string() { 669 669 + where_condition.lt = Some(serde_json::Value::String(lt_str.to_string())); 670 670 + } else if let Ok(lt_i64) = lt_val.i64() { 671 671 + where_condition.lt = Some(serde_json::Value::Number(lt_i64.into())); 672 672 + } 673 673 + } 674 674 + 675 675 + // Parse lte condition 676 676 + if let Some(lte_val) = condition_obj.get("lte") { 677 677 + if let Ok(lte_str) = lte_val.string() { 678 678 + where_condition.lte = Some(serde_json::Value::String(lte_str.to_string())); 679 679 + } else if let Ok(lte_i64) = lte_val.i64() { 680 680 + where_condition.lte = Some(serde_json::Value::Number(lte_i64.into())); 681 681 + } 682 682 + } 683 683 + 684 684 + // Convert indexedAt to indexed_at for database column 685 685 + let db_field_name = if field_name == "indexedAt" { 686 686 + "indexed_at".to_string() 687 687 + } else { 688 688 + field_name.to_string() 689 689 + }; 690 690 + 691 691 + where_clause.conditions.insert(db_field_name, where_condition); 475 692 } 476 693 } 477 694 } ··· 499 716 if !dids.is_empty() { 500 717 let did_condition = if dids.len() == 1 { 501 718 crate::models::WhereCondition { 719 719 + gt: None, 720 720 + gte: None, 721 721 + lt: None, 722 722 + lte: None, 502 723 eq: Some(serde_json::Value::String(dids[0].clone())), 503 724 in_values: None, 504 725 contains: None, 505 726 } 506 727 } else { 507 728 crate::models::WhereCondition { 729 729 + gt: None, 730 730 + gte: None, 731 731 + lt: None, 732 732 + lte: None, 508 733 eq: None, 509 734 in_values: Some(dids.into_iter().map(|d| serde_json::Value::String(d)).collect()), 510 735 contains: None, ··· 546 771 ) 547 772 .argument(async_graphql::dynamic::InputValue::new( 548 773 "groupBy", 549 549 - TypeRef::named_nn_list_nn(TypeRef::STRING), 774 774 + TypeRef::named_nn_list(format!("{}GroupByFieldInput", type_name)), 550 775 )) 551 776 .argument(async_graphql::dynamic::InputValue::new( 552 777 "where", 553 553 - TypeRef::named("JSON"), 778 778 + TypeRef::named(format!("{}WhereInput", type_name)), 554 779 )) 555 780 .argument(async_graphql::dynamic::InputValue::new( 556 781 "orderBy", ··· 571 796 // Build Subscription type with collection-specific subscriptions 572 797 let subscription = create_subscription_type(slice_uri.clone(), &lexicons); 573 798 574 574 - // Build and return the schema 799 799 + // Build and return the schema with complexity limits 575 800 let mut schema_builder = Schema::build(query.type_name(), Some(mutation.type_name()), Some(subscription.type_name())) 576 801 .register(query) 577 802 .register(mutation) 578 578 - .register(subscription); 803 803 + .register(subscription) 804 804 + .limit_depth(50) // Higher limit to support GraphiQL introspection with reverse joins 805 805 + .limit_complexity(5000); // Prevent expensive deeply nested queries 579 806 580 807 // Register JSON scalar type for complex fields 581 808 let json_scalar = Scalar::new("JSON"); 582 809 schema_builder = schema_builder.register(json_scalar); 583 810 811 811 + // Register filter input types for WHERE clauses 812 812 + let string_filter = InputObject::new("StringFilter") 813 813 + .field(InputValue::new("eq", TypeRef::named(TypeRef::STRING))) 814 814 + .field(InputValue::new("in", TypeRef::named_list(TypeRef::STRING))) 815 815 + .field(InputValue::new("contains", TypeRef::named(TypeRef::STRING))) 816 816 + .field(InputValue::new("gt", TypeRef::named(TypeRef::STRING))) 817 817 + .field(InputValue::new("gte", TypeRef::named(TypeRef::STRING))) 818 818 + .field(InputValue::new("lt", TypeRef::named(TypeRef::STRING))) 819 819 + .field(InputValue::new("lte", TypeRef::named(TypeRef::STRING))); 820 820 + schema_builder = schema_builder.register(string_filter); 821 821 + 822 822 + let int_filter = InputObject::new("IntFilter") 823 823 + .field(InputValue::new("eq", TypeRef::named(TypeRef::INT))) 824 824 + .field(InputValue::new("in", TypeRef::named_list(TypeRef::INT))) 825 825 + .field(InputValue::new("gt", TypeRef::named(TypeRef::INT))) 826 826 + .field(InputValue::new("gte", TypeRef::named(TypeRef::INT))) 827 827 + .field(InputValue::new("lt", TypeRef::named(TypeRef::INT))) 828 828 + .field(InputValue::new("lte", TypeRef::named(TypeRef::INT))); 829 829 + schema_builder = schema_builder.register(int_filter); 830 830 + 831 831 + let datetime_filter = InputObject::new("DateTimeFilter") 832 832 + .field(InputValue::new("eq", TypeRef::named(TypeRef::STRING))) 833 833 + .field(InputValue::new("gt", TypeRef::named(TypeRef::STRING))) 834 834 + .field(InputValue::new("gte", TypeRef::named(TypeRef::STRING))) 835 835 + .field(InputValue::new("lt", TypeRef::named(TypeRef::STRING))) 836 836 + .field(InputValue::new("lte", TypeRef::named(TypeRef::STRING))); 837 837 + schema_builder = schema_builder.register(datetime_filter); 838 838 + 584 839 // Register Blob type 585 840 let blob_type = create_blob_type(); 586 841 schema_builder = schema_builder.register(blob_type); ··· 608 863 let aggregation_order_by_input = create_aggregation_order_by_input(); 609 864 schema_builder = schema_builder.register(aggregation_order_by_input); 610 865 866 866 + // Register DateInterval enum for date truncation 867 867 + let date_interval_enum = create_date_interval_enum(); 868 868 + schema_builder = schema_builder.register(date_interval_enum); 869 869 + 611 870 // Register PageInfo type 612 871 let page_info_type = create_page_info_type(); 613 872 schema_builder = schema_builder.register(page_info_type); ··· 621 880 schema_builder = schema_builder.register(obj); 622 881 } 623 882 883 883 + // Register all WhereInput types 884 884 + for where_input in where_inputs_to_register { 885 885 + schema_builder = schema_builder.register(where_input); 886 886 + } 887 887 + 888 888 + // Register all GroupByField enums 889 889 + for group_by_enum in group_by_enums_to_register { 890 890 + schema_builder = schema_builder.register(group_by_enum); 891 891 + } 892 892 + 624 893 schema_builder 625 894 .finish() 626 895 .map_err(|e| format!("Schema build error: {:?}", e)) ··· 720 989 where_clause.conditions.insert( 721 990 "did".to_string(), 722 991 crate::models::WhereCondition { 992 992 + gt: None, 993 993 + gte: None, 994 994 + lt: None, 995 995 + lte: None, 723 996 eq: Some(serde_json::Value::String(did.clone())), 724 997 in_values: None, 725 998 contains: None, ··· 768 1041 if let Some(val) = value { 769 1042 // Check for explicit null value 770 1043 if val.is_null() { 771 771 - return Ok(Some(FieldValue::NULL)); 1044 1044 + return Ok(None); 1045 1045 + } 1046 1046 + 1047 1047 + // Check if this is an array of blobs 1048 1048 + if let GraphQLType::Array(inner) = &field_type { 1049 1049 + if matches!(inner.as_ref(), GraphQLType::Blob) { 1050 1050 + if let Some(arr) = val.as_array() { 1051 1051 + let blob_containers: Vec<FieldValue> = arr 1052 1052 + .iter() 1053 1053 + .filter_map(|blob_val| { 1054 1054 + let obj = blob_val.as_object()?; 1055 1055 + let blob_ref = obj 1056 1056 + .get("ref") 1057 1057 + .and_then(|r| r.as_object()) 1058 1058 + .and_then(|r| r.get("$link")) 1059 1059 + .and_then(|l| l.as_str()) 1060 1060 + .unwrap_or("") 1061 1061 + .to_string(); 1062 1062 + 1063 1063 + let mime_type = obj 1064 1064 + .get("mimeType") 1065 1065 + .and_then(|m| m.as_str()) 1066 1066 + .unwrap_or("image/jpeg") 1067 1067 + .to_string(); 1068 1068 + 1069 1069 + let size = obj 1070 1070 + .get("size") 1071 1071 + .and_then(|s| s.as_i64()) 1072 1072 + .unwrap_or(0); 1073 1073 + 1074 1074 + let blob_container = BlobContainer { 1075 1075 + blob_ref, 1076 1076 + mime_type, 1077 1077 + size, 1078 1078 + did: container.record.did.clone(), 1079 1079 + }; 1080 1080 + 1081 1081 + Some(FieldValue::owned_any(blob_container)) 1082 1082 + }) 1083 1083 + .collect(); 1084 1084 + 1085 1085 + return Ok(Some(FieldValue::list(blob_containers))); 1086 1086 + } 1087 1087 + 1088 1088 + // If not a proper array, return empty list 1089 1089 + return Ok(Some(FieldValue::list(Vec::<FieldValue>::new()))); 1090 1090 + } 772 1091 } 773 1092 774 1093 // Check if this is a blob field ··· 804 1123 return Ok(Some(FieldValue::owned_any(blob_container))); 805 1124 } 806 1125 807 807 - // If not a proper blob object, return NULL 808 808 - return Ok(Some(FieldValue::NULL)); 1126 1126 + // If not a proper blob object, return None (field is null) 1127 1127 + return Ok(None); 809 1128 } 810 1129 811 1130 // Check if this is a reference field that needs joining ··· 827 1146 return Ok(Some(FieldValue::value(graphql_val))); 828 1147 } 829 1148 Ok(None) => { 830 830 - return Ok(Some(FieldValue::NULL)); 1149 1149 + return Ok(None); 831 1150 } 832 1151 Err(e) => { 833 1152 tracing::error!("Error fetching linked record: {}", e); 834 834 - return Ok(Some(FieldValue::NULL)); 1153 1153 + return Ok(None); 835 1154 } 836 1155 } 837 1156 } ··· 841 1160 let graphql_val = json_to_graphql_value(val); 842 1161 Ok(Some(FieldValue::value(graphql_val))) 843 1162 } else { 844 844 - Ok(Some(FieldValue::NULL)) 1163 1163 + Ok(None) 845 1164 } 846 1165 }) 847 1166 })); 848 1167 } 849 1168 850 850 - // Add join fields for cross-referencing other collections by DID 1169 1169 + // Add join fields for cross-referencing other collections 851 1170 for collection in all_collections { 852 1171 let field_name = nsid_to_join_field_name(&collection.nsid); 853 1172 ··· 856 1175 continue; 857 1176 } 858 1177 1178 1178 + // Collect all string fields with format "at-uri" that might reference this collection 1179 1179 + // We'll check each one at runtime to see if it contains a URI to this collection 1180 1180 + let uri_ref_fields: Vec<_> = fields.iter() 1181 1181 + .filter(|f| matches!(f.format.as_deref(), Some("at-uri"))) 1182 1182 + .collect(); 1183 1183 + 859 1184 let collection_nsid = collection.nsid.clone(); 860 1185 let key_type = collection.key_type.clone(); 861 1186 let db_for_join = database.clone(); 862 862 - let slice_for_join = slice_uri.clone(); 1187 1187 + 1188 1188 + // If we found at-uri fields, create a resolver that checks each one at runtime 1189 1189 + if !uri_ref_fields.is_empty() { 1190 1190 + let ref_field_names: Vec<String> = uri_ref_fields.iter().map(|f| f.name.clone()).collect(); 1191 1191 + let db_for_uri_join = database.clone(); 1192 1192 + let target_collection = collection_nsid.clone(); 1193 1193 + 1194 1194 + object = object.field(Field::new( 1195 1195 + &field_name, 1196 1196 + TypeRef::named(&collection.type_name), 1197 1197 + move |ctx| { 1198 1198 + let db = db_for_uri_join.clone(); 1199 1199 + let field_names = ref_field_names.clone(); 1200 1200 + let expected_collection = target_collection.clone(); 1201 1201 + FieldFuture::new(async move { 1202 1202 + let container = ctx.parent_value.try_downcast_ref::<RecordContainer>()?; 1203 1203 + 1204 1204 + // Try each at-uri field to find one that references this collection 1205 1205 + for field_name in &field_names { 1206 1206 + if let Some(uri_value) = container.record.value.get(field_name) { 1207 1207 + if let Some(uri) = uri_value.as_str() { 1208 1208 + // Check if the URI is for the expected collection 1209 1209 + if uri.contains(&format!("/{}/", expected_collection)) { 1210 1210 + // Fetch the record at this URI 1211 1211 + match db.get_record(uri).await { 1212 1212 + Ok(Some(record)) => { 1213 1213 + let new_container = RecordContainer { record }; 1214 1214 + return Ok(Some(FieldValue::owned_any(new_container))); 1215 1215 + } 1216 1216 + Ok(None) => continue, // Try next field 1217 1217 + Err(_) => continue, // Try next field 1218 1218 + } 1219 1219 + } 1220 1220 + } 1221 1221 + } 1222 1222 + } 1223 1223 + // No matching URI found in any field 1224 1224 + Ok(None) 1225 1225 + }) 1226 1226 + }, 1227 1227 + )); 1228 1228 + continue; // Skip the normal DID-based join logic 1229 1229 + } 863 1230 864 1231 // Determine type and resolver based on key_type 865 1232 match key_type.as_str() { ··· 893 1260 )); 894 1261 } 895 1262 "tid" | "any" => { 896 896 - // Multiple records per DID - return array of the collection's type 897 897 - object = object.field( 1263 1263 + // Skip - these are handled as plural reverse joins below with URI filtering 1264 1264 + continue; 1265 1265 + 1266 1266 + // Multiple records per DID - return array of the collection's type (DISABLED) 1267 1267 + /*object = object.field( 898 1268 Field::new( 899 1269 &field_name, 900 1270 TypeRef::named_nn_list_nn(&collection.type_name), 901 1271 move |ctx| { 902 902 - let db = db_for_join.clone(); 903 1272 let nsid = collection_nsid.clone(); 904 1273 let slice = slice_for_join.clone(); 1274 1274 + let db_fallback = db_for_join.clone(); 905 1275 FieldFuture::new(async move { 906 1276 let container = ctx.parent_value.try_downcast_ref::<RecordContainer>()?; 907 1277 let did = &container.record.did; ··· 909 1279 // Get limit from argument, default to 50 910 1280 let limit = ctx.args.get("limit") 911 1281 .and_then(|v| v.i64().ok()) 912 912 - .map(|i| i as i32) 1282 1282 + .map(|i| i as usize) 913 1283 .unwrap_or(50) 914 1284 .min(100); // Cap at 100 to prevent abuse 915 1285 916 916 - // Build where clause to find all records of this collection for this DID 917 917 - let mut where_clause = crate::models::WhereClause { 918 918 - conditions: HashMap::new(), 919 919 - or_conditions: None, 920 920 - }; 921 921 - where_clause.conditions.insert( 922 922 - "collection".to_string(), 923 923 - crate::models::WhereCondition { 924 924 - eq: Some(serde_json::Value::String(nsid.clone())), 925 925 - in_values: None, 926 926 - contains: None, 927 927 - }, 928 928 - ); 929 929 - where_clause.conditions.insert( 930 930 - "did".to_string(), 931 931 - crate::models::WhereCondition { 932 932 - eq: Some(serde_json::Value::String(did.clone())), 933 933 - in_values: None, 934 934 - contains: None, 935 935 - }, 936 936 - ); 1286 1286 + // Try to get DataLoader from context 1287 1287 + if let Some(gql_ctx) = ctx.data_opt::<GraphQLContext>() { 1288 1288 + // Use DataLoader for batched loading 1289 1289 + let key = CollectionDidKey { 1290 1290 + slice_uri: slice.clone(), 1291 1291 + collection: nsid.clone(), 1292 1292 + did: did.clone(), 1293 1293 + }; 1294 1294 + 1295 1295 + match gql_ctx.collection_did_loader.load_one(key).await { 1296 1296 + Ok(Some(mut records)) => { 1297 1297 + // Apply limit after loading 1298 1298 + records.truncate(limit); 937 1299 938 938 - match db.get_slice_collections_records( 939 939 - &slice, 940 940 - Some(limit), 941 941 - None, // cursor 942 942 - None, // sort 943 943 - Some(&where_clause), 944 944 - ).await { 945 945 - Ok((records, _cursor)) => { 946 946 - let values: Vec<FieldValue> = records 947 947 - .into_iter() 948 948 - .map(|record| { 949 949 - // Convert Record to IndexedRecord 950 950 - let indexed_record = crate::models::IndexedRecord { 951 951 - uri: record.uri, 952 952 - cid: record.cid, 953 953 - did: record.did, 954 954 - collection: record.collection, 955 955 - value: record.json, 956 956 - indexed_at: record.indexed_at.to_rfc3339(), 957 957 - }; 958 958 - let container = RecordContainer { 959 959 - record: indexed_record, 960 960 - }; 961 961 - FieldValue::owned_any(container) 962 962 - }) 963 963 - .collect(); 964 964 - Ok(Some(FieldValue::list(values))) 1300 1300 + let values: Vec<FieldValue> = records 1301 1301 + .into_iter() 1302 1302 + .map(|indexed_record| { 1303 1303 + let container = RecordContainer { 1304 1304 + record: indexed_record, 1305 1305 + }; 1306 1306 + FieldValue::owned_any(container) 1307 1307 + }) 1308 1308 + .collect(); 1309 1309 + Ok(Some(FieldValue::list(values))) 1310 1310 + } 1311 1311 + Ok(None) => { 1312 1312 + Ok(Some(FieldValue::list(Vec::<FieldValue>::new()))) 1313 1313 + } 1314 1314 + Err(e) => { 1315 1315 + tracing::debug!("DataLoader error for {}: {:?}", nsid, e); 1316 1316 + Ok(Some(FieldValue::list(Vec::<FieldValue>::new()))) 1317 1317 + } 965 1318 } 966 966 - Err(e) => { 967 967 - tracing::debug!("Error querying {}: {}", nsid, e); 968 968 - Ok(Some(FieldValue::list(Vec::<FieldValue>::new()))) 1319 1319 + } else { 1320 1320 + // Fallback to direct database query if DataLoader not available 1321 1321 + let db = db_fallback.clone(); 1322 1322 + let mut where_clause = crate::models::WhereClause { 1323 1323 + conditions: HashMap::new(), 1324 1324 + or_conditions: None, 1325 1325 + }; 1326 1326 + where_clause.conditions.insert( 1327 1327 + "collection".to_string(), 1328 1328 + crate::models::WhereCondition { 1329 1329 + gt: None, 1330 1330 + gte: None, 1331 1331 + lt: None, 1332 1332 + lte: None, 1333 1333 + eq: Some(serde_json::Value::String(nsid.clone())), 1334 1334 + in_values: None, 1335 1335 + contains: None, 1336 1336 + }, 1337 1337 + ); 1338 1338 + where_clause.conditions.insert( 1339 1339 + "did".to_string(), 1340 1340 + crate::models::WhereCondition { 1341 1341 + gt: None, 1342 1342 + gte: None, 1343 1343 + lt: None, 1344 1344 + lte: None, 1345 1345 + eq: Some(serde_json::Value::String(did.clone())), 1346 1346 + in_values: None, 1347 1347 + contains: None, 1348 1348 + }, 1349 1349 + ); 1350 1350 + 1351 1351 + match db.get_slice_collections_records( 1352 1352 + &slice, 1353 1353 + Some(limit as i32), 1354 1354 + None, // cursor 1355 1355 + None, // sort 1356 1356 + Some(&where_clause), 1357 1357 + ).await { 1358 1358 + Ok((records, _cursor)) => { 1359 1359 + let values: Vec<FieldValue> = records 1360 1360 + .into_iter() 1361 1361 + .map(|record| { 1362 1362 + let indexed_record = crate::models::IndexedRecord { 1363 1363 + uri: record.uri, 1364 1364 + cid: record.cid, 1365 1365 + did: record.did, 1366 1366 + collection: record.collection, 1367 1367 + value: record.json, 1368 1368 + indexed_at: record.indexed_at.to_rfc3339(), 1369 1369 + }; 1370 1370 + let container = RecordContainer { 1371 1371 + record: indexed_record, 1372 1372 + }; 1373 1373 + FieldValue::owned_any(container) 1374 1374 + }) 1375 1375 + .collect(); 1376 1376 + Ok(Some(FieldValue::list(values))) 1377 1377 + } 1378 1378 + Err(e) => { 1379 1379 + tracing::debug!("Error querying {}: {}", nsid, e); 1380 1380 + Ok(Some(FieldValue::list(Vec::<FieldValue>::new()))) 1381 1381 + } 969 1382 } 970 1383 } 971 1384 }) ··· 975 1388 "limit", 976 1389 TypeRef::named(TypeRef::INT), 977 1390 )) 978 978 - ); 1391 1391 + );*/ 979 1392 } 980 1393 _ => { 981 1394 // Unknown key type, skip ··· 988 1401 // This enables bidirectional traversal (e.g., profile.plays and play.profile) 989 1402 for collection in all_collections { 990 1403 let reverse_field_name = format!("{}s", nsid_to_join_field_name(&collection.nsid)); 991 991 - let db_for_reverse = database.clone(); 992 1404 let slice_for_reverse = slice_uri.clone(); 993 1405 let collection_nsid = collection.nsid.clone(); 994 1406 let collection_type = collection.type_name.clone(); 1407 1407 + let at_uri_fields = collection.at_uri_fields.clone(); 995 1408 996 1409 object = object.field( 997 1410 Field::new( 998 1411 &reverse_field_name, 999 1412 TypeRef::named_nn_list_nn(&collection_type), 1000 1413 move |ctx| { 1001 1001 - let db = db_for_reverse.clone(); 1002 1414 let slice = slice_for_reverse.clone(); 1003 1415 let nsid = collection_nsid.clone(); 1416 1416 + let ref_fields = at_uri_fields.clone(); 1004 1417 FieldFuture::new(async move { 1005 1418 let container = ctx.parent_value.try_downcast_ref::<RecordContainer>()?; 1006 1006 - let did = &container.record.did; 1007 1419 1008 1420 // Get limit from argument, default to 50 1009 1421 let limit = ctx.args.get("limit") 1010 1422 .and_then(|v| v.i64().ok()) 1011 1011 - .map(|i| i as i32) 1423 1423 + .map(|i| i as usize) 1012 1424 .unwrap_or(50) 1013 1425 .min(100); // Cap at 100 to prevent abuse 1014 1426 1015 1015 - // Build where clause to find all records of this collection for this DID 1016 1016 - let mut where_clause = crate::models::WhereClause { 1017 1017 - conditions: HashMap::new(), 1018 1018 - or_conditions: None, 1019 1019 - }; 1020 1020 - where_clause.conditions.insert( 1021 1021 - "collection".to_string(), 1022 1022 - crate::models::WhereCondition { 1023 1023 - eq: Some(serde_json::Value::String(nsid.clone())), 1024 1024 - in_values: None, 1025 1025 - contains: None, 1026 1026 - }, 1027 1027 - ); 1028 1028 - where_clause.conditions.insert( 1029 1029 - "did".to_string(), 1030 1030 - crate::models::WhereCondition { 1031 1031 - eq: Some(serde_json::Value::String(did.clone())), 1032 1032 - in_values: None, 1033 1033 - contains: None, 1034 1034 - }, 1035 1035 - ); 1427 1427 + // Try to get DataLoader from context 1428 1428 + if let Some(gql_ctx) = ctx.data_opt::<GraphQLContext>() { 1429 1429 + let parent_uri = &container.record.uri; 1430 1430 + 1431 1431 + // Try each at-uri field from the lexicon 1432 1432 + tracing::debug!( 1433 1433 + "Trying reverse join for {} with at-uri fields: {:?}", 1434 1434 + nsid, 1435 1435 + ref_fields 1436 1436 + ); 1437 1437 + 1438 1438 + for ref_field in &ref_fields { 1439 1439 + let key = crate::graphql::dataloader::CollectionUriKey { 1440 1440 + slice_uri: slice.clone(), 1441 1441 + collection: nsid.clone(), 1442 1442 + parent_uri: parent_uri.clone(), 1443 1443 + reference_field: ref_field.clone(), 1444 1444 + }; 1445 1445 + 1446 1446 + tracing::debug!( 1447 1447 + "Querying {} via field '{}' for URI: {}", 1448 1448 + nsid, 1449 1449 + ref_field, 1450 1450 + parent_uri 1451 1451 + ); 1452 1452 + 1453 1453 + match gql_ctx.collection_uri_loader.load_one(key).await { 1454 1454 + Ok(Some(mut records)) => { 1455 1455 + if !records.is_empty() { 1456 1456 + tracing::debug!( 1457 1457 + "Found {} {} records via '{}' field for parent URI: {}", 1458 1458 + records.len(), 1459 1459 + nsid, 1460 1460 + ref_field, 1461 1461 + parent_uri 1462 1462 + ); 1463 1463 + 1464 1464 + // Apply limit 1465 1465 + records.truncate(limit); 1036 1466 1037 1037 - match db.get_slice_collections_records( 1038 1038 - &slice, 1039 1039 - Some(limit), 1040 1040 - None, // cursor 1041 1041 - None, // sort 1042 1042 - Some(&where_clause), 1043 1043 - ).await { 1044 1044 - Ok((records, _cursor)) => { 1045 1045 - let values: Vec<FieldValue> = records 1046 1046 - .into_iter() 1047 1047 - .map(|record| { 1048 1048 - // Convert Record to IndexedRecord 1049 1049 - let indexed_record = crate::models::IndexedRecord { 1050 1050 - uri: record.uri, 1051 1051 - cid: record.cid, 1052 1052 - did: record.did, 1053 1053 - collection: record.collection, 1054 1054 - value: record.json, 1055 1055 - indexed_at: record.indexed_at.to_rfc3339(), 1056 1056 - }; 1057 1057 - let container = RecordContainer { 1058 1058 - record: indexed_record, 1059 1059 - }; 1060 1060 - FieldValue::owned_any(container) 1061 1061 - }) 1062 1062 - .collect(); 1063 1063 - Ok(Some(FieldValue::list(values))) 1467 1467 + let values: Vec<FieldValue> = records 1468 1468 + .into_iter() 1469 1469 + .map(|indexed_record| { 1470 1470 + let container = RecordContainer { 1471 1471 + record: indexed_record, 1472 1472 + }; 1473 1473 + FieldValue::owned_any(container) 1474 1474 + }) 1475 1475 + .collect(); 1476 1476 + return Ok(Some(FieldValue::list(values))); 1477 1477 + } 1478 1478 + } 1479 1479 + Ok(None) => continue, 1480 1480 + Err(e) => { 1481 1481 + tracing::debug!("DataLoader error for {} field '{}': {:?}", nsid, ref_field, e); 1482 1482 + continue; 1483 1483 + } 1484 1484 + } 1064 1485 } 1065 1065 - Err(e) => { 1066 1066 - tracing::debug!("Error querying {}: {}", nsid, e); 1067 1067 - Ok(Some(FieldValue::list(Vec::<FieldValue>::new()))) 1068 1068 - } 1486 1486 + 1487 1487 + // No records found via any at-uri field 1488 1488 + tracing::debug!("No {} records found for parent URI: {}", nsid, parent_uri); 1489 1489 + return Ok(Some(FieldValue::list(Vec::<FieldValue>::new()))); 1069 1490 } 1491 1491 + 1492 1492 + // Fallback: DataLoader not available 1493 1493 + tracing::debug!("DataLoader not available for reverse join"); 1494 1494 + Ok(Some(FieldValue::list(Vec::<FieldValue>::new()))) 1070 1495 }) 1071 1496 }, 1072 1497 ) ··· 1075 1500 TypeRef::named(TypeRef::INT), 1076 1501 )) 1077 1502 ); 1503 1503 + 1504 1504 + // Add count field for the reverse join 1505 1505 + let count_field_name = format!("{}Count", reverse_field_name); 1506 1506 + let db_for_count = database.clone(); 1507 1507 + let slice_for_count = slice_uri.clone(); 1508 1508 + let collection_for_count = collection.nsid.clone(); 1509 1509 + let at_uri_fields_for_count = collection.at_uri_fields.clone(); 1510 1510 + 1511 1511 + object = object.field( 1512 1512 + Field::new( 1513 1513 + &count_field_name, 1514 1514 + TypeRef::named_nn(TypeRef::INT), 1515 1515 + move |ctx| { 1516 1516 + let slice = slice_for_count.clone(); 1517 1517 + let nsid = collection_for_count.clone(); 1518 1518 + let db = db_for_count.clone(); 1519 1519 + let ref_fields = at_uri_fields_for_count.clone(); 1520 1520 + FieldFuture::new(async move { 1521 1521 + let container = ctx.parent_value.try_downcast_ref::<RecordContainer>()?; 1522 1522 + let parent_uri = &container.record.uri; 1523 1523 + 1524 1524 + // Build where clause to count records referencing this URI 1525 1525 + for ref_field in &ref_fields { 1526 1526 + let mut where_clause = crate::models::WhereClause { 1527 1527 + conditions: HashMap::new(), 1528 1528 + or_conditions: None, 1529 1529 + }; 1530 1530 + 1531 1531 + where_clause.conditions.insert( 1532 1532 + "collection".to_string(), 1533 1533 + crate::models::WhereCondition { 1534 1534 + gt: None, 1535 1535 + gte: None, 1536 1536 + lt: None, 1537 1537 + lte: None, 1538 1538 + eq: Some(serde_json::Value::String(nsid.clone())), 1539 1539 + in_values: None, 1540 1540 + contains: None, 1541 1541 + }, 1542 1542 + ); 1543 1543 + 1544 1544 + where_clause.conditions.insert( 1545 1545 + ref_field.clone(), 1546 1546 + crate::models::WhereCondition { 1547 1547 + gt: None, 1548 1548 + gte: None, 1549 1549 + lt: None, 1550 1550 + lte: None, 1551 1551 + eq: Some(serde_json::Value::String(parent_uri.clone())), 1552 1552 + in_values: None, 1553 1553 + contains: None, 1554 1554 + }, 1555 1555 + ); 1556 1556 + 1557 1557 + match db.count_slice_collections_records(&slice, Some(&where_clause)).await { 1558 1558 + Ok(count) if count > 0 => { 1559 1559 + return Ok(Some(FieldValue::value(count as i32))); 1560 1560 + } 1561 1561 + Ok(_) => continue, 1562 1562 + Err(e) => { 1563 1563 + tracing::debug!("Count error for {}: {}", nsid, e); 1564 1564 + continue; 1565 1565 + } 1566 1566 + } 1567 1567 + } 1568 1568 + 1569 1569 + // No matching field found, return 0 1570 1570 + Ok(Some(FieldValue::value(0))) 1571 1571 + }) 1572 1572 + }, 1573 1573 + ) 1574 1574 + ); 1078 1575 } 1079 1576 1080 1577 object ··· 1144 1641 } 1145 1642 GraphQLType::Blob => { 1146 1643 // Blob object type with url resolver 1147 1147 - if is_required { 1148 1148 - TypeRef::named_nn("Blob") 1149 1149 - } else { 1150 1150 - TypeRef::named("Blob") 1151 1151 - } 1644 1644 + // Always nullable since blob data might be missing or malformed 1645 1645 + TypeRef::named("Blob") 1152 1646 } 1153 1647 GraphQLType::Json | GraphQLType::Ref | GraphQLType::Object(_) | GraphQLType::Union => { 1154 1648 // JSON scalar type - linked records and complex objects return as JSON ··· 1175 1669 TypeRef::named_nn_list_nn(inner_ref) 1176 1670 } else { 1177 1671 TypeRef::named_list(inner_ref) 1672 1672 + } 1673 1673 + } 1674 1674 + GraphQLType::Blob => { 1675 1675 + // Arrays of blobs - return list of Blob objects 1676 1676 + if is_required { 1677 1677 + TypeRef::named_nn_list("Blob") 1678 1678 + } else { 1679 1679 + TypeRef::named_list("Blob") 1178 1680 } 1179 1681 } 1180 1682 _ => { ··· 1715 2217 fn create_aggregation_order_by_input() -> InputObject { 1716 2218 InputObject::new("AggregationOrderBy") 1717 2219 .field(InputValue::new("count", TypeRef::named("SortDirection"))) 2220 2220 + } 2221 2221 + 2222 2222 + /// Creates the DateInterval enum for date truncation 2223 2223 + fn create_date_interval_enum() -> Enum { 2224 2224 + Enum::new("DateInterval") 2225 2225 + .item(EnumItem::new("second")) 2226 2226 + .item(EnumItem::new("minute")) 2227 2227 + .item(EnumItem::new("hour")) 2228 2228 + .item(EnumItem::new("day")) 2229 2229 + .item(EnumItem::new("week")) 2230 2230 + .item(EnumItem::new("month")) 2231 2231 + .item(EnumItem::new("quarter")) 2232 2232 + .item(EnumItem::new("year")) 1718 2233 } 1719 2234 1720 2235 /// Converts a serde_json::Value to an async_graphql::Value

+7

api/src/graphql/types.rs

··· 8 8 pub name: String, 9 9 pub field_type: GraphQLType, 10 10 pub is_required: bool, 11 11 + pub format: Option<String>, // e.g., "at-uri", "uri", "datetime" 11 12 } 12 13 13 14 /// GraphQL type representation mapped from lexicon types ··· 96 97 .and_then(|t| t.as_str()) 97 98 .unwrap_or("unknown"); 98 99 100 100 + let format = field_def 101 101 + .get("format") 102 102 + .and_then(|f| f.as_str()) 103 103 + .map(|s| s.to_string()); 104 104 + 99 105 GraphQLField { 100 106 name: field_name.clone(), 107 107 + format, 101 108 field_type: map_lexicon_type_to_graphql( 102 109 field_type_name, 103 110 field_def,

+52

api/src/models.rs

··· 90 90 pub timestamp: String, 91 91 pub count: i64, 92 92 } 93 93 + 94 94 + /// Date interval for date truncation in aggregations 95 95 + #[derive(Debug, Clone, Serialize, Deserialize)] 96 96 + #[serde(rename_all = "lowercase")] 97 97 + pub enum DateInterval { 98 98 + Second, 99 99 + Minute, 100 100 + Hour, 101 101 + Day, 102 102 + Week, 103 103 + Month, 104 104 + Quarter, 105 105 + Year, 106 106 + } 107 107 + 108 108 + impl DateInterval { 109 109 + /// Convert to PostgreSQL date_trunc() interval string 110 110 + pub fn to_pg_interval(&self) -> &'static str { 111 111 + match self { 112 112 + DateInterval::Second => "second", 113 113 + DateInterval::Minute => "minute", 114 114 + DateInterval::Hour => "hour", 115 115 + DateInterval::Day => "day", 116 116 + DateInterval::Week => "week", 117 117 + DateInterval::Month => "month", 118 118 + DateInterval::Quarter => "quarter", 119 119 + DateInterval::Year => "year", 120 120 + } 121 121 + } 122 122 + } 123 123 + 124 124 + /// Group by field specification for aggregations 125 125 + #[derive(Debug, Clone)] 126 126 + pub enum GroupByField { 127 127 + /// Simple field name 128 128 + Simple(String), 129 129 + /// Date-truncated field 130 130 + Truncated { 131 131 + field: String, 132 132 + interval: DateInterval, 133 133 + }, 134 134 + } 135 135 + 136 136 + impl GroupByField { 137 137 + /// Get the field name 138 138 + pub fn field_name(&self) -> &str { 139 139 + match self { 140 140 + GroupByField::Simple(name) => name, 141 141 + GroupByField::Truncated { field, .. } => field, 142 142 + } 143 143 + } 144 144 + }

+762

docs/graphql-api.md

··· 1 1 + # GraphQL API 2 2 + 3 3 + Slices provides a powerful GraphQL API for querying indexed AT Protocol data. The API automatically generates schema from your lexicons and provides efficient querying with relationship traversal. 4 4 + 5 5 + ## Accessing the API 6 6 + 7 7 + GraphQL endpoints are available per-slice: 8 8 + 9 9 + ``` 10 10 + POST /graphql?slice=<slice-uri> 11 11 + ``` 12 12 + 13 13 + ### GraphQL Playground 14 14 + 15 15 + Access the interactive GraphQL Playground in your browser: 16 16 + 17 17 + ``` 18 18 + https://api.slices.network/graphql?slice=<slice-uri> 19 19 + ``` 20 20 + 21 21 + ## Schema Generation 22 22 + 23 23 + The GraphQL schema is automatically generated from your slice's lexicons: 24 24 + 25 25 + - **Types**: One GraphQL type per collection (e.g., `social.grain.gallery` → `SocialGrainGallery`) 26 26 + - **Queries**: Collection queries with filtering, sorting, and pagination 27 27 + - **Mutations**: Create, update, delete operations per collection 28 28 + - **Subscriptions**: Real-time updates for record changes 29 29 + 30 30 + ## Querying Data 31 31 + 32 32 + ### Basic Query 33 33 + 34 34 + ```graphql 35 35 + query { 36 36 + socialGrainGalleries { 37 37 + edges { 38 38 + node { 39 39 + uri 40 40 + title 41 41 + description 42 42 + createdAt 43 43 + } 44 44 + } 45 45 + } 46 46 + } 47 47 + ``` 48 48 + 49 49 + ### Filtering 50 50 + 51 51 + Use `where` clauses with typed filter conditions. Each collection has its own `{Collection}WhereInput` type with appropriate filters for each field. 52 52 + 53 53 + ```graphql 54 54 + query { 55 55 + socialGrainGalleries(where: { 56 56 + title: { contains: "Aerial" } 57 57 + }) { 58 58 + edges { 59 59 + node { 60 60 + uri 61 61 + title 62 62 + description 63 63 + } 64 64 + } 65 65 + } 66 66 + } 67 67 + ``` 68 68 + 69 69 + #### Filter Types 70 70 + 71 71 + The API provides three filter types based on field data types: 72 72 + 73 73 + **StringFilter** - For string fields: 74 74 + - `eq`: Exact match 75 75 + - `in`: Match any value in array 76 76 + - `contains`: Substring match (case-insensitive) 77 77 + - `gt`: Greater than (lexicographic) 78 78 + - `gte`: Greater than or equal to 79 79 + - `lt`: Less than 80 80 + - `lte`: Less than or equal to 81 81 + 82 82 + **IntFilter** - For integer fields: 83 83 + - `eq`: Exact match 84 84 + - `in`: Match any value in array 85 85 + - `gt`: Greater than 86 86 + - `gte`: Greater than or equal to 87 87 + - `lt`: Less than 88 88 + - `lte`: Less than or equal to 89 89 + 90 90 + **DateTimeFilter** - For datetime fields: 91 91 + - `eq`: Exact match 92 92 + - `gt`: After datetime 93 93 + - `gte`: At or after datetime 94 94 + - `lt`: Before datetime 95 95 + - `lte`: At or before datetime 96 96 + 97 97 + #### Date Range Example 98 98 + 99 99 + ```graphql 100 100 + query RecentGalleries { 101 101 + socialGrainGalleries( 102 102 + where: { 103 103 + createdAt: { 104 104 + gte: "2025-01-01T00:00:00Z" 105 105 + lt: "2025-12-31T23:59:59Z" 106 106 + } 107 107 + } 108 108 + ) { 109 109 + edges { 110 110 + node { 111 111 + uri 112 112 + title 113 113 + createdAt 114 114 + } 115 115 + } 116 116 + } 117 117 + } 118 118 + ``` 119 119 + 120 120 + #### Multiple Conditions 121 121 + 122 122 + Combine multiple filters - they are AND'ed together: 123 123 + 124 124 + ```graphql 125 125 + query { 126 126 + socialGrainGalleries( 127 127 + where: { 128 128 + title: { contains: "Aerial" } 129 129 + createdAt: { gte: "2025-01-01T00:00:00Z" } 130 130 + } 131 131 + ) { 132 132 + edges { 133 133 + node { 134 134 + uri 135 135 + title 136 136 + description 137 137 + createdAt 138 138 + } 139 139 + } 140 140 + } 141 141 + } 142 142 + ``` 143 143 + 144 144 + ### Pagination 145 145 + 146 146 + Relay-style cursor pagination: 147 147 + 148 148 + ```graphql 149 149 + query { 150 150 + socialGrainGalleries(first: 10, after: "cursor") { 151 151 + edges { 152 152 + cursor 153 153 + node { 154 154 + uri 155 155 + title 156 156 + } 157 157 + } 158 158 + pageInfo { 159 159 + hasNextPage 160 160 + endCursor 161 161 + } 162 162 + } 163 163 + } 164 164 + ``` 165 165 + 166 166 + ### Sorting 167 167 + 168 168 + Each collection has its own typed `{Collection}SortFieldInput` for type-safe sorting: 169 169 + 170 170 + ```graphql 171 171 + query { 172 172 + socialGrainGalleries( 173 173 + sortBy: [ 174 174 + { field: createdAt, direction: desc } 175 175 + ] 176 176 + ) { 177 177 + edges { 178 178 + node { 179 179 + uri 180 180 + title 181 181 + createdAt 182 182 + } 183 183 + } 184 184 + } 185 185 + } 186 186 + ``` 187 187 + 188 188 + **Multi-field sorting:** 189 189 + ```graphql 190 190 + query { 191 191 + socialGrainGalleries( 192 192 + sortBy: [ 193 193 + { field: actorHandle, direction: asc } 194 194 + { field: createdAt, direction: desc } 195 195 + ] 196 196 + ) { 197 197 + edges { 198 198 + node { 199 199 + uri 200 200 + title 201 201 + actorHandle 202 202 + createdAt 203 203 + } 204 204 + } 205 205 + } 206 206 + } 207 207 + ``` 208 208 + 209 209 + The `field` enum values are collection-specific (e.g., `SocialGrainGallerySortFieldInput`). Use GraphQL introspection or the playground to see available fields for each collection. 210 210 + 211 211 + ## Aggregations 212 212 + 213 213 + Aggregation queries allow you to group records and perform calculations. Each collection has a corresponding `{Collection}Aggregated` query. 214 214 + 215 215 + ### Basic Aggregation 216 216 + 217 217 + Group records by one or more fields and get counts: 218 218 + 219 219 + ```graphql 220 220 + query TopTracks { 221 221 + fmTealAlphaFeedPlaysAggregated( 222 222 + groupBy: [trackName] 223 223 + orderBy: { count: desc } 224 224 + limit: 10 225 225 + ) { 226 226 + trackName 227 227 + count 228 228 + } 229 229 + } 230 230 + ``` 231 231 + 232 232 + ### Multi-Field Grouping 233 233 + 234 234 + Group by multiple fields using the typed `{Collection}GroupByField` enum: 235 235 + 236 236 + ```graphql 237 237 + query TopTracksByArtist { 238 238 + fmTealAlphaFeedPlaysAggregated( 239 239 + groupBy: [trackName, artists] 240 240 + orderBy: { count: desc } 241 241 + limit: 20 242 242 + ) { 243 243 + trackName 244 244 + artists 245 245 + count 246 246 + } 247 247 + } 248 248 + ``` 249 249 + 250 250 + ### Filtering Aggregations 251 251 + 252 252 + Combine typed filters with aggregations for time-based analysis: 253 253 + 254 254 + ```graphql 255 255 + query TopTracksThisWeek { 256 256 + fmTealAlphaFeedPlaysAggregated( 257 257 + groupBy: [trackName, artists] 258 258 + where: { 259 259 + indexedAt: { 260 260 + gte: "2025-01-01T00:00:00Z" 261 261 + lt: "2025-01-08T00:00:00Z" 262 262 + } 263 263 + trackName: { contains: "Love" } 264 264 + } 265 265 + orderBy: { count: desc } 266 266 + limit: 10 267 267 + ) { 268 268 + trackName 269 269 + artists 270 270 + count 271 271 + } 272 272 + } 273 273 + ``` 274 274 + 275 275 + ### Aggregation Features 276 276 + 277 277 + - **Typed GroupBy**: Each collection has a `{Collection}GroupByField` enum for type-safe field selection 278 278 + - **Typed Filters**: Use the same `{Collection}WhereInput` as regular queries 279 279 + - **Sorting**: Order by `count` (ascending or descending) or any grouped field 280 280 + - **Pagination**: Use `limit` to control result count 281 281 + - **Multiple Fields**: Group by any combination of fields from your lexicon 282 282 + - **Date Truncation**: Group by time intervals (second, minute, hour, day, week, month, quarter, year) 283 283 + 284 284 + ### Date Truncation 285 285 + 286 286 + Group records by time intervals using the `interval` parameter in `groupBy`: 287 287 + 288 288 + ```graphql 289 289 + query DailyPlays { 290 290 + fmTealAlphaFeedPlaysAggregated( 291 291 + groupBy: [ 292 292 + { field: "playedTime", interval: day } 293 293 + ] 294 294 + orderBy: { count: desc } 295 295 + limit: 30 296 296 + ) { 297 297 + playedTime 298 298 + count 299 299 + } 300 300 + } 301 301 + ``` 302 302 + 303 303 + **Supported Intervals:** 304 304 + - `second` - Group by second 305 305 + - `minute` - Group by minute 306 306 + - `hour` - Group by hour 307 307 + - `day` - Group by day (common for daily reports) 308 308 + - `week` - Group by week (Monday-Sunday) 309 309 + - `month` - Group by month 310 310 + - `quarter` - Group by quarter (Q1-Q4) 311 311 + - `year` - Group by year 312 312 + 313 313 + **Combining with Regular Fields:** 314 314 + ```graphql 315 315 + query TrackPlaysByDay { 316 316 + fmTealAlphaFeedPlaysAggregated( 317 317 + groupBy: [ 318 318 + { field: "trackName" }, 319 319 + { field: "playedTime", interval: day } 320 320 + ] 321 321 + orderBy: { count: desc } 322 322 + limit: 100 323 323 + ) { 324 324 + trackName 325 325 + playedTime 326 326 + count 327 327 + } 328 328 + } 329 329 + ``` 330 330 + 331 331 + **How it Works:** 332 332 + - Uses PostgreSQL's `date_trunc()` function for efficient time bucketing 333 333 + - Automatically handles timestamp casting for JSON fields 334 334 + - Returns truncated timestamps (e.g., `2025-01-15 00:00:00` for day interval) 335 335 + - Works with both system fields (`indexedAt`) and lexicon datetime fields 336 336 + 337 337 + ### Use Cases 338 338 + 339 339 + **Daily/Weekly/Monthly Reports**: 340 340 + ```graphql 341 341 + query WeeklyPlays { 342 342 + fmTealAlphaFeedPlaysAggregated( 343 343 + groupBy: [trackName] 344 344 + where: { 345 345 + playedTime: { 346 346 + gte: "2025-01-01T00:00:00Z" 347 347 + lt: "2025-01-08T00:00:00Z" 348 348 + } 349 349 + } 350 350 + orderBy: { count: desc } 351 351 + limit: 50 352 352 + ) { 353 353 + trackName 354 354 + count 355 355 + } 356 356 + } 357 357 + ``` 358 358 + 359 359 + **Trend Analysis**: 360 360 + ```graphql 361 361 + query TrendingArtists { 362 362 + fmTealAlphaFeedPlaysAggregated( 363 363 + groupBy: [artists] 364 364 + where: { 365 365 + playedTime: { gte: "2025-01-01T00:00:00Z" } 366 366 + } 367 367 + orderBy: { count: desc } 368 368 + limit: 20 369 369 + ) { 370 370 + artists 371 371 + count 372 372 + } 373 373 + } 374 374 + ``` 375 375 + 376 376 + ## Relationships 377 377 + 378 378 + The GraphQL API automatically generates relationship fields based on your lexicon's `at-uri` fields. 379 379 + 380 380 + ### Forward Joins (References) 381 381 + 382 382 + When a record has an `at-uri` field, you get a **singular** field that resolves to the referenced record. 383 383 + 384 384 + **Lexicon Schema (social.grain.gallery.item):** 385 385 + ```json 386 386 + { 387 387 + "lexicon": 1, 388 388 + "id": "social.grain.gallery.item", 389 389 + "defs": { 390 390 + "main": { 391 391 + "type": "record", 392 392 + "key": "tid", 393 393 + "record": { 394 394 + "type": "object", 395 395 + "required": ["gallery", "item", "position", "createdAt"], 396 396 + "properties": { 397 397 + "gallery": { 398 398 + "type": "string", 399 399 + "format": "at-uri" 400 400 + }, 401 401 + "item": { 402 402 + "type": "string", 403 403 + "format": "at-uri" 404 404 + }, 405 405 + "position": { "type": "integer" }, 406 406 + "createdAt": { "type": "string", "format": "datetime" } 407 407 + } 408 408 + } 409 409 + } 410 410 + } 411 411 + } 412 412 + ``` 413 413 + 414 414 + **Generated GraphQL Type:** 415 415 + ```graphql 416 416 + type SocialGrainGalleryItem { 417 417 + uri: String! 418 418 + gallery: String! # at-uri field from lexicon 419 419 + item: String! # at-uri field from lexicon 420 420 + position: Int! 421 421 + createdAt: String! 422 422 + 423 423 + # Auto-generated forward joins (singular) 424 424 + socialGrainGallery: SocialGrainGallery 425 425 + socialGrainPhoto: SocialGrainPhoto 426 426 + } 427 427 + ``` 428 428 + 429 429 + **Example Query:** 430 430 + ```graphql 431 431 + query { 432 432 + socialGrainGalleryItems(limit: 5) { 433 433 + position 434 434 + # Follow the reference to get the photo 435 435 + socialGrainPhoto { 436 436 + uri 437 437 + alt 438 438 + aspectRatio 439 439 + } 440 440 + # Follow the reference to get the gallery 441 441 + socialGrainGallery { 442 442 + title 443 443 + description 444 444 + } 445 445 + } 446 446 + } 447 447 + ``` 448 448 + 449 449 + ### Reverse Joins (Backlinks) 450 450 + 451 451 + When other records reference this record via `at-uri` fields, you get **plural** fields that find all records pointing here. 452 452 + 453 453 + **Lexicon Schema (social.grain.favorite):** 454 454 + ```json 455 455 + { 456 456 + "lexicon": 1, 457 457 + "id": "social.grain.favorite", 458 458 + "defs": { 459 459 + "main": { 460 460 + "type": "record", 461 461 + "key": "tid", 462 462 + "record": { 463 463 + "type": "object", 464 464 + "required": ["subject", "createdAt"], 465 465 + "properties": { 466 466 + "subject": { 467 467 + "type": "string", 468 468 + "format": "at-uri" 469 469 + }, 470 470 + "createdAt": { "type": "string", "format": "datetime" } 471 471 + } 472 472 + } 473 473 + } 474 474 + } 475 475 + } 476 476 + ``` 477 477 + 478 478 + **Generated GraphQL Types:** 479 479 + ```graphql 480 480 + type SocialGrainFavorite { 481 481 + uri: String! 482 482 + subject: String! # at-uri pointing to gallery 483 483 + createdAt: String! 484 484 + 485 485 + # Forward join (follows the subject field) 486 486 + socialGrainGallery: SocialGrainGallery 487 487 + } 488 488 + 489 489 + type SocialGrainGallery { 490 490 + uri: String! 491 491 + title: String 492 492 + 493 493 + # Auto-generated reverse joins (plural) 494 494 + # These find all records whose at-uri fields point here 495 495 + socialGrainFavorites: [SocialGrainFavorite!]! 496 496 + socialGrainComments: [SocialGrainComment!]! 497 497 + socialGrainGalleryItems: [SocialGrainGalleryItem!]! 498 498 + } 499 499 + ``` 500 500 + 501 501 + **Example Query:** 502 502 + ```graphql 503 503 + query { 504 504 + socialGrainGalleries(where: { 505 505 + actorHandle: { eq: "chadtmiller.com" } 506 506 + }) { 507 507 + edges { 508 508 + node { 509 509 + uri 510 510 + title 511 511 + # Get all favorites for this gallery 512 512 + socialGrainFavorites { 513 513 + uri 514 514 + createdAt 515 515 + actorHandle 516 516 + } 517 517 + # Get all comments for this gallery 518 518 + socialGrainComments { 519 519 + uri 520 520 + text 521 521 + actorHandle 522 522 + } 523 523 + } 524 524 + } 525 525 + } 526 526 + } 527 527 + ``` 528 528 + 529 529 + ### Count Fields 530 530 + 531 531 + For efficient counting without loading all data, use `*Count` fields: 532 532 + 533 533 + ```graphql 534 534 + query { 535 535 + socialGrainGalleries { 536 536 + edges { 537 537 + node { 538 538 + uri 539 539 + title 540 540 + # Efficient count queries (no data loading) 541 541 + socialGrainFavoritesCount 542 542 + socialGrainCommentsCount 543 543 + socialGrainPhotosCount 544 544 + } 545 545 + } 546 546 + } 547 547 + } 548 548 + ``` 549 549 + 550 550 + ### Combining Counts and Data 551 551 + 552 552 + Best practice: Get counts separately from limited data: 553 553 + 554 554 + ```graphql 555 555 + query { 556 556 + socialGrainGalleries { 557 557 + edges { 558 558 + node { 559 559 + uri 560 560 + title 561 561 + # Total count 562 562 + socialGrainFavoritesCount 563 563 + socialGrainCommentsCount 564 564 + 565 565 + # Show preview (first 3) 566 566 + socialGrainFavorites(limit: 3) { 567 567 + uri 568 568 + actorHandle 569 569 + } 570 570 + socialGrainComments(limit: 3) { 571 571 + uri 572 572 + text 573 573 + } 574 574 + } 575 575 + } 576 576 + } 577 577 + } 578 578 + ``` 579 579 + 580 580 + ## DataLoader & Performance 581 581 + 582 582 + The GraphQL API uses DataLoader for efficient batching: 583 583 + 584 584 + ### CollectionDidLoader 585 585 + - Batches queries by `(slice_uri, collection, did)` 586 586 + - Used for forward joins where the DID is known 587 587 + - Eliminates N+1 queries when following references 588 588 + 589 589 + ### CollectionUriLoader 590 590 + - Batches queries by `(slice_uri, collection, parent_uri, reference_field)` 591 591 + - Used for reverse joins based on at-uri fields 592 592 + - Efficiently loads all records that reference a parent URI 593 593 + - Supports multiple at-uri fields (tries each until match found) 594 594 + 595 595 + Example: Loading 100 galleries with favorites 596 596 + - **Without DataLoader**: 1 + 100 queries (N+1 problem) 597 597 + - **With DataLoader**: 1 + 1 query (batched) 598 598 + 599 599 + ## Complex Queries 600 600 + 601 601 + ### Nested Relationships 602 602 + 603 603 + ```graphql 604 604 + query { 605 605 + socialGrainGalleries { 606 606 + edges { 607 607 + node { 608 608 + title 609 609 + socialGrainGalleryItems { 610 610 + position 611 611 + socialGrainPhoto { 612 612 + uri 613 613 + alt 614 614 + photo { 615 615 + url(preset: "fullsize") 616 616 + } 617 617 + socialGrainPhotoExifs { 618 618 + fNumber 619 619 + iSO 620 620 + make 621 621 + model 622 622 + } 623 623 + } 624 624 + } 625 625 + } 626 626 + } 627 627 + } 628 628 + } 629 629 + ``` 630 630 + 631 631 + ### Full Example 632 632 + 633 633 + ```graphql 634 634 + query MyGrainGalleries { 635 635 + socialGrainGalleries( 636 636 + where: { actorHandle: { eq: "chadtmiller.com" } } 637 637 + orderBy: { field: "createdAt", direction: DESC } 638 638 + ) { 639 639 + edges { 640 640 + node { 641 641 + uri 642 642 + title 643 643 + description 644 644 + createdAt 645 645 + 646 646 + # Counts 647 647 + socialGrainFavoritesCount 648 648 + socialGrainCommentsCount 649 649 + 650 650 + # Preview data 651 651 + socialGrainFavorites(limit: 5) { 652 652 + uri 653 653 + createdAt 654 654 + actorHandle 655 655 + } 656 656 + 657 657 + socialGrainComments(limit: 3) { 658 658 + uri 659 659 + text 660 660 + createdAt 661 661 + actorHandle 662 662 + } 663 663 + 664 664 + # Gallery items with nested photos 665 665 + socialGrainGalleryItems { 666 666 + position 667 667 + socialGrainPhoto { 668 668 + uri 669 669 + alt 670 670 + photo { 671 671 + url(preset: "fullsize") 672 672 + } 673 673 + aspectRatio 674 674 + createdAt 675 675 + socialGrainPhotoExifs { 676 676 + fNumber 677 677 + iSO 678 678 + make 679 679 + model 680 680 + } 681 681 + } 682 682 + } 683 683 + } 684 684 + } 685 685 + pageInfo { 686 686 + hasNextPage 687 687 + endCursor 688 688 + } 689 689 + } 690 690 + } 691 691 + ``` 692 692 + 693 693 + ## Mutations 694 694 + 695 695 + **WIP** - Create, update, and delete operations for records. 696 696 + 697 697 + ## Subscriptions 698 698 + 699 699 + Real-time updates for record changes. Each collection has three subscription fields: 700 700 + 701 701 + ### Created Records 702 702 + 703 703 + Subscribe to newly created records: 704 704 + 705 705 + ```graphql 706 706 + subscription { 707 707 + socialGrainGalleryCreated { 708 708 + uri 709 709 + title 710 710 + description 711 711 + createdAt 712 712 + } 713 713 + } 714 714 + ``` 715 715 + 716 716 + ### Updated Records 717 717 + 718 718 + Subscribe to record updates: 719 719 + 720 720 + ```graphql 721 721 + subscription { 722 722 + socialGrainGalleryUpdated { 723 723 + uri 724 724 + title 725 725 + description 726 726 + updatedAt 727 727 + } 728 728 + } 729 729 + ``` 730 730 + 731 731 + ### Deleted Records 732 732 + 733 733 + Subscribe to record deletions (returns just the URI): 734 734 + 735 735 + ```graphql 736 736 + subscription { 737 737 + socialGrainGalleryDeleted 738 738 + } 739 739 + ``` 740 740 + 741 741 + ## Limits & Performance 742 742 + 743 743 + - **Depth Limit**: 50 (supports introspection with circular relationships) 744 744 + - **Complexity Limit**: 5000 (prevents expensive queries) 745 745 + - **Default Limit**: 50 records per query 746 746 + - **DataLoader**: Automatic batching eliminates N+1 queries 747 747 + 748 748 + ## Best Practices 749 749 + 750 750 + 1. **Use count fields** when you only need totals 751 751 + 2. **Limit nested data** with `limit` parameter 752 752 + 3. **Request only needed fields** (no over-fetching) 753 753 + 4. **Use cursors** for pagination, not offset 754 754 + 5. **Batch related queries** with DataLoader (automatic) 755 755 + 6. **Combine counts + limited data** for previews 756 756 + 757 757 + ## Error Handling 758 758 + 759 759 + GraphQL errors include: 760 760 + - `"Query is nested too deep"` - Exceeds depth limit (50) 761 761 + - `"Query is too complex"` - Exceeds complexity limit (5000) 762 762 + - `"Schema error"` - Invalid slice or missing lexicons

+21 -1

frontend/src/features/docs/handlers.tsx

··· 46 46 description: "Complete endpoint documentation", 47 47 }, 48 48 { 49 49 + slug: "graphql-api", 50 50 + title: "GraphQL API", 51 51 + description: "Query indexed data with GraphQL", 52 52 + }, 53 53 + { 49 54 slug: "sdk-usage", 50 55 title: "SDK Usage", 51 56 description: "Advanced client patterns and examples", ··· 80 85 } 81 86 } 82 87 88 88 + // Decode HTML entities 89 89 + function decodeHtmlEntities(text: string): string { 90 90 + const entities: Record<string, string> = { 91 91 + "&amp;": "&", 92 92 + "&lt;": "<", 93 93 + "&gt;": ">", 94 94 + "&quot;": '"', 95 95 + "&#39;": "'", 96 96 + "&nbsp;": " ", 97 97 + }; 98 98 + 99 99 + return text.replace(/&[^;]+;/g, (entity) => entities[entity] || entity); 100 100 + } 101 101 + 83 102 // Extract headers for table of contents 84 103 function extractHeaders(html: string) { 85 104 const headerRegex = /<h([1-6])[^>]*>(.*?)<\/h[1-6]>/g; ··· 88 107 let match; 89 108 while ((match = headerRegex.exec(html)) !== null) { 90 109 const level = parseInt(match[1]); 91 91 - const text = match[2].replace(/<[^>]+>/g, ""); // Strip HTML tags 110 110 + const rawText = match[2].replace(/<[^>]+>/g, ""); // Strip HTML tags 111 111 + const text = decodeHtmlEntities(rawText); // Decode HTML entities 92 112 const id = text 93 113 .toLowerCase() 94 114 .replace(/[^\w\s-]/g, "") // Remove special characters